sweetalert2 11.5.0 → 11.5.2

package/dist/sweetalert2.js

@@ -1,5 +1,5 @@
 /*!
-* sweetalert2 v11.5.0
+* sweetalert2 v11.5.2
 * Released under the MIT License.
 */
 (function (global, factory) {
@@ -17,6 +17,7 @@
    * Once we have the changes from that PR in Babel, and our core class fits reasonable in *one module*
    *   then we can use that language feature.
    */
+
   var privateProps = {
     awaitingPromise: new WeakMap(),
     promise: new WeakMap(),
@@ -25,98 +26,95 @@
   };
 
   const swalPrefix = 'swal2-';
+
   /**
    * @param {string[]} items
    * @returns {object}
    */
-
   const prefix = items => {
     const result = {};
-
     for (const i in items) {
       result[items[i]] = swalPrefix + items[i];
     }
-
     return result;
   };
   const swalClasses = prefix(['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', 'no-war']);
   const iconTypes = prefix(['success', 'warning', 'info', 'question', 'error']);
 
   const consolePrefix = 'SweetAlert2:';
+
   /**
    * Filter the unique values into a new array
    *
    * @param {Array} arr
    * @returns {Array}
    */
-
   const uniqueArray = arr => {
     const result = [];
-
     for (let i = 0; i < arr.length; i++) {
       if (result.indexOf(arr[i]) === -1) {
         result.push(arr[i]);
       }
     }
-
     return result;
   };
+
   /**
    * Capitalize the first letter of a string
    *
    * @param {string} str
    * @returns {string}
    */
-
   const capitalizeFirstLetter = str => str.charAt(0).toUpperCase() + str.slice(1);
+
   /**
    * Standardize console warnings
    *
    * @param {string | Array} message
    */
-
   const warn = message => {
     console.warn("".concat(consolePrefix, " ").concat(typeof message === 'object' ? message.join(' ') : message));
   };
+
   /**
    * Standardize console errors
    *
    * @param {string} message
    */
-
   const error = message => {
     console.error("".concat(consolePrefix, " ").concat(message));
   };
+
   /**
    * Private global state for `warnOnce`
    *
    * @type {Array}
    * @private
    */
-
   const previousWarnOnceMessages = [];
+
   /**
    * Show a console warning, but only if it hasn't already been shown
    *
    * @param {string} message
    */
-
   const warnOnce = message => {
     if (!previousWarnOnceMessages.includes(message)) {
       previousWarnOnceMessages.push(message);
       warn(message);
     }
   };
+
   /**
    * Show a one-time console warning about deprecated params/methods
    *
    * @param {string} deprecatedParam
    * @param {string} useInstead
    */
-
   const warnAboutDeprecation = (deprecatedParam, useInstead) => {
     warnOnce("\"".concat(deprecatedParam, "\" is deprecated and will be removed in the next major release. Please use \"").concat(useInstead, "\" instead."));
   };
+
   /**
    * If `arg` is a function, call it (with no arguments or context) and return the result.
    * Otherwise, just pass the value through
@@ -124,25 +122,24 @@
    * @param {Function | any} arg
    * @returns {any}
    */
-
   const callIfFunction = arg => typeof arg === 'function' ? arg() : arg;
+
   /**
    * @param {any} arg
    * @returns {boolean}
    */
-
   const hasToPromiseFn = arg => arg && typeof arg.toPromise === 'function';
+
   /**
    * @param {any} arg
    * @returns {Promise}
    */
-
   const asPromise = arg => hasToPromiseFn(arg) ? arg.toPromise() : Promise.resolve(arg);
+
   /**
    * @param {any} arg
    * @returns {boolean}
    */
-
   const isPromise = arg => arg && Promise.resolve(arg) === arg;
 
   /**
@@ -150,154 +147,153 @@
    *
    * @returns {HTMLElement | null}
    */
-
   const getContainer = () => document.body.querySelector(".".concat(swalClasses.container));
+
   /**
    * @param {string} selectorString
    * @returns {HTMLElement | null}
    */
-
   const elementBySelector = selectorString => {
     const container = getContainer();
     return container ? container.querySelector(selectorString) : null;
   };
+
   /**
    * @param {string} className
    * @returns {HTMLElement | null}
    */
-
   const elementByClass = className => {
     return elementBySelector(".".concat(className));
   };
+
   /**
    * @returns {HTMLElement | null}
    */
-
-
   const getPopup = () => elementByClass(swalClasses.popup);
+
   /**
    * @returns {HTMLElement | null}
    */
-
   const getIcon = () => elementByClass(swalClasses.icon);
+
   /**
    * @returns {HTMLElement | null}
    */
-
   const getTitle = () => elementByClass(swalClasses.title);
+
   /**
    * @returns {HTMLElement | null}
    */
-
   const getHtmlContainer = () => elementByClass(swalClasses['html-container']);
+
   /**
    * @returns {HTMLElement | null}
    */
-
   const getImage = () => elementByClass(swalClasses.image);
+
   /**
    * @returns {HTMLElement | null}
    */
-
   const getProgressSteps = () => elementByClass(swalClasses['progress-steps']);
+
   /**
    * @returns {HTMLElement | null}
    */
-
   const getValidationMessage = () => elementByClass(swalClasses['validation-message']);
+
   /**
    * @returns {HTMLElement | null}
    */
-
   const getConfirmButton = () => elementBySelector(".".concat(swalClasses.actions, " .").concat(swalClasses.confirm));
+
   /**
    * @returns {HTMLElement | null}
    */
-
   const getDenyButton = () => elementBySelector(".".concat(swalClasses.actions, " .").concat(swalClasses.deny));
+
   /**
    * @returns {HTMLElement | null}
    */
-
   const getInputLabel = () => elementByClass(swalClasses['input-label']);
+
   /**
    * @returns {HTMLElement | null}
    */
-
   const getLoader = () => elementBySelector(".".concat(swalClasses.loader));
+
   /**
    * @returns {HTMLElement | null}
    */
-
   const getCancelButton = () => elementBySelector(".".concat(swalClasses.actions, " .").concat(swalClasses.cancel));
+
   /**
    * @returns {HTMLElement | null}
    */
-
   const getActions = () => elementByClass(swalClasses.actions);
+
   /**
    * @returns {HTMLElement | null}
    */
-
   const getFooter = () => elementByClass(swalClasses.footer);
+
   /**
    * @returns {HTMLElement | null}
    */
-
   const getTimerProgressBar = () => elementByClass(swalClasses['timer-progress-bar']);
+
   /**
    * @returns {HTMLElement | null}
    */
+  const getCloseButton = () => elementByClass(swalClasses.close);
 
-  const getCloseButton = () => elementByClass(swalClasses.close); // https://github.com/jkup/focusable/blob/master/index.js
-
+  // https://github.com/jkup/focusable/blob/master/index.js
   const 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";
   /**
    * @returns {HTMLElement[]}
    */
-
   const getFocusableElements = () => {
-    const focusableElementsWithTabindex = Array.from(getPopup().querySelectorAll('[tabindex]:not([tabindex="-1"]):not([tabindex="0"])')) // sort according to tabindex
+    const focusableElementsWithTabindex = Array.from(getPopup().querySelectorAll('[tabindex]:not([tabindex="-1"]):not([tabindex="0"])'))
+    // sort according to tabindex
     .sort((a, b) => {
       const tabindexA = parseInt(a.getAttribute('tabindex'));
       const tabindexB = parseInt(b.getAttribute('tabindex'));
-
       if (tabindexA > tabindexB) {
         return 1;
       } else if (tabindexA < tabindexB) {
         return -1;
       }
-
       return 0;
     });
     const otherFocusableElements = Array.from(getPopup().querySelectorAll(focusable)).filter(el => el.getAttribute('tabindex') !== '-1');
     return uniqueArray(focusableElementsWithTabindex.concat(otherFocusableElements)).filter(el => isVisible(el));
   };
+
   /**
    * @returns {boolean}
    */
-
   const isModal = () => {
     return hasClass(document.body, swalClasses.shown) && !hasClass(document.body, swalClasses['toast-shown']) && !hasClass(document.body, swalClasses['no-backdrop']);
   };
+
   /**
    * @returns {boolean}
    */
-
   const isToast = () => {
     return getPopup() && hasClass(getPopup(), swalClasses.toast);
   };
+
   /**
    * @returns {boolean}
    */
-
   const isLoading = () => {
     return getPopup().hasAttribute('data-loading');
   };
 
+  // Remember state in cases where opening and handling a modal will fiddle with it.
   const states = {
     previousBodyPadding: null
   };
+
   /**
    * Securely set innerHTML of an element
    * https://github.com/sweetalert2/sweetalert2/issues/1926
@@ -305,10 +301,8 @@
    * @param {HTMLElement} elem
    * @param {string} html
    */
-
   const setInnerHtml = (elem, html) => {
     elem.textContent = '';
-
     if (html) {
       const parser = new DOMParser();
       const parsed = parser.parseFromString(html, "text/html");
@@ -324,32 +318,29 @@
       });
     }
   };
+
   /**
    * @param {HTMLElement} elem
    * @param {string} className
    * @returns {boolean}
    */
-
   const hasClass = (elem, className) => {
     if (!className) {
       return false;
     }
-
     const classList = className.split(/\s+/);
-
     for (let i = 0; i < classList.length; i++) {
       if (!elem.classList.contains(classList[i])) {
         return false;
       }
     }
-
     return true;
   };
+
   /**
    * @param {HTMLElement} elem
    * @param {SweetAlertOptions} params
    */
-
   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)) {
@@ -357,61 +348,55 @@
       }
     });
   };
+
   /**
    * @param {HTMLElement} elem
    * @param {SweetAlertOptions} params
    * @param {string} className
    */
-
-
   const applyCustomClass = (elem, params, className) => {
     removeCustomClasses(elem, params);
-
     if (params.customClass && params.customClass[className]) {
       if (typeof params.customClass[className] !== 'string' && !params.customClass[className].forEach) {
-        return warn("Invalid type of customClass.".concat(className, "! Expected string or iterable object, got \"").concat(typeof params.customClass[className], "\""));
+        warn("Invalid type of customClass.".concat(className, "! Expected string or iterable object, got \"").concat(typeof params.customClass[className], "\""));
+        return;
       }
-
       addClass(elem, params.customClass[className]);
     }
   };
+
   /**
    * @param {HTMLElement} popup
    * @param {import('./renderers/renderInput').InputClass} inputClass
    * @returns {HTMLInputElement | null}
    */
-
   const getInput = (popup, inputClass) => {
     if (!inputClass) {
       return null;
     }
-
     switch (inputClass) {
       case 'select':
       case 'textarea':
       case 'file':
         return popup.querySelector(".".concat(swalClasses.popup, " > .").concat(swalClasses[inputClass]));
-
       case 'checkbox':
         return popup.querySelector(".".concat(swalClasses.popup, " > .").concat(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"));
-
       case 'range':
         return popup.querySelector(".".concat(swalClasses.popup, " > .").concat(swalClasses.range, " input"));
-
       default:
         return popup.querySelector(".".concat(swalClasses.popup, " > .").concat(swalClasses.input));
     }
   };
+
   /**
    * @param {HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement} input
    */
-
   const focusInput = input => {
-    input.focus(); // place cursor at end of text in text input
+    input.focus();
 
+    // place cursor at end of text in text input
     if (input.type !== 'file') {
       // http://stackoverflow.com/a/2345915
       const val = input.value;
@@ -419,21 +404,19 @@
       input.value = val;
     }
   };
+
   /**
    * @param {HTMLElement | HTMLElement[] | null} target
    * @param {string | string[] | readonly string[]} classList
    * @param {boolean} condition
    */
-
   const toggleClass = (target, classList, condition) => {
     if (!target || !classList) {
       return;
     }
-
     if (typeof classList === 'string') {
       classList = classList.split(/\s+/).filter(Boolean);
     }
-
     classList.forEach(className => {
       if (Array.isArray(target)) {
         target.forEach(elem => {
@@ -444,22 +427,23 @@
       }
     });
   };
+
   /**
    * @param {HTMLElement | HTMLElement[] | null} target
    * @param {string | string[] | readonly string[]} classList
    */
-
   const addClass = (target, classList) => {
     toggleClass(target, classList, true);
   };
+
   /**
    * @param {HTMLElement | HTMLElement[] | null} target
    * @param {string | string[] | readonly string[]} classList
    */
-
   const removeClass = (target, classList) => {
     toggleClass(target, classList, false);
   };
+
   /**
    * Get direct child of an element by class name
    *
@@ -467,122 +451,116 @@
    * @param {string} className
    * @returns {HTMLElement | null}
    */
-
   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;
       }
     }
   };
+
   /**
    * @param {HTMLElement} elem
    * @param {string} property
    * @param {*} value
    */
-
   const applyNumericalStyle = (elem, property, value) => {
     if (value === "".concat(parseInt(value))) {
       value = parseInt(value);
     }
-
     if (value || parseInt(value) === 0) {
       elem.style[property] = typeof value === 'number' ? "".concat(value, "px") : value;
     } else {
       elem.style.removeProperty(property);
     }
   };
+
   /**
    * @param {HTMLElement} elem
    * @param {string} display
    */
-
   const show = function (elem) {
     let display = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'flex';
     elem.style.display = display;
   };
+
   /**
    * @param {HTMLElement} elem
    */
-
   const hide = elem => {
     elem.style.display = 'none';
   };
+
   /**
    * @param {HTMLElement} parent
    * @param {string} selector
    * @param {string} property
    * @param {string} value
    */
-
   const setStyle = (parent, selector, property, value) => {
     /** @type {HTMLElement} */
     const el = parent.querySelector(selector);
-
     if (el) {
       el.style[property] = value;
     }
   };
+
   /**
    * @param {HTMLElement} elem
    * @param {any} condition
    * @param {string} display
    */
-
   const toggle = function (elem, condition) {
     let display = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'flex';
     condition ? show(elem, display) : hide(elem);
   };
+
   /**
    * borrowed from jquery $(elem).is(':visible') implementation
    *
    * @param {HTMLElement} elem
    * @returns {boolean}
    */
-
   const isVisible = elem => !!(elem && (elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length));
+
   /**
    * @returns {boolean}
    */
-
   const allButtonsAreHidden = () => !isVisible(getConfirmButton()) && !isVisible(getDenyButton()) && !isVisible(getCancelButton());
+
   /**
+   * @param {HTMLElement} elem
    * @returns {boolean}
    */
-
   const isScrollable = elem => !!(elem.scrollHeight > elem.clientHeight);
+
   /**
    * borrowed from https://stackoverflow.com/a/46352119
    *
    * @param {HTMLElement} elem
    * @returns {boolean}
    */
-
   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;
   };
