sweetalert2 11.13.1 → 11.13.2

package/dist/sweetalert2.all.js

@@ -1,5 +1,5 @@
 /*!
-* sweetalert2 v11.13.1
+* sweetalert2 v11.13.2
 * Released under the MIT License.
 */
 (function (global, factory) {
@@ -8,34 +8,13 @@
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Sweetalert2 = factory());
 })(this, (function () { 'use strict';
 
-  function _arrayLikeToArray(r, a) {
-    (null == a || a > r.length) && (a = r.length);
-    for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
-    return n;
-  }
-  function _arrayWithHoles(r) {
-    if (Array.isArray(r)) return r;
-  }
-  function _arrayWithoutHoles(r) {
-    if (Array.isArray(r)) return _arrayLikeToArray(r);
-  }
   function _assertClassBrand(e, t, n) {
     if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n;
     throw new TypeError("Private element is not present on this object");
   }
-  function _assertThisInitialized(e) {
-    if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-    return e;
-  }
-  function _callSuper(t, o, e) {
-    return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e));
-  }
   function _checkPrivateRedeclaration(e, t) {
     if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object");
   }
-  function _classCallCheck(a, n) {
-    if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
-  }
   function _classPrivateFieldGet2(s, a) {
     return s.get(_assertClassBrand(s, a));
   }
@@ -45,201 +24,12 @@
   function _classPrivateFieldSet2(s, a, r) {
     return s.set(_assertClassBrand(s, a), r), r;
   }
-  function _construct(t, e, r) {
-    if (_isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments);
-    var o = [null];
-    o.push.apply(o, e);
-    var p = new (t.bind.apply(t, o))();
-    return p;
-  }
-  function _defineProperties(e, r) {
-    for (var t = 0; t < r.length; t++) {
-      var o = r[t];
-      o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o);
-    }
-  }
-  function _createClass(e, r, t) {
-    return r && _defineProperties(e.prototype, r), Object.defineProperty(e, "prototype", {
-      writable: !1
-    }), e;
-  }
-  function _createForOfIteratorHelper(r, e) {
-    var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
-    if (!t) {
-      if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e) {
-        t && (r = t);
-        var n = 0,
-          F = function () {};
-        return {
-          s: F,
-          n: function () {
-            return n >= r.length ? {
-              done: !0
-            } : {
-              done: !1,
-              value: r[n++]
-            };
-          },
-          e: function (r) {
-            throw r;
-          },
-          f: F
-        };
-      }
-      throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-    }
-    var o,
-      a = !0,
-      u = !1;
-    return {
-      s: function () {
-        t = t.call(r);
-      },
-      n: function () {
-        var r = t.next();
-        return a = r.done, r;
-      },
-      e: function (r) {
-        u = !0, o = r;
-      },
-      f: function () {
-        try {
-          a || null == t.return || t.return();
-        } finally {
-          if (u) throw o;
-        }
-      }
-    };
-  }
-  function _get() {
-    return _get = "undefined" != typeof Reflect && Reflect.get ? Reflect.get.bind() : function (e, t, r) {
-      var p = _superPropBase(e, t);
-      if (p) {
-        var n = Object.getOwnPropertyDescriptor(p, t);
-        return n.get ? n.get.call(arguments.length < 3 ? e : r) : n.value;
-      }
-    }, _get.apply(null, arguments);
-  }
-  function _getPrototypeOf(t) {
-    return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) {
-      return t.__proto__ || Object.getPrototypeOf(t);
-    }, _getPrototypeOf(t);
-  }
-  function _inherits(t, e) {
-    if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function");
-    t.prototype = Object.create(e && e.prototype, {
-      constructor: {
-        value: t,
-        writable: !0,
-        configurable: !0
-      }
-    }), Object.defineProperty(t, "prototype", {
-      writable: !1
-    }), e && _setPrototypeOf(t, e);
-  }
-  function _isNativeReflectConstruct() {
-    try {
-      var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
-    } catch (t) {}
-    return (_isNativeReflectConstruct = function () {
-      return !!t;
-    })();
-  }
-  function _iterableToArray(r) {
-    if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
-  }
-  function _iterableToArrayLimit(r, l) {
-    var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
-    if (null != t) {
-      var e,
-        n,
-        i,
-        u,
-        a = [],
-        f = !0,
-        o = !1;
-      try {
-        if (i = (t = t.call(r)).next, 0 === l) ; else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
-      } catch (r) {
-        o = !0, n = r;
-      } finally {
-        try {
-          if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
-        } finally {
-          if (o) throw n;
-        }
-      }
-      return a;
-    }
-  }
-  function _nonIterableRest() {
-    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-  }
-  function _nonIterableSpread() {
-    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-  }
-  function _possibleConstructorReturn(t, e) {
-    if (e && ("object" == typeof e || "function" == typeof e)) return e;
-    if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined");
-    return _assertThisInitialized(t);
-  }
-  function _setPrototypeOf(t, e) {
-    return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {
-      return t.__proto__ = e, t;
-    }, _setPrototypeOf(t, e);
-  }
-  function _slicedToArray(r, e) {
-    return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
-  }
-  function _superPropBase(t, o) {
-    for (; !{}.hasOwnProperty.call(t, o) && null !== (t = _getPrototypeOf(t)););
-    return t;
-  }
-  function _superPropGet(t, e, o, r) {
-    var p = _get(_getPrototypeOf(t.prototype ), e, o);
-    return "function" == typeof p ? function (t) {
-      return p.apply(o, t);
-    } : p;
-  }
-  function _toConsumableArray(r) {
-    return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread();
-  }
-  function _toPrimitive(t, r) {
-    if ("object" != typeof t || !t) return t;
-    var e = t[Symbol.toPrimitive];
-    if (void 0 !== e) {
-      var i = e.call(t, r);
-      if ("object" != typeof i) return i;
-      throw new TypeError("@@toPrimitive must return a primitive value.");
-    }
-    return (String )(t);
-  }
-  function _toPropertyKey(t) {
-    var i = _toPrimitive(t, "string");
-    return "symbol" == typeof i ? i : i + "";
-  }
-  function _typeof(o) {
-    "@babel/helpers - typeof";
-
-    return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
-      return typeof o;
-    } : function (o) {
-      return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
-    }, _typeof(o);
-  }
-  function _unsupportedIterableToArray(r, a) {
-    if (r) {
-      if ("string" == typeof r) return _arrayLikeToArray(r, a);
-      var t = {}.toString.call(r).slice(8, -1);
-      return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
-    }
-  }
 
-  var RESTORE_FOCUS_TIMEOUT = 100;
+  const RESTORE_FOCUS_TIMEOUT = 100;
 
   /** @type {GlobalState} */