+
   /**
    * @param {number} timer
    * @param {boolean} reset
    */
-
   const animateTimerProgressBar = function (timer) {
     let reset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
     const timerProgressBar = getTimerProgressBar();
-
     if (isVisible(timerProgressBar)) {
       if (reset) {
         timerProgressBar.style.transition = 'none';
         timerProgressBar.style.width = '100%';
       }
-
       setTimeout(() => {
         timerProgressBar.style.transition = "width ".concat(timer / 1000, "s linear");
         timerProgressBar.style.width = '0%';
@@ -603,9 +581,7 @@
   const RESTORE_FOCUS_TIMEOUT = 100;
 
   /** @type {GlobalState} */
-
   const globalState = {};
-
   const focusPreviousActiveElement = () => {
     if (globalState.previousActiveElement instanceof HTMLElement) {
       globalState.previousActiveElement.focus();
@@ -614,20 +590,18 @@
       document.body.focus();
     }
   };
+
   /**
    * Restore previous active (focused) element
    *
    * @param {boolean} returnFocus
    * @returns {Promise}
    */
-
-
   const restoreActiveElement = returnFocus => {
     return new Promise(resolve => {
       if (!returnFocus) {
         return resolve();
       }
-
       const x = window.scrollX;
       const y = window.scrollY;
       globalState.restoreFocusTimeout = setTimeout(() => {
@@ -647,39 +621,32 @@
   const isNodeEnv = () => typeof window === 'undefined' || typeof document === 'undefined';
 
   const 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, "\" />\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, "\"></select>\n   <div class=\"").concat(swalClasses.radio, "\"></div>\n   <label for=\"").concat(swalClasses.checkbox, "\" class=\"").concat(swalClasses.checkbox, "\">\n     <input type=\"checkbox\" />\n     <span class=\"").concat(swalClasses.label, "\"></span>\n   </label>\n   <textarea class=\"").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, '');
+
   /**
    * @returns {boolean}
    */
-
   const resetOldContainer = () => {
     const oldContainer = getContainer();
-
     if (!oldContainer) {
       return false;
     }
-
     oldContainer.remove();
     removeClass([document.documentElement, document.body], [swalClasses['no-backdrop'], swalClasses['toast-shown'], swalClasses['has-column']]);
     return true;
   };
-
   const resetValidationMessage = () => {
     globalState.currentInstance.resetValidationMessage();
   };
-
   const addInputChangeListeners = () => {
     const popup = getPopup();
     const input = getDirectChildByClass(popup, swalClasses.input);
     const file = getDirectChildByClass(popup, swalClasses.file);
     /** @type {HTMLInputElement} */
-
     const range = popup.querySelector(".".concat(swalClasses.range, " input"));
     /** @type {HTMLOutputElement} */
-
     const rangeOutput = popup.querySelector(".".concat(swalClasses.range, " output"));
     const select = getDirectChildByClass(popup, swalClasses.select);
     /** @type {HTMLInputElement} */
-
     const checkbox = popup.querySelector(".".concat(swalClasses.checkbox, " input"));
     const textarea = getDirectChildByClass(popup, swalClasses.textarea);
     input.oninput = resetValidationMessage;
@@ -687,72 +654,62 @@
     select.onchange = resetValidationMessage;
     checkbox.onchange = resetValidationMessage;
     textarea.oninput = resetValidationMessage;
-
     range.oninput = () => {
       resetValidationMessage();
       rangeOutput.value = range.value;
     };
-
     range.onchange = () => {
       resetValidationMessage();
       rangeOutput.value = range.value;
     };
   };
+
   /**
    * @param {string | HTMLElement} target
    * @returns {HTMLElement}
    */
-
-
   const getTarget = target => typeof target === 'string' ? document.querySelector(target) : target;
+
   /**
    * @param {SweetAlertOptions} params
    */
-
-
   const setupAccessibility = params => {
     const popup = getPopup();
     popup.setAttribute('role', params.toast ? 'alert' : 'dialog');
     popup.setAttribute('aria-live', params.toast ? 'polite' : 'assertive');
-
     if (!params.toast) {
       popup.setAttribute('aria-modal', 'true');
     }
   };
+
   /**
    * @param {HTMLElement} targetElement
    */
-
-
   const setupRTL = targetElement => {
     if (window.getComputedStyle(targetElement).direction === 'rtl') {
       addClass(getContainer(), swalClasses.rtl);
     }
   };
+
   /**
    * Add modal + backdrop + no-war message for Russians to DOM
    *
    * @param {SweetAlertOptions} params
    */
-
-
   const init = params => {
     // Clean up the old popup container if it exists
     const oldContainerExisted = resetOldContainer();
-    /* istanbul ignore if */
 
+    /* istanbul ignore if */
     if (isNodeEnv()) {
       error('SweetAlert2 requires document to initialize');
       return;
     }
-
     const container = document.createElement('div');
     container.className = swalClasses.container;
-
     if (oldContainerExisted) {
       addClass(container, swalClasses['no-transition']);
     }
-
     setInnerHtml(container, sweetHTML);
     const targetElement = getTarget(params.target);
     targetElement.appendChild(container);
@@ -765,42 +722,45 @@
    * @param {HTMLElement | object | string} param
    * @param {HTMLElement} target
    */
-
   const parseHtmlToContainer = (param, target) => {
     // DOM element
     if (param instanceof HTMLElement) {
       target.appendChild(param);
-    } // Object
+    }
+
+    // Object
     else if (typeof param === 'object') {
       handleObject(param, target);
-    } // Plain string
+    }
+
+    // Plain string
     else if (param) {
       setInnerHtml(target, param);
     }
   };
+
   /**
    * @param {object} param
    * @param {HTMLElement} target
    */
-
   const handleObject = (param, target) => {
     // JQuery element(s)
     if (param.jquery) {
       handleJqueryElem(target, param);
-    } // For other objects use their string representation
+    }
+
+    // For other objects use their string representation
     else {
       setInnerHtml(target, param.toString());
     }
   };
+
   /**
    * @param {HTMLElement} target
    * @param {HTMLElement} elem
    */
-
-
   const handleJqueryElem = (target, elem) => {
     target.textContent = '';
-
     if (0 in elem) {
       for (let i = 0; (i in elem); i++) {
         target.appendChild(elem[i].cloneNode(true));
@@ -813,21 +773,17 @@
   /**
    * @returns {'webkitAnimationEnd' | 'animationend' | false}
    */
-
   const animationEndEvent = (() => {
     // Prevent run in Node env
-
     /* istanbul ignore if */
     if (isNodeEnv()) {
       return false;
     }
-
     const testEl = document.createElement('div');
     const transEndEventNames = {
       WebkitAnimation: 'webkitAnimationEnd',
       // Chrome, Safari and Opera
       animation: 'animationend' // Standard syntax
-
     };
 
     for (const i in transEndEventNames) {
@@ -835,7 +791,6 @@
         return transEndEventNames[i];
       }
     }
-
     return false;
   })();
 
@@ -845,7 +800,6 @@
    *
    * @returns {number}
    */
-
   const measureScrollbar = () => {
     const scrollDiv = document.createElement('div');
     scrollDiv.className = swalClasses['scrollbar-measure'];
@@ -859,41 +813,43 @@
    * @param {SweetAlert2} instance
    * @param {SweetAlertOptions} params
    */
-
   const renderActions = (instance, params) => {
     const actions = getActions();
-    const loader = getLoader(); // Actions (buttons) wrapper
+    const loader = getLoader();
 
+    // Actions (buttons) wrapper
     if (!params.showConfirmButton && !params.showDenyButton && !params.showCancelButton) {
       hide(actions);
     } else {
       show(actions);
-    } // Custom class
-
+    }
 
-    applyCustomClass(actions, params, 'actions'); // Render all the buttons
+    // Custom class
+    applyCustomClass(actions, params, 'actions');
 
-    renderButtons(actions, loader, params); // Loader
+    // Render all the buttons
+    renderButtons(actions, loader, params);
 
+    // Loader
     setInnerHtml(loader, params.loaderHtml);
     applyCustomClass(loader, params, 'loader');
   };
+
   /**
    * @param {HTMLElement} actions
    * @param {HTMLElement} loader
    * @param {SweetAlertOptions} params
    */
-
   function renderButtons(actions, loader, params) {
     const confirmButton = getConfirmButton();
     const denyButton = getDenyButton();
-    const cancelButton = getCancelButton(); // Render buttons
+    const cancelButton = getCancelButton();
 
+    // Render buttons
     renderButton(confirmButton, 'confirm', params);
     renderButton(denyButton, 'deny', params);
     renderButton(cancelButton, 'cancel', params);
     handleButtonsStyling(confirmButton, denyButton, cancelButton, params);
-
     if (params.reverseButtons) {
       if (params.toast) {
         actions.insertBefore(cancelButton, confirmButton);
@@ -905,51 +861,46 @@
       }
     }
   }
+
   /**
    * @param {HTMLElement} confirmButton
    * @param {HTMLElement} denyButton
    * @param {HTMLElement} cancelButton
    * @param {SweetAlertOptions} params
    */
-
-
   function handleButtonsStyling(confirmButton, denyButton, cancelButton, params) {
     if (!params.buttonsStyling) {
       removeClass([confirmButton, denyButton, cancelButton], swalClasses.styled);
       return;
     }
+    addClass([confirmButton, denyButton, cancelButton], swalClasses.styled);
 
-    addClass([confirmButton, denyButton, cancelButton], swalClasses.styled); // Buttons background colors
-
+    // Buttons background colors
     if (params.confirmButtonColor) {
       confirmButton.style.backgroundColor = params.confirmButtonColor;
       addClass(confirmButton, swalClasses['default-outline']);
     }
-
     if (params.denyButtonColor) {
       denyButton.style.backgroundColor = params.denyButtonColor;
       addClass(denyButton, swalClasses['default-outline']);
     }
-
     if (params.cancelButtonColor) {
       cancelButton.style.backgroundColor = params.cancelButtonColor;
       addClass(cancelButton, swalClasses['default-outline']);
     }
   }
+
   /**
    * @param {HTMLElement} button
    * @param {'confirm' | 'deny' | 'cancel'} buttonType
    * @param {SweetAlertOptions} params
    */
-
-
   function renderButton(button, buttonType, params) {
     toggle(button, params["show".concat(capitalizeFirstLetter(buttonType), "Button")], 'inline-block');
     setInnerHtml(button, params["".concat(buttonType, "ButtonText")]); // Set caption text
-
     button.setAttribute('aria-label', params["".concat(buttonType, "ButtonAriaLabel")]); // ARIA label
-    // Add buttons custom classes
 
+    // Add buttons custom classes
     button.className = swalClasses[buttonType];
     applyCustomClass(button, params, "".concat(buttonType, "Button"));
     addClass(button, params["".concat(buttonType, "ButtonClass")]);
@@ -959,11 +910,11 @@
    * @param {SweetAlert2} instance
    * @param {SweetAlertOptions} params
    */
-
   const renderCloseButton = (instance, params) => {
     const closeButton = getCloseButton();
-    setInnerHtml(closeButton, params.closeButtonHtml); // Custom class
+    setInnerHtml(closeButton, params.closeButtonHtml);
 
+    // Custom class
     applyCustomClass(closeButton, params, 'closeButton');
     toggle(closeButton, params.showCloseButton);
     closeButton.setAttribute('aria-label', params.closeButtonAriaLabel);
@@ -973,25 +924,23 @@
    * @param {SweetAlert2} instance
    * @param {SweetAlertOptions} params
    */
-
   const renderContainer = (instance, params) => {
     const container = getContainer();
-
     if (!container) {
       return;
     }
-
     handleBackdropParam(container, params.backdrop);
     handlePositionParam(container, params.position);
-    handleGrowParam(container, params.grow); // Custom class
+    handleGrowParam(container, params.grow);
 
+    // Custom class
     applyCustomClass(container, params, 'container');
   };
+
   /**
    * @param {HTMLElement} container
    * @param {SweetAlertOptions['backdrop']} backdrop
    */
-
   function handleBackdropParam(container, backdrop) {
     if (typeof backdrop === 'string') {
       container.style.background = backdrop;
@@ -999,12 +948,11 @@
       addClass([document.documentElement, document.body], swalClasses['no-backdrop']);
     }
   }
+
   /**
    * @param {HTMLElement} container
    * @param {SweetAlertOptions['position']} position
    */
-
-
   function handlePositionParam(container, position) {
     if (position in swalClasses) {
       addClass(container, swalClasses[position]);
@@ -1013,16 +961,14 @@
       addClass(container, swalClasses.center);
     }
   }
+
   /**
    * @param {HTMLElement} container
    * @param {SweetAlertOptions['grow']} grow
    */
-
-
   function handleGrowParam(container, grow) {
     if (grow && typeof grow === 'string') {
       const growClass = "grow-".concat(grow);
-
       if (growClass in swalClasses) {
         addClass(container, swalClasses[growClass]);
       }
@@ -1030,120 +976,109 @@
   }
 
   /// <reference path="../../../../sweetalert2.d.ts"/>
-  /** @type {InputClass[]} */
 
+  /** @type {InputClass[]} */
   const inputClasses = ['input', 'file', 'range', 'select', 'radio', 'checkbox', 'textarea'];
+
   /**
    * @param {SweetAlert2} instance
    * @param {SweetAlertOptions} params
    */
-
   const renderInput = (instance, params) => {
     const popup = getPopup();
     const innerParams = privateProps.innerParams.get(instance);
     const rerender = !innerParams || params.input !== innerParams.input;
     inputClasses.forEach(inputClass => {
-      const inputContainer = getDirectChildByClass(popup, swalClasses[inputClass]); // set attributes
+      const inputContainer = getDirectChildByClass(popup, swalClasses[inputClass]);
 
-      setAttributes(inputClass, params.inputAttributes); // set class
+      // set attributes
+      setAttributes(inputClass, params.inputAttributes);
 
+      // set class
       inputContainer.className = swalClasses[inputClass];
-
       if (rerender) {
         hide(inputContainer);
       }
     });
-
     if (params.input) {
       if (rerender) {
         showInput(params);
-      } // set custom class
-
-
+      }
+      // set custom class
       setCustomClass(params);
     }
   };
+
   /**
    * @param {SweetAlertOptions} params
    */
-
   const showInput = params => {
     if (!renderInputType[params.input]) {
       error("Unexpected type of input! Expected \"text\", \"email\", \"password\", \"number\", \"tel\", \"select\", \"radio\", \"checkbox\", \"textarea\", \"file\" or \"url\", got \"".concat(params.input, "\""));
       return;
     }
-
     const inputContainer = getInputContainer(params.input);
     const input = renderInputType[params.input](inputContainer, params);
-    show(inputContainer); // input autofocus
+    show(inputContainer);
 
+    // input autofocus
     setTimeout(() => {
       focusInput(input);
     });
   };
+
   /**
    * @param {HTMLInputElement} input
    */
-
-
   const removeAttributes = input => {
     for (let i = 0; i < input.attributes.length; i++) {
       const attrName = input.attributes[i].name;
-
       if (!['type', 'value', 'style'].includes(attrName)) {
         input.removeAttribute(attrName);
       }
     }
   };
+
   /**
    * @param {InputClass} inputClass
    * @param {SweetAlertOptions['inputAttributes']} inputAttributes
    */
-
-
   const setAttributes = (inputClass, inputAttributes) => {
     const input = getInput(getPopup(), inputClass);
-
     if (!input) {
       return;
     }
-
     removeAttributes(input);
-
     for (const attr in inputAttributes) {
       input.setAttribute(attr, inputAttributes[attr]);
     }
   };
+
   /**
    * @param {SweetAlertOptions} params
    */
-
-
   const setCustomClass = params => {
     const inputContainer = getInputContainer(params.input);
-
     if (typeof params.customClass === 'object') {
       addClass(inputContainer, params.customClass.input);
     }
   };
+
   /**
    * @param {HTMLInputElement | HTMLTextAreaElement} input
    * @param {SweetAlertOptions} params
    */
-
-
   const setInputPlaceholder = (input, params) => {
     if (!input.placeholder || params.inputPlaceholder) {
       input.placeholder = params.inputPlaceholder;
     }
   };
+
   /**
    * @param {Input} input
    * @param {Input} prependTo
    * @param {SweetAlertOptions} params
    */
-
-
   const setInputLabel = (input, prependTo, params) => {
     if (params.inputLabel) {
       input.id = swalClasses.input;
@@ -1151,30 +1086,26 @@
       const labelClass = swalClasses['input-label'];
       label.setAttribute('for', input.id);
       label.className = labelClass;
-
       if (typeof params.customClass === 'object') {
         addClass(label, params.customClass.inputLabel);
       }
-
       label.innerText = params.inputLabel;
       prependTo.insertAdjacentElement('beforebegin', label);
     }
   };
+
   /**
    * @param {SweetAlertOptions['input']} inputType
    * @returns {HTMLElement}
    */
-
-
   const getInputContainer = inputType => {
     return getDirectChildByClass(getPopup(), swalClasses[inputType] || swalClasses.input);
   };
+
   /**
    * @param {HTMLInputElement | HTMLOutputElement | HTMLTextAreaElement} input
    * @param {SweetAlertOptions['inputValue']} inputValue
    */
-
-
   const checkAndSetInputValue = (input, inputValue) => {
     if (['string', 'number'].includes(typeof inputValue)) {
       input.value = "".concat(inputValue);
@@ -1182,16 +1113,15 @@
       warn("Unexpected type of inputValue! Expected \"string\", \"number\" or \"Promise\", got \"".concat(typeof inputValue, "\""));
     }
   };
-  /** @type {Record<string, (input: Input | HTMLElement, params: SweetAlertOptions) => Input>} */
-
 
+  /** @type {Record<string, (input: Input | HTMLElement, params: SweetAlertOptions) => Input>} */
   const renderInputType = {};
+
   /**
    * @param {HTMLInputElement} input
    * @param {SweetAlertOptions} params
    * @returns {HTMLInputElement}
    */
-
   renderInputType.text = renderInputType.email = renderInputType.password = renderInputType.number = renderInputType.tel = renderInputType.url = (input, params) => {
     checkAndSetInputValue(input, params.inputValue);
     setInputLabel(input, input, params);
@@ -1199,25 +1129,23 @@
     input.type = params.input;
     return input;
   };
+
   /**
    * @param {HTMLInputElement} input
    * @param {SweetAlertOptions} params
    * @returns {HTMLInputElement}
    */
-
-
   renderInputType.file = (input, params) => {
     setInputLabel(input, input, params);
     setInputPlaceholder(input, params);
     return input;
   };
+
   /**
    * @param {HTMLInputElement} range
    * @param {SweetAlertOptions} params
    * @returns {HTMLInputElement}
    */
-
-
   renderInputType.range = (range, params) => {
     const rangeInput = range.querySelector('input');
     const rangeOutput = range.querySelector('output');
@@ -1227,16 +1155,14 @@
     setInputLabel(rangeInput, range, params);
     return range;
   };
+
   /**
    * @param {HTMLSelectElement} select
    * @param {SweetAlertOptions} params
    * @returns {HTMLSelectElement}
    */
-
-
   renderInputType.select = (select, params) => {
     select.textContent = '';
-
     if (params.inputPlaceholder) {
       const placeholder = document.createElement('option');
       setInnerHtml(placeholder, params.inputPlaceholder);
@@ -1245,27 +1171,24 @@
       placeholder.selected = true;
       select.appendChild(placeholder);
     }
-
     setInputLabel(select, select, params);
     return select;
   };
+
   /**
    * @param {HTMLInputElement} radio
    * @returns {HTMLInputElement}
    */
-
-
   renderInputType.radio = radio => {
     radio.textContent = '';
     return radio;
   };
+
   /**
    * @param {HTMLLabelElement} checkboxContainer
    * @param {SweetAlertOptions} params
    * @returns {HTMLInputElement}
    */
-
-
   renderInputType.checkbox = (checkboxContainer, params) => {
     const checkbox = getInput(getPopup(), 'checkbox');
     checkbox.value = '1';
@@ -1275,40 +1198,36 @@
     setInnerHtml(label, params.inputPlaceholder);
     return checkbox;
   };
+
   /**
    * @param {HTMLTextAreaElement} textarea
    * @param {SweetAlertOptions} params
    * @returns {HTMLTextAreaElement}
    */
-
-
   renderInputType.textarea = (textarea, params) => {
     checkAndSetInputValue(textarea, params.inputValue);
     setInputPlaceholder(textarea, params);
     setInputLabel(textarea, textarea, params);
+
     /**
      * @param {HTMLElement} el
      * @returns {number}
      */
+    const getMargin = el => 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
-
-
+    // https://github.com/sweetalert2/sweetalert2/issues/2291
     setTimeout(() => {
       // https://github.com/sweetalert2/sweetalert2/issues/1699
       if ('MutationObserver' in window) {
         const initialPopupWidth = parseInt(window.getComputedStyle(getPopup()).width);
-
         const textareaResizeHandler = () => {
           const textareaWidth = textarea.offsetWidth + getMargin(textarea);
-
           if (textareaWidth > initialPopupWidth) {
             getPopup().style.width = "".concat(textareaWidth, "px");
           } else {
             getPopup().style.width = null;
           }
         };
-
         new MutationObserver(textareaResizeHandler).observe(textarea, {
           attributes: true,
           attributeFilter: ['style']
@@ -1322,23 +1241,26 @@
    * @param {SweetAlert2} instance
    * @param {SweetAlertOptions} params
    */
-
   const renderContent = (instance, params) => {
     const htmlContainer = getHtmlContainer();
-    applyCustomClass(htmlContainer, params, 'htmlContainer'); // Content as HTML
+    applyCustomClass(htmlContainer, params, 'htmlContainer');
 
+    // Content as HTML
     if (params.html) {
       parseHtmlToContainer(params.html, htmlContainer);
       show(htmlContainer, 'block');
-    } // Content as plain text
+    }
+
+    // Content as plain text
     else if (params.text) {
       htmlContainer.textContent = params.text;
       show(htmlContainer, 'block');
-    } // No content
+    }
+
+    // No content
     else {
       hide(htmlContainer);
     }
-
     renderInput(instance, params);
   };
 
@@ -1346,16 +1268,14 @@
    * @param {SweetAlert2} instance
    * @param {SweetAlertOptions} params
    */
-
   const renderFooter = (instance, params) => {
     const footer = getFooter();
     toggle(footer, params.footer);
-
     if (params.footer) {
       parseHtmlToContainer(params.footer, footer);
-    } // Custom class
-
+    }
 
+    // Custom class
     applyCustomClass(footer, params, 'footer');
   };
 
@@ -1363,81 +1283,78 @@
    * @param {SweetAlert2} instance
    * @param {SweetAlertOptions} params
    */
-
   const renderIcon = (instance, params) => {
     const innerParams = privateProps.innerParams.get(instance);
-    const icon = getIcon(); // if the given icon already rendered, apply the styling without re-rendering the icon
+    const icon = getIcon();
 
+    // if the given icon already rendered, apply the styling without re-rendering the icon
     if (innerParams && params.icon === innerParams.icon) {
       // Custom or default content
       setContent(icon, params);
       applyStyles(icon, params);
       return;
     }
-
     if (!params.icon && !params.iconHtml) {
       hide(icon);
       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, "\""));
       hide(icon);
       return;
     }
+    show(icon);
 
-    show(icon); // Custom or default content
-
+    // Custom or default content
     setContent(icon, params);
-    applyStyles(icon, params); // Animate icon
+    applyStyles(icon, params);
 
+    // Animate icon
     addClass(icon, params.showClass.icon);
   };
+
   /**
    * @param {HTMLElement} icon
    * @param {SweetAlertOptions} params
    */
-
   const applyStyles = (icon, params) => {
     for (const iconType in iconTypes) {
       if (params.icon !== iconType) {
         removeClass(icon, iconTypes[iconType]);
       }
     }
+    addClass(icon, iconTypes[params.icon]);
 
-    addClass(icon, iconTypes[params.icon]); // Icon color
-
-    setColor(icon, params); // Success icon background color
+    // Icon color
+    setColor(icon, params);
 
-    adjustSuccessIconBackgroundColor(); // Custom class
+    // Success icon background color
+    adjustSuccessIconBackgroundColor();
 
+    // Custom class
     applyCustomClass(icon, params, 'icon');
-  }; // Adjust success icon background color to match the popup background color
-
+  };
 
+  // Adjust success icon background color to match the popup background color
   const adjustSuccessIconBackgroundColor = () => {
     const popup = getPopup();
     const popupBackgroundColor = window.getComputedStyle(popup).getPropertyValue('background-color');
     /** @type {NodeListOf<HTMLElement>} */
-
     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;
     }
   };
-
   const 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";
   const 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";
+
   /**
    * @param {HTMLElement} icon
    * @param {SweetAlertOptions} params
    */
-
   const setContent = (icon, params) => {
     let oldContent = icon.innerHTML;
     let newContent;
-
     if (params.iconHtml) {
       newContent = iconContent(params.iconHtml);
     } else if (params.icon === 'success') {
@@ -1453,60 +1370,54 @@
       };
       newContent = iconContent(defaultIconHtml[params.icon]);
     }
-
     if (oldContent.trim() !== newContent.trim()) {
       setInnerHtml(icon, newContent);
     }
   };
+
   /**
    * @param {HTMLElement} icon
    * @param {SweetAlertOptions} params
    */
-
-
   const setColor = (icon, params) => {
     if (!params.iconColor) {
       return;
     }
-
     icon.style.color = params.iconColor;
     icon.style.borderColor = params.iconColor;
-
     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, 'backgroundColor', params.iconColor);
     }
-
     setStyle(icon, '.swal2-success-ring', 'borderColor', params.iconColor);
   };
+
   /**
    * @param {string} content
    * @returns {string}
    */
-
-
   const iconContent = content => "<div class=\"".concat(swalClasses['icon-content'], "\">").concat(content, "</div>");
 
   /**
    * @param {SweetAlert2} instance
    * @param {SweetAlertOptions} params
    */
-
   const renderImage = (instance, params) => {
     const image = getImage();
-
     if (!params.imageUrl) {
       hide(image);
       return;
     }
+    show(image, '');
 
-    show(image, ''); // Src, alt
-
+    // Src, alt
     image.setAttribute('src', params.imageUrl);
-    image.setAttribute('alt', params.imageAlt); // Width, height
+    image.setAttribute('alt', params.imageAlt);
 
+    // Width, height
     applyNumericalStyle(image, 'width', params.imageWidth);
-    applyNumericalStyle(image, 'height', params.imageHeight); // Class
+    applyNumericalStyle(image, 'height', params.imageHeight);
 
+    // Class
     image.className = swalClasses.image;
     applyCustomClass(image, params, 'image');
   };
@@ -1515,60 +1426,59 @@
    * @param {SweetAlert2} instance
    * @param {SweetAlertOptions} params
    */
-
   const renderPopup = (instance, params) => {
     const container = getContainer();
-    const popup = getPopup(); // Width
-    // https://github.com/sweetalert2/sweetalert2/issues/2170
+    const popup = getPopup();
 
+    // Width
+    // https://github.com/sweetalert2/sweetalert2/issues/2170
     if (params.toast) {
       applyNumericalStyle(container, 'width', params.width);
       popup.style.width = '100%';
       popup.insertBefore(getLoader(), getIcon());
     } else {
       applyNumericalStyle(popup, 'width', params.width);
-    } // Padding
-
+    }
 
-    applyNumericalStyle(popup, 'padding', params.padding); // Color
+    // Padding
+    applyNumericalStyle(popup, 'padding', params.padding);
 
+    // Color
     if (params.color) {
       popup.style.color = params.color;
-    } // Background
-
+    }
 
+    // Background
     if (params.background) {
       popup.style.background = params.background;
     }
+    hide(getValidationMessage());
 
-    hide(getValidationMessage()); // Classes
-
+    // Classes
     addClasses(popup, params);
   };
+
   /**
    * @param {HTMLElement} popup
    * @param {SweetAlertOptions} params
    */
-
   const addClasses = (popup, params) => {
     // Default Class + showClass when updating Swal.update({})
     popup.className = "".concat(swalClasses.popup, " ").concat(isVisible(popup) ? params.showClass.popup : '');
-
     if (params.toast) {
       addClass([document.documentElement, document.body], swalClasses['toast-shown']);
       addClass(popup, swalClasses.toast);
     } else {
       addClass(popup, swalClasses.modal);
-    } // Custom class
-
+    }
 
+    // Custom class
     applyCustomClass(popup, params, 'popup');
-
     if (typeof params.customClass === 'string') {
       addClass(popup, params.customClass);
-    } // Icon class (#1842)
-
+    }
 
+    // Icon class (#1842)
     if (params.icon) {
       addClass(popup, swalClasses["icon-".concat(params.icon)]);
     }
@@ -1578,61 +1488,51 @@
    * @param {SweetAlert2} instance
    * @param {SweetAlertOptions} params
    */
-
   const renderProgressSteps = (instance, params) => {
     const progressStepsContainer = getProgressSteps();
-
     if (!params.progressSteps || params.progressSteps.length === 0) {
       hide(progressStepsContainer);
       return;
     }
-
     show(progressStepsContainer);
     progressStepsContainer.textContent = '';
-
     if (params.currentProgressStep >= params.progressSteps.length) {
       warn('Invalid currentProgressStep parameter, it should be less than progressSteps.length ' + '(currentProgressStep like JS arrays starts from 0)');
     }
-
     params.progressSteps.forEach((step, index) => {
       const stepEl = createStepElement(step);
       progressStepsContainer.appendChild(stepEl);
-
       if (index === params.currentProgressStep) {
         addClass(stepEl, swalClasses['active-progress-step']);
       }
-
       if (index !== params.progressSteps.length - 1) {
         const lineEl = createLineElement(params);
         progressStepsContainer.appendChild(lineEl);
       }
     });
   };
+
   /**
    * @param {string} step
    * @returns {HTMLLIElement}
    */
-
   const createStepElement = step => {
     const stepEl = document.createElement('li');
     addClass(stepEl, swalClasses['progress-step']);
     setInnerHtml(stepEl, step);
     return stepEl;
   };
+
   /**
    * @param {SweetAlertOptions} params
    * @returns {HTMLLIElement}
    */
-
-
   const createLineElement = params => {
     const lineEl = document.createElement('li');
     addClass(lineEl, swalClasses['progress-step-line']);
-
     if (params.progressStepsDistance) {
       applyNumericalStyle(lineEl, 'width', params.progressStepsDistance);
     }
-
     return lineEl;
   };
 
@@ -1640,20 +1540,17 @@
    * @param {SweetAlert2} instance
    * @param {SweetAlertOptions} params
    */
-
   const renderTitle = (instance, params) => {
     const title = getTitle();
     toggle(title, params.title || params.titleText, 'block');
-
     if (params.title) {
       parseHtmlToContainer(params.title, title);
     }
-
     if (params.titleText) {
       title.innerText = params.titleText;
-    } // Custom class
-
+    }
 
+    // Custom class
     applyCustomClass(title, params, 'title');
   };
 
@@ -1661,7 +1558,6 @@
    * @param {SweetAlert2} instance
    * @param {SweetAlertOptions} params
    */
-
   const render = (instance, params) => {
     renderPopup(instance, params);
     renderContainer(instance, params);
@@ -1673,7 +1569,6 @@
     renderContent(instance, params);
     renderActions(instance, params);
     renderFooter(instance, params);
-
     if (typeof params.didRender === 'function') {
       params.didRender(getPopup());
     }
@@ -1682,18 +1577,14 @@
   /**
    * Hides loader and shows back the button which was hidden by .showLoading()
    */
-
   function hideLoading() {
     // do nothing if popup is closed
     const innerParams = privateProps.innerParams.get(this);
-
     if (!innerParams) {
       return;
     }
-
     const domCache = privateProps.domCache.get(this);
     hide(domCache.loader);
-
     if (isToast()) {
       if (innerParams.icon) {
         show(getIcon());
@@ -1701,7 +1592,6 @@
     } else {
       showRelatedButton(domCache);
     }
-
     removeClass([domCache.popup, domCache.actions], swalClasses.loading);
     domCache.popup.removeAttribute('aria-busy');
     domCache.popup.removeAttribute('data-loading');
@@ -1709,10 +1599,8 @@
     domCache.denyButton.disabled = false;
     domCache.cancelButton.disabled = false;
   }
-
   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()) {
@@ -1724,39 +1612,35 @@
    * Gets the input DOM node, this method works with input parameter.
    * @returns {HTMLElement | null}
    */
-
   function getInput$1(instance) {
     const innerParams = privateProps.innerParams.get(instance || this);
     const domCache = privateProps.domCache.get(instance || this);
-
     if (!domCache) {
       return null;
     }
-
     return getInput(domCache.popup, innerParams.input);
   }
 
   /*
    * Global function to determine if SweetAlert2 popup is shown
    */
-
   const isVisible$1 = () => {
     return isVisible(getPopup());
   };
+
   /*
    * Global function to click 'Confirm' button
    */
-
   const clickConfirm = () => getConfirmButton() && getConfirmButton().click();
+
   /*
    * Global function to click 'Deny' button
    */
-
   const clickDeny = () => getDenyButton() && getDenyButton().click();
+
   /*
    * Global function to click 'Cancel' button
    */
-
   const clickCancel = () => getCancelButton() && getCancelButton().click();
 
   const DismissReason = Object.freeze({
@@ -1770,7 +1654,6 @@
   /**
    * @param {GlobalState} globalState
    */
-
   const removeKeydownHandler = globalState => {
     if (globalState.keydownTarget && globalState.keydownHandlerAdded) {
       globalState.keydownTarget.removeEventListener('keydown', globalState.keydownHandler, {
@@ -1779,19 +1662,17 @@
       globalState.keydownHandlerAdded = false;
     }
   };
+
   /**
    * @param {SweetAlert2} instance
    * @param {GlobalState} globalState
    * @param {SweetAlertOptions} innerParams
    * @param {*} dismissWith
    */
-
   const addKeydownHandler = (instance, globalState, innerParams, dismissWith) => {
     removeKeydownHandler(globalState);
-
     if (!innerParams.toast) {
       globalState.keydownHandler = e => keydownHandler(instance, e, dismissWith);
-
       globalState.keydownTarget = innerParams.keydownListenerCapture ? window : getPopup();
       globalState.keydownListenerCapture = innerParams.keydownListenerCapture;
       globalState.keydownTarget.addEventListener('keydown', globalState.keydownHandler, {
@@ -1800,84 +1681,87 @@
       globalState.keydownHandlerAdded = true;
     }
   };
+
   /**
    * @param {SweetAlertOptions} innerParams
    * @param {number} index
    * @param {number} increment
    */
-
   const setFocus = (innerParams, index, increment) => {
-    const focusableElements = getFocusableElements(); // search for visible elements and select the next possible match
-
+    const focusableElements = getFocusableElements();
+    // search for visible elements and select the next possible match
     if (focusableElements.length) {
-      index = index + increment; // rollover to first item
+      index = index + increment;
 
+      // rollover to first item
       if (index === focusableElements.length) {
-        index = 0; // go to last item
+        index = 0;
+
+        // go to last item
       } else if (index === -1) {
         index = focusableElements.length - 1;
       }
-
       return focusableElements[index].focus();
-    } // no visible focusable elements, focus the popup
-
-
+    }
+    // no visible focusable elements, focus the popup
     getPopup().focus();
   };
   const arrowKeysNextButton = ['ArrowRight', 'ArrowDown'];
   const arrowKeysPreviousButton = ['ArrowLeft', 'ArrowUp'];
+
   /**
    * @param {SweetAlert2} instance
    * @param {KeyboardEvent} e
    * @param {function} dismissWith
    */
-
   const keydownHandler = (instance, e, dismissWith) => {
     const innerParams = privateProps.innerParams.get(instance);
-
     if (!innerParams) {
       return; // This instance has already been destroyed
-    } // Ignore keydown during IME composition
+    }
+
+    // Ignore keydown during IME composition
     // https://developer.mozilla.org/en-US/docs/Web/API/Document/keydown_event#ignoring_keydown_during_ime_composition
     // https://github.com/sweetalert2/sweetalert2/issues/720
     // https://github.com/sweetalert2/sweetalert2/issues/2406
-
-
     if (e.isComposing || e.keyCode === 229) {
       return;
     }
-
     if (innerParams.stopKeydownPropagation) {
       e.stopPropagation();
-    } // ENTER
-
+    }
 
+    // ENTER
     if (e.key === 'Enter') {
       handleEnter(instance, e, innerParams);
-    } // TAB
+    }
+
+    // TAB
     else if (e.key === 'Tab') {
       handleTab(e, innerParams);
-    } // ARROWS - switch focus between buttons
+    }
+
+    // ARROWS - switch focus between buttons
     else if ([...arrowKeysNextButton, ...arrowKeysPreviousButton].includes(e.key)) {
       handleArrows(e.key);
-    } // ESC
+    }
+
+    // ESC
     else if (e.key === 'Escape') {
       handleEsc(e, innerParams, dismissWith);
     }
   };
+
   /**
    * @param {SweetAlert2} instance
    * @param {KeyboardEvent} e
    * @param {SweetAlertOptions} innerParams
    */
-
-
   const handleEnter = (instance, e, innerParams) => {
     // https://github.com/sweetalert2/sweetalert2/issues/2386
     if (!callIfFunction(innerParams.allowEnterKey)) {
       return;
     }
-
     if (e.target && instance.getInput() && e.target instanceof HTMLElement && e.target.outerHTML === instance.getInput().outerHTML) {
       if (['textarea', 'file'].includes(innerParams.input)) {
         return; // do not submit
@@ -1887,75 +1771,66 @@
       e.preventDefault();
     }
   };
+
   /**
    * @param {KeyboardEvent} e
    * @param {SweetAlertOptions} innerParams
    */
-
-
   const handleTab = (e, innerParams) => {
     const targetElement = e.target;
     const focusableElements = getFocusableElements();
     let btnIndex = -1;
-
     for (let i = 0; i < focusableElements.length; i++) {
       if (targetElement === focusableElements[i]) {
         btnIndex = i;
         break;
       }
-    } // Cycle to the next button
-
+    }
 
+    // Cycle to the next button
     if (!e.shiftKey) {
       setFocus(innerParams, btnIndex, 1);
-    } // Cycle to the prev button
+    }
+
+    // Cycle to the prev button
     else {
       setFocus(innerParams, btnIndex, -1);
     }
-
     e.stopPropagation();
     e.preventDefault();
   };
+
   /**
    * @param {string} key
    */
-
-
   const handleArrows = key => {
     const confirmButton = getConfirmButton();
     const denyButton = getDenyButton();
     const cancelButton = getCancelButton();
-
     if (document.activeElement instanceof HTMLElement && ![confirmButton, denyButton, cancelButton].includes(document.activeElement)) {
       return;
     }
-
     const sibling = arrowKeysNextButton.includes(key) ? 'nextElementSibling' : 'previousElementSibling';
     let buttonToFocus = document.activeElement;
-
     for (let i = 0; i < getActions().children.length; i++) {
       buttonToFocus = buttonToFocus[sibling];
-
       if (!buttonToFocus) {
         return;
       }
-
       if (buttonToFocus instanceof HTMLButtonElement && isVisible(buttonToFocus)) {
         break;
       }
     }
-
     if (buttonToFocus instanceof HTMLButtonElement) {
       buttonToFocus.focus();
     }
   };
+
   /**
    * @param {KeyboardEvent} e
    * @param {SweetAlertOptions} innerParams
    * @param {function} dismissWith
    */
-
-
   const handleEsc = (e, innerParams, dismissWith) => {
     if (callIfFunction(innerParams.allowEscapeKey)) {
       e.preventDefault();
@@ -1972,11 +1847,13 @@
    * Once we have the changes from that PR in Babel, and our core class fits reasonable in *one module*
    *   then we can use that language feature.
    */
+
   var privateMethods = {
     swalPromiseResolve: new WeakMap(),
     swalPromiseReject: new WeakMap()
   };
 
+  // From https://developer.paciellogroup.com/blog/2018/06/the-current-state-of-modal-dialog-accessibility/
   // Adding aria-hidden="true" to elements outside of the active modal dialog ensures that
   // 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.
@@ -1987,11 +1864,9 @@
       if (el === getContainer() || el.contains(getContainer())) {
         return;
       }
-
       if (el.hasAttribute('aria-hidden')) {
         el.setAttribute('data-previous-aria-hidden', el.getAttribute('aria-hidden'));
       }
-
       el.setAttribute('aria-hidden', 'true');
     });
   };
@@ -2009,10 +1884,12 @@
 
   /* istanbul ignore file */
 
+  // Fix iOS scrolling http://stackoverflow.com/q/39626302
+
   const iOSfix = () => {
-    const iOS = // @ts-ignore
+    const iOS =
+    // @ts-ignore
     /iPad|iPhone|iPod/.test(navigator.userAgent) && !window.MSStream || navigator.platform === 'MacIntel' && navigator.maxTouchPoints > 1;
-
     if (iOS && !hasClass(document.body, swalClasses.iosfix)) {
       const offset = document.body.scrollTop;
       document.body.style.top = "".concat(offset * -1, "px");
@@ -2021,44 +1898,38 @@
       addBottomPaddingForTallPopups();
     }
   };
+
   /**
    * https://github.com/sweetalert2/sweetalert2/issues/1948
    */
-
   const addBottomPaddingForTallPopups = () => {
     const ua = navigator.userAgent;
     const iOS = !!ua.match(/iPad/i) || !!ua.match(/iPhone/i);
     const webkit = !!ua.match(/WebKit/i);
     const iOSSafari = iOS && webkit && !ua.match(/CriOS/i);
-
     if (iOSSafari) {
       const bottomPanelHeight = 44;
-
       if (getPopup().scrollHeight > window.innerHeight - bottomPanelHeight) {
         getContainer().style.paddingBottom = "".concat(bottomPanelHeight, "px");
       }
     }
   };
+
   /**
    * https://github.com/sweetalert2/sweetalert2/issues/1246
    */
-
-
   const lockBodyScroll = () => {
     const container = getContainer();
     let preventTouchMove;
     /**
      * @param {TouchEvent} e
      */
-
     container.ontouchstart = e => {
       preventTouchMove = shouldPreventTouchMove(e);
     };
     /**
      * @param {TouchEvent} e
      */
-
-
     container.ontouchmove = e => {
       if (preventTouchMove) {
         e.preventDefault();
@@ -2066,56 +1937,51 @@
       }
     };
   };
+
   /**
    * @param {TouchEvent} event
    * @returns {boolean}
    */
-
-
   const shouldPreventTouchMove = event => {
     const target = event.target;
     const container = getContainer();
-
     if (isStylus(event) || isZoom(event)) {
       return false;
     }
-
     if (target === container) {
       return true;
     }
-
-    if (!isScrollable(container) && target instanceof HTMLElement && target.tagName !== 'INPUT' && // #1603
-    target.tagName !== 'TEXTAREA' && // #2266
-    !(isScrollable(getHtmlContainer()) && // #1944
+    if (!isScrollable(container) && target instanceof HTMLElement && target.tagName !== 'INPUT' &&
+    // #1603
+    target.tagName !== 'TEXTAREA' &&
+    // #2266
+    !(isScrollable(getHtmlContainer()) &&
+    // #1944
     getHtmlContainer().contains(target))) {
       return true;
     }
-
     return false;
   };
+
   /**
    * https://github.com/sweetalert2/sweetalert2/issues/1786
    *
    * @param {*} event
    * @returns {boolean}
    */
-
-
   const isStylus = event => {
     return event.touches && event.touches.length && event.touches[0].touchType === 'stylus';
   };
+
   /**
    * https://github.com/sweetalert2/sweetalert2/issues/1891
    *
    * @param {TouchEvent} event
    * @returns {boolean}
    */
-
-
   const isZoom = event => {
     return event.touches && event.touches.length > 1;
   };
-
   const undoIOSfix = () => {
     if (hasClass(document.body, swalClasses.iosfix)) {
       const offset = parseInt(document.body.style.top, 10);
@@ -2129,9 +1995,8 @@
     // for queues, do not do this more than once
     if (states.previousBodyPadding !== null) {
       return;
-    } // if the body has overflow
-
-
+    }
+    // if the body has overflow
     if (document.body.scrollHeight > window.innerHeight) {
       // add padding so the content doesn't shift after removal of scrollbar
       states.previousBodyPadding = parseInt(window.getComputedStyle(document.body).getPropertyValue('padding-right'));
@@ -2156,10 +2021,9 @@
       restoreActiveElement(returnFocus).then(() => triggerDidCloseAndDispose(instance, didClose));
       removeKeydownHandler(globalState);
     }
-
-    const isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent); // workaround for #2088
+    const isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
+    // workaround for #2088
     // for some reason removing the container in Safari will scroll the document to bottom
-
     if (isSafari) {
       container.setAttribute('style', 'display:none !important');
       container.removeAttribute('class');
@@ -2167,25 +2031,20 @@
     } else {
       container.remove();
     }
-
     if (isModal()) {
       undoScrollbar();
       undoIOSfix();
       unsetAriaHidden();
     }
-
     removeBodyClasses();
   }
-
   function removeBodyClasses() {
     removeClass([document.documentElement, document.body], [swalClasses.shown, swalClasses['height-auto'], swalClasses['no-backdrop'], swalClasses['toast-shown']]);
   }
-
   function close(resolveValue) {
     resolveValue = prepareResolveValue(resolveValue);
     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) {
@@ -2200,20 +2059,15 @@
   function isAwaitingPromise() {
     return !!privateProps.awaitingPromise.get(this);
   }
-
   const triggerClosePopup = instance => {
     const popup = getPopup();
-
     if (!popup) {
       return false;
     }
-
     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);
     const backdrop = getContainer();
@@ -2222,11 +2076,9 @@
     handlePopupAnimation(instance, popup, innerParams);
     return true;
   };
-
   function rejectPromise(error) {
     const rejectPromise = privateMethods.swalPromiseReject.get(this);
     handleAwaitingPromise(this);
-
     if (rejectPromise) {
       // Reject Swal promise
       rejectPromise(error);
@@ -2234,14 +2086,13 @@
   }
   const handleAwaitingPromise = instance => {
     if (instance.isAwaitingPromise()) {
-      privateProps.awaitingPromise.delete(instance); // The instance might have been previously partly destroyed, we must resume the destroy process in this case #2335
-
+      privateProps.awaitingPromise.delete(instance);
+      // The instance might have been previously partly destroyed, we must resume the destroy process in this case #2335
       if (!privateProps.innerParams.get(instance)) {
         instance._destroy();
       }
     }
   };
-
   const prepareResolveValue = resolveValue => {
     // When user calls Swal.close()
     if (typeof resolveValue === 'undefined') {
@@ -2251,23 +2102,19 @@
         isDismissed: true
       };
     }
-
     return Object.assign({
       isConfirmed: false,
       isDenied: false,
       isDismissed: false
     }, resolveValue);
   };
-
   const handlePopupAnimation = (instance, popup, innerParams) => {
-    const container = getContainer(); // If animation is supported, animate
-
+    const container = getContainer();
+    // If animation is supported, animate
     const animationIsSupported = animationEndEvent && hasCssAnimation(popup);
-
     if (typeof innerParams.willClose === 'function') {
       innerParams.willClose(popup);
     }
-
     if (animationIsSupported) {
       animatePopup(instance, popup, container, innerParams.returnFocus, innerParams.didClose);
     } else {
@@ -2275,7 +2122,6 @@
       removePopupAndResetState(instance, container, innerParams.returnFocus, innerParams.didClose);
     }
   };
-
   const animatePopup = (instance, popup, container, returnFocus, didClose) => {
     globalState.swalCloseEventFinishedCallback = removePopupAndResetState.bind(null, instance, container, returnFocus, didClose);
     popup.addEventListener(animationEndEvent, function (e) {
@@ -2285,13 +2131,11 @@
       }
     });
   };
-
   const triggerDidCloseAndDispose = (instance, didClose) => {
     setTimeout(() => {
       if (typeof didClose === 'function') {
         didClose.bind(instance.params)();
       }
-
       instance._destroy();
     });
   };
@@ -2301,28 +2145,24 @@
    * @param {string[]} buttons
    * @param {boolean} disabled
    */
-
   function setButtonsDisabled(instance, buttons, disabled) {
     const domCache = privateProps.domCache.get(instance);
     buttons.forEach(button => {
       domCache[button].disabled = disabled;
     });
   }
+
   /**
    * @param {HTMLInputElement} input
    * @param {boolean} disabled
    */
-
-
   function setInputDisabled(input, disabled) {
     if (!input) {
       return;
     }
-
     if (input.type === 'radio') {
       const radiosContainer = input.parentNode.parentNode;
       const radios = radiosContainer.querySelectorAll('input');
-
       for (let i = 0; i < radios.length; i++) {
         radios[i].disabled = disabled;
       }
@@ -2330,7 +2170,6 @@
       input.disabled = disabled;
     }
   }
-
   function enableButtons() {
     setButtonsDisabled(this, ['confirmButton', 'denyButton', 'cancelButton'], false);
   }
@@ -2344,36 +2183,32 @@
     setInputDisabled(this.getInput(), true);
   }
 
+  // Show block with validation message
   function showValidationMessage(error) {
     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);
     const input = this.getInput();
-
     if (input) {
       input.setAttribute('aria-invalid', true);
       input.setAttribute('aria-describedby', swalClasses['validation-message']);
       focusInput(input);
       addClass(input, swalClasses.inputerror);
     }
-  } // Hide block with validation message
+  }
 
+  // Hide block with validation message
   function resetValidationMessage$1() {
     const domCache = privateProps.domCache.get(this);
-
     if (domCache.validationMessage) {
       hide(domCache.validationMessage);
     }
-
     const input = this.getInput();
-
     if (input) {
       input.removeAttribute('aria-invalid');
       input.removeAttribute('aria-describedby');
@@ -2478,84 +2313,78 @@
   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'];
   const deprecatedParams = {};
   const toastIncompatibleParams = ['allowOutsideClick', 'allowEnterKey', 'backdrop', 'focusConfirm', 'focusDeny', 'focusCancel', 'returnFocus', 'heightAuto', 'keydownListenerCapture'];
+
   /**
    * Is valid parameter
    *
    * @param {string} paramName
    * @returns {boolean}
    */
-
   const isValidParameter = paramName => {
     return Object.prototype.hasOwnProperty.call(defaultParams, paramName);
   };
+
   /**
    * Is valid parameter for Swal.update() method
    *
    * @param {string} paramName
    * @returns {boolean}
    */
-
   const isUpdatableParameter = paramName => {
     return updatableParams.indexOf(paramName) !== -1;
   };
+
   /**
    * Is deprecated parameter
    *
    * @param {string} paramName
    * @returns {string | undefined}
    */
-
   const isDeprecatedParameter = paramName => {
     return deprecatedParams[paramName];
   };
+
   /**
    * @param {string} param
    */
-
   const checkIfParamIsValid = param => {
     if (!isValidParameter(param)) {
       warn("Unknown parameter \"".concat(param, "\""));
     }
   };
+
   /**
    * @param {string} param
    */
-
-
   const checkIfToastParamIsValid = param => {
     if (toastIncompatibleParams.includes(param)) {
       warn("The parameter \"".concat(param, "\" is incompatible with toasts"));
     }
   };
+
   /**
    * @param {string} param
    */
-
-
   const checkIfParamIsDeprecated = param => {
     if (isDeprecatedParameter(param)) {
       warnAboutDeprecation(param, isDeprecatedParameter(param));
     }
   };
+
   /**
    * Show relevant warnings for given params
    *
    * @param {SweetAlertOptions} params
    */
-
-
   const showWarningsForParams = params => {
-    if (!params.backdrop && params.allowOutsideClick) {
+    if (params.backdrop === false && params.allowOutsideClick) {
       warn('"allowOutsideClick" parameter requires `backdrop` parameter to be set to `true`');
     }
-
     for (const param in params) {
       checkIfParamIsValid(param);
-
       if (params.toast) {
         checkIfToastParamIsValid(param);
       }
-
       checkIfParamIsDeprecated(param);
     }
   };
@@ -2563,15 +2392,12 @@
   /**
    * Updates popup parameters.
    */
-
   function update(params) {
     const popup = getPopup();
     const innerParams = privateProps.innerParams.get(this);
-
     if (!popup || hasClass(popup, innerParams.hideClass.popup)) {
       return 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.");
     }
-
     const validUpdatableParams = filterValidParams(params);
     const updatedParams = Object.assign({}, innerParams, validUpdatableParams);
     render(this, updatedParams);
@@ -2584,7 +2410,6 @@
       }
     });
   }