-  var globalState = {};
-  var focusPreviousActiveElement = function focusPreviousActiveElement() {
+  const globalState = {};
+  const focusPreviousActiveElement = () => {
     if (globalState.previousActiveElement instanceof HTMLElement) {
       globalState.previousActiveElement.focus();
       globalState.previousActiveElement = null;
@@ -254,14 +44,14 @@
    * @param {boolean} returnFocus
    * @returns {Promise<void>}
    */
-  var restoreActiveElement = function restoreActiveElement(returnFocus) {
-    return new Promise(function (resolve) {
+  const restoreActiveElement = returnFocus => {
+    return new Promise(resolve => {
       if (!returnFocus) {
         return resolve();
       }
-      var x = window.scrollX;
-      var y = window.scrollY;
-      globalState.restoreFocusTimeout = setTimeout(function () {
+      const x = window.scrollX;
+      const y = window.scrollY;
+      globalState.restoreFocusTimeout = setTimeout(() => {
         focusPreviousActiveElement();
         resolve();
       }, RESTORE_FOCUS_TIMEOUT); // issues/900
@@ -270,7 +60,7 @@
     });
   };
 
-  var swalPrefix = 'swal2-';
+  const swalPrefix = 'swal2-';
 
   /**
    * @typedef {Record<SwalClass, string>} SwalClasses
@@ -282,20 +72,20 @@
    */
 
   /** @type {SwalClass[]} */
-  var classNames = ['container', 'shown', 'height-auto', 'iosfix', 'popup', 'modal', 'no-backdrop', 'no-transition', 'toast', 'toast-shown', 'show', 'hide', 'close', 'title', 'html-container', 'actions', 'confirm', 'deny', 'cancel', 'default-outline', 'footer', 'icon', 'icon-content', 'image', 'input', 'file', 'range', 'select', 'radio', 'checkbox', 'label', 'textarea', 'inputerror', 'input-label', 'validation-message', 'progress-steps', 'active-progress-step', 'progress-step', 'progress-step-line', 'loader', 'loading', 'styled', 'top', 'top-start', 'top-end', 'top-left', 'top-right', 'center', 'center-start', 'center-end', 'center-left', 'center-right', 'bottom', 'bottom-start', 'bottom-end', 'bottom-left', 'bottom-right', 'grow-row', 'grow-column', 'grow-fullscreen', 'rtl', 'timer-progress-bar', 'timer-progress-bar-container', 'scrollbar-measure', 'icon-success', 'icon-warning', 'icon-info', 'icon-question', 'icon-error'];
-  var swalClasses = classNames.reduce(function (acc, className) {
+  const classNames = ['container', 'shown', 'height-auto', 'iosfix', 'popup', 'modal', 'no-backdrop', 'no-transition', 'toast', 'toast-shown', 'show', 'hide', 'close', 'title', 'html-container', 'actions', 'confirm', 'deny', 'cancel', 'default-outline', 'footer', 'icon', 'icon-content', 'image', 'input', 'file', 'range', 'select', 'radio', 'checkbox', 'label', 'textarea', 'inputerror', 'input-label', 'validation-message', 'progress-steps', 'active-progress-step', 'progress-step', 'progress-step-line', 'loader', 'loading', 'styled', 'top', 'top-start', 'top-end', 'top-left', 'top-right', 'center', 'center-start', 'center-end', 'center-left', 'center-right', 'bottom', 'bottom-start', 'bottom-end', 'bottom-left', 'bottom-right', 'grow-row', 'grow-column', 'grow-fullscreen', 'rtl', 'timer-progress-bar', 'timer-progress-bar-container', 'scrollbar-measure', 'icon-success', 'icon-warning', 'icon-info', 'icon-question', 'icon-error'];
+  const swalClasses = classNames.reduce((acc, className) => {
     acc[className] = swalPrefix + className;
     return acc;
   }, /** @type {SwalClasses} */{});
 
   /** @type {SwalIcon[]} */
-  var icons = ['success', 'warning', 'info', 'question', 'error'];
-  var iconTypes = icons.reduce(function (acc, icon) {
+  const icons = ['success', 'warning', 'info', 'question', 'error'];
+  const iconTypes = icons.reduce((acc, icon) => {
     acc[icon] = swalPrefix + icon;
     return acc;
   }, /** @type {SwalIcons} */{});
 
-  var consolePrefix = 'SweetAlert2:';
+  const consolePrefix = 'SweetAlert2:';
 
   /**
    * Capitalize the first letter of a string
@@ -303,17 +93,15 @@
    * @param {string} str
    * @returns {string}
    */
-  var capitalizeFirstLetter = function capitalizeFirstLetter(str) {
-    return str.charAt(0).toUpperCase() + str.slice(1);
-  };
+  const capitalizeFirstLetter = str => str.charAt(0).toUpperCase() + str.slice(1);
 
   /**
    * Standardize console warnings
    *
    * @param {string | string[]} message
    */
-  var warn = function warn(message) {
-    console.warn("".concat(consolePrefix, " ").concat(_typeof(message) === 'object' ? message.join(' ') : message));
+  const warn = message => {
+    console.warn(`${consolePrefix} ${typeof message === 'object' ? message.join(' ') : message}`);
   };
 
   /**
@@ -321,8 +109,8 @@
    *
    * @param {string} message
    */
-  var error = function error(message) {
-    console.error("".concat(consolePrefix, " ").concat(message));
+  const error = message => {
+    console.error(`${consolePrefix} ${message}`);
   };
 
   /**
@@ -331,14 +119,14 @@
    * @type {string[]}
    * @private
    */
-  var previousWarnOnceMessages = [];
+  const previousWarnOnceMessages = [];
 
   /**
    * Show a console warning, but only if it hasn't already been shown
    *
    * @param {string} message
    */
-  var warnOnce = function warnOnce(message) {
+  const warnOnce = message => {
     if (!previousWarnOnceMessages.includes(message)) {
       previousWarnOnceMessages.push(message);
       warn(message);
@@ -351,9 +139,9 @@
    * @param {string} deprecatedParam
    * @param {string?} useInstead
    */
-  var warnAboutDeprecation = function warnAboutDeprecation(deprecatedParam) {
-    var useInstead = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
-    warnOnce("\"".concat(deprecatedParam, "\" is deprecated and will be removed in the next major release.").concat(useInstead ? " Use \"".concat(useInstead, "\" instead.") : ''));
+  const warnAboutDeprecation = function (deprecatedParam) {
+    let useInstead = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+    warnOnce(`"${deprecatedParam}" is deprecated and will be removed in the next major release.${useInstead ? ` Use "${useInstead}" instead.` : ''}`);
   };
 
   /**
@@ -363,49 +151,39 @@
    * @param {Function | any} arg
    * @returns {any}
    */
-  var callIfFunction = function callIfFunction(arg) {
-    return typeof arg === 'function' ? arg() : arg;
-  };
+  const callIfFunction = arg => typeof arg === 'function' ? arg() : arg;
 
   /**
    * @param {any} arg
    * @returns {boolean}
    */
-  var hasToPromiseFn = function hasToPromiseFn(arg) {
-    return arg && typeof arg.toPromise === 'function';
-  };
+  const hasToPromiseFn = arg => arg && typeof arg.toPromise === 'function';
 
   /**
    * @param {any} arg
    * @returns {Promise<any>}
    */
-  var asPromise = function asPromise(arg) {
-    return hasToPromiseFn(arg) ? arg.toPromise() : Promise.resolve(arg);
-  };
+  const asPromise = arg => hasToPromiseFn(arg) ? arg.toPromise() : Promise.resolve(arg);
 
   /**
    * @param {any} arg
    * @returns {boolean}
    */
-  var isPromise = function isPromise(arg) {
-    return arg && Promise.resolve(arg) === arg;
-  };
+  const isPromise = arg => arg && Promise.resolve(arg) === arg;
 
   /**
    * Gets the popup container which contains the backdrop and the popup itself.
    *
    * @returns {HTMLElement | null}
    */
-  var getContainer = function getContainer() {
-    return document.body.querySelector(".".concat(swalClasses.container));
-  };
+  const getContainer = () => document.body.querySelector(`.${swalClasses.container}`);
 
   /**
    * @param {string} selectorString
    * @returns {HTMLElement | null}
    */
-  var elementBySelector = function elementBySelector(selectorString) {
-    var container = getContainer();
+  const elementBySelector = selectorString => {
+    const container = getContainer();
     return container ? container.querySelector(selectorString) : null;
   };
 
@@ -413,146 +191,127 @@
    * @param {string} className
    * @returns {HTMLElement | null}
    */
-  var elementByClass = function elementByClass(className) {
-    return elementBySelector(".".concat(className));
+  const elementByClass = className => {
+    return elementBySelector(`.${className}`);
   };
 
   /**
    * @returns {HTMLElement | null}
    */
-  var getPopup = function getPopup() {
-    return elementByClass(swalClasses.popup);
-  };
+  const getPopup = () => elementByClass(swalClasses.popup);
 
   /**
    * @returns {HTMLElement | null}
    */
-  var getIcon = function getIcon() {
-    return elementByClass(swalClasses.icon);
-  };
+  const getIcon = () => elementByClass(swalClasses.icon);
 
   /**
    * @returns {HTMLElement | null}
    */
-  var getIconContent = function getIconContent() {
-    return elementByClass(swalClasses['icon-content']);
-  };
+  const getIconContent = () => elementByClass(swalClasses['icon-content']);
 
   /**
    * @returns {HTMLElement | null}
    */
-  var getTitle = function getTitle() {
-    return elementByClass(swalClasses.title);
-  };
+  const getTitle = () => elementByClass(swalClasses.title);
 
   /**
    * @returns {HTMLElement | null}
    */
-  var getHtmlContainer = function getHtmlContainer() {
-    return elementByClass(swalClasses['html-container']);
-  };
+  const getHtmlContainer = () => elementByClass(swalClasses['html-container']);
 
   /**
    * @returns {HTMLElement | null}
    */
-  var getImage = function getImage() {
-    return elementByClass(swalClasses.image);
-  };
+  const getImage = () => elementByClass(swalClasses.image);
 
   /**
    * @returns {HTMLElement | null}
    */
-  var getProgressSteps = function getProgressSteps() {
-    return elementByClass(swalClasses['progress-steps']);
-  };
+  const getProgressSteps = () => elementByClass(swalClasses['progress-steps']);
 
   /**
    * @returns {HTMLElement | null}
    */
-  var getValidationMessage = function getValidationMessage() {
-    return elementByClass(swalClasses['validation-message']);
-  };
+  const getValidationMessage = () => elementByClass(swalClasses['validation-message']);
 
   /**
    * @returns {HTMLButtonElement | null}
    */
-  var getConfirmButton = function getConfirmButton() {
-    return /** @type {HTMLButtonElement} */elementBySelector(".".concat(swalClasses.actions, " .").concat(swalClasses.confirm));
-  };
+  const getConfirmButton = () => (/** @type {HTMLButtonElement} */elementBySelector(`.${swalClasses.actions} .${swalClasses.confirm}`));
 
   /**
    * @returns {HTMLButtonElement | null}
    */
-  var getCancelButton = function getCancelButton() {
-    return /** @type {HTMLButtonElement} */elementBySelector(".".concat(swalClasses.actions, " .").concat(swalClasses.cancel));
-  };
+  const getCancelButton = () => (/** @type {HTMLButtonElement} */elementBySelector(`.${swalClasses.actions} .${swalClasses.cancel}`));
 
   /**
    * @returns {HTMLButtonElement | null}
    */
-  var getDenyButton = function getDenyButton() {
-    return /** @type {HTMLButtonElement} */elementBySelector(".".concat(swalClasses.actions, " .").concat(swalClasses.deny));
-  };
+  const getDenyButton = () => (/** @type {HTMLButtonElement} */elementBySelector(`.${swalClasses.actions} .${swalClasses.deny}`));
 
   /**
    * @returns {HTMLElement | null}
    */
-  var getInputLabel = function getInputLabel() {
-    return elementByClass(swalClasses['input-label']);
-  };
+  const getInputLabel = () => elementByClass(swalClasses['input-label']);
 
   /**
    * @returns {HTMLElement | null}
    */
-  var getLoader = function getLoader() {
-    return elementBySelector(".".concat(swalClasses.loader));
-  };
+  const getLoader = () => elementBySelector(`.${swalClasses.loader}`);
 
   /**
    * @returns {HTMLElement | null}
    */
-  var getActions = function getActions() {
-    return elementByClass(swalClasses.actions);
-  };
+  const getActions = () => elementByClass(swalClasses.actions);
 
   /**
    * @returns {HTMLElement | null}
    */
-  var getFooter = function getFooter() {
-    return elementByClass(swalClasses.footer);
-  };
+  const getFooter = () => elementByClass(swalClasses.footer);
 
   /**
    * @returns {HTMLElement | null}
    */
-  var getTimerProgressBar = function getTimerProgressBar() {
-    return elementByClass(swalClasses['timer-progress-bar']);
-  };
+  const getTimerProgressBar = () => elementByClass(swalClasses['timer-progress-bar']);
 
   /**
    * @returns {HTMLElement | null}
    */
-  var getCloseButton = function getCloseButton() {
-    return elementByClass(swalClasses.close);
-  };
+  const getCloseButton = () => elementByClass(swalClasses.close);
 
   // https://github.com/jkup/focusable/blob/master/index.js
-  var focusable = "\n  a[href],\n  area[href],\n  input:not([disabled]),\n  select:not([disabled]),\n  textarea:not([disabled]),\n  button:not([disabled]),\n  iframe,\n  object,\n  embed,\n  [tabindex=\"0\"],\n  [contenteditable],\n  audio[controls],\n  video[controls],\n  summary\n";
+  const focusable = `
+  a[href],
+  area[href],
+  input:not([disabled]),
+  select:not([disabled]),
+  textarea:not([disabled]),
+  button:not([disabled]),
+  iframe,
+  object,
+  embed,
+  [tabindex="0"],
+  [contenteditable],
+  audio[controls],
+  video[controls],
+  summary
+`;
   /**
    * @returns {HTMLElement[]}
    */
-  var getFocusableElements = function getFocusableElements() {
-    var popup = getPopup();
+  const getFocusableElements = () => {
+    const popup = getPopup();
     if (!popup) {
       return [];
     }
     /** @type {NodeListOf<HTMLElement>} */
-    var focusableElementsWithTabindex = popup.querySelectorAll('[tabindex]:not([tabindex="-1"]):not([tabindex="0"])');
-    var focusableElementsWithTabindexSorted = Array.from(focusableElementsWithTabindex)
+    const focusableElementsWithTabindex = popup.querySelectorAll('[tabindex]:not([tabindex="-1"]):not([tabindex="0"])');
+    const focusableElementsWithTabindexSorted = Array.from(focusableElementsWithTabindex)
     // sort according to tabindex
-    .sort(function (a, b) {
-      var tabindexA = parseInt(a.getAttribute('tabindex') || '0');
-      var tabindexB = parseInt(b.getAttribute('tabindex') || '0');
+    .sort((a, b) => {
+      const tabindexA = parseInt(a.getAttribute('tabindex') || '0');
+      const tabindexB = parseInt(b.getAttribute('tabindex') || '0');
       if (tabindexA > tabindexB) {
         return 1;
       } else if (tabindexA < tabindexB) {
@@ -562,27 +321,23 @@
     });
 
     /** @type {NodeListOf<HTMLElement>} */
-    var otherFocusableElements = popup.querySelectorAll(focusable);
-    var otherFocusableElementsFiltered = Array.from(otherFocusableElements).filter(function (el) {
-      return el.getAttribute('tabindex') !== '-1';
-    });
-    return _toConsumableArray(new Set(focusableElementsWithTabindexSorted.concat(otherFocusableElementsFiltered))).filter(function (el) {
-      return isVisible$1(el);
-    });
+    const otherFocusableElements = popup.querySelectorAll(focusable);
+    const otherFocusableElementsFiltered = Array.from(otherFocusableElements).filter(el => el.getAttribute('tabindex') !== '-1');
+    return [...new Set(focusableElementsWithTabindexSorted.concat(otherFocusableElementsFiltered))].filter(el => isVisible$1(el));
   };
 
   /**
    * @returns {boolean}
    */
-  var isModal = function isModal() {
+  const isModal = () => {
     return hasClass(document.body, swalClasses.shown) && !hasClass(document.body, swalClasses['toast-shown']) && !hasClass(document.body, swalClasses['no-backdrop']);
   };
 
   /**
    * @returns {boolean}
    */
-  var isToast = function isToast() {
-    var popup = getPopup();
+  const isToast = () => {
+    const popup = getPopup();
     if (!popup) {
       return false;
     }
@@ -592,8 +347,8 @@
   /**
    * @returns {boolean}
    */
-  var isLoading = function isLoading() {
-    var popup = getPopup();
+  const isLoading = () => {
+    const popup = getPopup();
     if (!popup) {
       return false;
     }
@@ -607,20 +362,20 @@
    * @param {HTMLElement} elem
    * @param {string} html
    */
-  var setInnerHtml = function setInnerHtml(elem, html) {
+  const setInnerHtml = (elem, html) => {
     elem.textContent = '';
     if (html) {
-      var parser = new DOMParser();
-      var parsed = parser.parseFromString(html, "text/html");
-      var head = parsed.querySelector('head');
+      const parser = new DOMParser();
+      const parsed = parser.parseFromString(html, `text/html`);
+      const head = parsed.querySelector('head');
       if (head) {
-        Array.from(head.childNodes).forEach(function (child) {
+        Array.from(head.childNodes).forEach(child => {
           elem.appendChild(child);
         });
       }
-      var body = parsed.querySelector('body');
+      const body = parsed.querySelector('body');
       if (body) {
-        Array.from(body.childNodes).forEach(function (child) {
+        Array.from(body.childNodes).forEach(child => {
           if (child instanceof HTMLVideoElement || child instanceof HTMLAudioElement) {
             elem.appendChild(child.cloneNode(true)); // https://github.com/sweetalert2/sweetalert2/issues/2507
           } else {
@@ -636,12 +391,12 @@
    * @param {string} className
    * @returns {boolean}
    */
-  var hasClass = function hasClass(elem, className) {
+  const hasClass = (elem, className) => {
     if (!className) {
       return false;
     }
-    var classList = className.split(/\s+/);
-    for (var i = 0; i < classList.length; i++) {
+    const classList = className.split(/\s+/);
+    for (let i = 0; i < classList.length; i++) {
       if (!elem.classList.contains(classList[i])) {
         return false;
       }
@@ -653,8 +408,8 @@
    * @param {HTMLElement} elem
    * @param {SweetAlertOptions} params
    */
-  var removeCustomClasses = function removeCustomClasses(elem, params) {
-    Array.from(elem.classList).forEach(function (className) {
+  const removeCustomClasses = (elem, params) => {
+    Array.from(elem.classList).forEach(className => {
       if (!Object.values(swalClasses).includes(className) && !Object.values(iconTypes).includes(className) && !Object.values(params.showClass || {}).includes(className)) {
         elem.classList.remove(className);
       }
@@ -666,17 +421,17 @@
    * @param {SweetAlertOptions} params
    * @param {string} className
    */
-  var applyCustomClass = function applyCustomClass(elem, params, className) {
+  const applyCustomClass = (elem, params, className) => {
     removeCustomClasses(elem, params);
     if (!params.customClass) {
       return;
     }
-    var customClass = params.customClass[(/** @type {keyof SweetAlertCustomClass} */className)];
+    const customClass = params.customClass[(/** @type {keyof SweetAlertCustomClass} */className)];
     if (!customClass) {
       return;
     }
     if (typeof customClass !== 'string' && !customClass.forEach) {
-      warn("Invalid type of customClass.".concat(className, "! Expected string or iterable object, got \"").concat(_typeof(customClass), "\""));
+      warn(`Invalid type of customClass.${className}! Expected string or iterable object, got "${typeof customClass}"`);
       return;
     }
     addClass(elem, customClass);
@@ -687,7 +442,7 @@
    * @param {import('./renderers/renderInput').InputClass | SweetAlertInput} inputClass
    * @returns {HTMLInputElement | null}
    */
-  var getInput$1 = function getInput(popup, inputClass) {
+  const getInput$1 = (popup, inputClass) => {
     if (!inputClass) {
       return null;
     }
@@ -695,28 +450,28 @@
       case 'select':
       case 'textarea':
       case 'file':
-        return popup.querySelector(".".concat(swalClasses.popup, " > .").concat(swalClasses[inputClass]));
+        return popup.querySelector(`.${swalClasses.popup} > .${swalClasses[inputClass]}`);
       case 'checkbox':
-        return popup.querySelector(".".concat(swalClasses.popup, " > .").concat(swalClasses.checkbox, " input"));
+        return popup.querySelector(`.${swalClasses.popup} > .${swalClasses.checkbox} input`);
       case 'radio':
-        return popup.querySelector(".".concat(swalClasses.popup, " > .").concat(swalClasses.radio, " input:checked")) || popup.querySelector(".".concat(swalClasses.popup, " > .").concat(swalClasses.radio, " input:first-child"));
+        return popup.querySelector(`.${swalClasses.popup} > .${swalClasses.radio} input:checked`) || popup.querySelector(`.${swalClasses.popup} > .${swalClasses.radio} input:first-child`);
       case 'range':
-        return popup.querySelector(".".concat(swalClasses.popup, " > .").concat(swalClasses.range, " input"));
+        return popup.querySelector(`.${swalClasses.popup} > .${swalClasses.range} input`);
       default:
-        return popup.querySelector(".".concat(swalClasses.popup, " > .").concat(swalClasses.input));
+        return popup.querySelector(`.${swalClasses.popup} > .${swalClasses.input}`);
     }
   };
 
   /**
    * @param {HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement} input
    */
-  var focusInput = function focusInput(input) {
+  const focusInput = input => {
     input.focus();
 
     // place cursor at end of text in text input
     if (input.type !== 'file') {
       // http://stackoverflow.com/a/2345915
-      var val = input.value;
+      const val = input.value;
       input.value = '';
       input.value = val;
     }
@@ -727,16 +482,16 @@
    * @param {string | string[] | readonly string[] | undefined} classList
    * @param {boolean} condition
    */
-  var toggleClass = function toggleClass(target, classList, condition) {
+  const toggleClass = (target, classList, condition) => {
     if (!target || !classList) {
       return;
     }
     if (typeof classList === 'string') {
       classList = classList.split(/\s+/).filter(Boolean);
     }
-    classList.forEach(function (className) {
+    classList.forEach(className => {
       if (Array.isArray(target)) {
-        target.forEach(function (elem) {
+        target.forEach(elem => {
           if (condition) {
             elem.classList.add(className);
           } else {
@@ -757,7 +512,7 @@
    * @param {HTMLElement | HTMLElement[] | null} target
    * @param {string | string[] | readonly string[] | undefined} classList
    */
-  var addClass = function addClass(target, classList) {
+  const addClass = (target, classList) => {
     toggleClass(target, classList, true);
   };
 
@@ -765,7 +520,7 @@
    * @param {HTMLElement | HTMLElement[] | null} target
    * @param {string | string[] | readonly string[] | undefined} classList
    */
-  var removeClass = function removeClass(target, classList) {
+  const removeClass = (target, classList) => {
     toggleClass(target, classList, false);
   };
 
@@ -776,10 +531,10 @@
    * @param {string} className
    * @returns {HTMLElement | undefined}
    */
-  var getDirectChildByClass = function getDirectChildByClass(elem, className) {
-    var children = Array.from(elem.children);
-    for (var i = 0; i < children.length; i++) {
-      var child = children[i];
+  const getDirectChildByClass = (elem, className) => {
+    const children = Array.from(elem.children);
+    for (let i = 0; i < children.length; i++) {
+      const child = children[i];
       if (child instanceof HTMLElement && hasClass(child, className)) {
         return child;
       }
@@ -791,12 +546,12 @@
    * @param {string} property
    * @param {*} value
    */
-  var applyNumericalStyle = function applyNumericalStyle(elem, property, value) {
-    if (value === "".concat(parseInt(value))) {
+  const applyNumericalStyle = (elem, property, value) => {
+    if (value === `${parseInt(value)}`) {
       value = parseInt(value);
     }
     if (value || parseInt(value) === 0) {
-      elem.style.setProperty(property, typeof value === 'number' ? "".concat(value, "px") : value);
+      elem.style.setProperty(property, typeof value === 'number' ? `${value}px` : value);
     } else {
       elem.style.removeProperty(property);
     }
@@ -806,8 +561,8 @@
    * @param {HTMLElement | null} elem
    * @param {string} display
    */
-  var show = function show(elem) {
-    var display = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'flex';
+  const show = function (elem) {
+    let display = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'flex';
     if (!elem) {
       return;
     }
@@ -817,7 +572,7 @@
   /**
    * @param {HTMLElement | null} elem
    */
-  var hide = function hide(elem) {
+  const hide = elem => {
     if (!elem) {
       return;
     }
@@ -828,12 +583,12 @@
    * @param {HTMLElement | null} elem
    * @param {string} display
    */
-  var showWhenInnerHtmlPresent = function showWhenInnerHtmlPresent(elem) {
-    var display = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'block';
+  const showWhenInnerHtmlPresent = function (elem) {
+    let display = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'block';
     if (!elem) {
       return;
     }
-    new MutationObserver(function () {
+    new MutationObserver(() => {
       toggle(elem, elem.innerHTML, display);
     }).observe(elem, {
       childList: true,
@@ -847,9 +602,9 @@
    * @param {string} property
    * @param {string} value
    */
-  var setStyle = function setStyle(parent, selector, property, value) {
+  const setStyle = (parent, selector, property, value) => {
     /** @type {HTMLElement | null} */
-    var el = parent.querySelector(selector);
+    const el = parent.querySelector(selector);
     if (el) {
       el.style.setProperty(property, value);
     }
@@ -860,8 +615,8 @@
    * @param {any} condition
    * @param {string} display
    */
-  var toggle = function toggle(elem, condition) {
-    var display = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'flex';
+  const toggle = function (elem, condition) {
+    let display = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'flex';
     if (condition) {
       show(elem, display);
     } else {
@@ -875,24 +630,18 @@
    * @param {HTMLElement | null} elem
    * @returns {boolean}
    */
-  var isVisible$1 = function isVisible(elem) {
-    return !!(elem && (elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length));
-  };
+  const isVisible$1 = elem => !!(elem && (elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length));
 
   /**
    * @returns {boolean}
    */
-  var allButtonsAreHidden = function allButtonsAreHidden() {
-    return !isVisible$1(getConfirmButton()) && !isVisible$1(getDenyButton()) && !isVisible$1(getCancelButton());
-  };
+  const allButtonsAreHidden = () => !isVisible$1(getConfirmButton()) && !isVisible$1(getDenyButton()) && !isVisible$1(getCancelButton());
 
   /**
    * @param {HTMLElement} elem
    * @returns {boolean}
    */
-  var isScrollable = function isScrollable(elem) {
-    return !!(elem.scrollHeight > elem.clientHeight);
-  };
+  const isScrollable = elem => !!(elem.scrollHeight > elem.clientHeight);
 
   /**
    * borrowed from https://stackoverflow.com/a/46352119
@@ -900,10 +649,10 @@
    * @param {HTMLElement} elem
    * @returns {boolean}
    */
-  var hasCssAnimation = function hasCssAnimation(elem) {
-    var style = window.getComputedStyle(elem);
-    var animDuration = parseFloat(style.getPropertyValue('animation-duration') || '0');
-    var transDuration = parseFloat(style.getPropertyValue('transition-duration') || '0');
+  const hasCssAnimation = elem => {
+    const style = window.getComputedStyle(elem);
+    const animDuration = parseFloat(style.getPropertyValue('animation-duration') || '0');
+    const transDuration = parseFloat(style.getPropertyValue('transition-duration') || '0');
     return animDuration > 0 || transDuration > 0;
   };
 
@@ -911,9 +660,9 @@
    * @param {number} timer
    * @param {boolean} reset
    */
-  var animateTimerProgressBar = function animateTimerProgressBar(timer) {
-    var reset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-    var timerProgressBar = getTimerProgressBar();
+  const animateTimerProgressBar = function (timer) {
+    let reset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    const timerProgressBar = getTimerProgressBar();
     if (!timerProgressBar) {
       return;
     }
@@ -922,23 +671,23 @@
         timerProgressBar.style.transition = 'none';
         timerProgressBar.style.width = '100%';
       }
-      setTimeout(function () {
-        timerProgressBar.style.transition = "width ".concat(timer / 1000, "s linear");
+      setTimeout(() => {
+        timerProgressBar.style.transition = `width ${timer / 1000}s linear`;
         timerProgressBar.style.width = '0%';
       }, 10);
     }
   };
-  var stopTimerProgressBar = function stopTimerProgressBar() {
-    var timerProgressBar = getTimerProgressBar();
+  const stopTimerProgressBar = () => {
+    const timerProgressBar = getTimerProgressBar();
     if (!timerProgressBar) {
       return;
     }
-    var timerProgressBarWidth = parseInt(window.getComputedStyle(timerProgressBar).width);
+    const timerProgressBarWidth = parseInt(window.getComputedStyle(timerProgressBar).width);
     timerProgressBar.style.removeProperty('transition');
     timerProgressBar.style.width = '100%';
-    var timerProgressBarFullWidth = parseInt(window.getComputedStyle(timerProgressBar).width);
-    var timerProgressBarPercent = timerProgressBarWidth / timerProgressBarFullWidth * 100;
-    timerProgressBar.style.width = "".concat(timerProgressBarPercent, "%");
+    const timerProgressBarFullWidth = parseInt(window.getComputedStyle(timerProgressBar).width);
+    const timerProgressBarPercent = timerProgressBarWidth / timerProgressBarFullWidth * 100;
+    timerProgressBar.style.width = `${timerProgressBarPercent}%`;
   };
 
   /**
@@ -946,17 +695,48 @@
    *
    * @returns {boolean}
    */
-  var isNodeEnv = function isNodeEnv() {
-    return typeof window === 'undefined' || typeof document === 'undefined';
-  };
-
-  var sweetHTML = "\n <div aria-labelledby=\"".concat(swalClasses.title, "\" aria-describedby=\"").concat(swalClasses['html-container'], "\" class=\"").concat(swalClasses.popup, "\" tabindex=\"-1\">\n   <button type=\"button\" class=\"").concat(swalClasses.close, "\"></button>\n   <ul class=\"").concat(swalClasses['progress-steps'], "\"></ul>\n   <div class=\"").concat(swalClasses.icon, "\"></div>\n   <img class=\"").concat(swalClasses.image, "\" />\n   <h2 class=\"").concat(swalClasses.title, "\" id=\"").concat(swalClasses.title, "\"></h2>\n   <div class=\"").concat(swalClasses['html-container'], "\" id=\"").concat(swalClasses['html-container'], "\"></div>\n   <input class=\"").concat(swalClasses.input, "\" id=\"").concat(swalClasses.input, "\" />\n   <input type=\"file\" class=\"").concat(swalClasses.file, "\" />\n   <div class=\"").concat(swalClasses.range, "\">\n     <input type=\"range\" />\n     <output></output>\n   </div>\n   <select class=\"").concat(swalClasses.select, "\" id=\"").concat(swalClasses.select, "\"></select>\n   <div class=\"").concat(swalClasses.radio, "\"></div>\n   <label class=\"").concat(swalClasses.checkbox, "\">\n     <input type=\"checkbox\" id=\"").concat(swalClasses.checkbox, "\" />\n     <span class=\"").concat(swalClasses.label, "\"></span>\n   </label>\n   <textarea class=\"").concat(swalClasses.textarea, "\" id=\"").concat(swalClasses.textarea, "\"></textarea>\n   <div class=\"").concat(swalClasses['validation-message'], "\" id=\"").concat(swalClasses['validation-message'], "\"></div>\n   <div class=\"").concat(swalClasses.actions, "\">\n     <div class=\"").concat(swalClasses.loader, "\"></div>\n     <button type=\"button\" class=\"").concat(swalClasses.confirm, "\"></button>\n     <button type=\"button\" class=\"").concat(swalClasses.deny, "\"></button>\n     <button type=\"button\" class=\"").concat(swalClasses.cancel, "\"></button>\n   </div>\n   <div class=\"").concat(swalClasses.footer, "\"></div>\n   <div class=\"").concat(swalClasses['timer-progress-bar-container'], "\">\n     <div class=\"").concat(swalClasses['timer-progress-bar'], "\"></div>\n   </div>\n </div>\n").replace(/(^|\n)\s*/g, '');
+  const isNodeEnv = () => typeof window === 'undefined' || typeof document === 'undefined';
+
+  const sweetHTML = `
+ <div aria-labelledby="${swalClasses.title}" aria-describedby="${swalClasses['html-container']}" class="${swalClasses.popup}" tabindex="-1">
+   <button type="button" class="${swalClasses.close}"></button>
+   <ul class="${swalClasses['progress-steps']}"></ul>
+   <div class="${swalClasses.icon}"></div>
+   <img class="${swalClasses.image}" />
+   <h2 class="${swalClasses.title}" id="${swalClasses.title}"></h2>
+   <div class="${swalClasses['html-container']}" id="${swalClasses['html-container']}"></div>
+   <input class="${swalClasses.input}" id="${swalClasses.input}" />
+   <input type="file" class="${swalClasses.file}" />
+   <div class="${swalClasses.range}">
+     <input type="range" />
+     <output></output>
+   </div>
+   <select class="${swalClasses.select}" id="${swalClasses.select}"></select>
+   <div class="${swalClasses.radio}"></div>
+   <label class="${swalClasses.checkbox}">
+     <input type="checkbox" id="${swalClasses.checkbox}" />
+     <span class="${swalClasses.label}"></span>
+   </label>
+   <textarea class="${swalClasses.textarea}" id="${swalClasses.textarea}"></textarea>
+   <div class="${swalClasses['validation-message']}" id="${swalClasses['validation-message']}"></div>
+   <div class="${swalClasses.actions}">
+     <div class="${swalClasses.loader}"></div>
+     <button type="button" class="${swalClasses.confirm}"></button>
+     <button type="button" class="${swalClasses.deny}"></button>
+     <button type="button" class="${swalClasses.cancel}"></button>
+   </div>
+   <div class="${swalClasses.footer}"></div>
+   <div class="${swalClasses['timer-progress-bar-container']}">
+     <div class="${swalClasses['timer-progress-bar']}"></div>
+   </div>
+ </div>
+`.replace(/(^|\n)\s*/g, '');
 
   /**
    * @returns {boolean}
    */
-  var resetOldContainer = function resetOldContainer() {
-    var oldContainer = getContainer();
+  const resetOldContainer = () => {
+    const oldContainer = getContainer();
     if (!oldContainer) {
       return false;
     }
@@ -964,31 +744,31 @@
     removeClass([document.documentElement, document.body], [swalClasses['no-backdrop'], swalClasses['toast-shown'], swalClasses['has-column']]);
     return true;
   };
-  var resetValidationMessage$1 = function resetValidationMessage() {
+  const resetValidationMessage$1 = () => {
     globalState.currentInstance.resetValidationMessage();
   };
-  var addInputChangeListeners = function addInputChangeListeners() {
-    var popup = getPopup();
-    var input = getDirectChildByClass(popup, swalClasses.input);
-    var file = getDirectChildByClass(popup, swalClasses.file);
+  const addInputChangeListeners = () => {
+    const popup = getPopup();
+    const input = getDirectChildByClass(popup, swalClasses.input);
+    const file = getDirectChildByClass(popup, swalClasses.file);
     /** @type {HTMLInputElement} */
-    var range = popup.querySelector(".".concat(swalClasses.range, " input"));
+    const range = popup.querySelector(`.${swalClasses.range} input`);
     /** @type {HTMLOutputElement} */
-    var rangeOutput = popup.querySelector(".".concat(swalClasses.range, " output"));
-    var select = getDirectChildByClass(popup, swalClasses.select);
+    const rangeOutput = popup.querySelector(`.${swalClasses.range} output`);
+    const select = getDirectChildByClass(popup, swalClasses.select);
     /** @type {HTMLInputElement} */
-    var checkbox = popup.querySelector(".".concat(swalClasses.checkbox, " input"));
-    var textarea = getDirectChildByClass(popup, swalClasses.textarea);
+    const checkbox = popup.querySelector(`.${swalClasses.checkbox} input`);
+    const textarea = getDirectChildByClass(popup, swalClasses.textarea);
     input.oninput = resetValidationMessage$1;
     file.onchange = resetValidationMessage$1;
     select.onchange = resetValidationMessage$1;
     checkbox.onchange = resetValidationMessage$1;
     textarea.oninput = resetValidationMessage$1;
-    range.oninput = function () {
+    range.oninput = () => {
       resetValidationMessage$1();
       rangeOutput.value = range.value;
     };
-    range.onchange = function () {
+    range.onchange = () => {
       resetValidationMessage$1();
       rangeOutput.value = range.value;
     };
@@ -998,15 +778,13 @@
    * @param {string | HTMLElement} target
    * @returns {HTMLElement}
    */
-  var getTarget = function getTarget(target) {
-    return typeof target === 'string' ? document.querySelector(target) : target;
-  };
+  const getTarget = target => typeof target === 'string' ? document.querySelector(target) : target;
 
   /**
    * @param {SweetAlertOptions} params
    */
-  var setupAccessibility = function setupAccessibility(params) {
-    var popup = getPopup();
+  const setupAccessibility = params => {
+    const popup = getPopup();
     popup.setAttribute('role', params.toast ? 'alert' : 'dialog');
     popup.setAttribute('aria-live', params.toast ? 'polite' : 'assertive');
     if (!params.toast) {
@@ -1017,7 +795,7 @@
   /**
    * @param {HTMLElement} targetElement
    */
-  var setupRTL = function setupRTL(targetElement) {
+  const setupRTL = targetElement => {
     if (window.getComputedStyle(targetElement).direction === 'rtl') {
       addClass(getContainer(), swalClasses.rtl);
     }
@@ -1028,20 +806,20 @@
    *
    * @param {SweetAlertOptions} params
    */
-  var init = function init(params) {
+  const init = params => {
     // Clean up the old popup container if it exists
-    var oldContainerExisted = resetOldContainer();
+    const oldContainerExisted = resetOldContainer();
     if (isNodeEnv()) {
       error('SweetAlert2 requires document to initialize');
       return;
     }
-    var container = document.createElement('div');
+    const container = document.createElement('div');
     container.className = swalClasses.container;
     if (oldContainerExisted) {
       addClass(container, swalClasses['no-transition']);
     }
     setInnerHtml(container, sweetHTML);
-    var targetElement = getTarget(params.target);
+    const targetElement = getTarget(params.target);
     targetElement.appendChild(container);
     setupAccessibility(params);
     setupRTL(targetElement);
@@ -1052,14 +830,14 @@
    * @param {HTMLElement | object | string} param
    * @param {HTMLElement} target
    */
-  var parseHtmlToContainer = function parseHtmlToContainer(param, target) {
+  const parseHtmlToContainer = (param, target) => {
     // DOM element
     if (param instanceof HTMLElement) {
       target.appendChild(param);
     }
 
     // Object
-    else if (_typeof(param) === 'object') {
+    else if (typeof param === 'object') {
       handleObject(param, target);
     }
 
@@ -1073,7 +851,7 @@
    * @param {any} param
    * @param {HTMLElement} target
    */
-  var handleObject = function handleObject(param, target) {
+  const handleObject = (param, target) => {
     // JQuery element(s)
     if (param.jquery) {
       handleJqueryElem(target, param);
@@ -1089,10 +867,10 @@
    * @param {HTMLElement} target
    * @param {any} elem
    */
-  var handleJqueryElem = function handleJqueryElem(target, elem) {
+  const handleJqueryElem = (target, elem) => {
     target.textContent = '';
     if (0 in elem) {
-      for (var i = 0; i in elem; i++) {
+      for (let i = 0; i in elem; i++) {
         target.appendChild(elem[i].cloneNode(true));
       }
     } else {
@@ -1103,12 +881,12 @@
   /**
    * @returns {'webkitAnimationEnd' | 'animationend' | false}
    */
-  var animationEndEvent = function () {
+  const animationEndEvent = (() => {
     // Prevent run in Node env
     if (isNodeEnv()) {
       return false;
     }
-    var testEl = document.createElement('div');
+    const testEl = document.createElement('div');
 
     // Chrome, Safari and Opera
     if (typeof testEl.style.webkitAnimation !== 'undefined') {
@@ -1120,15 +898,15 @@
       return 'animationend';
     }
     return false;
-  }();
+  })();
 
   /**
    * @param {SweetAlert} instance
    * @param {SweetAlertOptions} params
    */
-  var renderActions = function renderActions(instance, params) {
-    var actions = getActions();
-    var loader = getLoader();
+  const renderActions = (instance, params) => {
+    const actions = getActions();
+    const loader = getLoader();
     if (!actions || !loader) {
       return;
     }
@@ -1157,9 +935,9 @@
    * @param {SweetAlertOptions} params
    */
   function renderButtons(actions, loader, params) {
-    var confirmButton = getConfirmButton();
-    var denyButton = getDenyButton();
-    var cancelButton = getCancelButton();
+    const confirmButton = getConfirmButton();
+    const denyButton = getDenyButton();
+    const cancelButton = getCancelButton();
     if (!confirmButton || !denyButton || !cancelButton) {
       return;
     }
@@ -1215,22 +993,22 @@
    * @param {SweetAlertOptions} params
    */
   function renderButton(button, buttonType, params) {
-    var buttonName = /** @type {'Confirm' | 'Deny' | 'Cancel'} */capitalizeFirstLetter(buttonType);
-    toggle(button, params["show".concat(buttonName, "Button")], 'inline-block');
-    setInnerHtml(button, params["".concat(buttonType, "ButtonText")] || ''); // Set caption text
-    button.setAttribute('aria-label', params["".concat(buttonType, "ButtonAriaLabel")] || ''); // ARIA label
+    const buttonName = /** @type {'Confirm' | 'Deny' | 'Cancel'} */capitalizeFirstLetter(buttonType);
+    toggle(button, params[`show${buttonName}Button`], 'inline-block');
+    setInnerHtml(button, params[`${buttonType}ButtonText`] || ''); // Set caption text
+    button.setAttribute('aria-label', params[`${buttonType}ButtonAriaLabel`] || ''); // ARIA label
 
     // Add buttons custom classes
     button.className = swalClasses[buttonType];
-    applyCustomClass(button, params, "".concat(buttonType, "Button"));
+    applyCustomClass(button, params, `${buttonType}Button`);
   }
 
   /**
    * @param {SweetAlert} instance
    * @param {SweetAlertOptions} params
    */
-  var renderCloseButton = function renderCloseButton(instance, params) {
-    var closeButton = getCloseButton();
+  const renderCloseButton = (instance, params) => {
+    const closeButton = getCloseButton();
     if (!closeButton) {
       return;
     }
@@ -1246,8 +1024,8 @@
    * @param {SweetAlert} instance
    * @param {SweetAlertOptions} params
    */
-  var renderContainer = function renderContainer(instance, params) {
-    var container = getContainer();
+  const renderContainer = (instance, params) => {
+    const container = getContainer();
     if (!container) {
       return;
     }
@@ -1295,7 +1073,7 @@
     if (!grow) {
       return;
     }
-    addClass(container, swalClasses["grow-".concat(grow)]);
+    addClass(container, swalClasses[`grow-${grow}`]);
   }
 
   /**
@@ -1313,22 +1091,25 @@
     domCache: new WeakMap()
   };
 
+  /// <reference path="../../../../sweetalert2.d.ts"/>
+
+
   /** @type {InputClass[]} */
-  var inputClasses = ['input', 'file', 'range', 'select', 'radio', 'checkbox', 'textarea'];
+  const inputClasses = ['input', 'file', 'range', 'select', 'radio', 'checkbox', 'textarea'];
 
   /**
    * @param {SweetAlert} instance
    * @param {SweetAlertOptions} params
    */
-  var renderInput = function renderInput(instance, params) {
-    var popup = getPopup();
+  const renderInput = (instance, params) => {
+    const popup = getPopup();
     if (!popup) {
       return;
     }
-    var innerParams = privateProps.innerParams.get(instance);
-    var rerender = !innerParams || params.input !== innerParams.input;
-    inputClasses.forEach(function (inputClass) {
-      var inputContainer = getDirectChildByClass(popup, swalClasses[inputClass]);
+    const innerParams = privateProps.innerParams.get(instance);
+    const rerender = !innerParams || params.input !== innerParams.input;
+    inputClasses.forEach(inputClass => {
+      const inputContainer = getDirectChildByClass(popup, swalClasses[inputClass]);
       if (!inputContainer) {
         return;
       }
@@ -1354,24 +1135,24 @@
   /**
    * @param {SweetAlertOptions} params
    */
-  var showInput = function showInput(params) {
+  const showInput = params => {
     if (!params.input) {
       return;
     }
     if (!renderInputType[params.input]) {
-      error("Unexpected type of input! Expected ".concat(Object.keys(renderInputType).join(' | '), ", got \"").concat(params.input, "\""));
+      error(`Unexpected type of input! Expected ${Object.keys(renderInputType).join(' | ')}, got "${params.input}"`);
       return;
     }
-    var inputContainer = getInputContainer(params.input);
+    const inputContainer = getInputContainer(params.input);
     if (!inputContainer) {
       return;
     }
-    var input = renderInputType[params.input](inputContainer, params);
+    const input = renderInputType[params.input](inputContainer, params);
     show(inputContainer);
 
     // input autofocus
     if (params.inputAutoFocus) {
-      setTimeout(function () {
+      setTimeout(() => {
         focusInput(input);
       });
     }
@@ -1380,9 +1161,9 @@
   /**
    * @param {HTMLInputElement} input
    */
-  var removeAttributes = function removeAttributes(input) {
-    for (var i = 0; i < input.attributes.length; i++) {
-      var attrName = input.attributes[i].name;
+  const removeAttributes = input => {
+    for (let i = 0; i < input.attributes.length; i++) {
+      const attrName = input.attributes[i].name;
       if (!['id', 'type', 'value', 'style'].includes(attrName)) {
         input.removeAttribute(attrName);
       }
@@ -1393,17 +1174,17 @@
    * @param {InputClass} inputClass
    * @param {SweetAlertOptions['inputAttributes']} inputAttributes
    */
-  var setAttributes = function setAttributes(inputClass, inputAttributes) {
-    var popup = getPopup();
+  const setAttributes = (inputClass, inputAttributes) => {
+    const popup = getPopup();
     if (!popup) {
       return;
     }
-    var input = getInput$1(popup, inputClass);
+    const input = getInput$1(popup, inputClass);
     if (!input) {
       return;
     }
     removeAttributes(input);
-    for (var attr in inputAttributes) {
+    for (const attr in inputAttributes) {
       input.setAttribute(attr, inputAttributes[attr]);
     }
   };
@@ -1411,11 +1192,11 @@
   /**
    * @param {SweetAlertOptions} params
    */
-  var setCustomClass = function setCustomClass(params) {
+  const setCustomClass = params => {
     if (!params.input) {
       return;
     }
-    var inputContainer = getInputContainer(params.input);
+    const inputContainer = getInputContainer(params.input);
     if (inputContainer) {
       applyCustomClass(inputContainer, params, 'input');
     }
@@ -1425,7 +1206,7 @@
    * @param {HTMLInputElement | HTMLTextAreaElement} input
    * @param {SweetAlertOptions} params
    */
-  var setInputPlaceholder = function setInputPlaceholder(input, params) {
+  const setInputPlaceholder = (input, params) => {
     if (!input.placeholder && params.inputPlaceholder) {
       input.placeholder = params.inputPlaceholder;
     }
@@ -1436,13 +1217,13 @@
    * @param {Input} prependTo
    * @param {SweetAlertOptions} params
    */
-  var setInputLabel = function setInputLabel(input, prependTo, params) {
+  const setInputLabel = (input, prependTo, params) => {
     if (params.inputLabel) {
-      var label = document.createElement('label');
-      var labelClass = swalClasses['input-label'];
+      const label = document.createElement('label');
+      const labelClass = swalClasses['input-label'];
       label.setAttribute('for', input.id);
       label.className = labelClass;
-      if (_typeof(params.customClass) === 'object') {
+      if (typeof params.customClass === 'object') {
         addClass(label, params.customClass.inputLabel);
       }
       label.innerText = params.inputLabel;
@@ -1454,8 +1235,8 @@
    * @param {SweetAlertInput} inputType
    * @returns {HTMLElement | undefined}
    */
-  var getInputContainer = function getInputContainer(inputType) {
-    var popup = getPopup();
+  const getInputContainer = inputType => {
+    const popup = getPopup();
     if (!popup) {
       return;
     }
@@ -1466,16 +1247,16 @@
    * @param {HTMLInputElement | HTMLOutputElement | HTMLTextAreaElement} input
    * @param {SweetAlertOptions['inputValue']} inputValue
    */
-  var checkAndSetInputValue = function checkAndSetInputValue(input, inputValue) {
-    if (['string', 'number'].includes(_typeof(inputValue))) {
-      input.value = "".concat(inputValue);
+  const checkAndSetInputValue = (input, inputValue) => {
+    if (['string', 'number'].includes(typeof inputValue)) {
+      input.value = `${inputValue}`;
     } else if (!isPromise(inputValue)) {
-      warn("Unexpected type of inputValue! Expected \"string\", \"number\" or \"Promise\", got \"".concat(_typeof(inputValue), "\""));
+      warn(`Unexpected type of inputValue! Expected "string", "number" or "Promise", got "${typeof inputValue}"`);
     }
   };
 
   /** @type {Record<SweetAlertInput, (input: Input | HTMLElement, params: SweetAlertOptions) => Input>} */
-  var renderInputType = {};
+  const renderInputType = {};
 
   /**
    * @param {HTMLInputElement} input
@@ -1483,7 +1264,7 @@
    * @returns {HTMLInputElement}
    */
   renderInputType.text = renderInputType.email = renderInputType.password = renderInputType.number = renderInputType.tel = renderInputType.url = renderInputType.search = renderInputType.date = renderInputType['datetime-local'] = renderInputType.time = renderInputType.week = renderInputType.month = /** @type {(input: Input | HTMLElement, params: SweetAlertOptions) => Input} */
-  function (input, params) {
+  (input, params) => {
     checkAndSetInputValue(input, params.inputValue);
     setInputLabel(input, input, params);
     setInputPlaceholder(input, params);
@@ -1496,7 +1277,7 @@
    * @param {SweetAlertOptions} params
    * @returns {HTMLInputElement}
    */
-  renderInputType.file = function (input, params) {
+  renderInputType.file = (input, params) => {
     setInputLabel(input, input, params);
     setInputPlaceholder(input, params);
     return input;
@@ -1507,9 +1288,9 @@
    * @param {SweetAlertOptions} params
    * @returns {HTMLInputElement}
    */
-  renderInputType.range = function (range, params) {
-    var rangeInput = range.querySelector('input');
-    var rangeOutput = range.querySelector('output');
+  renderInputType.range = (range, params) => {
+    const rangeInput = range.querySelector('input');
+    const rangeOutput = range.querySelector('output');
     checkAndSetInputValue(rangeInput, params.inputValue);
     rangeInput.type = params.input;
     checkAndSetInputValue(rangeOutput, params.inputValue);
@@ -1522,10 +1303,10 @@
    * @param {SweetAlertOptions} params
    * @returns {HTMLSelectElement}
    */
-  renderInputType.select = function (select, params) {
+  renderInputType.select = (select, params) => {
     select.textContent = '';
     if (params.inputPlaceholder) {
-      var placeholder = document.createElement('option');
+      const placeholder = document.createElement('option');
       setInnerHtml(placeholder, params.inputPlaceholder);
       placeholder.value = '';
       placeholder.disabled = true;
@@ -1540,7 +1321,7 @@
    * @param {HTMLInputElement} radio
    * @returns {HTMLInputElement}
    */
-  renderInputType.radio = function (radio) {
+  renderInputType.radio = radio => {
     radio.textContent = '';
     return radio;
   };
@@ -1550,11 +1331,11 @@
    * @param {SweetAlertOptions} params
    * @returns {HTMLInputElement}
    */
-  renderInputType.checkbox = function (checkboxContainer, params) {
-    var checkbox = getInput$1(getPopup(), 'checkbox');
+  renderInputType.checkbox = (checkboxContainer, params) => {
+    const checkbox = getInput$1(getPopup(), 'checkbox');
     checkbox.value = '1';
     checkbox.checked = Boolean(params.inputValue);
-    var label = checkboxContainer.querySelector('span');
+    const label = checkboxContainer.querySelector('span');
     setInnerHtml(label, params.inputPlaceholder);
     return checkbox;
   };
@@ -1564,7 +1345,7 @@
    * @param {SweetAlertOptions} params
    * @returns {HTMLTextAreaElement}
    */
-  renderInputType.textarea = function (textarea, params) {
+  renderInputType.textarea = (textarea, params) => {
     checkAndSetInputValue(textarea, params.inputValue);
     setInputPlaceholder(textarea, params);
     setInputLabel(textarea, textarea, params);
@@ -1573,23 +1354,21 @@
      * @param {HTMLElement} el
      * @returns {number}
      */
-    var getMargin = function getMargin(el) {
-      return parseInt(window.getComputedStyle(el).marginLeft) + parseInt(window.getComputedStyle(el).marginRight);
-    };
+    const getMargin = el => parseInt(window.getComputedStyle(el).marginLeft) + parseInt(window.getComputedStyle(el).marginRight);
 
     // https://github.com/sweetalert2/sweetalert2/issues/2291
-    setTimeout(function () {
+    setTimeout(() => {
       // https://github.com/sweetalert2/sweetalert2/issues/1699
       if ('MutationObserver' in window) {
-        var initialPopupWidth = parseInt(window.getComputedStyle(getPopup()).width);
-        var textareaResizeHandler = function textareaResizeHandler() {
+        const initialPopupWidth = parseInt(window.getComputedStyle(getPopup()).width);
+        const textareaResizeHandler = () => {
           // check if texarea is still in document (i.e. popup wasn't closed in the meantime)
           if (!document.body.contains(textarea)) {
             return;
           }
-          var textareaWidth = textarea.offsetWidth + getMargin(textarea);
+          const textareaWidth = textarea.offsetWidth + getMargin(textarea);
           if (textareaWidth > initialPopupWidth) {
-            getPopup().style.width = "".concat(textareaWidth, "px");
+            getPopup().style.width = `${textareaWidth}px`;
           } else {
             applyNumericalStyle(getPopup(), 'width', params.width);
           }
@@ -1607,8 +1386,8 @@
    * @param {SweetAlert} instance
    * @param {SweetAlertOptions} params
    */
-  var renderContent = function renderContent(instance, params) {
-    var htmlContainer = getHtmlContainer();
+  const renderContent = (instance, params) => {
+    const htmlContainer = getHtmlContainer();
     if (!htmlContainer) {
       return;
     }
@@ -1638,8 +1417,8 @@
    * @param {SweetAlert} instance
    * @param {SweetAlertOptions} params
    */
-  var renderFooter = function renderFooter(instance, params) {
-    var footer = getFooter();
+  const renderFooter = (instance, params) => {
+    const footer = getFooter();
     if (!footer) {
       return;
     }
@@ -1657,9 +1436,9 @@
    * @param {SweetAlert} instance
    * @param {SweetAlertOptions} params
    */
-  var renderIcon = function renderIcon(instance, params) {
-    var innerParams = privateProps.innerParams.get(instance);
-    var icon = getIcon();
+  const renderIcon = (instance, params) => {
+    const innerParams = privateProps.innerParams.get(instance);
+    const icon = getIcon();
     if (!icon) {
       return;
     }
@@ -1676,7 +1455,7 @@
       return;
     }
     if (params.icon && Object.keys(iconTypes).indexOf(params.icon) === -1) {
-      error("Unknown icon! Expected \"success\", \"error\", \"warning\", \"info\" or \"question\", got \"".concat(params.icon, "\""));
+      error(`Unknown icon! Expected "success", "error", "warning", "info" or "question", got "${params.icon}"`);
       hide(icon);
       return;
     }
@@ -1694,11 +1473,8 @@
    * @param {HTMLElement} icon
    * @param {SweetAlertOptions} params
    */
-  var applyStyles = function applyStyles(icon, params) {
-    for (var _i = 0, _Object$entries = Object.entries(iconTypes); _i < _Object$entries.length; _i++) {
-      var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
-        iconType = _Object$entries$_i[0],
-        iconClassName = _Object$entries$_i[1];
+  const applyStyles = (icon, params) => {
+    for (const [iconType, iconClassName] of Object.entries(iconTypes)) {
       if (params.icon !== iconType) {
         removeClass(icon, iconClassName);
       }
@@ -1716,31 +1492,41 @@
   };
 
   // Adjust success icon background color to match the popup background color
-  var adjustSuccessIconBackgroundColor = function adjustSuccessIconBackgroundColor() {
-    var popup = getPopup();
+  const adjustSuccessIconBackgroundColor = () => {
+    const popup = getPopup();
     if (!popup) {
       return;
     }
-    var popupBackgroundColor = window.getComputedStyle(popup).getPropertyValue('background-color');
+    const popupBackgroundColor = window.getComputedStyle(popup).getPropertyValue('background-color');
     /** @type {NodeListOf<HTMLElement>} */
-    var successIconParts = popup.querySelectorAll('[class^=swal2-success-circular-line], .swal2-success-fix');
-    for (var i = 0; i < successIconParts.length; i++) {
+    const successIconParts = popup.querySelectorAll('[class^=swal2-success-circular-line], .swal2-success-fix');
+    for (let i = 0; i < successIconParts.length; i++) {
       successIconParts[i].style.backgroundColor = popupBackgroundColor;
     }
   };
-  var successIconHtml = "\n  <div class=\"swal2-success-circular-line-left\"></div>\n  <span class=\"swal2-success-line-tip\"></span> <span class=\"swal2-success-line-long\"></span>\n  <div class=\"swal2-success-ring\"></div> <div class=\"swal2-success-fix\"></div>\n  <div class=\"swal2-success-circular-line-right\"></div>\n";
-  var errorIconHtml = "\n  <span class=\"swal2-x-mark\">\n    <span class=\"swal2-x-mark-line-left\"></span>\n    <span class=\"swal2-x-mark-line-right\"></span>\n  </span>\n";
+  const successIconHtml = `
+  <div class="swal2-success-circular-line-left"></div>
+  <span class="swal2-success-line-tip"></span> <span class="swal2-success-line-long"></span>
+  <div class="swal2-success-ring"></div> <div class="swal2-success-fix"></div>
+  <div class="swal2-success-circular-line-right"></div>
+`;
+  const errorIconHtml = `
+  <span class="swal2-x-mark">
+    <span class="swal2-x-mark-line-left"></span>
+    <span class="swal2-x-mark-line-right"></span>
+  </span>
+`;
 
   /**
    * @param {HTMLElement} icon
    * @param {SweetAlertOptions} params
    */
-  var setContent = function setContent(icon, params) {
+  const setContent = (icon, params) => {
     if (!params.icon && !params.iconHtml) {
       return;
     }
-    var oldContent = icon.innerHTML;
-    var newContent = '';
+    let oldContent = icon.innerHTML;
+    let newContent = '';
     if (params.iconHtml) {
       newContent = iconContent(params.iconHtml);
     } else if (params.icon === 'success') {
@@ -1749,7 +1535,7 @@
     } else if (params.icon === 'error') {
       newContent = errorIconHtml;
     } else if (params.icon) {
-      var defaultIconHtml = {
+      const defaultIconHtml = {
         question: '?',
         warning: '!',
         info: 'i'
@@ -1765,14 +1551,13 @@
    * @param {HTMLElement} icon
    * @param {SweetAlertOptions} params
    */
-  var setColor = function setColor(icon, params) {
+  const setColor = (icon, params) => {
     if (!params.iconColor) {
       return;
     }
     icon.style.color = params.iconColor;
     icon.style.borderColor = params.iconColor;
-    for (var _i2 = 0, _arr = ['.swal2-success-line-tip', '.swal2-success-line-long', '.swal2-x-mark-line-left', '.swal2-x-mark-line-right']; _i2 < _arr.length; _i2++) {
-      var sel = _arr[_i2];
+    for (const sel of ['.swal2-success-line-tip', '.swal2-success-line-long', '.swal2-x-mark-line-left', '.swal2-x-mark-line-right']) {
       setStyle(icon, sel, 'background-color', params.iconColor);
     }
     setStyle(icon, '.swal2-success-ring', 'border-color', params.iconColor);
@@ -1782,16 +1567,14 @@
    * @param {string} content
    * @returns {string}
    */
-  var iconContent = function iconContent(content) {
-    return "<div class=\"".concat(swalClasses['icon-content'], "\">").concat(content, "</div>");
-  };
+  const iconContent = content => `<div class="${swalClasses['icon-content']}">${content}</div>`;
 
   /**
    * @param {SweetAlert} instance
    * @param {SweetAlertOptions} params
    */
-  var renderImage = function renderImage(instance, params) {
-    var image = getImage();
+  const renderImage = (instance, params) => {
+    const image = getImage();
     if (!image) {
       return;
     }
@@ -1818,9 +1601,9 @@
    * @param {SweetAlert} instance
    * @param {SweetAlertOptions} params
    */
-  var renderPopup = function renderPopup(instance, params) {
-    var container = getContainer();
-    var popup = getPopup();
+  const renderPopup = (instance, params) => {
+    const container = getContainer();
+    const popup = getPopup();
     if (!container || !popup) {
       return;
     }
@@ -1830,7 +1613,7 @@
     if (params.toast) {
       applyNumericalStyle(container, 'width', params.width);
       popup.style.width = '100%';
-      var loader = getLoader();
+      const loader = getLoader();
       if (loader) {
         popup.insertBefore(loader, getIcon());
       }
@@ -1860,10 +1643,10 @@
    * @param {HTMLElement} popup
    * @param {SweetAlertOptions} params
    */
-  var addClasses$1 = function addClasses(popup, params) {
-    var showClass = params.showClass || {};
+  const addClasses$1 = (popup, params) => {
+    const showClass = params.showClass || {};
     // Default Class + showClass when updating Swal.update({})
-    popup.className = "".concat(swalClasses.popup, " ").concat(isVisible$1(popup) ? showClass.popup : '');
+    popup.className = `${swalClasses.popup} ${isVisible$1(popup) ? showClass.popup : ''}`;
     if (params.toast) {
       addClass([document.documentElement, document.body], swalClasses['toast-shown']);
       addClass(popup, swalClasses.toast);
@@ -1880,7 +1663,7 @@
 
     // Icon class (#1842)
     if (params.icon) {
-      addClass(popup, swalClasses["icon-".concat(params.icon)]);
+      addClass(popup, swalClasses[`icon-${params.icon}`]);
     }
   };
 
@@ -1888,13 +1671,15 @@
    * @param {SweetAlert} instance
    * @param {SweetAlertOptions} params
    */
-  var renderProgressSteps = function renderProgressSteps(instance, params) {
-    var progressStepsContainer = getProgressSteps();
+  const renderProgressSteps = (instance, params) => {
+    const progressStepsContainer = getProgressSteps();
     if (!progressStepsContainer) {
       return;
     }
-    var progressSteps = params.progressSteps,
-      currentProgressStep = params.currentProgressStep;
+    const {
+      progressSteps,
+      currentProgressStep
+    } = params;
     if (!progressSteps || progressSteps.length === 0 || currentProgressStep === undefined) {
       hide(progressStepsContainer);
       return;
@@ -1904,14 +1689,14 @@
     if (currentProgressStep >= progressSteps.length) {
       warn('Invalid currentProgressStep parameter, it should be less than progressSteps.length ' + '(currentProgressStep like JS arrays starts from 0)');
     }
-    progressSteps.forEach(function (step, index) {
-      var stepEl = createStepElement(step);
+    progressSteps.forEach((step, index) => {
+      const stepEl = createStepElement(step);
       progressStepsContainer.appendChild(stepEl);
       if (index === currentProgressStep) {
         addClass(stepEl, swalClasses['active-progress-step']);
       }
       if (index !== progressSteps.length - 1) {
-        var lineEl = createLineElement(params);
+        const lineEl = createLineElement(params);
         progressStepsContainer.appendChild(lineEl);
       }
     });
@@ -1921,8 +1706,8 @@
    * @param {string} step
    * @returns {HTMLLIElement}
    */
-  var createStepElement = function createStepElement(step) {
-    var stepEl = document.createElement('li');
+  const createStepElement = step => {
+    const stepEl = document.createElement('li');
     addClass(stepEl, swalClasses['progress-step']);
     setInnerHtml(stepEl, step);
     return stepEl;
@@ -1932,8 +1717,8 @@
    * @param {SweetAlertOptions} params
    * @returns {HTMLLIElement}
    */
-  var createLineElement = function createLineElement(params) {
-    var lineEl = document.createElement('li');
+  const createLineElement = params => {
+    const lineEl = document.createElement('li');
     addClass(lineEl, swalClasses['progress-step-line']);
     if (params.progressStepsDistance) {
       applyNumericalStyle(lineEl, 'width', params.progressStepsDistance);
@@ -1945,8 +1730,8 @@
    * @param {SweetAlert} instance
    * @param {SweetAlertOptions} params
    */
-  var renderTitle = function renderTitle(instance, params) {
-    var title = getTitle();
+  const renderTitle = (instance, params) => {
+    const title = getTitle();
     if (!title) {
       return;
     }
@@ -1967,7 +1752,7 @@
    * @param {SweetAlert} instance
    * @param {SweetAlertOptions} params
    */
-  var render = function render(instance, params) {
+  const render = (instance, params) => {
     renderPopup(instance, params);
     renderContainer(instance, params);
     renderProgressSteps(instance, params);
@@ -1978,7 +1763,7 @@
     renderContent(instance, params);
     renderActions(instance, params);
     renderFooter(instance, params);
-    var popup = getPopup();
+    const popup = getPopup();
     if (typeof params.didRender === 'function' && popup) {
       params.didRender(popup);
     }
@@ -1987,14 +1772,14 @@
   /*
    * Global function to determine if SweetAlert2 popup is shown
    */
-  var isVisible = function isVisible() {
+  const isVisible = () => {
     return isVisible$1(getPopup());
   };
 
   /*
    * Global function to click 'Confirm' button
    */
-  var clickConfirm = function clickConfirm() {
+  const clickConfirm = () => {
     var _dom$getConfirmButton;
     return (_dom$getConfirmButton = getConfirmButton()) === null || _dom$getConfirmButton === void 0 ? void 0 : _dom$getConfirmButton.click();
   };
@@ -2002,7 +1787,7 @@
   /*
    * Global function to click 'Deny' button
    */
-  var clickDeny = function clickDeny() {
+  const clickDeny = () => {
     var _dom$getDenyButton;
     return (_dom$getDenyButton = getDenyButton()) === null || _dom$getDenyButton === void 0 ? void 0 : _dom$getDenyButton.click();
   };
@@ -2010,7 +1795,7 @@
   /*
    * Global function to click 'Cancel' button
    */
-  var clickCancel = function clickCancel() {
+  const clickCancel = () => {
     var _dom$getCancelButton;
     return (_dom$getCancelButton = getCancelButton()) === null || _dom$getCancelButton === void 0 ? void 0 : _dom$getCancelButton.click();
   };
@@ -2018,7 +1803,7 @@
   /** @typedef {'cancel' | 'backdrop' | 'close' | 'esc' | 'timer'} DismissReason */
 
   /** @type {Record<DismissReason, DismissReason>} */
-  var DismissReason = Object.freeze({
+  const DismissReason = Object.freeze({
     cancel: 'cancel',
     backdrop: 'backdrop',
     close: 'close',
@@ -2029,7 +1814,7 @@
   /**
    * @param {GlobalState} globalState
    */
-  var removeKeydownHandler = function removeKeydownHandler(globalState) {
+  const removeKeydownHandler = globalState => {
     if (globalState.keydownTarget && globalState.keydownHandlerAdded) {
       globalState.keydownTarget.removeEventListener('keydown', globalState.keydownHandler, {
         capture: globalState.keydownListenerCapture
@@ -2043,12 +1828,10 @@
    * @param {SweetAlertOptions} innerParams
    * @param {*} dismissWith
    */
-  var addKeydownHandler = function addKeydownHandler(globalState, innerParams, dismissWith) {
+  const addKeydownHandler = (globalState, innerParams, dismissWith) => {
     removeKeydownHandler(globalState);
     if (!innerParams.toast) {
-      globalState.keydownHandler = function (e) {
-        return keydownHandler(innerParams, e, dismissWith);
-      };
+      globalState.keydownHandler = e => keydownHandler(innerParams, e, dismissWith);
       globalState.keydownTarget = innerParams.keydownListenerCapture ? window : getPopup();
       globalState.keydownListenerCapture = innerParams.keydownListenerCapture;
       globalState.keydownTarget.addEventListener('keydown', globalState.keydownHandler, {
@@ -2062,9 +1845,9 @@
    * @param {number} index
    * @param {number} increment
    */
-  var setFocus = function setFocus(index, increment) {
+  const setFocus = (index, increment) => {
     var _dom$getPopup;
-    var focusableElements = getFocusableElements();
+    const focusableElements = getFocusableElements();
     // search for visible elements and select the next possible match
     if (focusableElements.length) {
       index = index + increment;
@@ -2083,15 +1866,15 @@
     // no visible focusable elements, focus the popup
     (_dom$getPopup = getPopup()) === null || _dom$getPopup === void 0 || _dom$getPopup.focus();
   };
-  var arrowKeysNextButton = ['ArrowRight', 'ArrowDown'];
-  var arrowKeysPreviousButton = ['ArrowLeft', 'ArrowUp'];
+  const arrowKeysNextButton = ['ArrowRight', 'ArrowDown'];
+  const arrowKeysPreviousButton = ['ArrowLeft', 'ArrowUp'];
 
   /**
    * @param {SweetAlertOptions} innerParams
    * @param {KeyboardEvent} event
    * @param {Function} dismissWith
    */
-  var keydownHandler = function keydownHandler(innerParams, event, dismissWith) {
+  const keydownHandler = (innerParams, event, dismissWith) => {
     if (!innerParams) {
       return; // This instance has already been destroyed
     }
@@ -2118,7 +1901,7 @@
     }
 
     // ARROWS - switch focus between buttons
-    else if ([].concat(arrowKeysNextButton, arrowKeysPreviousButton).includes(event.key)) {
+    else if ([...arrowKeysNextButton, ...arrowKeysPreviousButton].includes(event.key)) {
       handleArrows(event.key);
     }
 
@@ -2132,12 +1915,12 @@
    * @param {KeyboardEvent} event
    * @param {SweetAlertOptions} innerParams
    */
-  var handleEnter = function handleEnter(event, innerParams) {
+  const handleEnter = (event, innerParams) => {
     // https://github.com/sweetalert2/sweetalert2/issues/2386
     if (!callIfFunction(innerParams.allowEnterKey)) {
       return;
     }
-    var input = getInput$1(getPopup(), innerParams.input);
+    const input = getInput$1(getPopup(), innerParams.input);
     if (event.target && input && event.target instanceof HTMLElement && event.target.outerHTML === input.outerHTML) {
       if (['textarea', 'file'].includes(innerParams.input)) {
         return; // do not submit
@@ -2150,11 +1933,11 @@
   /**
    * @param {KeyboardEvent} event
    */
-  var handleTab = function handleTab(event) {
-    var targetElement = event.target;
-    var focusableElements = getFocusableElements();
-    var btnIndex = -1;
-    for (var i = 0; i < focusableElements.length; i++) {
+  const handleTab = event => {
+    const targetElement = event.target;
+    const focusableElements = getFocusableElements();
+    let btnIndex = -1;
+    for (let i = 0; i < focusableElements.length; i++) {
       if (targetElement === focusableElements[i]) {
         btnIndex = i;
         break;
@@ -2177,25 +1960,25 @@
   /**
    * @param {string} key
    */
-  var handleArrows = function handleArrows(key) {
-    var actions = getActions();
-    var confirmButton = getConfirmButton();
-    var denyButton = getDenyButton();
-    var cancelButton = getCancelButton();
+  const handleArrows = key => {
+    const actions = getActions();
+    const confirmButton = getConfirmButton();
+    const denyButton = getDenyButton();
+    const cancelButton = getCancelButton();
     if (!actions || !confirmButton || !denyButton || !cancelButton) {
       return;
     }
     /** @type HTMLElement[] */
-    var buttons = [confirmButton, denyButton, cancelButton];
+    const buttons = [confirmButton, denyButton, cancelButton];
     if (document.activeElement instanceof HTMLElement && !buttons.includes(document.activeElement)) {
       return;
     }
-    var sibling = arrowKeysNextButton.includes(key) ? 'nextElementSibling' : 'previousElementSibling';
-    var buttonToFocus = document.activeElement;
+    const sibling = arrowKeysNextButton.includes(key) ? 'nextElementSibling' : 'previousElementSibling';
+    let buttonToFocus = document.activeElement;
     if (!buttonToFocus) {
       return;
     }
-    for (var i = 0; i < actions.children.length; i++) {
+    for (let i = 0; i < actions.children.length; i++) {
       buttonToFocus = buttonToFocus[sibling];
       if (!buttonToFocus) {
         return;
@@ -2214,7 +1997,7 @@
    * @param {SweetAlertOptions} innerParams
    * @param {Function} dismissWith
    */
-  var handleEsc = function handleEsc(event, innerParams, dismissWith) {
+  const handleEsc = (event, innerParams, dismissWith) => {
     if (callIfFunction(innerParams.allowEscapeKey)) {
       event.preventDefault();
       dismissWith(DismissReason.esc);
@@ -2241,10 +2024,10 @@
   // elements not within the active modal dialog will not be surfaced if a user opens a screen
   // reader’s list of elements (headings, form controls, landmarks, etc.) in the document.
 
-  var setAriaHidden = function setAriaHidden() {
-    var container = getContainer();
-    var bodyChildren = Array.from(document.body.children);
-    bodyChildren.forEach(function (el) {
+  const setAriaHidden = () => {
+    const container = getContainer();
+    const bodyChildren = Array.from(document.body.children);
+    bodyChildren.forEach(el => {
       if (el.contains(container)) {
         return;
       }
@@ -2254,9 +2037,9 @@
       el.setAttribute('aria-hidden', 'true');
     });
   };
-  var unsetAriaHidden = function unsetAriaHidden() {
-    var bodyChildren = Array.from(document.body.children);
-    bodyChildren.forEach(function (el) {
+  const unsetAriaHidden = () => {
+    const bodyChildren = Array.from(document.body.children);
+    bodyChildren.forEach(el => {
       if (el.hasAttribute('data-previous-aria-hidden')) {
         el.setAttribute('aria-hidden', el.getAttribute('data-previous-aria-hidden') || '');
         el.removeAttribute('data-previous-aria-hidden');
@@ -2267,16 +2050,16 @@
   };
 
   // @ts-ignore
-  var isSafariOrIOS = typeof window !== 'undefined' && !!window.GestureEvent; // true for Safari desktop + all iOS browsers https://stackoverflow.com/a/70585394
+  const isSafariOrIOS = typeof window !== 'undefined' && !!window.GestureEvent; // true for Safari desktop + all iOS browsers https://stackoverflow.com/a/70585394
 
   /**
    * Fix iOS scrolling
    * http://stackoverflow.com/q/39626302
    */
-  var iOSfix = function iOSfix() {
+  const iOSfix = () => {
     if (isSafariOrIOS && !hasClass(document.body, swalClasses.iosfix)) {
-      var offset = document.body.scrollTop;
-      document.body.style.top = "".concat(offset * -1, "px");
+      const offset = document.body.scrollTop;
+      document.body.style.top = `${offset * -1}px`;
       addClass(document.body, swalClasses.iosfix);
       lockBodyScroll();
     }
@@ -2285,23 +2068,23 @@
   /**
    * https://github.com/sweetalert2/sweetalert2/issues/1246
    */
-  var lockBodyScroll = function lockBodyScroll() {
-    var container = getContainer();
+  const lockBodyScroll = () => {
+    const container = getContainer();
     if (!container) {
       return;
     }
     /** @type {boolean} */
-    var preventTouchMove;
+    let preventTouchMove;
     /**
      * @param {TouchEvent} event
      */
-    container.ontouchstart = function (event) {
+    container.ontouchstart = event => {
       preventTouchMove = shouldPreventTouchMove(event);
     };
     /**
      * @param {TouchEvent} event
      */
-    container.ontouchmove = function (event) {
+    container.ontouchmove = event => {
       if (preventTouchMove) {
         event.preventDefault();
         event.stopPropagation();
@@ -2313,10 +2096,10 @@
    * @param {TouchEvent} event
    * @returns {boolean}
    */
-  var shouldPreventTouchMove = function shouldPreventTouchMove(event) {
-    var target = event.target;
-    var container = getContainer();
-    var htmlContainer = getHtmlContainer();
+  const shouldPreventTouchMove = event => {
+    const target = event.target;
+    const container = getContainer();
+    const htmlContainer = getHtmlContainer();
     if (!container || !htmlContainer) {
       return false;
     }
@@ -2344,7 +2127,7 @@
    * @param {*} event
    * @returns {boolean}
    */
-  var isStylus = function isStylus(event) {
+  const isStylus = event => {
     return event.touches && event.touches.length && event.touches[0].touchType === 'stylus';
   };
 
@@ -2354,12 +2137,12 @@
    * @param {TouchEvent} event
    * @returns {boolean}
    */
-  var isZoom = function isZoom(event) {
+  const isZoom = event => {
     return event.touches && event.touches.length > 1;
   };
-  var undoIOSfix = function undoIOSfix() {
+  const undoIOSfix = () => {
     if (hasClass(document.body, swalClasses.iosfix)) {
-      var offset = parseInt(document.body.style.top, 10);
+      const offset = parseInt(document.body.style.top, 10);
       removeClass(document.body, swalClasses.iosfix);
       document.body.style.top = '';
       document.body.scrollTop = offset * -1;
@@ -2372,11 +2155,11 @@
    *
    * @returns {number}
    */
-  var measureScrollbar = function measureScrollbar() {
-    var scrollDiv = document.createElement('div');
+  const measureScrollbar = () => {
+    const scrollDiv = document.createElement('div');
     scrollDiv.className = swalClasses['scrollbar-measure'];
     document.body.appendChild(scrollDiv);
-    var scrollbarWidth = scrollDiv.getBoundingClientRect().width - scrollDiv.clientWidth;
+    const scrollbarWidth = scrollDiv.getBoundingClientRect().width - scrollDiv.clientWidth;
     document.body.removeChild(scrollDiv);
     return scrollbarWidth;
   };
@@ -2385,12 +2168,12 @@
    * Remember state in cases where opening and handling a modal will fiddle with it.
    * @type {number | null}
    */
-  var previousBodyPadding = null;
+  let previousBodyPadding = null;
 
   /**
    * @param {string} initialBodyOverflow
    */
-  var replaceScrollbarWithPadding = function replaceScrollbarWithPadding(initialBodyOverflow) {
+  const replaceScrollbarWithPadding = initialBodyOverflow => {
     // for queues, do not do this more than once
     if (previousBodyPadding !== null) {
       return;
@@ -2400,12 +2183,12 @@
     ) {
       // add padding so the content doesn't shift after removal of scrollbar
       previousBodyPadding = parseInt(window.getComputedStyle(document.body).getPropertyValue('padding-right'));
-      document.body.style.paddingRight = "".concat(previousBodyPadding + measureScrollbar(), "px");
+      document.body.style.paddingRight = `${previousBodyPadding + measureScrollbar()}px`;
     }
   };
-  var undoReplaceScrollbarWithPadding = function undoReplaceScrollbarWithPadding() {
+  const undoReplaceScrollbarWithPadding = () => {
     if (previousBodyPadding !== null) {
-      document.body.style.paddingRight = "".concat(previousBodyPadding, "px");
+      document.body.style.paddingRight = `${previousBodyPadding}px`;
       previousBodyPadding = null;
     }
   };
@@ -2420,9 +2203,7 @@
     if (isToast()) {
       triggerDidCloseAndDispose(instance, didClose);
     } else {
-      restoreActiveElement(returnFocus).then(function () {
-        return triggerDidCloseAndDispose(instance, didClose);
-      });
+      restoreActiveElement(returnFocus).then(() => triggerDidCloseAndDispose(instance, didClose));
       removeKeydownHandler(globalState);
     }
 
@@ -2457,8 +2238,8 @@
    */
   function close(resolveValue) {
     resolveValue = prepareResolveValue(resolveValue);
-    var swalPromiseResolve = privateMethods.swalPromiseResolve.get(this);
-    var didClose = triggerClosePopup(this);
+    const swalPromiseResolve = privateMethods.swalPromiseResolve.get(this);
+    const didClose = triggerClosePopup(this);
     if (this.isAwaitingPromise) {
       // A swal awaiting for a promise (after a click on Confirm or Deny) cannot be dismissed anymore #2335
       if (!resolveValue.isDismissed) {
@@ -2470,18 +2251,18 @@
       swalPromiseResolve(resolveValue);
     }
   }
-  var triggerClosePopup = function triggerClosePopup(instance) {
-    var popup = getPopup();
+  const triggerClosePopup = instance => {
+    const popup = getPopup();
     if (!popup) {
       return false;
     }
-    var innerParams = privateProps.innerParams.get(instance);
+    const innerParams = privateProps.innerParams.get(instance);
     if (!innerParams || hasClass(popup, innerParams.hideClass.popup)) {
       return false;
     }
     removeClass(popup, innerParams.showClass.popup);
     addClass(popup, innerParams.hideClass.popup);
-    var backdrop = getContainer();
+    const backdrop = getContainer();
     removeClass(backdrop, innerParams.showClass.backdrop);
     addClass(backdrop, innerParams.hideClass.backdrop);
     handlePopupAnimation(instance, popup, innerParams);
@@ -2492,7 +2273,7 @@
    * @param {any} error
    */
   function rejectPromise(error) {
-    var rejectPromise = privateMethods.swalPromiseReject.get(this);
+    const rejectPromise = privateMethods.swalPromiseReject.get(this);
     handleAwaitingPromise(this);
     if (rejectPromise) {
       // Reject Swal promise
@@ -2503,7 +2284,7 @@
   /**
    * @param {SweetAlert} instance
    */
-  var handleAwaitingPromise = function handleAwaitingPromise(instance) {
+  const handleAwaitingPromise = instance => {
     if (instance.isAwaitingPromise) {
       delete instance.isAwaitingPromise;
       // The instance might have been previously partly destroyed, we must resume the destroy process in this case #2335
@@ -2517,7 +2298,7 @@
    * @param {any} resolveValue
    * @returns {SweetAlertResult}
    */
-  var prepareResolveValue = function prepareResolveValue(resolveValue) {
+  const prepareResolveValue = resolveValue => {
     // When user calls Swal.close()
     if (typeof resolveValue === 'undefined') {
       return {
@@ -2538,10 +2319,10 @@
    * @param {HTMLElement} popup
    * @param {SweetAlertOptions} innerParams
    */
-  var handlePopupAnimation = function handlePopupAnimation(instance, popup, innerParams) {
-    var container = getContainer();
+  const handlePopupAnimation = (instance, popup, innerParams) => {
+    const container = getContainer();
     // If animation is supported, animate
-    var animationIsSupported = animationEndEvent && hasCssAnimation(popup);
+    const animationIsSupported = animationEndEvent && hasCssAnimation(popup);
     if (typeof innerParams.willClose === 'function') {
       innerParams.willClose(popup);
     }
@@ -2560,7 +2341,7 @@
    * @param {boolean} returnFocus
    * @param {Function} didClose
    */
-  var animatePopup = function animatePopup(instance, popup, container, returnFocus, didClose) {
+  const animatePopup = (instance, popup, container, returnFocus, didClose) => {
     if (!animationEndEvent) {
       return;
     }
@@ -2577,8 +2358,8 @@
    * @param {SweetAlert} instance
    * @param {Function} didClose
    */
-  var triggerDidCloseAndDispose = function triggerDidCloseAndDispose(instance, didClose) {
-    setTimeout(function () {
+  const triggerDidCloseAndDispose = (instance, didClose) => {
+    setTimeout(() => {
       if (typeof didClose === 'function') {
         didClose.bind(instance.params)();
       }
@@ -2595,8 +2376,8 @@
    *
    * @param {HTMLButtonElement | null} [buttonToReplace]
    */
-  var showLoading = function showLoading(buttonToReplace) {
-    var popup = getPopup();
+  const showLoading = buttonToReplace => {
+    let popup = getPopup();
     if (!popup) {
       new Swal();
     }
@@ -2604,7 +2385,7 @@
     if (!popup) {
       return;
     }
-    var loader = getLoader();
+    const loader = getLoader();
     if (isToast()) {
       hide(getIcon());
     } else {
@@ -2620,9 +2401,9 @@
    * @param {HTMLElement} popup
    * @param {HTMLButtonElement | null} [buttonToReplace]
    */
-  var replaceButton = function replaceButton(popup, buttonToReplace) {
-    var actions = getActions();
-    var loader = getLoader();
+  const replaceButton = (popup, buttonToReplace) => {
+    const actions = getActions();
+    const loader = getLoader();
     if (!actions || !loader) {
       return;
     }
@@ -2642,12 +2423,10 @@
    * @param {SweetAlert} instance
    * @param {SweetAlertOptions} params
    */
-  var handleInputOptionsAndValue = function handleInputOptionsAndValue(instance, params) {
+  const handleInputOptionsAndValue = (instance, params) => {
     if (params.input === 'select' || params.input === 'radio') {
       handleInputOptions(instance, params);
-    } else if (['text', 'email', 'number', 'tel', 'textarea'].some(function (i) {
-      return i === params.input;
-    }) && (hasToPromiseFn(params.inputValue) || isPromise(params.inputValue))) {
+    } else if (['text', 'email', 'number', 'tel', 'textarea'].some(i => i === params.input) && (hasToPromiseFn(params.inputValue) || isPromise(params.inputValue))) {
       showLoading(getConfirmButton());
       handleInputValue(instance, params);
     }
@@ -2658,8 +2437,8 @@
    * @param {SweetAlertOptions} innerParams
    * @returns {SweetAlertInputValue}
    */
-  var getInputValue = function getInputValue(instance, innerParams) {
-    var input = instance.getInput();
+  const getInputValue = (instance, innerParams) => {
+    const input = instance.getInput();
     if (!input) {
       return null;
     }
@@ -2679,55 +2458,49 @@
    * @param {HTMLInputElement} input
    * @returns {number}
    */
-  var getCheckboxValue = function getCheckboxValue(input) {
-    return input.checked ? 1 : 0;
-  };
+  const getCheckboxValue = input => input.checked ? 1 : 0;
 
   /**
    * @param {HTMLInputElement} input
    * @returns {string | null}
    */
-  var getRadioValue = function getRadioValue(input) {
-    return input.checked ? input.value : null;
-  };
+  const getRadioValue = input => input.checked ? input.value : null;
 
   /**
    * @param {HTMLInputElement} input
    * @returns {FileList | File | null}
    */
-  var getFileValue = function getFileValue(input) {
-    return input.files && input.files.length ? input.getAttribute('multiple') !== null ? input.files : input.files[0] : null;
-  };
+  const getFileValue = input => input.files && input.files.length ? input.getAttribute('multiple') !== null ? input.files : input.files[0] : null;
 
   /**
    * @param {SweetAlert} instance
    * @param {SweetAlertOptions} params
    */
-  var handleInputOptions = function handleInputOptions(instance, params) {
-    var popup = getPopup();
+  const handleInputOptions = (instance, params) => {
+    const popup = getPopup();
     if (!popup) {
       return;
     }
     /**
      * @param {Record<string, any>} inputOptions
      */
-    var processInputOptions = function processInputOptions(inputOptions) {
+    const processInputOptions = inputOptions => {
       if (params.input === 'select') {
-        populateSelectOptions(popup, _formatInputOptions(inputOptions), params);
+        populateSelectOptions(popup, formatInputOptions(inputOptions), params);
       } else if (params.input === 'radio') {
-        populateRadioOptions(popup, _formatInputOptions(inputOptions), params);
+        populateRadioOptions(popup, formatInputOptions(inputOptions), params);
       }
     };
     if (hasToPromiseFn(params.inputOptions) || isPromise(params.inputOptions)) {
       showLoading(getConfirmButton());
-      asPromise(params.inputOptions).then(function (inputOptions) {
+      asPromise(params.inputOptions).then(inputOptions => {
         instance.hideLoading();
         processInputOptions(inputOptions);
       });
-    } else if (_typeof(params.inputOptions) === 'object') {
+    } else if (typeof params.inputOptions === 'object') {
       processInputOptions(params.inputOptions);
     } else {
-      error("Unexpected type of inputOptions! Expected object, Map or Promise, got ".concat(_typeof(params.inputOptions)));
+      error(`Unexpected type of inputOptions! Expected object, Map or Promise, got ${typeof params.inputOptions}`);
     }
   };
 
@@ -2735,19 +2508,19 @@
    * @param {SweetAlert} instance
    * @param {SweetAlertOptions} params
    */
-  var handleInputValue = function handleInputValue(instance, params) {
-    var input = instance.getInput();
+  const handleInputValue = (instance, params) => {
+    const input = instance.getInput();
     if (!input) {
       return;
     }
     hide(input);
-    asPromise(params.inputValue).then(function (inputValue) {
-      input.value = params.input === 'number' ? "".concat(parseFloat(inputValue) || 0) : "".concat(inputValue);
+    asPromise(params.inputValue).then(inputValue => {
+      input.value = params.input === 'number' ? `${parseFloat(inputValue) || 0}` : `${inputValue}`;
       show(input);
       input.focus();
       instance.hideLoading();
-    })["catch"](function (err) {
-      error("Error in inputValue promise: ".concat(err));
+    }).catch(err => {
+      error(`Error in inputValue promise: ${err}`);
       input.value = '';
       show(input);
       input.focus();
@@ -2761,7 +2534,7 @@
    * @param {SweetAlertOptions} params
    */
   function populateSelectOptions(popup, inputOptions, params) {
-    var select = getDirectChildByClass(popup, swalClasses.select);
+    const select = getDirectChildByClass(popup, swalClasses.select);
     if (!select) {
       return;
     }
@@ -2770,29 +2543,27 @@
      * @param {string} optionLabel
      * @param {string} optionValue
      */
-    var renderOption = function renderOption(parent, optionLabel, optionValue) {
-      var option = document.createElement('option');
+    const renderOption = (parent, optionLabel, optionValue) => {
+      const option = document.createElement('option');
       option.value = optionValue;
       setInnerHtml(option, optionLabel);
       option.selected = isSelected(optionValue, params.inputValue);
       parent.appendChild(option);
     };
-    inputOptions.forEach(function (inputOption) {
-      var optionValue = inputOption[0];
-      var optionLabel = inputOption[1];
+    inputOptions.forEach(inputOption => {
+      const optionValue = inputOption[0];
+      const optionLabel = inputOption[1];
       // <optgroup> spec:
       // https://www.w3.org/TR/html401/interact/forms.html#h-17.6
       // "...all OPTGROUP elements must be specified directly within a SELECT element (i.e., groups may not be nested)..."
       // check whether this is a <optgroup>
       if (Array.isArray(optionLabel)) {
         // if it is an array, then it is an <optgroup>
-        var optgroup = document.createElement('optgroup');
+        const optgroup = document.createElement('optgroup');
         optgroup.label = optionValue;
         optgroup.disabled = false; // not configurable for now
         select.appendChild(optgroup);
-        optionLabel.forEach(function (o) {
-          return renderOption(optgroup, o[1], o[0]);
-        });
+        optionLabel.forEach(o => renderOption(optgroup, o[1], o[0]));
       } else {
         // case of <option>
         renderOption(select, optionLabel, optionValue);
@@ -2807,29 +2578,29 @@
    * @param {SweetAlertOptions} params
    */
   function populateRadioOptions(popup, inputOptions, params) {
-    var radio = getDirectChildByClass(popup, swalClasses.radio);
+    const radio = getDirectChildByClass(popup, swalClasses.radio);
     if (!radio) {
       return;
     }
-    inputOptions.forEach(function (inputOption) {
-      var radioValue = inputOption[0];
-      var radioLabel = inputOption[1];
-      var radioInput = document.createElement('input');
-      var radioLabelElement = document.createElement('label');
+    inputOptions.forEach(inputOption => {
+      const radioValue = inputOption[0];
+      const radioLabel = inputOption[1];
+      const radioInput = document.createElement('input');
+      const radioLabelElement = document.createElement('label');
       radioInput.type = 'radio';
       radioInput.name = swalClasses.radio;
       radioInput.value = radioValue;
       if (isSelected(radioValue, params.inputValue)) {
         radioInput.checked = true;
       }
-      var label = document.createElement('span');
+      const label = document.createElement('span');
       setInnerHtml(label, radioLabel);
       label.className = swalClasses.label;
       radioLabelElement.appendChild(radioInput);
       radioLabelElement.appendChild(label);
       radio.appendChild(radioLabelElement);
     });
-    var radios = radio.querySelectorAll('input');
+    const radios = radio.querySelectorAll('input');
     if (radios.length) {
       radios[0].focus();
     }
@@ -2842,24 +2613,24 @@
    * @typedef {string[]} InputOptionFlattened
    * @returns {InputOptionFlattened[]}
    */
-  var _formatInputOptions = function formatInputOptions(inputOptions) {
+  const formatInputOptions = inputOptions => {
     /** @type {InputOptionFlattened[]} */
-    var result = [];
+    const result = [];
     if (inputOptions instanceof Map) {
-      inputOptions.forEach(function (value, key) {
-        var valueFormatted = value;
-        if (_typeof(valueFormatted) === 'object') {
+      inputOptions.forEach((value, key) => {
+        let valueFormatted = value;
+        if (typeof valueFormatted === 'object') {
           // case of <optgroup>
-          valueFormatted = _formatInputOptions(valueFormatted);
+          valueFormatted = formatInputOptions(valueFormatted);
         }
         result.push([key, valueFormatted]);
       });
     } else {
-      Object.keys(inputOptions).forEach(function (key) {
-        var valueFormatted = inputOptions[key];
-        if (_typeof(valueFormatted) === 'object') {
+      Object.keys(inputOptions).forEach(key => {
+        let valueFormatted = inputOptions[key];
+        if (typeof valueFormatted === 'object') {
           // case of <optgroup>
-          valueFormatted = _formatInputOptions(valueFormatted);
+          valueFormatted = formatInputOptions(valueFormatted);
         }
         result.push([key, valueFormatted]);
       });
@@ -2872,17 +2643,15 @@
    * @param {SweetAlertInputValue} inputValue
    * @returns {boolean}
    */
-  var isSelected = function isSelected(optionValue, inputValue) {
+  const isSelected = (optionValue, inputValue) => {
     return !!inputValue && inputValue.toString() === optionValue.toString();
   };
 
-  var _this = undefined;
-
   /**
    * @param {SweetAlert} instance
    */
-  var handleConfirmButtonClick = function handleConfirmButtonClick(instance) {
-    var innerParams = privateProps.innerParams.get(instance);
+  const handleConfirmButtonClick = instance => {
+    const innerParams = privateProps.innerParams.get(instance);
     instance.disableButtons();
     if (innerParams.input) {
       handleConfirmOrDenyWithInput(instance, 'confirm');
@@ -2894,8 +2663,8 @@
   /**
    * @param {SweetAlert} instance
    */
-  var handleDenyButtonClick = function handleDenyButtonClick(instance) {
-    var innerParams = privateProps.innerParams.get(instance);
+  const handleDenyButtonClick = instance => {
+    const innerParams = privateProps.innerParams.get(instance);
     instance.disableButtons();
     if (innerParams.returnInputValueOnDeny) {
       handleConfirmOrDenyWithInput(instance, 'deny');
@@ -2908,7 +2677,7 @@
    * @param {SweetAlert} instance
    * @param {Function} dismissWith
    */
-  var handleCancelButtonClick = function handleCancelButtonClick(instance, dismissWith) {
+  const handleCancelButtonClick = (instance, dismissWith) => {
     instance.disableButtons();
     dismissWith(DismissReason.cancel);
   };
@@ -2917,14 +2686,14 @@
    * @param {SweetAlert} instance
    * @param {'confirm' | 'deny'} type
    */
-  var handleConfirmOrDenyWithInput = function handleConfirmOrDenyWithInput(instance, type) {
-    var innerParams = privateProps.innerParams.get(instance);
+  const handleConfirmOrDenyWithInput = (instance, type) => {
+    const innerParams = privateProps.innerParams.get(instance);
     if (!innerParams.input) {
-      error("The \"input\" parameter is needed to be set when using returnInputValueOn".concat(capitalizeFirstLetter(type)));
+      error(`The "input" parameter is needed to be set when using returnInputValueOn${capitalizeFirstLetter(type)}`);
       return;
     }
-    var input = instance.getInput();
-    var inputValue = getInputValue(instance, innerParams);
+    const input = instance.getInput();
+    const inputValue = getInputValue(instance, innerParams);
     if (innerParams.inputValidator) {
       handleInputValidator(instance, inputValue, type);
     } else if (input && !input.checkValidity()) {
@@ -2942,13 +2711,11 @@
    * @param {SweetAlertInputValue} inputValue
    * @param {'confirm' | 'deny'} type
    */
-  var handleInputValidator = function handleInputValidator(instance, inputValue, type) {
-    var innerParams = privateProps.innerParams.get(instance);
+  const handleInputValidator = (instance, inputValue, type) => {
+    const innerParams = privateProps.innerParams.get(instance);
     instance.disableInput();
-    var validationPromise = Promise.resolve().then(function () {
-      return asPromise(innerParams.inputValidator(inputValue, innerParams.validationMessage));
-    });
-    validationPromise.then(function (validationMessage) {
+    const validationPromise = Promise.resolve().then(() => asPromise(innerParams.inputValidator(inputValue, innerParams.validationMessage)));
+    validationPromise.then(validationMessage => {
       instance.enableButtons();
       instance.enableInput();
       if (validationMessage) {
@@ -2965,17 +2732,15 @@
    * @param {SweetAlert} instance
    * @param {any} value
    */
-  var deny = function deny(instance, value) {
-    var innerParams = privateProps.innerParams.get(instance || _this);
+  const deny = (instance, value) => {
+    const innerParams = privateProps.innerParams.get(instance || undefined);
     if (innerParams.showLoaderOnDeny) {
       showLoading(getDenyButton());
     }
     if (innerParams.preDeny) {
       instance.isAwaitingPromise = true; // Flagging the instance as awaiting a promise so it's own promise's reject/resolve methods doesn't get destroyed until the result from this preDeny's promise is received
-      var preDenyPromise = Promise.resolve().then(function () {
-        return asPromise(innerParams.preDeny(value, innerParams.validationMessage));
-      });
-      preDenyPromise.then(function (preDenyValue) {
+      const preDenyPromise = Promise.resolve().then(() => asPromise(innerParams.preDeny(value, innerParams.validationMessage)));
+      preDenyPromise.then(preDenyValue => {
         if (preDenyValue === false) {
           instance.hideLoading();
           handleAwaitingPromise(instance);
@@ -2985,13 +2750,11 @@
             value: typeof preDenyValue === 'undefined' ? value : preDenyValue
           });
         }
-      })["catch"](function (error) {
-        return rejectWith(instance || _this, error);
-      });
+      }).catch(error => rejectWith(instance || undefined, error));
     } else {
       instance.close({
         isDenied: true,
-        value: value
+        value
       });
     }
   };
@@ -3000,10 +2763,10 @@
    * @param {SweetAlert} instance
    * @param {any} value
    */
-  var succeedWith = function succeedWith(instance, value) {
+  const succeedWith = (instance, value) => {
     instance.close({
       isConfirmed: true,
-      value: value
+      value
     });
   };
 
@@ -3012,7 +2775,7 @@
    * @param {SweetAlert} instance
    * @param {string} error
    */
-  var rejectWith = function rejectWith(instance, error) {
+  const rejectWith = (instance, error) => {
     instance.rejectPromise(error);
   };
 
@@ -3021,27 +2784,23 @@
    * @param {SweetAlert} instance
    * @param {any} value
    */
-  var confirm = function confirm(instance, value) {
-    var innerParams = privateProps.innerParams.get(instance || _this);
+  const confirm = (instance, value) => {
+    const innerParams = privateProps.innerParams.get(instance || undefined);
     if (innerParams.showLoaderOnConfirm) {
       showLoading();
     }
     if (innerParams.preConfirm) {
       instance.resetValidationMessage();
       instance.isAwaitingPromise = true; // Flagging the instance as awaiting a promise so it's own promise's reject/resolve methods doesn't get destroyed until the result from this preConfirm's promise is received
-      var preConfirmPromise = Promise.resolve().then(function () {
-        return asPromise(innerParams.preConfirm(value, innerParams.validationMessage));
-      });
-      preConfirmPromise.then(function (preConfirmValue) {
+      const preConfirmPromise = Promise.resolve().then(() => asPromise(innerParams.preConfirm(value, innerParams.validationMessage)));
+      preConfirmPromise.then(preConfirmValue => {
         if (isVisible$1(getValidationMessage()) || preConfirmValue === false) {
           instance.hideLoading();
           handleAwaitingPromise(instance);
         } else {
           succeedWith(instance, typeof preConfirmValue === 'undefined' ? value : preConfirmValue);
         }
-      })["catch"](function (error) {
-        return rejectWith(instance || _this, error);
-      });
+      }).catch(error => rejectWith(instance || undefined, error));
     } else {
       succeedWith(instance, value);
     }
@@ -3052,11 +2811,11 @@
    */
   function hideLoading() {
     // do nothing if popup is closed
-    var innerParams = privateProps.innerParams.get(this);
+    const innerParams = privateProps.innerParams.get(this);
     if (!innerParams) {
       return;
     }
-    var domCache = privateProps.domCache.get(this);
+    const domCache = privateProps.domCache.get(this);
     hide(domCache.loader);
     if (isToast()) {
       if (innerParams.icon) {
@@ -3072,8 +2831,8 @@
     domCache.denyButton.disabled = false;
     domCache.cancelButton.disabled = false;
   }
-  var showRelatedButton = function showRelatedButton(domCache) {
-    var buttonToReplace = domCache.popup.getElementsByClassName(domCache.loader.getAttribute('data-button-to-replace'));
+  const showRelatedButton = domCache => {
+    const buttonToReplace = domCache.popup.getElementsByClassName(domCache.loader.getAttribute('data-button-to-replace'));
     if (buttonToReplace.length) {
       show(buttonToReplace[0], 'inline-block');
     } else if (allButtonsAreHidden()) {
@@ -3087,8 +2846,8 @@
    * @returns {HTMLInputElement | null}
    */
   function getInput() {
-    var innerParams = privateProps.innerParams.get(this);
-    var domCache = privateProps.domCache.get(this);
+    const innerParams = privateProps.innerParams.get(this);
+    const domCache = privateProps.domCache.get(this);
     if (!domCache) {
       return null;
     }
@@ -3101,8 +2860,8 @@
    * @param {boolean} disabled
    */
   function setButtonsDisabled(instance, buttons, disabled) {
-    var domCache = privateProps.domCache.get(instance);
-    buttons.forEach(function (button) {
+    const domCache = privateProps.domCache.get(instance);
+    buttons.forEach(button => {
       domCache[button].disabled = disabled;
     });
   }
@@ -3112,14 +2871,14 @@
    * @param {boolean} disabled
    */
   function setInputDisabled(input, disabled) {
-    var popup = getPopup();
+    const popup = getPopup();
     if (!popup || !input) {
       return;
     }
     if (input.type === 'radio') {
       /** @type {NodeListOf<HTMLInputElement>} */
-      var radios = popup.querySelectorAll("[name=\"".concat(swalClasses.radio, "\"]"));
-      for (var i = 0; i < radios.length; i++) {
+      const radios = popup.querySelectorAll(`[name="${swalClasses.radio}"]`);
+      for (let i = 0; i < radios.length; i++) {
         radios[i].disabled = disabled;
       }
     } else {
@@ -3166,15 +2925,15 @@
    * @this {SweetAlert}
    */
   function showValidationMessage(error) {
-    var domCache = privateProps.domCache.get(this);
-    var params = privateProps.innerParams.get(this);
+    const domCache = privateProps.domCache.get(this);
+    const params = privateProps.innerParams.get(this);
     setInnerHtml(domCache.validationMessage, error);
     domCache.validationMessage.className = swalClasses['validation-message'];
     if (params.customClass && params.customClass.validationMessage) {
       addClass(domCache.validationMessage, params.customClass.validationMessage);
     }
     show(domCache.validationMessage);
-    var input = this.getInput();
+    const input = this.getInput();
     if (input) {
       input.setAttribute('aria-invalid', 'true');
       input.setAttribute('aria-describedby', swalClasses['validation-message']);
@@ -3189,11 +2948,11 @@
    * @this {SweetAlert}
    */
   function resetValidationMessage() {
-    var domCache = privateProps.domCache.get(this);
+    const domCache = privateProps.domCache.get(this);
     if (domCache.validationMessage) {
       hide(domCache.validationMessage);
     }
-    var input = this.getInput();
+    const input = this.getInput();
     if (input) {
       input.removeAttribute('aria-invalid');
       input.removeAttribute('aria-describedby');
@@ -3201,7 +2960,7 @@
     }
   }
 
-  var defaultParams = {
+  const defaultParams = {
     title: '',
     titleText: '',
     text: '',
@@ -3292,13 +3051,13 @@
     didDestroy: undefined,
     scrollbarPadding: true
   };
-  var updatableParams = ['allowEscapeKey', 'allowOutsideClick', 'background', 'buttonsStyling', 'cancelButtonAriaLabel', 'cancelButtonColor', 'cancelButtonText', 'closeButtonAriaLabel', 'closeButtonHtml', 'color', 'confirmButtonAriaLabel', 'confirmButtonColor', 'confirmButtonText', 'currentProgressStep', 'customClass', 'denyButtonAriaLabel', 'denyButtonColor', 'denyButtonText', 'didClose', 'didDestroy', 'footer', 'hideClass', 'html', 'icon', 'iconColor', 'iconHtml', 'imageAlt', 'imageHeight', 'imageUrl', 'imageWidth', 'preConfirm', 'preDeny', 'progressSteps', 'returnFocus', 'reverseButtons', 'showCancelButton', 'showCloseButton', 'showConfirmButton', 'showDenyButton', 'text', 'title', 'titleText', 'willClose'];
+  const updatableParams = ['allowEscapeKey', 'allowOutsideClick', 'background', 'buttonsStyling', 'cancelButtonAriaLabel', 'cancelButtonColor', 'cancelButtonText', 'closeButtonAriaLabel', 'closeButtonHtml', 'color', 'confirmButtonAriaLabel', 'confirmButtonColor', 'confirmButtonText', 'currentProgressStep', 'customClass', 'denyButtonAriaLabel', 'denyButtonColor', 'denyButtonText', 'didClose', 'didDestroy', 'footer', 'hideClass', 'html', 'icon', 'iconColor', 'iconHtml', 'imageAlt', 'imageHeight', 'imageUrl', 'imageWidth', 'preConfirm', 'preDeny', 'progressSteps', 'returnFocus', 'reverseButtons', 'showCancelButton', 'showCloseButton', 'showConfirmButton', 'showDenyButton', 'text', 'title', 'titleText', 'willClose'];
 
   /** @type {Record<string, string | undefined>} */
-  var deprecatedParams = {
+  const deprecatedParams = {
     allowEnterKey: undefined
   };
-  var toastIncompatibleParams = ['allowOutsideClick', 'allowEnterKey', 'backdrop', 'focusConfirm', 'focusDeny', 'focusCancel', 'returnFocus', 'heightAuto', 'keydownListenerCapture'];
+  const toastIncompatibleParams = ['allowOutsideClick', 'allowEnterKey', 'backdrop', 'focusConfirm', 'focusDeny', 'focusCancel', 'returnFocus', 'heightAuto', 'keydownListenerCapture'];
 
   /**
    * Is valid parameter
@@ -3306,7 +3065,7 @@
    * @param {string} paramName
    * @returns {boolean}
    */
-  var isValidParameter = function isValidParameter(paramName) {
+  const isValidParameter = paramName => {
     return Object.prototype.hasOwnProperty.call(defaultParams, paramName);
   };
 
@@ -3316,7 +3075,7 @@
    * @param {string} paramName
    * @returns {boolean}
    */
-  var isUpdatableParameter = function isUpdatableParameter(paramName) {
+  const isUpdatableParameter = paramName => {
     return updatableParams.indexOf(paramName) !== -1;
   };
 
@@ -3326,33 +3085,33 @@
    * @param {string} paramName
    * @returns {string | undefined}
    */
-  var isDeprecatedParameter = function isDeprecatedParameter(paramName) {
+  const isDeprecatedParameter = paramName => {
     return deprecatedParams[paramName];
   };
 
   /**
    * @param {string} param
    */
-  var checkIfParamIsValid = function checkIfParamIsValid(param) {
+  const checkIfParamIsValid = param => {
     if (!isValidParameter(param)) {
-      warn("Unknown parameter \"".concat(param, "\""));
+      warn(`Unknown parameter "${param}"`);
     }
   };
 
   /**
    * @param {string} param
    */
-  var checkIfToastParamIsValid = function checkIfToastParamIsValid(param) {
+  const checkIfToastParamIsValid = param => {
     if (toastIncompatibleParams.includes(param)) {
-      warn("The parameter \"".concat(param, "\" is incompatible with toasts"));
+      warn(`The parameter "${param}" is incompatible with toasts`);
     }
   };
 
   /**
    * @param {string} param
    */
-  var checkIfParamIsDeprecated = function checkIfParamIsDeprecated(param) {
-    var isDeprecated = isDeprecatedParameter(param);
+  const checkIfParamIsDeprecated = param => {
+    const isDeprecated = isDeprecatedParameter(param);
     if (isDeprecated) {
       warnAboutDeprecation(param, isDeprecated);
     }
@@ -3363,11 +3122,11 @@
    *
    * @param {SweetAlertOptions} params
    */
-  var showWarningsForParams = function showWarningsForParams(params) {
+  const showWarningsForParams = params => {
     if (params.backdrop === false && params.allowOutsideClick) {
       warn('"allowOutsideClick" parameter requires `backdrop` parameter to be set to `true`');
     }
-    for (var param in params) {
+    for (const param in params) {
       checkIfParamIsValid(param);
       if (params.toast) {
         checkIfToastParamIsValid(param);
@@ -3382,14 +3141,14 @@
    * @param {SweetAlertOptions} params
    */
   function update(params) {
-    var popup = getPopup();
-    var innerParams = privateProps.innerParams.get(this);
+    const popup = getPopup();
+    const innerParams = privateProps.innerParams.get(this);
     if (!popup || hasClass(popup, innerParams.hideClass.popup)) {
-      warn("You're trying to update the closed or closing popup, that won't work. Use the update() method in preConfirm parameter or show a new popup.");
+      warn(`You're trying to update the closed or closing popup, that won't work. Use the update() method in preConfirm parameter or show a new popup.`);
       return;
     }
-    var validUpdatableParams = filterValidParams(params);
-    var updatedParams = Object.assign({}, innerParams, validUpdatableParams);
+    const validUpdatableParams = filterValidParams(params);
+    const updatedParams = Object.assign({}, innerParams, validUpdatableParams);
     render(this, updatedParams);
     privateProps.innerParams.set(this, updatedParams);
     Object.defineProperties(this, {
@@ -3405,13 +3164,13 @@
    * @param {SweetAlertOptions} params
    * @returns {SweetAlertOptions}
    */
-  var filterValidParams = function filterValidParams(params) {
-    var validUpdatableParams = {};
-    Object.keys(params).forEach(function (param) {
+  const filterValidParams = params => {
+    const validUpdatableParams = {};
+    Object.keys(params).forEach(param => {
       if (isUpdatableParameter(param)) {
         validUpdatableParams[param] = params[param];
       } else {
-        warn("Invalid parameter to update: ".concat(param));
+        warn(`Invalid parameter to update: ${param}`);
       }
     });
     return validUpdatableParams;
@@ -3421,8 +3180,8 @@
    * Dispose the current SweetAlert2 instance
    */
   function _destroy() {
-    var domCache = privateProps.domCache.get(this);
-    var innerParams = privateProps.innerParams.get(this);
+    const domCache = privateProps.domCache.get(this);
+    const innerParams = privateProps.innerParams.get(this);
     if (!innerParams) {
       disposeWeakMaps(this); // The WeakMaps might have been partly destroyed, we must recall it to dispose any remaining WeakMaps #2335
       return; // This instance has already been destroyed
@@ -3442,7 +3201,7 @@
   /**
    * @param {SweetAlert} instance
    */
-  var disposeSwal = function disposeSwal(instance) {
+  const disposeSwal = instance => {
     disposeWeakMaps(instance);
     // Unset this.params so GC will dispose it (#1569)
     delete instance.params;
@@ -3456,7 +3215,7 @@
   /**
    * @param {SweetAlert} instance
    */
-  var disposeWeakMaps = function disposeWeakMaps(instance) {
+  const disposeWeakMaps = instance => {
     // If the current instance is awaiting a promise result, we keep the privateMethods to call them once the promise result is retrieved #2335
     if (instance.isAwaitingPromise) {
       unsetWeakMaps(privateProps, instance);
@@ -3489,9 +3248,9 @@
    * @param {object} obj
    * @param {SweetAlert} instance
    */
-  var unsetWeakMaps = function unsetWeakMaps(obj, instance) {
-    for (var i in obj) {
-      obj[i]["delete"](instance);
+  const unsetWeakMaps = (obj, instance) => {
+    for (const i in obj) {
+      obj[i].delete(instance);
     }
   };
 
@@ -3521,7 +3280,7 @@
    * @param {DomCache} domCache
    * @param {Function} dismissWith
    */
-  var handlePopupClick = function handlePopupClick(innerParams, domCache, dismissWith) {
+  const handlePopupClick = (innerParams, domCache, dismissWith) => {
     if (innerParams.toast) {
       handleToastClick(innerParams, domCache, dismissWith);
     } else {
@@ -3540,9 +3299,9 @@
    * @param {DomCache} domCache
    * @param {Function} dismissWith
    */
-  var handleToastClick = function handleToastClick(innerParams, domCache, dismissWith) {
+  const handleToastClick = (innerParams, domCache, dismissWith) => {
     // Closing toast by internal click
-    domCache.popup.onclick = function () {
+    domCache.popup.onclick = () => {
       if (innerParams && (isAnyButtonShown(innerParams) || innerParams.timer || innerParams.input)) {
         return;
       }
@@ -3554,18 +3313,18 @@
    * @param {SweetAlertOptions} innerParams
    * @returns {boolean}
    */
-  var isAnyButtonShown = function isAnyButtonShown(innerParams) {
+  const isAnyButtonShown = innerParams => {
     return !!(innerParams.showConfirmButton || innerParams.showDenyButton || innerParams.showCancelButton || innerParams.showCloseButton);
   };
-  var ignoreOutsideClick = false;
+  let ignoreOutsideClick = false;
 
   /**
    * @param {DomCache} domCache
    */
-  var handleModalMousedown = function handleModalMousedown(domCache) {
-    domCache.popup.onmousedown = function () {
+  const handleModalMousedown = domCache => {
+    domCache.popup.onmousedown = () => {
       domCache.container.onmouseup = function (e) {
-        domCache.container.onmouseup = function () {};
+        domCache.container.onmouseup = () => {};
         // We only check if the mouseup target is the container because usually it doesn't
         // have any other direct children aside of the popup
         if (e.target === domCache.container) {
@@ -3578,14 +3337,14 @@
   /**
    * @param {DomCache} domCache
    */
-  var handleContainerMousedown = function handleContainerMousedown(domCache) {
-    domCache.container.onmousedown = function (e) {
+  const handleContainerMousedown = domCache => {
+    domCache.container.onmousedown = e => {
       // prevent the modal text from being selected on double click on the container (allowOutsideClick: false)
       if (e.target === domCache.container) {
         e.preventDefault();
       }
       domCache.popup.onmouseup = function (e) {
-        domCache.popup.onmouseup = function () {};
+        domCache.popup.onmouseup = () => {};
         // We also need to check if the mouseup target is a child of the popup
         if (e.target === domCache.popup || e.target instanceof HTMLElement && domCache.popup.contains(e.target)) {
           ignoreOutsideClick = true;
@@ -3599,8 +3358,8 @@
    * @param {DomCache} domCache
    * @param {Function} dismissWith
    */
-  var handleModalClick = function handleModalClick(innerParams, domCache, dismissWith) {
-    domCache.container.onclick = function (e) {
+  const handleModalClick = (innerParams, domCache, dismissWith) => {
+    domCache.container.onclick = e => {
       if (ignoreOutsideClick) {
         ignoreOutsideClick = false;
         return;
@@ -3611,23 +3370,19 @@
     };
   };
 
-  var isJqueryElement = function isJqueryElement(elem) {
-    return _typeof(elem) === 'object' && elem.jquery;
-  };
-  var isElement = function isElement(elem) {
-    return elem instanceof Element || isJqueryElement(elem);
-  };
-  var argsToParams = function argsToParams(args) {
-    var params = {};
-    if (_typeof(args[0]) === 'object' && !isElement(args[0])) {
+  const isJqueryElement = elem => typeof elem === 'object' && elem.jquery;
+  const isElement = elem => elem instanceof Element || isJqueryElement(elem);
+  const argsToParams = args => {
+    const params = {};
+    if (typeof args[0] === 'object' && !isElement(args[0])) {
       Object.assign(params, args[0]);
     } else {
-      ['title', 'html', 'icon'].forEach(function (name, index) {
-        var arg = args[index];
+      ['title', 'html', 'icon'].forEach((name, index) => {
+        const arg = args[index];
         if (typeof arg === 'string' || isElement(arg)) {
           params[name] = arg;
         } else if (arg !== undefined) {
-          error("Unexpected type of ".concat(name, "! Expected \"string\" or \"Element\", got ").concat(_typeof(arg)));
+          error(`Unexpected type of ${name}! Expected "string" or "Element", got ${typeof arg}`);
         }
       });
     }
@@ -3644,7 +3399,7 @@
     for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
       args[_key] = arguments[_key];
     }
-    return _construct(this, args);
+    return new this(...args);
   }
 
   /**
@@ -3667,19 +3422,12 @@
    * @returns {SweetAlert}
    */
   function mixin(mixinParams) {
-    var MixinSwal = /*#__PURE__*/function (_this) {
-      function MixinSwal() {
-        _classCallCheck(this, MixinSwal);
-        return _callSuper(this, MixinSwal, arguments);
+    class MixinSwal extends this {
+      _main(params, priorityMixinParams) {
+        return super._main(params, Object.assign({}, mixinParams, priorityMixinParams));
       }
-      _inherits(MixinSwal, _this);
-      return _createClass(MixinSwal, [{
-        key: "_main",
-        value: function _main(params, priorityMixinParams) {
-          return _superPropGet(MixinSwal, "_main", this)([params, Object.assign({}, mixinParams, priorityMixinParams)]);
-        }
-      }]);
-    }(this); // @ts-ignore
+    }
+    // @ts-ignore
     return MixinSwal;
   }
 
@@ -3689,7 +3437,7 @@
    *
    * @returns {number | undefined}
    */
-  var getTimerLeft = function getTimerLeft() {
+  const getTimerLeft = () => {
     return globalState.timeout && globalState.timeout.getTimerLeft();
   };
 
@@ -3699,7 +3447,7 @@
    *
    * @returns {number | undefined}
    */
-  var stopTimer = function stopTimer() {
+  const stopTimer = () => {
     if (globalState.timeout) {
       stopTimerProgressBar();
       return globalState.timeout.stop();
@@ -3712,9 +3460,9 @@
    *
    * @returns {number | undefined}
    */
-  var resumeTimer = function resumeTimer() {
+  const resumeTimer = () => {
     if (globalState.timeout) {
-      var remaining = globalState.timeout.start();
+      const remaining = globalState.timeout.start();
       animateTimerProgressBar(remaining);
       return remaining;
     }
@@ -3726,8 +3474,8 @@
    *
    * @returns {number | undefined}
    */
-  var toggleTimer = function toggleTimer() {
-    var timer = globalState.timeout;
+  const toggleTimer = () => {
+    const timer = globalState.timeout;
     return timer && (timer.running ? stopTimer() : resumeTimer());
   };
 
@@ -3738,9 +3486,9 @@
    * @param {number} ms
    * @returns {number | undefined}
    */
-  var increaseTimer = function increaseTimer(ms) {
+  const increaseTimer = ms => {
     if (globalState.timeout) {
-      var remaining = globalState.timeout.increase(ms);
+      const remaining = globalState.timeout.increase(ms);
       animateTimerProgressBar(remaining, true);
       return remaining;
     }
@@ -3753,31 +3501,31 @@
    *
    * @returns {boolean}
    */
-  var isTimerRunning = function isTimerRunning() {
+  const isTimerRunning = () => {
     return !!(globalState.timeout && globalState.timeout.isRunning());
   };
 
-  var bodyClickListenerAdded = false;
-  var clickHandlers = {};
+  let bodyClickListenerAdded = false;
+  const clickHandlers = {};
 
   /**
    * @param {string} attr
    */
   function bindClickHandler() {
-    var attr = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'data-swal-template';
+    let attr = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'data-swal-template';
     clickHandlers[attr] = this;
     if (!bodyClickListenerAdded) {
       document.body.addEventListener('click', bodyClickListener);
       bodyClickListenerAdded = true;
     }
   }
-  var bodyClickListener = function bodyClickListener(event) {
-    for (var el = event.target; el && el !== document; el = el.parentNode) {
-      for (var attr in clickHandlers) {
-        var template = el.getAttribute(attr);
+  const bodyClickListener = event => {
+    for (let el = event.target; el && el !== document; el = el.parentNode) {
+      for (const attr in clickHandlers) {
+        const template = el.getAttribute(attr);
         if (template) {
           clickHandlers[attr].fire({
-            template: template
+            template
           });
           return;
         }
@@ -3828,13 +3576,12 @@
     toggleTimer: toggleTimer
   });
 
-  var Timer = /*#__PURE__*/function () {
+  class Timer {
     /**
      * @param {Function} callback
      * @param {number} delay
      */
-    function Timer(callback, delay) {
-      _classCallCheck(this, Timer);
+    constructor(callback, delay) {
       this.callback = callback;
       this.remaining = delay;
       this.running = false;
@@ -3844,88 +3591,77 @@
     /**
      * @returns {number}
      */
-    return _createClass(Timer, [{
-      key: "start",
-      value: function start() {
-        if (!this.running) {
-          this.running = true;
-          this.started = new Date();
-          this.id = setTimeout(this.callback, this.remaining);
-        }
-        return this.remaining;
+    start() {
+      if (!this.running) {
+        this.running = true;
+        this.started = new Date();
+        this.id = setTimeout(this.callback, this.remaining);
       }
+      return this.remaining;
+    }
 
-      /**
-       * @returns {number}
-       */
-    }, {
-      key: "stop",
-      value: function stop() {
-        if (this.started && this.running) {
-          this.running = false;
-          clearTimeout(this.id);
-          this.remaining -= new Date().getTime() - this.started.getTime();
-        }
-        return this.remaining;
+    /**
+     * @returns {number}
+     */
+    stop() {
+      if (this.started && this.running) {
+        this.running = false;
+        clearTimeout(this.id);
+        this.remaining -= new Date().getTime() - this.started.getTime();
       }
+      return this.remaining;
+    }
 
-      /**
-       * @param {number} n
-       * @returns {number}
-       */
-    }, {
-      key: "increase",
-      value: function increase(n) {
-        var running = this.running;
-        if (running) {
-          this.stop();
-        }
-        this.remaining += n;
-        if (running) {
-          this.start();
-        }
-        return this.remaining;
+    /**
+     * @param {number} n
+     * @returns {number}
+     */
+    increase(n) {
+      const running = this.running;
+      if (running) {
+        this.stop();
       }
-
-      /**
-       * @returns {number}
-       */
-    }, {
-      key: "getTimerLeft",
-      value: function getTimerLeft() {
-        if (this.running) {
-          this.stop();
-          this.start();
-        }
-        return this.remaining;
+      this.remaining += n;
+      if (running) {
+        this.start();
       }
+      return this.remaining;
+    }
 
-      /**
-       * @returns {boolean}
-       */
-    }, {
-      key: "isRunning",
-      value: function isRunning() {
-        return this.running;
+    /**
+     * @returns {number}
+     */
+    getTimerLeft() {
+      if (this.running) {
+        this.stop();
+        this.start();
       }
-    }]);
-  }();
+      return this.remaining;
+    }
+
+    /**
+     * @returns {boolean}
+     */
+    isRunning() {
+      return this.running;
+    }
+  }
 
-  var swalStringParams = ['swal-title', 'swal-html', 'swal-footer'];
+  const swalStringParams = ['swal-title', 'swal-html', 'swal-footer'];
 
   /**
    * @param {SweetAlertOptions} params
    * @returns {SweetAlertOptions}
    */
-  var getTemplateParams = function getTemplateParams(params) {
-    var template = typeof params.template === 'string' ? (/** @type {HTMLTemplateElement} */document.querySelector(params.template)) : params.template;
+  const getTemplateParams = params => {
+    const template = typeof params.template === 'string' ? (/** @type {HTMLTemplateElement} */document.querySelector(params.template)) : params.template;
     if (!template) {
       return {};
     }
     /** @type {DocumentFragment} */
-    var templateContent = template.content;
+    const templateContent = template.content;
     showWarningsForElements(templateContent);
-    var result = Object.assign(getSwalParams(templateContent), getSwalFunctionParams(templateContent), getSwalButtons(templateContent), getSwalImage(templateContent), getSwalIcon(templateContent), getSwalInput(templateContent), getSwalStringParams(templateContent, swalStringParams));
+    const result = Object.assign(getSwalParams(templateContent), getSwalFunctionParams(templateContent), getSwalButtons(templateContent), getSwalImage(templateContent), getSwalIcon(templateContent), getSwalInput(templateContent), getSwalStringParams(templateContent, swalStringParams));
     return result;
   };
 
@@ -3933,21 +3669,21 @@
    * @param {DocumentFragment} templateContent
    * @returns {Record<string, any>}
    */
-  var getSwalParams = function getSwalParams(templateContent) {
+  const getSwalParams = templateContent => {
     /** @type {Record<string, any>} */
-    var result = {};
+    const result = {};
     /** @type {HTMLElement[]} */
-    var swalParams = Array.from(templateContent.querySelectorAll('swal-param'));
-    swalParams.forEach(function (param) {
+    const swalParams = Array.from(templateContent.querySelectorAll('swal-param'));
+    swalParams.forEach(param => {
       showWarningsForAttributes(param, ['name', 'value']);
-      var paramName = /** @type {keyof SweetAlertOptions} */param.getAttribute('name');
-      var value = param.getAttribute('value');
+      const paramName = /** @type {keyof SweetAlertOptions} */param.getAttribute('name');
+      const value = param.getAttribute('value');
       if (!paramName || !value) {
         return;
       }
       if (typeof defaultParams[paramName] === 'boolean') {
         result[paramName] = value !== 'false';
-      } else if (_typeof(defaultParams[paramName]) === 'object') {
+      } else if (typeof defaultParams[paramName] === 'object') {
         result[paramName] = JSON.parse(value);
       } else {
         result[paramName] = value;
@@ -3960,18 +3696,18 @@
    * @param {DocumentFragment} templateContent
    * @returns {Record<string, any>}
    */
-  var getSwalFunctionParams = function getSwalFunctionParams(templateContent) {
+  const getSwalFunctionParams = templateContent => {
     /** @type {Record<string, any>} */
-    var result = {};
+    const result = {};
     /** @type {HTMLElement[]} */
-    var swalFunctions = Array.from(templateContent.querySelectorAll('swal-function-param'));
-    swalFunctions.forEach(function (param) {
-      var paramName = /** @type {keyof SweetAlertOptions} */param.getAttribute('name');
-      var value = param.getAttribute('value');
+    const swalFunctions = Array.from(templateContent.querySelectorAll('swal-function-param'));
+    swalFunctions.forEach(param => {
+      const paramName = /** @type {keyof SweetAlertOptions} */param.getAttribute('name');
+      const value = param.getAttribute('value');
       if (!paramName || !value) {
         return;
       }
-      result[paramName] = new Function("return ".concat(value))();
+      result[paramName] = new Function(`return ${value}`)();
     });
     return result;
   };
@@ -3980,24 +3716,24 @@
    * @param {DocumentFragment} templateContent
    * @returns {Record<string, any>}
    */
-  var getSwalButtons = function getSwalButtons(templateContent) {
+  const getSwalButtons = templateContent => {
     /** @type {Record<string, any>} */
-    var result = {};
+    const result = {};
     /** @type {HTMLElement[]} */
-    var swalButtons = Array.from(templateContent.querySelectorAll('swal-button'));
-    swalButtons.forEach(function (button) {
+    const swalButtons = Array.from(templateContent.querySelectorAll('swal-button'));
+    swalButtons.forEach(button => {
       showWarningsForAttributes(button, ['type', 'color', 'aria-label']);
-      var type = button.getAttribute('type');
+      const type = button.getAttribute('type');
       if (!type || !['confirm', 'cancel', 'deny'].includes(type)) {
         return;
       }
-      result["".concat(type, "ButtonText")] = button.innerHTML;
-      result["show".concat(capitalizeFirstLetter(type), "Button")] = true;
+      result[`${type}ButtonText`] = button.innerHTML;
+      result[`show${capitalizeFirstLetter(type)}Button`] = true;
       if (button.hasAttribute('color')) {
-        result["".concat(type, "ButtonColor")] = button.getAttribute('color');
+        result[`${type}ButtonColor`] = button.getAttribute('color');
       }
       if (button.hasAttribute('aria-label')) {
-        result["".concat(type, "ButtonAriaLabel")] = button.getAttribute('aria-label');
+        result[`${type}ButtonAriaLabel`] = button.getAttribute('aria-label');
       }
     });
     return result;
@@ -4007,10 +3743,10 @@
    * @param {DocumentFragment} templateContent
    * @returns {Pick<SweetAlertOptions, 'imageUrl' | 'imageWidth' | 'imageHeight' | 'imageAlt'>}
    */
-  var getSwalImage = function getSwalImage(templateContent) {
-    var result = {};
+  const getSwalImage = templateContent => {
+    const result = {};
     /** @type {HTMLElement | null} */
-    var image = templateContent.querySelector('swal-image');
+    const image = templateContent.querySelector('swal-image');
     if (image) {
       showWarningsForAttributes(image, ['src', 'width', 'height', 'alt']);
       if (image.hasAttribute('src')) {
@@ -4033,10 +3769,10 @@
    * @param {DocumentFragment} templateContent
    * @returns {Record<string, any>}
    */
-  var getSwalIcon = function getSwalIcon(templateContent) {
-    var result = {};
+  const getSwalIcon = templateContent => {
+    const result = {};
     /** @type {HTMLElement | null} */
-    var icon = templateContent.querySelector('swal-icon');
+    const icon = templateContent.querySelector('swal-icon');
     if (icon) {
       showWarningsForAttributes(icon, ['type', 'color']);
       if (icon.hasAttribute('type')) {
@@ -4054,11 +3790,11 @@
    * @param {DocumentFragment} templateContent
    * @returns {Record<string, any>}
    */
-  var getSwalInput = function getSwalInput(templateContent) {
+  const getSwalInput = templateContent => {
     /** @type {Record<string, any>} */
-    var result = {};
+    const result = {};
     /** @type {HTMLElement | null} */
-    var input = templateContent.querySelector('swal-input');
+    const input = templateContent.querySelector('swal-input');
     if (input) {
       showWarningsForAttributes(input, ['type', 'label', 'placeholder', 'value']);
       result.input = input.getAttribute('type') || 'text';
@@ -4073,16 +3809,16 @@
       }
     }
     /** @type {HTMLElement[]} */
-    var inputOptions = Array.from(templateContent.querySelectorAll('swal-input-option'));
+    const inputOptions = Array.from(templateContent.querySelectorAll('swal-input-option'));
     if (inputOptions.length) {
       result.inputOptions = {};
-      inputOptions.forEach(function (option) {
+      inputOptions.forEach(option => {
         showWarningsForAttributes(option, ['value']);
-        var optionValue = option.getAttribute('value');
+        const optionValue = option.getAttribute('value');
         if (!optionValue) {
           return;
         }
-        var optionName = option.innerHTML;
+        const optionName = option.innerHTML;
         result.inputOptions[optionValue] = optionName;
       });
     }
@@ -4094,13 +3830,13 @@
    * @param {string[]} paramNames
    * @returns {Record<string, any>}
    */
-  var getSwalStringParams = function getSwalStringParams(templateContent, paramNames) {
+  const getSwalStringParams = (templateContent, paramNames) => {
     /** @type {Record<string, any>} */
-    var result = {};
-    for (var i in paramNames) {
-      var paramName = paramNames[i];
+    const result = {};
+    for (const i in paramNames) {
+      const paramName = paramNames[i];
       /** @type {HTMLElement | null} */
-      var tag = templateContent.querySelector(paramName);
+      const tag = templateContent.querySelector(paramName);
       if (tag) {
         showWarningsForAttributes(tag, []);
         result[paramName.replace(/^swal-/, '')] = tag.innerHTML.trim();
@@ -4112,12 +3848,12 @@
   /**
    * @param {DocumentFragment} templateContent
    */
-  var showWarningsForElements = function showWarningsForElements(templateContent) {
-    var allowedElements = swalStringParams.concat(['swal-param', 'swal-function-param', 'swal-button', 'swal-image', 'swal-icon', 'swal-input', 'swal-input-option']);
-    Array.from(templateContent.children).forEach(function (el) {
-      var tagName = el.tagName.toLowerCase();
+  const showWarningsForElements = templateContent => {
+    const allowedElements = swalStringParams.concat(['swal-param', 'swal-function-param', 'swal-button', 'swal-image', 'swal-icon', 'swal-input', 'swal-input-option']);
+    Array.from(templateContent.children).forEach(el => {
+      const tagName = el.tagName.toLowerCase();
       if (!allowedElements.includes(tagName)) {
-        warn("Unrecognized element <".concat(tagName, ">"));
+        warn(`Unrecognized element <${tagName}>`);
       }
     });
   };
@@ -4126,33 +3862,33 @@
    * @param {HTMLElement} el
    * @param {string[]} allowedAttributes
    */
-  var showWarningsForAttributes = function showWarningsForAttributes(el, allowedAttributes) {
-    Array.from(el.attributes).forEach(function (attribute) {
+  const showWarningsForAttributes = (el, allowedAttributes) => {
+    Array.from(el.attributes).forEach(attribute => {
       if (allowedAttributes.indexOf(attribute.name) === -1) {
-        warn(["Unrecognized attribute \"".concat(attribute.name, "\" on <").concat(el.tagName.toLowerCase(), ">."), "".concat(allowedAttributes.length ? "Allowed attributes are: ".concat(allowedAttributes.join(', ')) : 'To set the value, use HTML within the element.')]);
+        warn([`Unrecognized attribute "${attribute.name}" on <${el.tagName.toLowerCase()}>.`, `${allowedAttributes.length ? `Allowed attributes are: ${allowedAttributes.join(', ')}` : 'To set the value, use HTML within the element.'}`]);
       }
     });
   };
 
-  var SHOW_CLASS_TIMEOUT = 10;
+  const SHOW_CLASS_TIMEOUT = 10;
 
   /**
    * Open popup, add necessary classes and styles, fix scrollbar
    *
    * @param {SweetAlertOptions} params
    */
-  var openPopup = function openPopup(params) {
-    var container = getContainer();
-    var popup = getPopup();
+  const openPopup = params => {
+    const container = getContainer();
+    const popup = getPopup();
     if (typeof params.willOpen === 'function') {
       params.willOpen(popup);
     }
-    var bodyStyles = window.getComputedStyle(document.body);
-    var initialBodyOverflow = bodyStyles.overflowY;
+    const bodyStyles = window.getComputedStyle(document.body);
+    const initialBodyOverflow = bodyStyles.overflowY;
     addClasses(container, popup, params);
 
     // scrolling is 'hidden' until animation is done, after that 'auto'
-    setTimeout(function () {
+    setTimeout(() => {
       setScrollingVisibility(container, popup);
     }, SHOW_CLASS_TIMEOUT);
     if (isModal()) {
@@ -4163,9 +3899,7 @@
       globalState.previousActiveElement = document.activeElement;
     }
     if (typeof params.didOpen === 'function') {
-      setTimeout(function () {
-        return params.didOpen(popup);
-      });
+      setTimeout(() => params.didOpen(popup));
     }
     removeClass(container, swalClasses['no-transition']);
   };
@@ -4173,13 +3907,13 @@
   /**
    * @param {AnimationEvent} event
    */
-  var _swalOpenAnimationFinished = function swalOpenAnimationFinished(event) {
-    var popup = getPopup();
+  const swalOpenAnimationFinished = event => {
+    const popup = getPopup();
     if (event.target !== popup || !animationEndEvent) {
       return;
     }
-    var container = getContainer();
-    popup.removeEventListener(animationEndEvent, _swalOpenAnimationFinished);
+    const container = getContainer();
+    popup.removeEventListener(animationEndEvent, swalOpenAnimationFinished);
     container.style.overflowY = 'auto';
   };
 
@@ -4187,10 +3921,10 @@
    * @param {HTMLElement} container
    * @param {HTMLElement} popup
    */
-  var setScrollingVisibility = function setScrollingVisibility(container, popup) {
+  const setScrollingVisibility = (container, popup) => {
     if (animationEndEvent && hasCssAnimation(popup)) {
       container.style.overflowY = 'hidden';
-      popup.addEventListener(animationEndEvent, _swalOpenAnimationFinished);
+      popup.addEventListener(animationEndEvent, swalOpenAnimationFinished);
     } else {
       container.style.overflowY = 'auto';
     }
@@ -4201,14 +3935,14 @@
    * @param {boolean} scrollbarPadding
    * @param {string} initialBodyOverflow
    */
-  var fixScrollContainer = function fixScrollContainer(container, scrollbarPadding, initialBodyOverflow) {
+  const fixScrollContainer = (container, scrollbarPadding, initialBodyOverflow) => {
     iOSfix();
     if (scrollbarPadding && initialBodyOverflow !== 'hidden') {
       replaceScrollbarWithPadding(initialBodyOverflow);
     }
 
     // sweetalert2/issues/1247
-    setTimeout(function () {
+    setTimeout(() => {
       container.scrollTop = 0;
     });
   };
@@ -4218,13 +3952,13 @@
    * @param {HTMLElement} popup
    * @param {SweetAlertOptions} params
    */
-  var addClasses = function addClasses(container, popup, params) {
+  const addClasses = (container, popup, params) => {
     addClass(container, params.showClass.backdrop);
     if (params.animation) {
       // this workaround with opacity is needed for https://github.com/sweetalert2/sweetalert2/issues/2059
       popup.style.setProperty('opacity', '0', 'important');
       show(popup, 'grid');
-      setTimeout(function () {
+      setTimeout(() => {
         // Animate popup right after showing it
         addClass(popup, params.showClass.popup);
         // and remove the opacity workaround
@@ -4245,7 +3979,7 @@
      * @param {string} [validationMessage]
      * @returns {Promise<string | void>}
      */
-    email: function email(string, validationMessage) {
+    email: (string, validationMessage) => {
       return /^[a-zA-Z0-9.+_'-]+@[a-zA-Z0-9.-]+\.[a-zA-Z0-9-]+$/.test(string) ? Promise.resolve() : Promise.resolve(validationMessage || 'Invalid email address');
     },
     /**
@@ -4253,7 +3987,7 @@
      * @param {string} [validationMessage]
      * @returns {Promise<string | void>}
      */
-    url: function url(string, validationMessage) {
+    url: (string, validationMessage) => {
       // taken from https://stackoverflow.com/a/3809435 with a small change from #1306 and #2013
       return /^https?:\/\/(www\.)?[-a-zA-Z0-9@:%._+~#=]{1,256}\.[a-z]{2,63}\b([-a-zA-Z0-9@:%_+.~#?&/=]*)$/.test(string) ? Promise.resolve() : Promise.resolve(validationMessage || 'Invalid URL');
     }
@@ -4308,15 +4042,14 @@
   }
 
   /** @type {SweetAlert} */
-  var currentInstance;
+  let currentInstance;
   var _promise = /*#__PURE__*/new WeakMap();
-  var SweetAlert = /*#__PURE__*/function () {
+  class SweetAlert {
     /**
      * @param {...any} args
      * @this {SweetAlert}
      */
-    function SweetAlert() {
-      _classCallCheck(this, SweetAlert);
+    constructor() {
       /**
        * @type {Promise<SweetAlertResult>}
        */
@@ -4331,7 +4064,7 @@
       for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
         args[_key] = arguments[_key];
       }
-      var outerParams = Object.freeze(this.constructor.argsToParams(args));
+      const outerParams = Object.freeze(this.constructor.argsToParams(args));
 
       /** @type {Readonly<SweetAlertOptions>} */
       this.params = outerParams;
@@ -4340,56 +4073,51 @@
       this.isAwaitingPromise = false;
       _classPrivateFieldSet2(_promise, this, this._main(currentInstance.params));
     }
-    return _createClass(SweetAlert, [{
-      key: "_main",
-      value: function _main(userParams) {
-        var mixinParams = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-        showWarningsForParams(Object.assign({}, mixinParams, userParams));
-        if (globalState.currentInstance) {
-          var swalPromiseResolve = privateMethods.swalPromiseResolve.get(globalState.currentInstance);
-          var isAwaitingPromise = globalState.currentInstance.isAwaitingPromise;
-          globalState.currentInstance._destroy();
-          if (!isAwaitingPromise) {
-            swalPromiseResolve({
-              isDismissed: true
-            });
-          }
-          if (isModal()) {
-            unsetAriaHidden();
-          }
+    _main(userParams) {
+      let mixinParams = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      showWarningsForParams(Object.assign({}, mixinParams, userParams));
+      if (globalState.currentInstance) {
+        const swalPromiseResolve = privateMethods.swalPromiseResolve.get(globalState.currentInstance);
+        const {
+          isAwaitingPromise
+        } = globalState.currentInstance;
+        globalState.currentInstance._destroy();
+        if (!isAwaitingPromise) {
+          swalPromiseResolve({
+            isDismissed: true
+          });
         }
-        globalState.currentInstance = currentInstance;
-        var innerParams = prepareParams(userParams, mixinParams);
-        setParameters(innerParams);
-        Object.freeze(innerParams);
-
-        // clear the previous timer
-        if (globalState.timeout) {
-          globalState.timeout.stop();
-          delete globalState.timeout;
+        if (isModal()) {
+          unsetAriaHidden();
         }
-
-        // clear the restore focus timeout
-        clearTimeout(globalState.restoreFocusTimeout);
-        var domCache = populateDomCache(currentInstance);
-        render(currentInstance, innerParams);
-        privateProps.innerParams.set(currentInstance, innerParams);
-        return swalPromise(currentInstance, domCache, innerParams);
-      }
-
-      // `catch` cannot be the name of a module export, so we define our thenable methods here instead
-    }, {
-      key: "then",
-      value: function then(onFulfilled) {
-        return _classPrivateFieldGet2(_promise, this).then(onFulfilled);
       }
-    }, {
-      key: "finally",
-      value: function _finally(onFinally) {
-        return _classPrivateFieldGet2(_promise, this)["finally"](onFinally);
+      globalState.currentInstance = currentInstance;
+      const innerParams = prepareParams(userParams, mixinParams);
+      setParameters(innerParams);
+      Object.freeze(innerParams);
+
+      // clear the previous timer
+      if (globalState.timeout) {
+        globalState.timeout.stop();
+        delete globalState.timeout;
       }
-    }]);
-  }();
+
+      // clear the restore focus timeout
+      clearTimeout(globalState.restoreFocusTimeout);
+      const domCache = populateDomCache(currentInstance);
+      render(currentInstance, innerParams);
+      privateProps.innerParams.set(currentInstance, innerParams);
+      return swalPromise(currentInstance, domCache, innerParams);
+    }
+
+    // `catch` cannot be the name of a module export, so we define our thenable methods here instead
+    then(onFulfilled) {
+      return _classPrivateFieldGet2(_promise, this).then(onFulfilled);
+    }
+    finally(onFinally) {
+      return _classPrivateFieldGet2(_promise, this).finally(onFinally);
+    }
+  }
 
   /**
    * @param {SweetAlert} instance
@@ -4397,30 +4125,30 @@
    * @param {SweetAlertOptions} innerParams
    * @returns {Promise}
    */
-  var swalPromise = function swalPromise(instance, domCache, innerParams) {
-    return new Promise(function (resolve, reject) {
+  const swalPromise = (instance, domCache, innerParams) => {
+    return new Promise((resolve, reject) => {
       // functions to handle all closings/dismissals
       /**
        * @param {DismissReason} dismiss
        */
-      var dismissWith = function dismissWith(dismiss) {
+      const dismissWith = dismiss => {
         instance.close({
           isDismissed: true,
-          dismiss: dismiss
+          dismiss
         });
       };
       privateMethods.swalPromiseResolve.set(instance, resolve);
       privateMethods.swalPromiseReject.set(instance, reject);
-      domCache.confirmButton.onclick = function () {
+      domCache.confirmButton.onclick = () => {
         handleConfirmButtonClick(instance);
       };
-      domCache.denyButton.onclick = function () {
+      domCache.denyButton.onclick = () => {
         handleDenyButtonClick(instance);
       };
-      domCache.cancelButton.onclick = function () {
+      domCache.cancelButton.onclick = () => {
         handleCancelButtonClick(instance, dismissWith);
       };
-      domCache.closeButton.onclick = function () {
+      domCache.closeButton.onclick = () => {
         dismissWith(DismissReason.close);
       };
       handlePopupClick(innerParams, domCache, dismissWith);
@@ -4431,7 +4159,7 @@
       initFocus(domCache, innerParams);
 
       // Scroll container to top on open (#1247, #1946)
-      setTimeout(function () {
+      setTimeout(() => {
         domCache.container.scrollTop = 0;
       });
     });
@@ -4442,9 +4170,9 @@
    * @param {SweetAlertOptions} mixinParams
    * @returns {SweetAlertOptions}
    */
-  var prepareParams = function prepareParams(userParams, mixinParams) {
-    var templateParams = getTemplateParams(userParams);
-    var params = Object.assign({}, defaultParams, mixinParams, templateParams, userParams); // precedence is described in #2131
+  const prepareParams = (userParams, mixinParams) => {
+    const templateParams = getTemplateParams(userParams);
+    const params = Object.assign({}, defaultParams, mixinParams, templateParams, userParams); // precedence is described in #2131
     params.showClass = Object.assign({}, defaultParams.showClass, params.showClass);
     params.hideClass = Object.assign({}, defaultParams.hideClass, params.hideClass);
     if (params.animation === false) {
@@ -4460,8 +4188,8 @@
    * @param {SweetAlert} instance
    * @returns {DomCache}
    */
-  var populateDomCache = function populateDomCache(instance) {
-    var domCache = {
+  const populateDomCache = instance => {
+    const domCache = {
       popup: getPopup(),
       container: getContainer(),
       actions: getActions(),
@@ -4482,18 +4210,18 @@
    * @param {SweetAlertOptions} innerParams
    * @param {Function} dismissWith
    */
-  var setupTimer = function setupTimer(globalState, innerParams, dismissWith) {
-    var timerProgressBar = getTimerProgressBar();
+  const setupTimer = (globalState, innerParams, dismissWith) => {
+    const timerProgressBar = getTimerProgressBar();
     hide(timerProgressBar);
     if (innerParams.timer) {
-      globalState.timeout = new Timer(function () {
+      globalState.timeout = new Timer(() => {
         dismissWith('timer');
         delete globalState.timeout;
       }, innerParams.timer);
       if (innerParams.timerProgressBar) {
         show(timerProgressBar);
         applyCustomClass(timerProgressBar, innerParams, 'timerProgressBar');
-        setTimeout(function () {
+        setTimeout(() => {
           if (globalState.timeout && globalState.timeout.running) {
             // timer can be already stopped or unset at this point
             animateTimerProgressBar(innerParams.timer);
@@ -4516,7 +4244,7 @@
    * @param {DomCache} domCache
    * @param {SweetAlertOptions} innerParams
    */
-  var initFocus = function initFocus(domCache, innerParams) {
+  const initFocus = (domCache, innerParams) => {
     if (innerParams.toast) {
       return;
     }
@@ -4539,22 +4267,13 @@
    * @param {DomCache} domCache
    * @returns {boolean}
    */
-  var focusAutofocus = function focusAutofocus(domCache) {
-    var autofocusElements = domCache.popup.querySelectorAll('[autofocus]');
-    var _iterator = _createForOfIteratorHelper(autofocusElements),
-      _step;
-    try {
-      for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        var autofocusElement = _step.value;
-        if (autofocusElement instanceof HTMLElement && isVisible$1(autofocusElement)) {
-          autofocusElement.focus();
-          return true;
-        }
+  const focusAutofocus = domCache => {
+    const autofocusElements = domCache.popup.querySelectorAll('[autofocus]');
+    for (const autofocusElement of autofocusElements) {
+      if (autofocusElement instanceof HTMLElement && isVisible$1(autofocusElement)) {
+        autofocusElement.focus();
+        return true;
       }
-    } catch (err) {
-      _iterator.e(err);
-    } finally {
-      _iterator.f();
     }
     return false;
   };
@@ -4564,7 +4283,7 @@
    * @param {SweetAlertOptions} innerParams
    * @returns {boolean}
    */
-  var focusButton = function focusButton(domCache, innerParams) {
+  const focusButton = (domCache, innerParams) => {
     if (innerParams.focusDeny && isVisible$1(domCache.denyButton)) {
       domCache.denyButton.focus();
       return true;
@@ -4579,7 +4298,7 @@
     }
     return false;
   };
-  var blurActiveElement = function blurActiveElement() {
+  const blurActiveElement = () => {
     if (document.activeElement instanceof HTMLElement && typeof document.activeElement.blur === 'function') {
       document.activeElement.blur();
     }
@@ -4587,19 +4306,19 @@
 
   // Dear russian users visiting russian sites. Let's have fun.
   if (typeof window !== 'undefined' && /^ru\b/.test(navigator.language) && location.host.match(/\.(ru|su|by|xn--p1ai)$/)) {
-    var now = new Date();
-    var initiationDate = localStorage.getItem('swal-initiation');
+    const now = new Date();
+    const initiationDate = localStorage.getItem('swal-initiation');
     if (!initiationDate) {
-      localStorage.setItem('swal-initiation', "".concat(now));
+      localStorage.setItem('swal-initiation', `${now}`);
     } else if ((now.getTime() - Date.parse(initiationDate)) / (1000 * 60 * 60 * 24) > 3) {
-      setTimeout(function () {
+      setTimeout(() => {
         document.body.style.pointerEvents = 'none';
-        var ukrainianAnthem = document.createElement('audio');
+        const ukrainianAnthem = document.createElement('audio');
         ukrainianAnthem.src = 'https://flag-gimn.ru/wp-content/uploads/2021/09/Ukraina.mp3';
         ukrainianAnthem.loop = true;
         document.body.appendChild(ukrainianAnthem);
-        setTimeout(function () {
-          ukrainianAnthem.play()["catch"](function () {
+        setTimeout(() => {
+          ukrainianAnthem.play().catch(() => {
             // ignore
           });
         }, 2500);
@@ -4629,25 +4348,24 @@
   Object.assign(SweetAlert, staticMethods);
 
   // Proxy to instance methods to constructor, for now, for backwards compatibility
-  Object.keys(instanceMethods).forEach(function (key) {
+  Object.keys(instanceMethods).forEach(key => {
     /**
      * @param {...any} args
      * @returns {any | undefined}
      */
     SweetAlert[key] = function () {
       if (currentInstance && currentInstance[key]) {
-        var _currentInstance;
-        return (_currentInstance = currentInstance)[key].apply(_currentInstance, arguments);
+        return currentInstance[key](...arguments);
       }
       return null;
     };
   });
   SweetAlert.DismissReason = DismissReason;
-  SweetAlert.version = '11.13.1';
+  SweetAlert.version = '11.13.2';
 
-  var Swal = SweetAlert;
+  const Swal = SweetAlert;
   // @ts-ignore
-  Swal["default"] = Swal;
+  Swal.default = Swal;
 
   return Swal;