-
   const filterValidParams = params => {
     const validUpdatableParams = {};
     Object.keys(params).forEach(param => {
@@ -2600,45 +2425,40 @@
   function _destroy() {
     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
-    } // Check if there is another Swal closing
-
+    }
 
+    // Check if there is another Swal closing
     if (domCache.popup && globalState.swalCloseEventFinishedCallback) {
       globalState.swalCloseEventFinishedCallback();
       delete globalState.swalCloseEventFinishedCallback;
     }
-
     if (typeof innerParams.didDestroy === 'function') {
       innerParams.didDestroy();
     }
-
     disposeSwal(this);
   }
+
   /**
    * @param {SweetAlert2} instance
    */
-
   const disposeSwal = instance => {
-    disposeWeakMaps(instance); // Unset this.params so GC will dispose it (#1569)
+    disposeWeakMaps(instance);
+    // Unset this.params so GC will dispose it (#1569)
     // @ts-ignore
-
-    delete instance.params; // Unset globalState props so GC will dispose globalState (#1569)
-
+    delete instance.params;
+    // Unset globalState props so GC will dispose globalState (#1569)
     delete globalState.keydownHandler;
-    delete globalState.keydownTarget; // Unset currentInstance
-
+    delete globalState.keydownTarget;
+    // Unset currentInstance
     delete globalState.currentInstance;
   };
+
   /**
    * @param {SweetAlert2} 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
     // @ts-ignore
@@ -2650,12 +2470,11 @@
       unsetWeakMaps(privateProps, instance);
     }
   };
+
   /**
    * @param {object} obj
    * @param {SweetAlert2} instance
    */
-
-
   const unsetWeakMaps = (obj, instance) => {
     for (const i in obj) {
       obj[i].delete(instance);
@@ -2690,44 +2509,35 @@
    * Shows loader (spinner), this is useful with AJAX requests.
    * By default the loader be shown instead of the "Confirm" button.
    */
-
   const showLoading = buttonToReplace => {
     let popup = getPopup();
-
     if (!popup) {
       new Swal(); // eslint-disable-line no-new
     }
 
     popup = getPopup();
     const loader = getLoader();
-
     if (isToast()) {
       hide(getIcon());
     } else {
       replaceButton(popup, buttonToReplace);
     }
-
     show(loader);
     popup.setAttribute('data-loading', 'true');
     popup.setAttribute('aria-busy', 'true');
     popup.focus();
   };
-
   const replaceButton = (popup, buttonToReplace) => {
     const actions = getActions();
     const loader = getLoader();
-
     if (!buttonToReplace && isVisible(getConfirmButton())) {
       buttonToReplace = getConfirmButton();
     }
-
     show(actions);
-
     if (buttonToReplace) {
       hide(buttonToReplace);
       loader.setAttribute('data-button-to-replace', buttonToReplace.className);
     }
-
     loader.parentNode.insertBefore(loader, buttonToReplace);
     addClass([popup, actions], swalClasses.loading);
   };
@@ -2740,7 +2550,6 @@
    * @param {SweetAlert2} instance
    * @param {SweetAlertOptions} params
    */
-
   const handleInputOptionsAndValue = (instance, params) => {
     if (params.input === 'select' || params.input === 'radio') {
       handleInputOptions(instance, params);
@@ -2749,69 +2558,59 @@
       handleInputValue(instance, params);
     }
   };
+
   /**
    * @param {SweetAlert2} instance
    * @param {SweetAlertOptions} innerParams
    * @returns {string | number | File | FileList | null}
    */
-
   const getInputValue = (instance, innerParams) => {
     const input = instance.getInput();
-
     if (!input) {
       return null;
     }
-
     switch (innerParams.input) {
       case 'checkbox':
         return getCheckboxValue(input);
-
       case 'radio':
         return getRadioValue(input);
-
       case 'file':
         return getFileValue(input);
-
       default:
         return innerParams.inputAutoTrim ? input.value.trim() : input.value;
     }
   };
+
   /**
    * @param {HTMLInputElement} input
    * @returns {number}
    */
-
   const getCheckboxValue = input => input.checked ? 1 : 0;
+
   /**
    * @param {HTMLInputElement} input
    * @returns {string | null}
    */
-
-
   const getRadioValue = input => input.checked ? input.value : null;
+
   /**
    * @param {HTMLInputElement} input
    * @returns {FileList | File | null}
    */
-
-
   const getFileValue = input => input.files.length ? input.getAttribute('multiple') !== null ? input.files : input.files[0] : null;
+
   /**
    * @param {SweetAlert2} instance
    * @param {SweetAlertOptions} params
    */
-
-
   const handleInputOptions = (instance, params) => {
     const popup = getPopup();
     /**
      * @param {Record<string, any>} inputOptions
      */
-
     const processInputOptions = inputOptions => {
       populateInputOptions[params.input](popup, formatInputOptions(inputOptions), params);
     };
-
     if (hasToPromiseFn(params.inputOptions) || isPromise(params.inputOptions)) {
       showLoading(getConfirmButton());
       asPromise(params.inputOptions).then(inputOptions => {
@@ -2824,12 +2623,11 @@
       error("Unexpected type of inputOptions! Expected object, Map or Promise, got ".concat(typeof params.inputOptions));
     }
   };
+
   /**
    * @param {SweetAlert2} instance
    * @param {SweetAlertOptions} params
    */
-
-
   const handleInputValue = (instance, params) => {
     const input = instance.getInput();
     hide(input);
@@ -2846,7 +2644,6 @@
       instance.hideLoading();
     });
   };
-
   const populateInputOptions = {
     /**
      * @param {HTMLElement} popup
@@ -2860,7 +2657,6 @@
        * @param {string} optionLabel
        * @param {string} optionValue
        */
-
       const renderOption = (parent, optionLabel, optionValue) => {
         const option = document.createElement('option');
         option.value = optionValue;
@@ -2868,20 +2664,18 @@
         option.selected = isSelected(optionValue, params.inputValue);
         parent.appendChild(option);
       };
-
       inputOptions.forEach(inputOption => {
         const optionValue = inputOption[0];
-        const optionLabel = inputOption[1]; // <optgroup> spec:
+        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>
           const optgroup = document.createElement('optgroup');
           optgroup.label = optionValue;
           optgroup.disabled = false; // not configurable for now
-
           select.appendChild(optgroup);
           optionLabel.forEach(o => renderOption(optgroup, o[1], o[0]));
         } else {
@@ -2891,7 +2685,6 @@
       });
       select.focus();
     },
-
     /**
      * @param {HTMLElement} popup
      * @param {Record<string, any>} inputOptions
@@ -2907,11 +2700,9 @@
         radioInput.type = 'radio';
         radioInput.name = swalClasses.radio;
         radioInput.value = radioValue;
-
         if (isSelected(radioValue, params.inputValue)) {
           radioInput.checked = true;
         }
-
         const label = document.createElement('span');
         setInnerHtml(label, radioLabel);
         label.className = swalClasses.label;
@@ -2920,55 +2711,47 @@
         radio.appendChild(radioLabelElement);
       });
       const radios = radio.querySelectorAll('input');
-
       if (radios.length) {
         radios[0].focus();
       }
     }
   };
+
   /**
    * Converts `inputOptions` into an array of `[value, label]`s
    *
    * @param {Record<string, any>} inputOptions
    * @returns {Array<Array<string>>}
    */
-
   const formatInputOptions = inputOptions => {
     const result = [];
-
     if (typeof Map !== 'undefined' && inputOptions instanceof Map) {
       inputOptions.forEach((value, key) => {
         let valueFormatted = value;
-
         if (typeof valueFormatted === 'object') {
           // case of <optgroup>
           valueFormatted = formatInputOptions(valueFormatted);
         }
-
         result.push([key, valueFormatted]);
       });
     } else {
       Object.keys(inputOptions).forEach(key => {
         let valueFormatted = inputOptions[key];
-
         if (typeof valueFormatted === 'object') {
           // case of <optgroup>
           valueFormatted = formatInputOptions(valueFormatted);
         }
-
         result.push([key, valueFormatted]);
       });
     }
-
     return result;
   };
+
   /**
    * @param {string} optionValue
    * @param {InputValue | Promise<InputValue> | { toPromise: () => InputValue }} inputValue
    * @returns {boolean}
    */
-
-
   const isSelected = (optionValue, inputValue) => {
     return inputValue && inputValue.toString() === optionValue.toString();
   };
@@ -2976,55 +2759,49 @@
   /**
    * @param {SweetAlert2} instance
    */
-
   const handleConfirmButtonClick = instance => {
     const innerParams = privateProps.innerParams.get(instance);
     instance.disableButtons();
-
     if (innerParams.input) {
       handleConfirmOrDenyWithInput(instance, 'confirm');
     } else {
       confirm(instance, true);
     }
   };
+
   /**
    * @param {SweetAlert2} instance
    */
-
   const handleDenyButtonClick = instance => {
     const innerParams = privateProps.innerParams.get(instance);
     instance.disableButtons();
-
     if (innerParams.returnInputValueOnDeny) {
       handleConfirmOrDenyWithInput(instance, 'deny');
     } else {
       deny(instance, false);
     }
   };
+
   /**
    * @param {SweetAlert2} instance
    * @param {Function} dismissWith
    */
-
   const handleCancelButtonClick = (instance, dismissWith) => {
     instance.disableButtons();
     dismissWith(DismissReason.cancel);
   };
+
   /**
    * @param {SweetAlert2} instance
    * @param {'confirm' | 'deny'} type
    */
-
   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)));
       return;
     }
-
     const inputValue = getInputValue(instance, innerParams);
-
     if (innerParams.inputValidator) {
       handleInputValidator(instance, inputValue, type);
     } else if (!instance.getInput().checkValidity()) {
@@ -3036,13 +2813,12 @@
       confirm(instance, inputValue);
     }
   };
+
   /**
    * @param {SweetAlert2} instance
    * @param {string | number | File | FileList | null} inputValue
    * @param {'confirm' | 'deny'} type
    */
-
-
   const handleInputValidator = (instance, inputValue, type) => {
     const innerParams = privateProps.innerParams.get(instance);
     instance.disableInput();
@@ -3050,7 +2826,6 @@
     validationPromise.then(validationMessage => {
       instance.enableButtons();
       instance.enableInput();
-
       if (validationMessage) {
         instance.showValidationMessage(validationMessage);
       } else if (type === 'deny') {
@@ -3060,22 +2835,18 @@
       }
     });
   };
+
   /**
    * @param {SweetAlert2} instance
    * @param {any} value
    */
-
-
   const deny = (instance, value) => {
     const innerParams = privateProps.innerParams.get(instance || undefined);
-
     if (innerParams.showLoaderOnDeny) {
       showLoading(getDenyButton());
     }
-
     if (innerParams.preDeny) {
       privateProps.awaitingPromise.set(instance || undefined, 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
-
       const preDenyPromise = Promise.resolve().then(() => asPromise(innerParams.preDeny(value, innerParams.validationMessage)));
       preDenyPromise.then(preDenyValue => {
         if (preDenyValue === false) {
@@ -3095,47 +2866,41 @@
       });
     }
   };
+
   /**
    * @param {SweetAlert2} instance
    * @param {any} value
    */
-
-
   const succeedWith = (instance, value) => {
     instance.close({
       isConfirmed: true,
       value
     });
   };
+
   /**
    *
    * @param {SweetAlert2} instance
    * @param {string} error
    */
-
-
   const rejectWith = (instance, error$$1) => {
     // @ts-ignore
     instance.rejectPromise(error$$1);
   };
+
   /**
    *
    * @param {SweetAlert2} instance
    * @param {any} value
    */
-
-
   const confirm = (instance, value) => {
     const innerParams = privateProps.innerParams.get(instance || undefined);
-
     if (innerParams.showLoaderOnConfirm) {
       showLoading();
     }
-
     if (innerParams.preConfirm) {
       instance.resetValidationMessage();
       privateProps.awaitingPromise.set(instance || undefined, 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
-
       const preConfirmPromise = Promise.resolve().then(() => asPromise(innerParams.preConfirm(value, innerParams.validationMessage)));
       preConfirmPromise.then(preConfirmValue => {
         if (isVisible(getValidationMessage()) || preConfirmValue === false) {
@@ -3152,77 +2917,67 @@
 
   const handlePopupClick = (instance, domCache, dismissWith) => {
     const innerParams = privateProps.innerParams.get(instance);
-
     if (innerParams.toast) {
       handleToastClick(instance, domCache, dismissWith);
     } else {
       // Ignore click events that had mousedown on the popup but mouseup on the container
       // This can happen when the user drags a slider
-      handleModalMousedown(domCache); // Ignore click events that had mousedown on the container but mouseup on the popup
+      handleModalMousedown(domCache);
 
+      // Ignore click events that had mousedown on the container but mouseup on the popup
       handleContainerMousedown(domCache);
       handleModalClick(instance, domCache, dismissWith);
     }
   };
-
   const handleToastClick = (instance, domCache, dismissWith) => {
     // Closing toast by internal click
     domCache.popup.onclick = () => {
       const innerParams = privateProps.innerParams.get(instance);
-
       if (innerParams && (isAnyButtonShown(innerParams) || innerParams.timer || innerParams.input)) {
         return;
       }
-
       dismissWith(DismissReason.close);
     };
   };
+
   /**
    * @param {*} innerParams
    * @returns {boolean}
    */
-
-
   const isAnyButtonShown = innerParams => {
     return innerParams.showConfirmButton || innerParams.showDenyButton || innerParams.showCancelButton || innerParams.showCloseButton;
   };
-
   let ignoreOutsideClick = false;
-
   const handleModalMousedown = domCache => {
     domCache.popup.onmousedown = () => {
       domCache.container.onmouseup = function (e) {
-        domCache.container.onmouseup = undefined; // We only check if the mouseup target is the container because usually it doesn't
+        domCache.container.onmouseup = undefined;
+        // 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) {
           ignoreOutsideClick = true;
         }
       };
     };
   };
-
   const handleContainerMousedown = domCache => {
     domCache.container.onmousedown = () => {
       domCache.popup.onmouseup = function (e) {
-        domCache.popup.onmouseup = undefined; // We also need to check if the mouseup target is a child of the popup
-
+        domCache.popup.onmouseup = undefined;
+        // We also need to check if the mouseup target is a child of the popup
         if (e.target === domCache.popup || domCache.popup.contains(e.target)) {
           ignoreOutsideClick = true;
         }
       };
     };
   };
-
   const handleModalClick = (instance, domCache, dismissWith) => {
     domCache.container.onclick = e => {
       const innerParams = privateProps.innerParams.get(instance);
-
       if (ignoreOutsideClick) {
         ignoreOutsideClick = false;
         return;
       }
-
       if (e.target === domCache.container && callIfFunction(innerParams.allowOutsideClick)) {
         dismissWith(DismissReason.backdrop);
       }
@@ -3230,18 +2985,14 @@
   };
 
   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((name, index) => {
         const arg = args[index];
-
         if (typeof arg === 'string' || isElement(arg)) {
           params[name] = arg;
         } else if (arg !== undefined) {
@@ -3249,17 +3000,14 @@
         }
       });
     }
-
     return params;
   };
 
   function fire() {
     const Swal = this; // eslint-disable-line @typescript-eslint/no-this-alias
-
     for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
       args[_key] = arguments[_key];
     }
-
     return new Swal(...args);
   }
 
@@ -3286,36 +3034,39 @@
       _main(params, priorityMixinParams) {
         return super._main(params, Object.assign({}, mixinParams, priorityMixinParams));
       }
-
     }
-
     return MixinSwal;
   }
 
   /**
    * If `timer` parameter is set, returns number of milliseconds of timer remained.
    * Otherwise, returns undefined.
+   *
+   * @returns {number | undefined}
    */
-
   const getTimerLeft = () => {
     return globalState.timeout && globalState.timeout.getTimerLeft();
   };
+
   /**
    * Stop timer. Returns number of milliseconds of timer remained.
    * If `timer` parameter isn't set, returns undefined.
+   *
+   * @returns {number | undefined}
    */
-
   const stopTimer = () => {
     if (globalState.timeout) {
       stopTimerProgressBar();
       return globalState.timeout.stop();
     }
   };
+
   /**
    * Resume timer. Returns number of milliseconds of timer remained.
    * If `timer` parameter isn't set, returns undefined.
+   *
+   * @returns {number | undefined}
    */
-
   const resumeTimer = () => {
     if (globalState.timeout) {
       const remaining = globalState.timeout.start();
@@ -3323,20 +3074,25 @@
       return remaining;
     }
   };
+
   /**
    * Resume timer. Returns number of milliseconds of timer remained.
    * If `timer` parameter isn't set, returns undefined.
+   *
+   * @returns {number | undefined}
    */
-
   const toggleTimer = () => {
     const timer = globalState.timeout;
     return timer && (timer.running ? stopTimer() : resumeTimer());
   };
+
   /**
    * Increase timer. Returns number of milliseconds of an updated timer.
    * If `timer` parameter isn't set, returns undefined.
+   *
+   * @param {number} n
+   * @returns {number | undefined}
    */
-
   const increaseTimer = n => {
     if (globalState.timeout) {
       const remaining = globalState.timeout.increase(n);
@@ -3344,12 +3100,14 @@
       return remaining;
     }
   };
+
   /**
    * Check if timer is running. Returns true if timer is running
    * or false if timer is paused or stopped.
    * If `timer` parameter isn't set, returns undefined
+   *
+   * @returns {boolean}
    */
-
   const isTimerRunning = () => {
     return globalState.timeout && globalState.timeout.isRunning();
   };
@@ -3359,18 +3117,15 @@
   function bindClickHandler() {
     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;
     }
   }
-
   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
@@ -3434,94 +3189,76 @@
       this.running = false;
       this.start();
     }
-
     start() {
       if (!this.running) {
         this.running = true;
         this.started = new Date();
         this.id = setTimeout(this.callback, this.remaining);
       }
-
       return this.remaining;
     }
-
     stop() {
       if (this.running) {
         this.running = false;
         clearTimeout(this.id);
         this.remaining -= new Date().getTime() - this.started.getTime();
       }
-
       return this.remaining;
     }
-
     increase(n) {
       const running = this.running;
-
       if (running) {
         this.stop();
       }
-
       this.remaining += n;
-
       if (running) {
         this.start();
       }
-
       return this.remaining;
     }
-
     getTimerLeft() {
       if (this.running) {
         this.stop();
         this.start();
       }
-
       return this.remaining;
     }
-
     isRunning() {
       return this.running;
     }
-
   }
 
   const swalStringParams = ['swal-title', 'swal-html', 'swal-footer'];
+
   /**
    * @param {SweetAlertOptions} params
    * @returns {SweetAlertOptions}
    */
-
   const getTemplateParams = params => {
     /** @type {HTMLTemplateElement} */
     const template = typeof params.template === 'string' ? document.querySelector(params.template) : params.template;
-
     if (!template) {
       return {};
     }
     /** @type {DocumentFragment} */
-
-
     const templateContent = template.content;
     showWarningsForElements(templateContent);
     const result = Object.assign(getSwalParams(templateContent), getSwalFunctionParams(templateContent), getSwalButtons(templateContent), getSwalImage(templateContent), getSwalIcon(templateContent), getSwalInput(templateContent), getSwalStringParams(templateContent, swalStringParams));
     return result;
   };
+
   /**
    * @param {DocumentFragment} templateContent
    * @returns {SweetAlertOptions}
    */
-
   const getSwalParams = templateContent => {
     const result = {};
     /** @type {HTMLElement[]} */
-
     const swalParams = Array.from(templateContent.querySelectorAll('swal-param'));
     swalParams.forEach(param => {
       showWarningsForAttributes(param, ['name', 'value']);
       const paramName = param.getAttribute('name');
       const value = param.getAttribute('value');
-
       if (typeof defaultParams[paramName] === 'boolean') {
         result[paramName] = value !== 'false';
       } else if (typeof defaultParams[paramName] === 'object') {
@@ -3532,16 +3269,14 @@
     });
     return result;
   };
+
   /**
    * @param {DocumentFragment} templateContent
    * @returns {SweetAlertOptions}
    */
-
-
   const getSwalFunctionParams = templateContent => {
     const result = {};
     /** @type {HTMLElement[]} */
-
     const swalFunctions = Array.from(templateContent.querySelectorAll('swal-function-param'));
     swalFunctions.forEach(param => {
       const paramName = param.getAttribute('name');
@@ -3550,133 +3285,104 @@
     });
     return result;
   };
+
   /**
    * @param {DocumentFragment} templateContent
    * @returns {SweetAlertOptions}
    */
-
-
   const getSwalButtons = templateContent => {
     const result = {};
     /** @type {HTMLElement[]} */
-
     const swalButtons = Array.from(templateContent.querySelectorAll('swal-button'));
     swalButtons.forEach(button => {
       showWarningsForAttributes(button, ['type', 'color', 'aria-label']);
       const type = button.getAttribute('type');
       result["".concat(type, "ButtonText")] = button.innerHTML;
       result["show".concat(capitalizeFirstLetter(type), "Button")] = true;
-
       if (button.hasAttribute('color')) {
         result["".concat(type, "ButtonColor")] = button.getAttribute('color');
       }
-
       if (button.hasAttribute('aria-label')) {
         result["".concat(type, "ButtonAriaLabel")] = button.getAttribute('aria-label');
       }
     });
     return result;
   };
+
   /**
    * @param {DocumentFragment} templateContent
    * @returns {SweetAlertOptions}
    */
-
-
   const getSwalImage = templateContent => {
     const result = {};
     /** @type {HTMLElement} */
-
     const image = templateContent.querySelector('swal-image');
-
     if (image) {
       showWarningsForAttributes(image, ['src', 'width', 'height', 'alt']);
-
       if (image.hasAttribute('src')) {
         result.imageUrl = image.getAttribute('src');
       }
-
       if (image.hasAttribute('width')) {
         result.imageWidth = image.getAttribute('width');
       }
-
       if (image.hasAttribute('height')) {
         result.imageHeight = image.getAttribute('height');
       }
-
       if (image.hasAttribute('alt')) {
         result.imageAlt = image.getAttribute('alt');
       }
     }
-
     return result;
   };
+
   /**
    * @param {DocumentFragment} templateContent
    * @returns {SweetAlertOptions}
    */
-
-
   const getSwalIcon = templateContent => {
     const result = {};
     /** @type {HTMLElement} */
-
     const icon = templateContent.querySelector('swal-icon');
-
     if (icon) {
       showWarningsForAttributes(icon, ['type', 'color']);
-
       if (icon.hasAttribute('type')) {
         /** @type {SweetAlertIcon} */
         // @ts-ignore
         result.icon = icon.getAttribute('type');
       }
-
       if (icon.hasAttribute('color')) {
         result.iconColor = icon.getAttribute('color');
       }
-
       result.iconHtml = icon.innerHTML;
     }
-
     return result;
   };
+
   /**
    * @param {DocumentFragment} templateContent
    * @returns {SweetAlertOptions}
    */
-
-
   const getSwalInput = templateContent => {
     const result = {};
     /** @type {HTMLElement} */
-
     const input = templateContent.querySelector('swal-input');
-
     if (input) {
       showWarningsForAttributes(input, ['type', 'label', 'placeholder', 'value']);
       /** @type {SweetAlertInput} */
       // @ts-ignore
-
       result.input = input.getAttribute('type') || 'text';
-
       if (input.hasAttribute('label')) {
         result.inputLabel = input.getAttribute('label');
       }
-
       if (input.hasAttribute('placeholder')) {
         result.inputPlaceholder = input.getAttribute('placeholder');
       }
-
       if (input.hasAttribute('value')) {
         result.inputValue = input.getAttribute('value');
       }
     }
     /** @type {HTMLElement[]} */
-
-
     const inputOptions = Array.from(templateContent.querySelectorAll('swal-input-option'));
-
     if (inputOptions.length) {
       result.inputOptions = {};
       inputOptions.forEach(option => {
@@ -3686,54 +3392,45 @@
         result.inputOptions[optionValue] = optionName;
       });
     }
-
     return result;
   };
+
   /**
    * @param {DocumentFragment} templateContent
    * @param {string[]} paramNames
    * @returns {SweetAlertOptions}
    */
-
-
   const getSwalStringParams = (templateContent, paramNames) => {
     const result = {};
-
     for (const i in paramNames) {
       const paramName = paramNames[i];
       /** @type {HTMLElement} */
-
       const tag = templateContent.querySelector(paramName);
-
       if (tag) {
         showWarningsForAttributes(tag, []);
         result[paramName.replace(/^swal-/, '')] = tag.innerHTML.trim();
       }
     }
-
     return result;
   };
+
   /**
    * @param {DocumentFragment} templateContent
    */
-
-
   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, ">"));
       }
     });
   };
+
   /**
    * @param {HTMLElement} el
    * @param {string[]} allowedAttributes
    */
-
-
   const showWarningsForAttributes = (el, allowedAttributes) => {
     Array.from(el.attributes).forEach(attribute => {
       if (allowedAttributes.indexOf(attribute.name) === -1) {
@@ -3743,64 +3440,56 @@
   };
 
   const SHOW_CLASS_TIMEOUT = 10;
+
   /**
    * Open popup, add necessary classes and styles, fix scrollbar
    *
    * @param {SweetAlertOptions} params
    */
-
   const openPopup = params => {
     const container = getContainer();
     const popup = getPopup();
-
     if (typeof params.willOpen === 'function') {
       params.willOpen(popup);
     }
-
     const bodyStyles = window.getComputedStyle(document.body);
     const initialBodyOverflow = bodyStyles.overflowY;
-    addClasses$1(container, popup, params); // scrolling is 'hidden' until animation is done, after that 'auto'
+    addClasses$1(container, popup, params);
 
+    // scrolling is 'hidden' until animation is done, after that 'auto'
     setTimeout(() => {
       setScrollingVisibility(container, popup);
     }, SHOW_CLASS_TIMEOUT);
-
     if (isModal()) {
       fixScrollContainer(container, params.scrollbarPadding, initialBodyOverflow);
       setAriaHidden();
     }
-
     if (!isToast() && !globalState.previousActiveElement) {
       globalState.previousActiveElement = document.activeElement;
     }
-
     if (typeof params.didOpen === 'function') {
       setTimeout(() => params.didOpen(popup));
     }
-
     removeClass(container, swalClasses['no-transition']);
   };
+
   /**
    * @param {AnimationEvent} event
    */
-
   const swalOpenAnimationFinished = event => {
     const popup = getPopup();
-
     if (event.target !== popup) {
       return;
     }
-
     const container = getContainer();
     popup.removeEventListener(animationEndEvent, swalOpenAnimationFinished);
     container.style.overflowY = 'auto';
   };
+
   /**
    * @param {HTMLElement} container
    * @param {HTMLElement} popup
    */
-
-
   const setScrollingVisibility = (container, popup) => {
     if (animationEndEvent && hasCssAnimation(popup)) {
       container.style.overflowY = 'hidden';
@@ -3809,46 +3498,42 @@
       container.style.overflowY = 'auto';
     }
   };
+
   /**
    * @param {HTMLElement} container
    * @param {boolean} scrollbarPadding
    * @param {string} initialBodyOverflow
    */
-
-
   const fixScrollContainer = (container, scrollbarPadding, initialBodyOverflow) => {
     iOSfix();
-
     if (scrollbarPadding && initialBodyOverflow !== 'hidden') {
       fixScrollbar();
-    } // sweetalert2/issues/1247
-
+    }
 
+    // sweetalert2/issues/1247
     setTimeout(() => {
       container.scrollTop = 0;
     });
   };
+
   /**
    * @param {HTMLElement} container
    * @param {HTMLElement} popup
    * @param {SweetAlertOptions} params
    */
-
-
   const addClasses$1 = (container, popup, params) => {
-    addClass(container, params.showClass.backdrop); // this workaround with opacity is needed for https://github.com/sweetalert2/sweetalert2/issues/2059
-
+    addClass(container, params.showClass.backdrop);
+    // this workaround with opacity is needed for https://github.com/sweetalert2/sweetalert2/issues/2059
     popup.style.setProperty('opacity', '0', 'important');
     show(popup, 'grid');
     setTimeout(() => {
       // Animate popup right after showing it
-      addClass(popup, params.showClass.popup); // and remove the opacity workaround
-
+      addClass(popup, params.showClass.popup);
+      // and remove the opacity workaround
       popup.style.removeProperty('opacity');
     }, SHOW_CLASS_TIMEOUT); // 10ms in order to fix #2062
 
     addClass([document.documentElement, document.body], swalClasses.shown);
-
     if (params.heightAuto && params.backdrop && !params.toast) {
       addClass([document.documentElement, document.body], swalClasses['height-auto']);
     }
@@ -3863,7 +3548,6 @@
     email: (string, validationMessage) => {
       return /^[a-zA-Z0-9.+_-]+@[a-zA-Z0-9.-]+\.[a-zA-Z0-9-]{2,24}$/.test(string) ? Promise.resolve() : Promise.resolve(validationMessage || 'Invalid email address');
     },
-
     /**
      * @param {string} string
      * @param {string} validationMessage
@@ -3878,7 +3562,6 @@
   /**
    * @param {SweetAlertOptions} params
    */
-
   function setDefaultInputValidators(params) {
     // Use default `inputValidator` for supported input types if not provided
     if (!params.inputValidator) {
@@ -3889,11 +3572,10 @@
       });
     }
   }
+
   /**
    * @param {SweetAlertOptions} params
    */
-
-
   function validateCustomTargetElement(params) {
     // Determine if the custom target element is valid
     if (!params.target || typeof params.target === 'string' && !document.querySelector(params.target) || typeof params.target !== 'string' && !params.target.appendChild) {
@@ -3901,44 +3583,41 @@
       params.target = 'body';
     }
   }
+
   /**
    * Set type, text and actions on popup
    *
    * @param {SweetAlertOptions} params
    */
-
-
   function setParameters(params) {
-    setDefaultInputValidators(params); // showLoaderOnConfirm && preConfirm
+    setDefaultInputValidators(params);
 
+    // showLoaderOnConfirm && preConfirm
     if (params.showLoaderOnConfirm && !params.preConfirm) {
       warn('showLoaderOnConfirm is set to true, but preConfirm is not defined.\n' + 'showLoaderOnConfirm should be used together with preConfirm, see usage example:\n' + 'https://sweetalert2.github.io/#ajax-request');
     }
+    validateCustomTargetElement(params);
 
-    validateCustomTargetElement(params); // Replace newlines with <br> in title
-
+    // Replace newlines with <br> in title
     if (typeof params.title === 'string') {
       params.title = params.title.split('\n').join('<br />');
     }
-
     init(params);
   }
 
   let currentInstance;
-
   class SweetAlert {
     constructor() {
       // Prevent run in Node env
       if (typeof window === 'undefined') {
         return;
       }
+      currentInstance = this;
 
-      currentInstance = this; // @ts-ignore
-
+      // @ts-ignore
       for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
         args[_key] = arguments[_key];
       }
-
       const outerParams = Object.freeze(this.constructor.argsToParams(args));
       Object.defineProperties(this, {
         params: {
@@ -3947,68 +3626,61 @@
           enumerable: true,
           configurable: true
         }
-      }); // @ts-ignore
+      });
 
+      // @ts-ignore
       const promise = currentInstance._main(currentInstance.params);
-
       privateProps.promise.set(this, promise);
     }
-
     _main(userParams) {
       let mixinParams = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
       showWarningsForParams(Object.assign({}, mixinParams, userParams));
-
       if (globalState.currentInstance) {
         // @ts-ignore
         globalState.currentInstance._destroy();
-
         if (isModal()) {
           unsetAriaHidden();
         }
       }
-
       globalState.currentInstance = currentInstance;
       const innerParams = prepareParams(userParams, mixinParams);
       setParameters(innerParams);
-      Object.freeze(innerParams); // clear the previous timer
+      Object.freeze(innerParams);
 
+      // clear the previous timer
       if (globalState.timeout) {
         globalState.timeout.stop();
         delete globalState.timeout;
-      } // clear the restore focus 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
-
+    }
 
+    // `catch` cannot be the name of a module export, so we define our thenable methods here instead
     then(onFulfilled) {
       const promise = privateProps.promise.get(this);
       return promise.then(onFulfilled);
     }
-
     finally(onFinally) {
       const promise = privateProps.promise.get(this);
       return promise.finally(onFinally);
     }
-
   }
+
   /**
    * @param {SweetAlert2} instance
    * @param {DomCache} domCache
    * @param {SweetAlertOptions} innerParams
    * @returns {Promise}
    */
-
-
   const swalPromise = (instance, domCache, innerParams) => {
     return new Promise((resolve, reject) => {
       // functions to handle all closings/dismissals
-
       /**
        * @param {DismissReason} dismiss
        */
@@ -4019,60 +3691,52 @@
           dismiss
         });
       };
-
       privateMethods.swalPromiseResolve.set(instance, resolve);
       privateMethods.swalPromiseReject.set(instance, reject);
-
       domCache.confirmButton.onclick = () => {
         handleConfirmButtonClick(instance);
       };
-
       domCache.denyButton.onclick = () => {
         handleDenyButtonClick(instance);
       };
-
       domCache.cancelButton.onclick = () => {
         handleCancelButtonClick(instance, dismissWith);
       };
-
       domCache.closeButton.onclick = () => {
         // @ts-ignore
         dismissWith(DismissReason.close);
       };
-
       handlePopupClick(instance, domCache, dismissWith);
       addKeydownHandler(instance, globalState, innerParams, dismissWith);
       handleInputOptionsAndValue(instance, innerParams);
       openPopup(innerParams);
       setupTimer(globalState, innerParams, dismissWith);
-      initFocus(domCache, innerParams); // Scroll container to top on open (#1247, #1946)
+      initFocus(domCache, innerParams);
 
+      // Scroll container to top on open (#1247, #1946)
       setTimeout(() => {
         domCache.container.scrollTop = 0;
       });
     });
   };
+
   /**
    * @param {SweetAlertOptions} userParams
    * @param {SweetAlertOptions} mixinParams
    * @returns {SweetAlertOptions}
    */
-
-
   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);
     return params;
   };
+
   /**
    * @param {SweetAlert2} instance
    * @returns {DomCache}
    */
-
-
   const populateDomCache = instance => {
     const domCache = {
       popup: getPopup(),
@@ -4089,23 +3753,20 @@
     privateProps.domCache.set(instance, domCache);
     return domCache;
   };
+
   /**
    * @param {GlobalState} globalState
    * @param {SweetAlertOptions} innerParams
    * @param {Function} dismissWith
    */
-
-
   const setupTimer = (globalState$$1, innerParams, dismissWith) => {
     const timerProgressBar = getTimerProgressBar();
     hide(timerProgressBar);
-
     if (innerParams.timer) {
       globalState$$1.timeout = new Timer(() => {
         dismissWith('timer');
         delete globalState$$1.timeout;
       }, innerParams.timer);
-
       if (innerParams.timerProgressBar) {
         show(timerProgressBar);
         applyCustomClass(timerProgressBar, innerParams, 'timerProgressBar');
@@ -4118,68 +3779,62 @@
       }
     }
   };
+
   /**
    * @param {DomCache} domCache
    * @param {SweetAlertOptions} innerParams
    */
-
-
   const initFocus = (domCache, innerParams) => {
     if (innerParams.toast) {
       return;
     }
-
     if (!callIfFunction(innerParams.allowEnterKey)) {
       blurActiveElement();
       return;
     }
-
     if (!focusButton(domCache, innerParams)) {
       setFocus(innerParams, -1, 1);
     }
   };
+
   /**
    * @param {DomCache} domCache
    * @param {SweetAlertOptions} innerParams
    * @returns {boolean}
    */
-
-
   const focusButton = (domCache, innerParams) => {
     if (innerParams.focusDeny && isVisible(domCache.denyButton)) {
       domCache.denyButton.focus();
       return true;
     }
-
     if (innerParams.focusCancel && isVisible(domCache.cancelButton)) {
       domCache.cancelButton.focus();
       return true;
     }
-
     if (innerParams.focusConfirm && isVisible(domCache.confirmButton)) {
       domCache.confirmButton.focus();
       return true;
     }
-
     return false;
   };
-
   const blurActiveElement = () => {
     if (document.activeElement instanceof HTMLElement && typeof document.activeElement.blur === 'function') {
       document.activeElement.blur();
     }
-  }; // Dear russian users visiting russian sites. Let's play a game.
-
+  };
 
+  // Dear russian users visiting russian sites. Let's play a game.
   if (typeof window !== 'undefined' && /^ru\b/.test(navigator.language) && location.host.match(/\.(ru|su|xn--p1ai)$/)) {
     document.body.style.pointerEvents = 'none';
-  } // Assign instance methods from src/instanceMethods/*.js to prototype
-
+  }
 
-  Object.assign(SweetAlert.prototype, instanceMethods); // Assign static methods from src/staticMethods/*.js to constructor
+  // Assign instance methods from src/instanceMethods/*.js to prototype
+  Object.assign(SweetAlert.prototype, instanceMethods);
 
-  Object.assign(SweetAlert, staticMethods); // Proxy to instance methods to constructor, for now, for backwards compatibility
+  // Assign static methods from src/staticMethods/*.js to constructor
+  Object.assign(SweetAlert, staticMethods);
 
+  // Proxy to instance methods to constructor, for now, for backwards compatibility
   Object.keys(instanceMethods).forEach(key => {
     /**
      * @param {...any} args
@@ -4192,10 +3847,10 @@
     };
   });
   SweetAlert.DismissReason = DismissReason;
-  SweetAlert.version = '11.5.0';
-
-  const Swal = SweetAlert; // @ts-ignore
+  SweetAlert.version = '11.5.2';
 
+  const Swal = SweetAlert;
+  // @ts-ignore
   Swal.default = Swal;
 
   return Swal;