/*!
 * sweetalert2 v8.2.4
 * Released under the MIT License.
 */
(function (global, factory) {
  typeof exports === "object" && typeof module !== "undefined"
    ? (module.exports = factory())
    : typeof define === "function" && define.amd
    ? define(factory)
    : (global.Sweetalert2 = factory());
})(this, function () {
  "use strict";

  function _typeof(obj) {
    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
      _typeof = function (obj) {
        return typeof obj;
      };
    } else {
      _typeof = function (obj) {
        return obj &&
          typeof Symbol === "function" &&
          obj.constructor === Symbol &&
          obj !== Symbol.prototype
          ? "symbol"
          : typeof obj;
      };
    }

    return _typeof(obj);
  }

  function _classCallCheck(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError("Cannot call a class as a function");
    }
  }

  function _defineProperties(target, props) {
    for (var i = 0; i < props.length; i++) {
      var descriptor = props[i];
      descriptor.enumerable = descriptor.enumerable || false;
      descriptor.configurable = true;
      if ("value" in descriptor) descriptor.writable = true;
      Object.defineProperty(target, descriptor.key, descriptor);
    }
  }

  function _createClass(Constructor, protoProps, staticProps) {
    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
    if (staticProps) _defineProperties(Constructor, staticProps);
    return Constructor;
  }

  function _extends() {
    _extends =
      Object.assign ||
      function (target) {
        for (var i = 1; i < arguments.length; i++) {
          var source = arguments[i];

          for (var key in source) {
            if (Object.prototype.hasOwnProperty.call(source, key)) {
              target[key] = source[key];
            }
          }
        }

        return target;
      };

    return _extends.apply(this, arguments);
  }

  function _inherits(subClass, superClass) {
    if (typeof superClass !== "function" && superClass !== null) {
      throw new TypeError("Super expression must either be null or a function");
    }

    subClass.prototype = Object.create(superClass && superClass.prototype, {
      constructor: {
        value: subClass,
        writable: true,
        configurable: true,
      },
    });
    if (superClass) _setPrototypeOf(subClass, superClass);
  }

  function _getPrototypeOf(o) {
    _getPrototypeOf = Object.setPrototypeOf
      ? Object.getPrototypeOf
      : function _getPrototypeOf(o) {
          return o.__proto__ || Object.getPrototypeOf(o);
        };
    return _getPrototypeOf(o);
  }

  function _setPrototypeOf(o, p) {
    _setPrototypeOf =
      Object.setPrototypeOf ||
      function _setPrototypeOf(o, p) {
        o.__proto__ = p;
        return o;
      };

    return _setPrototypeOf(o, p);
  }

  function isNativeReflectConstruct() {
    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
    if (Reflect.construct.sham) return false;
    if (typeof Proxy === "function") return true;

    try {
      Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
      return true;
    } catch (e) {
      return false;
    }
  }

  function _construct(Parent, args, Class) {
    if (isNativeReflectConstruct()) {
      _construct = Reflect.construct;
    } else {
      _construct = function _construct(Parent, args, Class) {
        var a = [null];
        a.push.apply(a, args);
        var Constructor = Function.bind.apply(Parent, a);
        var instance = new Constructor();
        if (Class) _setPrototypeOf(instance, Class.prototype);
        return instance;
      };
    }

    return _construct.apply(null, arguments);
  }

  function _assertThisInitialized(self) {
    if (self === void 0) {
      throw new ReferenceError(
        "this hasn't been initialised - super() hasn't been called"
      );
    }

    return self;
  }

  function _possibleConstructorReturn(self, call) {
    if (call && (typeof call === "object" || typeof call === "function")) {
      return call;
    }

    return _assertThisInitialized(self);
  }

  function _superPropBase(object, property) {
    while (!Object.prototype.hasOwnProperty.call(object, property)) {
      object = _getPrototypeOf(object);
      if (object === null) break;
    }

    return object;
  }

  function _get(target, property, receiver) {
    if (typeof Reflect !== "undefined" && Reflect.get) {
      _get = Reflect.get;
    } else {
      _get = function _get(target, property, receiver) {
        var base = _superPropBase(target, property);

        if (!base) return;
        var desc = Object.getOwnPropertyDescriptor(base, property);

        if (desc.get) {
          return desc.get.call(receiver);
        }

        return desc.value;
      };
    }

    return _get(target, property, receiver || target);
  }

  var consolePrefix = "SweetAlert2:";
  /**
   * Filter the unique values into a new array
   * @param arr
   */

  var uniqueArray = function uniqueArray(arr) {
    var result = [];

    for (var i = 0; i < arr.length; i++) {
      if (result.indexOf(arr[i]) === -1) {
        result.push(arr[i]);
      }
    }

    return result;
  };
  /**
   * Convert NodeList to Array
   * @param nodeList
   */

  var toArray = function toArray(nodeList) {
    return Array.prototype.slice.call(nodeList);
  };
  /**
   * Converts `inputOptions` into an array of `[value, label]`s
   * @param inputOptions
   */

  var formatInputOptions = function formatInputOptions(inputOptions) {
    var result = [];

    if (typeof Map !== "undefined" && inputOptions instanceof Map) {
      inputOptions.forEach(function (value, key) {
        result.push([key, value]);
      });
    } else {
      Object.keys(inputOptions).forEach(function (key) {
        result.push([key, inputOptions[key]]);
      });
    }

    return result;
  };
  /**
   * Standardise console warnings
   * @param message
   */

  var warn = function warn(message) {
    console.warn("".concat(consolePrefix, " ").concat(message));
  };
  /**
   * Standardise console errors
   * @param message
   */

  var error = function error(message) {
    console.error("".concat(consolePrefix, " ").concat(message));
  };
  /**
   * Private global state for `warnOnce`
   * @type {Array}
   * @private
   */

  var previousWarnOnceMessages = [];
  /**
   * Show a console warning, but only if it hasn't already been shown
   * @param message
   */

  var warnOnce = function warnOnce(message) {
    if (!(previousWarnOnceMessages.indexOf(message) !== -1)) {
      previousWarnOnceMessages.push(message);
      warn(message);
    }
  };
  /**
   * If `arg` is a function, call it (with no arguments or context) and return the result.
   * Otherwise, just pass the value through
   * @param arg
   */

  var callIfFunction = function callIfFunction(arg) {
    return typeof arg === "function" ? arg() : arg;
  };
  var isPromise = function isPromise(arg) {
    return arg && Promise.resolve(arg) === arg;
  };

  var DismissReason = Object.freeze({
    cancel: "cancel",
    backdrop: "backdrop",
    close: "close",
    esc: "esc",
    timer: "timer",
  });

  var argsToParams = function argsToParams(args) {
    var params = {};

    switch (_typeof(args[0])) {
      case "object":
        _extends(params, args[0]);

        break;

      default:
        ["title", "html", "type"].forEach(function (name, index) {
          switch (_typeof(args[index])) {
            case "string":
              params[name] = args[index];
              break;

            case "undefined":
              break;

            default:
              error(
                "Unexpected type of "
                  .concat(name, '! Expected "string", got ')
                  .concat(_typeof(args[index]))
              );
          }
        });
    }

    return params;
  };

  var swalPrefix = "swal2-";
  var prefix = function prefix(items) {
    var result = {};

    for (var i in items) {
      result[items[i]] = swalPrefix + items[i];
    }

    return result;
  };
  var swalClasses = prefix([
    "container",
    "shown",
    "height-auto",
    "iosfix",
    "popup",
    "modal",
    "no-backdrop",
    "toast",
    "toast-shown",
    "toast-column",
    "fade",
    "show",
    "hide",
    "noanimation",
    "close",
    "title",
    "header",
    "content",
    "actions",
    "confirm",
    "cancel",
    "footer",
    "icon",
    "icon-text",
    "image",
    "input",
    "file",
    "range",
    "select",
    "radio",
    "checkbox",
    "label",
    "textarea",
    "inputerror",
    "validation-message",
    "progress-steps",
    "active-progress-step",
    "progress-step",
    "progress-step-line",
    "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",
  ]);
  var iconTypes = prefix(["success", "warning", "info", "question", "error"]);

  var states = {
    previousBodyPadding: null,
  };
  var hasClass = function hasClass(elem, className) {
    return elem.classList.contains(className);
  };
  var focusInput = function focusInput(input) {
    input.focus(); // place cursor at end of text in text input

    if (input.type !== "file") {
      // http://stackoverflow.com/a/2345915
      var val = input.value;
      input.value = "";
      input.value = val;
    }
  };

  var addOrRemoveClass = function addOrRemoveClass(target, classList, add) {
    if (!target || !classList) {
      return;
    }

    if (typeof classList === "string") {
      classList = classList.split(/\s+/).filter(Boolean);
    }

    classList.forEach(function (className) {
      if (target.forEach) {
        target.forEach(function (elem) {
          add
            ? elem.classList.add(className)
            : elem.classList.remove(className);
        });
      } else {
        add
          ? target.classList.add(className)
          : target.classList.remove(className);
      }
    });
  };

  var addClass = function addClass(target, classList) {
    addOrRemoveClass(target, classList, true);
  };
  var removeClass = function removeClass(target, classList) {
    addOrRemoveClass(target, classList, false);
  };
  var getChildByClass = function getChildByClass(elem, className) {
    for (var i = 0; i < elem.childNodes.length; i++) {
      if (hasClass(elem.childNodes[i], className)) {
        return elem.childNodes[i];
      }
    }
  };
  var show = function show(elem) {
    elem.style.opacity = "";
    elem.style.display = elem.id === swalClasses.content ? "block" : "flex";
  };
  var hide = function hide(elem) {
    elem.style.opacity = "";
    elem.style.display = "none";
  }; // borrowed from jquery $(elem).is(':visible') implementation

  var isVisible = function isVisible(elem) {
    return !!(
      elem &&
      (elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length)
    );
  };
  var contains = function contains(haystack, needle) {
    if (typeof haystack.contains === "function") {
      return haystack.contains(needle);
    }
  };

  var getContainer = function getContainer() {
    return document.body.querySelector("." + swalClasses.container);
  };

  var elementBySelector = function elementBySelector(selectorString) {
    var container = getContainer();
    return container ? container.querySelector(selectorString) : null;
  };

  var elementByClass = function elementByClass(className) {
    return elementBySelector("." + className);
  };

  var getPopup = function getPopup() {
    return elementByClass(swalClasses.popup);
  };
  var getIcons = function getIcons() {
    var popup = getPopup();
    return toArray(popup.querySelectorAll("." + swalClasses.icon));
  };
  var getTitle = function getTitle() {
    return elementByClass(swalClasses.title);
  };
  var getContent = function getContent() {
    return elementByClass(swalClasses.content);
  };
  var getImage = function getImage() {
    return elementByClass(swalClasses.image);
  };
  var getProgressSteps = function getProgressSteps() {
    return elementByClass(swalClasses["progress-steps"]);
  };
  var getValidationMessage = function getValidationMessage() {
    return elementByClass(swalClasses["validation-message"]);
  };
  var getConfirmButton = function getConfirmButton() {
    return elementBySelector(
      "." + swalClasses.actions + " ." + swalClasses.confirm
    );
  };
  var getCancelButton = function getCancelButton() {
    return elementBySelector(
      "." + swalClasses.actions + " ." + swalClasses.cancel
    );
  };
  var getActions = function getActions() {
    return elementByClass(swalClasses.actions);
  };
  var getFooter = function getFooter() {
    return elementByClass(swalClasses.footer);
  };
  var getCloseButton = function getCloseButton() {
    return elementByClass(swalClasses.close);
  };
  var getFocusableElements = function getFocusableElements() {
    var focusableElementsWithTabindex = toArray(
      getPopup().querySelectorAll(
        '[tabindex]:not([tabindex="-1"]):not([tabindex="0"])'
      )
    ) // sort according to tabindex
      .sort(function (a, b) {
        a = parseInt(a.getAttribute("tabindex"));
        b = parseInt(b.getAttribute("tabindex"));

        if (a > b) {
          return 1;
        } else if (a < b) {
          return -1;
        }

        return 0;
      }); // https://github.com/jkup/focusable/blob/master/index.js

    var otherFocusableElements = toArray(
      getPopup().querySelectorAll(
        'a[href], area[href], input:not([disabled]), select:not([disabled]), textarea:not([disabled]), button:not([disabled]), iframe, object, embed, [tabindex="0"], [contenteditable], audio[controls], video[controls]'
      )
    ).filter(function (el) {
      return el.getAttribute("tabindex") !== "-1";
    });
    return uniqueArray(
      focusableElementsWithTabindex.concat(otherFocusableElements)
    ).filter(function (el) {
      return isVisible(el);
    });
  };
  var isModal = function isModal() {
    return (
      !isToast() &&
      !document.body.classList.contains(swalClasses["no-backdrop"])
    );
  };
  var isToast = function isToast() {
    return document.body.classList.contains(swalClasses["toast-shown"]);
  };
  var isLoading = function isLoading() {
    return getPopup().hasAttribute("data-loading");
  };

  // Detect Node env
  var isNodeEnv = function isNodeEnv() {
    return typeof window === "undefined" || typeof document === "undefined";
  };

  var sweetHTML = '\n <div aria-labelledby="'
    .concat(swalClasses.title, '" aria-describedby="')
    .concat(swalClasses.content, '" class="')
    .concat(swalClasses.popup, '" tabindex="-1">\n   <div class="')
    .concat(swalClasses.header, '">\n     <ul class="')
    .concat(swalClasses["progress-steps"], '"></ul>\n     <div class="')
    .concat(swalClasses.icon, " ")
    .concat(
      iconTypes.error,
      '">\n       <span class="swal2-x-mark"><span class="swal2-x-mark-line-left"></span><span class="swal2-x-mark-line-right"></span></span>\n     </div>\n     <div class="'
    )
    .concat(swalClasses.icon, " ")
    .concat(iconTypes.question, '">\n       <span class="')
    .concat(
      swalClasses["icon-text"],
      '">?</span>\n      </div>\n     <div class="'
    )
    .concat(swalClasses.icon, " ")
    .concat(iconTypes.warning, '">\n       <span class="')
    .concat(
      swalClasses["icon-text"],
      '">!</span>\n      </div>\n     <div class="'
    )
    .concat(swalClasses.icon, " ")
    .concat(iconTypes.info, '">\n       <span class="')
    .concat(
      swalClasses["icon-text"],
      '">i</span>\n      </div>\n     <div class="'
    )
    .concat(swalClasses.icon, " ")
    .concat(
      iconTypes.success,
      '">\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     </div>\n     <img class="'
    )
    .concat(swalClasses.image, '" />\n     <h2 class="')
    .concat(swalClasses.title, '" id="')
    .concat(swalClasses.title, '"></h2>\n     <button type="button" class="')
    .concat(swalClasses.close, '">\xD7</button>\n   </div>\n   <div class="')
    .concat(swalClasses.content, '">\n     <div id="')
    .concat(swalClasses.content, '"></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>\n   <div class="'
    )
    .concat(swalClasses.actions, '">\n     <button type="button" class="')
    .concat(
      swalClasses.confirm,
      '">OK</button>\n     <button type="button" class="'
    )
    .concat(swalClasses.cancel, '">Cancel</button>\n   </div>\n   <div class="')
    .concat(swalClasses.footer, '">\n   </div>\n </div>\n')
    .replace(/(^|\n)\s*/g, "");
  /*
   * Add modal + backdrop to DOM
   */

  var init = function init(params) {
    // Clean up the old popup if it exists
    var c = getContainer();

    if (c) {
      c.parentNode.removeChild(c);
      removeClass(
        [document.documentElement, document.body],
        [
          swalClasses["no-backdrop"],
          swalClasses["toast-shown"],
          swalClasses["has-column"],
        ]
      );
    }
    /* istanbul ignore if */

    if (isNodeEnv()) {
      error("SweetAlert2 requires document to initialize");
      return;
    }

    var container = document.createElement("div");
    container.className = swalClasses.container;
    container.innerHTML = sweetHTML;
    var targetElement =
      typeof params.target === "string"
        ? document.querySelector(params.target)
        : params.target;
    targetElement.appendChild(container);
    var popup = getPopup();
    var content = getContent();
    var input = getChildByClass(content, swalClasses.input);
    var file = getChildByClass(content, swalClasses.file);
    var range = content.querySelector(".".concat(swalClasses.range, " input"));
    var rangeOutput = content.querySelector(
      ".".concat(swalClasses.range, " output")
    );
    var select = getChildByClass(content, swalClasses.select);
    var checkbox = content.querySelector(
      ".".concat(swalClasses.checkbox, " input")
    );
    var textarea = getChildByClass(content, swalClasses.textarea); // a11y

    popup.setAttribute("role", params.toast ? "alert" : "dialog");
    popup.setAttribute("aria-live", params.toast ? "polite" : "assertive");

    if (!params.toast) {
      popup.setAttribute("aria-modal", "true");
    } // RTL

    if (window.getComputedStyle(targetElement).direction === "rtl") {
      addClass(getContainer(), swalClasses.rtl);
    }

    var oldInputVal; // IE11 workaround, see #1109 for details

    var resetValidationMessage = function resetValidationMessage(e) {
      if (Swal.isVisible() && oldInputVal !== e.target.value) {
        Swal.resetValidationMessage();
      }

      oldInputVal = e.target.value;
    };

    input.oninput = resetValidationMessage;
    file.onchange = resetValidationMessage;
    select.onchange = resetValidationMessage;
    checkbox.onchange = resetValidationMessage;
    textarea.oninput = resetValidationMessage;

    range.oninput = function (e) {
      resetValidationMessage(e);
      rangeOutput.value = range.value;
    };

    range.onchange = function (e) {
      resetValidationMessage(e);
      range.nextSibling.value = range.value;
    };

    return popup;
  };

  var parseHtmlToContainer = function parseHtmlToContainer(param, target) {
    if (!param) {
      return hide(target);
    } // DOM element

    if (param instanceof HTMLElement) {
      target.appendChild(param); // JQuery element(s)
    } else if (_typeof(param) === "object") {
      target.innerHTML = "";

      if (0 in param) {
        for (var i = 0; i in param; i++) {
          target.appendChild(param[i].cloneNode(true));
        }
      } else {
        target.appendChild(param.cloneNode(true));
      }
    } else if (param) {
      target.innerHTML = param;
    }

    show(target);
  };

  var animationEndEvent = (function () {
    // Prevent run in Node env

    /* istanbul ignore if */
    if (isNodeEnv()) {
      return false;
    }

    var testEl = document.createElement("div");
    var transEndEventNames = {
      WebkitAnimation: "webkitAnimationEnd",
      OAnimation: "oAnimationEnd oanimationend",
      animation: "animationend",
    };

    for (var i in transEndEventNames) {
      if (
        transEndEventNames.hasOwnProperty(i) &&
        typeof testEl.style[i] !== "undefined"
      ) {
        return transEndEventNames[i];
      }
    }

    return false;
  })();

  // Measure width of scrollbar
  // https://github.com/twbs/bootstrap/blob/master/js/modal.js#L279-L286
  var measureScrollbar = function measureScrollbar() {
    var supportsTouch = "ontouchstart" in window || navigator.msMaxTouchPoints;

    if (supportsTouch) {
      return 0;
    }

    var scrollDiv = document.createElement("div");
    scrollDiv.style.width = "50px";
    scrollDiv.style.height = "50px";
    scrollDiv.style.overflow = "scroll";
    document.body.appendChild(scrollDiv);
    var scrollbarWidth = scrollDiv.offsetWidth - scrollDiv.clientWidth;
    document.body.removeChild(scrollDiv);
    return scrollbarWidth;
  };

  var renderActions = function renderActions(params) {
    var actions = getActions();
    var confirmButton = getConfirmButton();
    var cancelButton = getCancelButton(); // Actions (buttons) wrapper

    if (!params.showConfirmButton && !params.showCancelButton) {
      hide(actions);
    } else {
      show(actions);
    } // Cancel button

    if (params.showCancelButton) {
      cancelButton.style.display = "inline-block";
    } else {
      hide(cancelButton);
    } // Confirm button

    if (params.showConfirmButton) {
      confirmButton.style.removeProperty("display");
    } else {
      hide(confirmButton);
    } // Edit text on confirm and cancel buttons

    confirmButton.innerHTML = params.confirmButtonText;
    cancelButton.innerHTML = params.cancelButtonText; // ARIA labels for confirm and cancel buttons

    confirmButton.setAttribute("aria-label", params.confirmButtonAriaLabel);
    cancelButton.setAttribute("aria-label", params.cancelButtonAriaLabel); // Add buttons custom classes

    confirmButton.className = swalClasses.confirm;
    addClass(confirmButton, params.confirmButtonClass);
    cancelButton.className = swalClasses.cancel;
    addClass(cancelButton, params.cancelButtonClass); // Buttons styling

    if (params.buttonsStyling) {
      addClass([confirmButton, cancelButton], swalClasses.styled); // Buttons background colors

      if (params.confirmButtonColor) {
        confirmButton.style.backgroundColor = params.confirmButtonColor;
      }

      if (params.cancelButtonColor) {
        cancelButton.style.backgroundColor = params.cancelButtonColor;
      } // Loading state

      var confirmButtonBackgroundColor = window
        .getComputedStyle(confirmButton)
        .getPropertyValue("background-color");
      confirmButton.style.borderLeftColor = confirmButtonBackgroundColor;
      confirmButton.style.borderRightColor = confirmButtonBackgroundColor;
    } else {
      removeClass([confirmButton, cancelButton], swalClasses.styled);
      confirmButton.style.backgroundColor =
        confirmButton.style.borderLeftColor =
        confirmButton.style.borderRightColor =
          "";
      cancelButton.style.backgroundColor =
        cancelButton.style.borderLeftColor =
        cancelButton.style.borderRightColor =
          "";
    }
  };

  var renderContent = function renderContent(params) {
    var content = getContent().querySelector("#" + swalClasses.content); // Content as HTML

    if (params.html) {
      parseHtmlToContainer(params.html, content); // Content as plain text
    } else if (params.text) {
      content.textContent = params.text;
      show(content);
    } else {
      hide(content);
    }
  };

  var renderIcon = function renderIcon(params) {
    var icons = getIcons();

    for (var i = 0; i < icons.length; i++) {
      hide(icons[i]);
    }

    if (params.type) {
      if (Object.keys(iconTypes).indexOf(params.type) !== -1) {
        var icon = Swal.getPopup().querySelector(
          ".".concat(swalClasses.icon, ".").concat(iconTypes[params.type])
        );
        show(icon); // Animate icon

        if (params.animation) {
          addClass(icon, "swal2-animate-".concat(params.type, "-icon"));
        }
      } else {
        error(
          'Unknown type! Expected "success", "error", "warning", "info" or "question", got "'.concat(
            params.type,
            '"'
          )
        );
      }
    }
  };

  var renderImage = function renderImage(params) {
    var image = getImage();

    if (params.imageUrl) {
      image.setAttribute("src", params.imageUrl);
      image.setAttribute("alt", params.imageAlt);
      show(image);

      if (params.imageWidth) {
        image.setAttribute("width", params.imageWidth);
      } else {
        image.removeAttribute("width");
      }

      if (params.imageHeight) {
        image.setAttribute("height", params.imageHeight);
      } else {
        image.removeAttribute("height");
      }

      image.className = swalClasses.image;

      if (params.imageClass) {
        addClass(image, params.imageClass);
      }
    } else {
      hide(image);
    }
  };

  var renderProgressSteps = function renderProgressSteps(params) {
    var progressStepsContainer = getProgressSteps();
    var currentProgressStep = parseInt(
      params.currentProgressStep === null
        ? Swal.getQueueStep()
        : params.currentProgressStep,
      10
    );

    if (params.progressSteps && params.progressSteps.length) {
      show(progressStepsContainer);
      progressStepsContainer.innerHTML = "";

      if (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(function (step, index) {
        var stepEl = document.createElement("li");
        addClass(stepEl, swalClasses["progress-step"]);
        stepEl.innerHTML = step;

        if (index === currentProgressStep) {
          addClass(stepEl, swalClasses["active-progress-step"]);
        }

        progressStepsContainer.appendChild(stepEl);

        if (index !== params.progressSteps.length - 1) {
          var line = document.createElement("li");
          addClass(line, swalClasses["progress-step-line"]);

          if (params.progressStepsDistance) {
            line.style.width = params.progressStepsDistance;
          }

          progressStepsContainer.appendChild(line);
        }
      });
    } else {
      hide(progressStepsContainer);
    }
  };

  var renderTitle = function renderTitle(params) {
    var title = getTitle();

    if (params.titleText) {
      title.innerText = params.titleText;
    } else if (params.title) {
      if (typeof params.title === "string") {
        params.title = params.title.split("\n").join("<br />");
      }

      parseHtmlToContainer(params.title, title);
    }
  };

  /*
   * Global function to determine if SweetAlert2 popup is shown
   */

  var isVisible$1 = function isVisible$$1() {
    return isVisible(getPopup());
  };
  /*
   * Global function to click 'Confirm' button
   */

  var clickConfirm = function clickConfirm() {
    return getConfirmButton().click();
  };
  /*
   * Global function to click 'Cancel' button
   */

  var clickCancel = function clickCancel() {
    return getCancelButton().click();
  };

  function fire() {
    var Swal = this;

    for (
      var _len = arguments.length, args = new Array(_len), _key = 0;
      _key < _len;
      _key++
    ) {
      args[_key] = arguments[_key];
    }

    return _construct(Swal, args);
  }

  /**
   * Returns an extended version of `Swal` containing `params` as defaults.
   * Useful for reusing Swal configuration.
   *
   * For example:
   *
   * Before:
   * const textPromptOptions = { input: 'text', showCancelButton: true }
   * const {value: firstName} = await Swal.fire({ ...textPromptOptions, title: 'What is your first name?' })
   * const {value: lastName} = await Swal.fire({ ...textPromptOptions, title: 'What is your last name?' })
   *
   * After:
   * const TextPrompt = Swal.mixin({ input: 'text', showCancelButton: true })
   * const {value: firstName} = await TextPrompt('What is your first name?')
   * const {value: lastName} = await TextPrompt('What is your last name?')
   *
   * @param mixinParams
   */
  function mixin(mixinParams) {
    var MixinSwal =
      /*#__PURE__*/
      (function (_this) {
        _inherits(MixinSwal, _this);

        function MixinSwal() {
          _classCallCheck(this, MixinSwal);

          return _possibleConstructorReturn(
            this,
            _getPrototypeOf(MixinSwal).apply(this, arguments)
          );
        }

        _createClass(MixinSwal, [
          {
            key: "_main",
            value: function _main(params) {
              return _get(
                _getPrototypeOf(MixinSwal.prototype),
                "_main",
                this
              ).call(this, _extends({}, mixinParams, params));
            },
          },
        ]);

        return MixinSwal;
      })(this);

    return MixinSwal;
  }

  // private global state for the queue feature
  var currentSteps = [];
  /*
   * Global function for chaining sweetAlert popups
   */

  var queue = function queue(steps) {
    var Swal = this;
    currentSteps = steps;

    var resetQueue = function resetQueue() {
      currentSteps = [];
      document.body.removeAttribute("data-swal2-queue-step");
    };

    var queueResult = [];
    return new Promise(function (resolve) {
      (function step(i, callback) {
        if (i < currentSteps.length) {
          document.body.setAttribute("data-swal2-queue-step", i);
          Swal.fire(currentSteps[i]).then(function (result) {
            if (typeof result.value !== "undefined") {
              queueResult.push(result.value);
              step(i + 1, callback);
            } else {
              resetQueue();
              resolve({
                dismiss: result.dismiss,
              });
            }
          });
        } else {
          resetQueue();
          resolve({
            value: queueResult,
          });
        }
      })(0);
    });
  };
  /*
   * Global function for getting the index of current popup in queue
   */

  var getQueueStep = function getQueueStep() {
    return document.body.getAttribute("data-swal2-queue-step");
  };
  /*
   * Global function for inserting a popup to the queue
   */

  var insertQueueStep = function insertQueueStep(step, index) {
    if (index && index < currentSteps.length) {
      return currentSteps.splice(index, 0, step);
    }

    return currentSteps.push(step);
  };
  /*
   * Global function for deleting a popup from the queue
   */

  var deleteQueueStep = function deleteQueueStep(index) {
    if (typeof currentSteps[index] !== "undefined") {
      currentSteps.splice(index, 1);
    }
  };

  /**
   * Show spinner instead of Confirm button and disable Cancel button
   */

  var showLoading = function showLoading() {
    var popup = getPopup();

    if (!popup) {
      Swal.fire("");
    }

    popup = getPopup();
    var actions = getActions();
    var confirmButton = getConfirmButton();
    var cancelButton = getCancelButton();
    show(actions);
    show(confirmButton);
    addClass([popup, actions], swalClasses.loading);
    confirmButton.disabled = true;
    cancelButton.disabled = true;
    popup.setAttribute("data-loading", true);
    popup.setAttribute("aria-busy", true);
    popup.focus();
  };

  var RESTORE_FOCUS_TIMEOUT = 100;

  var globalState = {};
  var restoreActiveElement = function restoreActiveElement() {
    return new Promise(function (resolve) {
      var x = window.scrollX;
      var y = window.scrollY;
      globalState.restoreFocusTimeout = setTimeout(function () {
        if (
          globalState.previousActiveElement &&
          globalState.previousActiveElement.focus
        ) {
          globalState.previousActiveElement.focus();
          globalState.previousActiveElement = null;
        } else if (document.body) {
          document.body.focus();
        }

        resolve();
      }, RESTORE_FOCUS_TIMEOUT); // issues/900

      if (typeof x !== "undefined" && typeof y !== "undefined") {
        // IE doesn't have scrollX/scrollY support
        window.scrollTo(x, y);
      }
    });
  };

  /**
   * If `timer` parameter is set, returns number of milliseconds of timer remained.
   * Otherwise, returns undefined.
   */

  var getTimerLeft = function getTimerLeft() {
    return globalState.timeout && globalState.timeout.getTimerLeft();
  };
  /**
   * Stop timer. Returns number of milliseconds of timer remained.
   * If `timer` parameter isn't set, returns undefined.
   */

  var stopTimer = function stopTimer() {
    return globalState.timeout && globalState.timeout.stop();
  };
  /**
   * Resume timer. Returns number of milliseconds of timer remained.
   * If `timer` parameter isn't set, returns undefined.
   */

  var resumeTimer = function resumeTimer() {
    return globalState.timeout && globalState.timeout.start();
  };
  /**
   * Resume timer. Returns number of milliseconds of timer remained.
   * If `timer` parameter isn't set, returns undefined.
   */

  var toggleTimer = function toggleTimer() {
    var timer = globalState.timeout;
    return timer && (timer.running ? timer.stop() : timer.start());
  };
  /**
   * Increase timer. Returns number of milliseconds of an updated timer.
   * If `timer` parameter isn't set, returns undefined.
   */

  var increaseTimer = function increaseTimer(n) {
    return globalState.timeout && globalState.timeout.increase(n);
  };
  /**
   * 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
   */

  var isTimerRunning = function isTimerRunning() {
    return globalState.timeout && globalState.timeout.isRunning();
  };

  var defaultParams = {
    title: "",
    titleText: "",
    text: "",
    html: "",
    footer: "",
    type: null,
    toast: false,
    customClass: "",
    customContainerClass: "",
    target: "body",
    backdrop: true,
    animation: true,
    heightAuto: true,
    allowOutsideClick: true,
    allowEscapeKey: true,
    allowEnterKey: true,
    stopKeydownPropagation: true,
    keydownListenerCapture: false,
    showConfirmButton: true,
    showCancelButton: false,
    preConfirm: null,
    confirmButtonText: "OK",
    confirmButtonAriaLabel: "",
    confirmButtonColor: null,
    confirmButtonClass: "",
    cancelButtonText: "Cancel",
    cancelButtonAriaLabel: "",
    cancelButtonColor: null,
    cancelButtonClass: "",
    buttonsStyling: true,
    reverseButtons: false,
    focusConfirm: true,
    focusCancel: false,
    showCloseButton: false,
    closeButtonAriaLabel: "Close this dialog",
    showLoaderOnConfirm: false,
    imageUrl: null,
    imageWidth: null,
    imageHeight: null,
    imageAlt: "",
    imageClass: "",
    timer: null,
    width: null,
    padding: null,
    background: null,
    input: null,
    inputPlaceholder: "",
    inputValue: "",
    inputOptions: {},
    inputAutoTrim: true,
    inputClass: "",
    inputAttributes: {},
    inputValidator: null,
    validationMessage: null,
    grow: false,
    position: "center",
    progressSteps: [],
    currentProgressStep: null,
    progressStepsDistance: null,
    onBeforeOpen: null,
    onAfterClose: null,
    onOpen: null,
    onClose: null,
    scrollbarPadding: true,
  };
  var deprecatedParams = [];
  var toastIncompatibleParams = [
    "allowOutsideClick",
    "allowEnterKey",
    "backdrop",
    "focusConfirm",
    "focusCancel",
    "heightAuto",
    "keydownListenerCapture",
  ];
  /**
   * Is valid parameter
   * @param {String} paramName
   */

  var isValidParameter = function isValidParameter(paramName) {
    return defaultParams.hasOwnProperty(paramName);
  };
  /**
   * Is valid parameter for Swal.update() method
   * @param {String} paramName
   */

  var isUpdatableParameter = function isUpdatableParameter(paramName) {
    return (
      [
        "title",
        "titleText",
        "text",
        "html",
        "type",
        "showConfirmButton",
        "showCancelButton",
        "confirmButtonText",
        "confirmButtonAriaLabel",
        "confirmButtonColor",
        "confirmButtonClass",
        "cancelButtonText",
        "cancelButtonAriaLabel",
        "cancelButtonColor",
        "cancelButtonClass",
        "buttonsStyling",
        "reverseButtons",
        "imageUrl",
        "imageWidth",
        "imageHeigth",
        "imageAlt",
        "imageClass",
        "progressSteps",
        "currentProgressStep",
      ].indexOf(paramName) !== -1
    );
  };
  /**
   * Is deprecated parameter
   * @param {String} paramName
   */

  var isDeprecatedParameter = function isDeprecatedParameter(paramName) {
    return deprecatedParams.indexOf(paramName) !== -1;
  };
  /**
   * Show relevant warnings for given params
   *
   * @param params
   */

  var showWarningsForParams = function showWarningsForParams(params) {
    for (var param in params) {
      if (!isValidParameter(param)) {
        warn('Unknown parameter "'.concat(param, '"'));
      }

      if (params.toast && toastIncompatibleParams.indexOf(param) !== -1) {
        warn('The parameter "'.concat(param, '" is incompatible with toasts'));
      }

      if (isDeprecatedParameter(param)) {
        warnOnce(
          'The parameter "'.concat(
            param,
            '" is deprecated and will be removed in the next major release.'
          )
        );
      }
    }
  };

  var staticMethods = Object.freeze({
    isValidParameter: isValidParameter,
    isUpdatableParameter: isUpdatableParameter,
    isDeprecatedParameter: isDeprecatedParameter,
    argsToParams: argsToParams,
    isVisible: isVisible$1,
    clickConfirm: clickConfirm,
    clickCancel: clickCancel,
    getContainer: getContainer,
    getPopup: getPopup,
    getTitle: getTitle,
    getContent: getContent,
    getImage: getImage,
    getIcons: getIcons,
    getCloseButton: getCloseButton,
    getActions: getActions,
    getConfirmButton: getConfirmButton,
    getCancelButton: getCancelButton,
    getFooter: getFooter,
    getFocusableElements: getFocusableElements,
    getValidationMessage: getValidationMessage,
    isLoading: isLoading,
    fire: fire,
    mixin: mixin,
    queue: queue,
    getQueueStep: getQueueStep,
    insertQueueStep: insertQueueStep,
    deleteQueueStep: deleteQueueStep,
    showLoading: showLoading,
    enableLoading: showLoading,
    getTimerLeft: getTimerLeft,
    stopTimer: stopTimer,
    resumeTimer: resumeTimer,
    toggleTimer: toggleTimer,
    increaseTimer: increaseTimer,
    isTimerRunning: isTimerRunning,
  });

  /**
   * This module containts `WeakMap`s for each effectively-"private  property" that a `Swal` has.
   * For example, to set the private property "foo" of `this` to "bar", you can `privateProps.foo.set(this, 'bar')`
   * This is the approach that Babel will probably take to implement private methods/fields
   *   https://github.com/tc39/proposal-private-methods
   *   https://github.com/babel/babel/pull/7555
   * 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 = {
    promise: new WeakMap(),
    innerParams: new WeakMap(),
    domCache: new WeakMap(),
  };

  /**
   * Enables buttons and hide loader.
   */

  function hideLoading() {
    var innerParams = privateProps.innerParams.get(this);
    var domCache = privateProps.domCache.get(this);

    if (!innerParams.showConfirmButton) {
      hide(domCache.confirmButton);

      if (!innerParams.showCancelButton) {
        hide(domCache.actions);
      }
    }

    removeClass([domCache.popup, domCache.actions], swalClasses.loading);
    domCache.popup.removeAttribute("aria-busy");
    domCache.popup.removeAttribute("data-loading");
    domCache.confirmButton.disabled = false;
    domCache.cancelButton.disabled = false;
  }

  function getInput(inputType) {
    var innerParams = privateProps.innerParams.get(this);
    var domCache = privateProps.domCache.get(this);
    inputType = inputType || innerParams.input;

    if (!inputType) {
      return null;
    }

    switch (inputType) {
      case "select":
      case "textarea":
      case "file":
        return getChildByClass(domCache.content, swalClasses[inputType]);

      case "checkbox":
        return domCache.popup.querySelector(
          ".".concat(swalClasses.checkbox, " input")
        );

      case "radio":
        return (
          domCache.popup.querySelector(
            ".".concat(swalClasses.radio, " input:checked")
          ) ||
          domCache.popup.querySelector(
            ".".concat(swalClasses.radio, " input:first-child")
          )
        );

      case "range":
        return domCache.popup.querySelector(
          ".".concat(swalClasses.range, " input")
        );

      default:
        return getChildByClass(domCache.content, swalClasses.input);
    }
  }

  var fixScrollbar = function fixScrollbar() {
    // for queues, do not do this more than once
    if (states.previousBodyPadding !== null) {
      return;
    } // 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")
      );
      document.body.style.paddingRight =
        states.previousBodyPadding + measureScrollbar() + "px";
    }
  };
  var undoScrollbar = function undoScrollbar() {
    if (states.previousBodyPadding !== null) {
      document.body.style.paddingRight = states.previousBodyPadding + "px";
      states.previousBodyPadding = null;
    }
  };

  /* istanbul ignore next */

  var iOSfix = function iOSfix() {
    var iOS = /iPad|iPhone|iPod/.test(navigator.userAgent) && !window.MSStream;

    if (iOS && !hasClass(document.body, swalClasses.iosfix)) {
      var offset = document.body.scrollTop;
      document.body.style.top = offset * -1 + "px";
      addClass(document.body, swalClasses.iosfix);
    }
  };
  /* istanbul ignore next */

  var undoIOSfix = function undoIOSfix() {
    if (hasClass(document.body, swalClasses.iosfix)) {
      var offset = parseInt(document.body.style.top, 10);
      removeClass(document.body, swalClasses.iosfix);
      document.body.style.top = "";
      document.body.scrollTop = offset * -1;
    }
  };

  var isIE11 = function isIE11() {
    return !!window.MSInputMethodContext && !!document.documentMode;
  }; // Fix IE11 centering sweetalert2/issues/933

  /* istanbul ignore next */

  var fixVerticalPositionIE = function fixVerticalPositionIE() {
    var container = getContainer();
    var popup = getPopup();
    container.style.removeProperty("align-items");

    if (popup.offsetTop < 0) {
      container.style.alignItems = "flex-start";
    }
  };
  /* istanbul ignore next */

  var IEfix = function IEfix() {
    if (typeof window !== "undefined" && isIE11()) {
      fixVerticalPositionIE();
      window.addEventListener("resize", fixVerticalPositionIE);
    }
  };
  /* istanbul ignore next */

  var undoIEfix = function undoIEfix() {
    if (typeof window !== "undefined" && isIE11()) {
      window.removeEventListener("resize", fixVerticalPositionIE);
    }
  };

  // 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.

  var setAriaHidden = function setAriaHidden() {
    var bodyChildren = toArray(document.body.children);
    bodyChildren.forEach(function (el) {
      if (el === getContainer() || contains(el, getContainer())) {
        return;
      }

      if (el.hasAttribute("aria-hidden")) {
        el.setAttribute(
          "data-previous-aria-hidden",
          el.getAttribute("aria-hidden")
        );
      }

      el.setAttribute("aria-hidden", "true");
    });
  };
  var unsetAriaHidden = function unsetAriaHidden() {
    var bodyChildren = toArray(document.body.children);
    bodyChildren.forEach(function (el) {
      if (el.hasAttribute("data-previous-aria-hidden")) {
        el.setAttribute(
          "aria-hidden",
          el.getAttribute("data-previous-aria-hidden")
        );
        el.removeAttribute("data-previous-aria-hidden");
      } else {
        el.removeAttribute("aria-hidden");
      }
    });
  };

  /**
   * This module containts `WeakMap`s for each effectively-"private  property" that a `Swal` has.
   * For example, to set the private property "foo" of `this` to "bar", you can `privateProps.foo.set(this, 'bar')`
   * This is the approach that Babel will probably take to implement private methods/fields
   *   https://github.com/tc39/proposal-private-methods
   *   https://github.com/babel/babel/pull/7555
   * 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(),
  };

  /*
   * Instance method to close sweetAlert
   */

  function close(resolveValue) {
    var container = getContainer();
    var popup = getPopup();
    var innerParams = privateProps.innerParams.get(this);
    var swalPromiseResolve = privateMethods.swalPromiseResolve.get(this);
    var onClose = innerParams.onClose;
    var onAfterClose = innerParams.onAfterClose;

    if (!popup) {
      return;
    }

    if (onClose !== null && typeof onClose === "function") {
      onClose(popup);
    }

    removeClass(popup, swalClasses.show);
    addClass(popup, swalClasses.hide);

    var removePopupAndResetState = function removePopupAndResetState() {
      if (!isToast()) {
        restoreActiveElement().then(function () {
          return triggerOnAfterClose(onAfterClose);
        });
        globalState.keydownTarget.removeEventListener(
          "keydown",
          globalState.keydownHandler,
          {
            capture: globalState.keydownListenerCapture,
          }
        );
        globalState.keydownHandlerAdded = false;
      } else {
        triggerOnAfterClose(onAfterClose);
      }

      if (container.parentNode) {
        container.parentNode.removeChild(container);
      }

      removeClass(
        [document.documentElement, document.body],
        [
          swalClasses.shown,
          swalClasses["height-auto"],
          swalClasses["no-backdrop"],
          swalClasses["toast-shown"],
          swalClasses["toast-column"],
        ]
      );

      if (isModal()) {
        undoScrollbar();
        undoIOSfix();
        undoIEfix();
        unsetAriaHidden();
      }
    }; // If animation is supported, animate

    if (animationEndEvent && !hasClass(popup, swalClasses.noanimation)) {
      popup.addEventListener(
        animationEndEvent,
        function swalCloseEventFinished() {
          popup.removeEventListener(animationEndEvent, swalCloseEventFinished);

          if (hasClass(popup, swalClasses.hide)) {
            removePopupAndResetState();
          }
        }
      );
    } else {
      // Otherwise, remove immediately
      removePopupAndResetState();
    } // Resolve Swal promise

    swalPromiseResolve(resolveValue || {});
  }

  var triggerOnAfterClose = function triggerOnAfterClose(onAfterClose) {
    if (onAfterClose !== null && typeof onAfterClose === "function") {
      setTimeout(function () {
        onAfterClose();
      });
    }
  };

  function enableButtons() {
    var domCache = privateProps.domCache.get(this);
    domCache.confirmButton.disabled = false;
    domCache.cancelButton.disabled = false;
  }
  function disableButtons() {
    var domCache = privateProps.domCache.get(this);
    domCache.confirmButton.disabled = true;
    domCache.cancelButton.disabled = true;
  }
  function enableConfirmButton() {
    var domCache = privateProps.domCache.get(this);
    domCache.confirmButton.disabled = false;
  }
  function disableConfirmButton() {
    var domCache = privateProps.domCache.get(this);
    domCache.confirmButton.disabled = true;
  }
  function enableInput() {
    var input = this.getInput();

    if (!input) {
      return false;
    }

    if (input.type === "radio") {
      var radiosContainer = input.parentNode.parentNode;
      var radios = radiosContainer.querySelectorAll("input");

      for (var i = 0; i < radios.length; i++) {
        radios[i].disabled = false;
      }
    } else {
      input.disabled = false;
    }
  }
  function disableInput() {
    var input = this.getInput();

    if (!input) {
      return false;
    }

    if (input && input.type === "radio") {
      var radiosContainer = input.parentNode.parentNode;
      var radios = radiosContainer.querySelectorAll("input");

      for (var i = 0; i < radios.length; i++) {
        radios[i].disabled = true;
      }
    } else {
      input.disabled = true;
    }
  }

  function showValidationMessage(error) {
    var domCache = privateProps.domCache.get(this);
    domCache.validationMessage.innerHTML = error;
    var popupComputedStyle = window.getComputedStyle(domCache.popup);
    domCache.validationMessage.style.marginLeft = "-".concat(
      popupComputedStyle.getPropertyValue("padding-left")
    );
    domCache.validationMessage.style.marginRight = "-".concat(
      popupComputedStyle.getPropertyValue("padding-right")
    );
    show(domCache.validationMessage);
    var 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

  function resetValidationMessage() {
    var domCache = privateProps.domCache.get(this);

    if (domCache.validationMessage) {
      hide(domCache.validationMessage);
    }

    var input = this.getInput();

    if (input) {
      input.removeAttribute("aria-invalid");
      input.removeAttribute("aria-describedBy");
      removeClass(input, swalClasses.inputerror);
    }
  }

  function getProgressSteps$1() {
    var innerParams = privateProps.innerParams.get(this);
    return innerParams.progressSteps;
  }
  function setProgressSteps(progressSteps) {
    var innerParams = privateProps.innerParams.get(this);

    var updatedParams = _extends({}, innerParams, {
      progressSteps: progressSteps,
    });

    privateProps.innerParams.set(this, updatedParams);
    renderProgressSteps(updatedParams);
  }
  function showProgressSteps() {
    var domCache = privateProps.domCache.get(this);
    show(domCache.progressSteps);
  }
  function hideProgressSteps() {
    var domCache = privateProps.domCache.get(this);
    hide(domCache.progressSteps);
  }

  var Timer = function Timer(callback, delay) {
    _classCallCheck(this, Timer);

    var id,
      started,
      remaining = delay;
    this.running = false;

    this.start = function () {
      if (!this.running) {
        this.running = true;
        started = new Date();
        id = setTimeout(callback, remaining);
      }

      return remaining;
    };

    this.stop = function () {
      if (this.running) {
        this.running = false;
        clearTimeout(id);
        remaining -= new Date() - started;
      }

      return remaining;
    };

    this.increase = function (n) {
      var running = this.running;

      if (running) {
        this.stop();
      }

      remaining += n;

      if (running) {
        this.start();
      }

      return remaining;
    };

    this.getTimerLeft = function () {
      if (this.running) {
        this.stop();
        this.start();
      }

      return remaining;
    };

    this.isRunning = function () {
      return this.running;
    };

    this.start();
  };

  var defaultInputValidators = {
    email: function 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 ? validationMessage : "Invalid email address"
          );
    },
    url: function url(string, validationMessage) {
      // taken from https://stackoverflow.com/a/3809435 with a small change from #1306
      return /^https?:\/\/(www\.)?[-a-zA-Z0-9@:%._+~#=]{2,256}\.[a-z]{2,63}\b([-a-zA-Z0-9@:%_+.~#?&//=]*)$/.test(
        string
      )
        ? Promise.resolve()
        : Promise.resolve(
            validationMessage ? validationMessage : "Invalid URL"
          );
    },
  };

  /**
   * Set type, text and actions on popup
   *
   * @param params
   * @returns {boolean}
   */

  function setParameters(params) {
    // Use default `inputValidator` for supported input types if not provided
    if (!params.inputValidator) {
      Object.keys(defaultInputValidators).forEach(function (key) {
        if (params.input === key) {
          params.inputValidator = defaultInputValidators[key];
        }
      });
    } // 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)
    ) {
      warn('Target parameter is not valid, defaulting to "body"');
      params.target = "body";
    } // Animation

    if (typeof params.animation === "function") {
      params.animation = params.animation.call();
    }

    var popup;
    var oldPopup = getPopup();
    var targetElement =
      typeof params.target === "string"
        ? document.querySelector(params.target)
        : params.target; // If the model target has changed, refresh the popup

    if (
      oldPopup &&
      targetElement &&
      oldPopup.parentNode !== targetElement.parentNode
    ) {
      popup = init(params);
    } else {
      popup = oldPopup || init(params);
    } // Set popup width

    if (params.width) {
      popup.style.width =
        typeof params.width === "number" ? params.width + "px" : params.width;
    } // Set popup padding

    if (params.padding !== null) {
      popup.style.padding =
        typeof params.padding === "number"
          ? params.padding + "px"
          : params.padding;
    } // Set popup background

    if (params.background) {
      popup.style.background = params.background;
    }

    var popupBackgroundColor = window
      .getComputedStyle(popup)
      .getPropertyValue("background-color");
    var successIconParts = popup.querySelectorAll(
      "[class^=swal2-success-circular-line], .swal2-success-fix"
    );

    for (var i = 0; i < successIconParts.length; i++) {
      successIconParts[i].style.backgroundColor = popupBackgroundColor;
    }

    var container = getContainer();
    var closeButton = getCloseButton();
    var footer = getFooter(); // Title

    renderTitle(params); // Content

    renderContent(params); // Backdrop

    if (typeof params.backdrop === "string") {
      getContainer().style.background = params.backdrop;
    } else if (!params.backdrop) {
      addClass(
        [document.documentElement, document.body],
        swalClasses["no-backdrop"]
      );
    }

    if (!params.backdrop && params.allowOutsideClick) {
      warn(
        '"allowOutsideClick" parameter requires `backdrop` parameter to be set to `true`'
      );
    } // Position

    if (params.position in swalClasses) {
      addClass(container, swalClasses[params.position]);
    } else {
      warn('The "position" parameter is not valid, defaulting to "center"');
      addClass(container, swalClasses.center);
    } // Grow

    if (params.grow && typeof params.grow === "string") {
      var growClass = "grow-" + params.grow;

      if (growClass in swalClasses) {
        addClass(container, swalClasses[growClass]);
      }
    } // Close button

    if (params.showCloseButton) {
      closeButton.setAttribute("aria-label", params.closeButtonAriaLabel);
      show(closeButton);
    } else {
      hide(closeButton);
    } // Default Class

    popup.className = swalClasses.popup;

    if (params.toast) {
      addClass(
        [document.documentElement, document.body],
        swalClasses["toast-shown"]
      );
      addClass(popup, swalClasses.toast);
    } else {
      addClass(popup, swalClasses.modal);
    } // Custom Class

    if (params.customClass) {
      addClass(popup, params.customClass);
    }

    if (params.customContainerClass) {
      addClass(container, params.customContainerClass);
    } // Progress steps

    renderProgressSteps(params); // Icon

    renderIcon(params); // Image

    renderImage(params); // Actions (buttons)

    renderActions(params); // Footer

    parseHtmlToContainer(params.footer, footer); // CSS animation

    if (params.animation === true) {
      removeClass(popup, swalClasses.noanimation);
    } else {
      addClass(popup, swalClasses.noanimation);
    } // 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"
      );
    }
  }

  /**
   * Open popup, add necessary classes and styles, fix scrollbar
   *
   * @param {Array} params
   */

  var openPopup = function openPopup(params) {
    var container = getContainer();
    var popup = getPopup();

    if (
      params.onBeforeOpen !== null &&
      typeof params.onBeforeOpen === "function"
    ) {
      params.onBeforeOpen(popup);
    }

    if (params.animation) {
      addClass(popup, swalClasses.show);
      addClass(container, swalClasses.fade);
      removeClass(popup, swalClasses.hide);
    } else {
      removeClass(popup, swalClasses.fade);
    }

    show(popup); // scrolling is 'hidden' until animation is done, after that 'auto'

    container.style.overflowY = "hidden";

    if (animationEndEvent && !hasClass(popup, swalClasses.noanimation)) {
      popup.addEventListener(
        animationEndEvent,
        function swalCloseEventFinished() {
          popup.removeEventListener(animationEndEvent, swalCloseEventFinished);
          container.style.overflowY = "auto";
        }
      );
    } else {
      container.style.overflowY = "auto";
    }

    addClass(
      [document.documentElement, document.body, container],
      swalClasses.shown
    );

    if (params.heightAuto && params.backdrop && !params.toast) {
      addClass(
        [document.documentElement, document.body],
        swalClasses["height-auto"]
      );
    }

    if (isModal()) {
      if (params.scrollbarPadding) {
        fixScrollbar();
      }

      iOSfix();
      IEfix();
      setAriaHidden(); // sweetalert2/issues/1247

      setTimeout(function () {
        container.scrollTop = 0;
      });
    }

    if (!isToast() && !globalState.previousActiveElement) {
      globalState.previousActiveElement = document.activeElement;
    }

    if (params.onOpen !== null && typeof params.onOpen === "function") {
      setTimeout(function () {
        params.onOpen(popup);
      });
    }
  };

  function _main(userParams) {
    var _this = this;

    showWarningsForParams(userParams);

    var innerParams = _extends({}, defaultParams, userParams);

    setParameters(innerParams);
    Object.freeze(innerParams);
    privateProps.innerParams.set(this, innerParams); // clear the previous timer

    if (globalState.timeout) {
      globalState.timeout.stop();
      delete globalState.timeout;
    } // clear the restore focus timeout

    clearTimeout(globalState.restoreFocusTimeout);
    var domCache = {
      popup: getPopup(),
      container: getContainer(),
      content: getContent(),
      actions: getActions(),
      confirmButton: getConfirmButton(),
      cancelButton: getCancelButton(),
      closeButton: getCloseButton(),
      validationMessage: getValidationMessage(),
      progressSteps: getProgressSteps(),
    };
    privateProps.domCache.set(this, domCache);
    var constructor = this.constructor;
    return new Promise(function (resolve) {
      // functions to handle all closings/dismissals
      var succeedWith = function succeedWith(value) {
        _this.closePopup({
          value: value,
        });
      };

      var dismissWith = function dismissWith(dismiss) {
        _this.closePopup({
          dismiss: dismiss,
        });
      };

      privateMethods.swalPromiseResolve.set(_this, resolve); // Close on timer

      if (innerParams.timer) {
        globalState.timeout = new Timer(function () {
          dismissWith("timer");
          delete globalState.timeout;
        }, innerParams.timer);
      } // Get the value of the popup input

      var getInputValue = function getInputValue() {
        var input = _this.getInput();

        if (!input) {
          return null;
        }

        switch (innerParams.input) {
          case "checkbox":
            return input.checked ? 1 : 0;

          case "radio":
            return input.checked ? input.value : null;

          case "file":
            return input.files.length ? input.files[0] : null;

          default:
            return innerParams.inputAutoTrim ? input.value.trim() : input.value;
        }
      }; // input autofocus

      if (innerParams.input) {
        setTimeout(function () {
          var input = _this.getInput();

          if (input) {
            focusInput(input);
          }
        }, 0);
      }

      var confirm = function confirm(value) {
        if (innerParams.showLoaderOnConfirm) {
          constructor.showLoading(); // TODO: make showLoading an *instance* method
        }

        if (innerParams.preConfirm) {
          _this.resetValidationMessage();

          var preConfirmPromise = Promise.resolve().then(function () {
            return innerParams.preConfirm(value, innerParams.validationMessage);
          });
          preConfirmPromise.then(function (preConfirmValue) {
            if (
              isVisible(domCache.validationMessage) ||
              preConfirmValue === false
            ) {
              _this.hideLoading();
            } else {
              succeedWith(
                typeof preConfirmValue === "undefined" ? value : preConfirmValue
              );
            }
          });
        } else {
          succeedWith(value);
        }
      }; // Mouse interactions

      var onButtonEvent = function onButtonEvent(e) {
        var target = e.target;
        var confirmButton = domCache.confirmButton,
          cancelButton = domCache.cancelButton;
        var targetedConfirm =
          confirmButton &&
          (confirmButton === target || confirmButton.contains(target));
        var targetedCancel =
          cancelButton &&
          (cancelButton === target || cancelButton.contains(target));

        switch (e.type) {
          case "click":
            // Clicked 'confirm'
            if (targetedConfirm && constructor.isVisible()) {
              _this.disableButtons();

              if (innerParams.input) {
                var inputValue = getInputValue();

                if (innerParams.inputValidator) {
                  _this.disableInput();

                  var validationPromise = Promise.resolve().then(function () {
                    return innerParams.inputValidator(
                      inputValue,
                      innerParams.validationMessage
                    );
                  });
                  validationPromise.then(function (validationMessage) {
                    _this.enableButtons();

                    _this.enableInput();

                    if (validationMessage) {
                      _this.showValidationMessage(validationMessage);
                    } else {
                      confirm(inputValue);
                    }
                  });
                } else if (!_this.getInput().checkValidity()) {
                  _this.enableButtons();

                  _this.showValidationMessage(innerParams.validationMessage);
                } else {
                  confirm(inputValue);
                }
              } else {
                confirm(true);
              } // Clicked 'cancel'
            } else if (targetedCancel && constructor.isVisible()) {
              _this.disableButtons();

              dismissWith(constructor.DismissReason.cancel);
            }

            break;

          default:
        }
      };

      var buttons = domCache.popup.querySelectorAll("button");

      for (var i = 0; i < buttons.length; i++) {
        buttons[i].onclick = onButtonEvent;
        buttons[i].onmouseover = onButtonEvent;
        buttons[i].onmouseout = onButtonEvent;
        buttons[i].onmousedown = onButtonEvent;
      } // Closing popup by close button

      domCache.closeButton.onclick = function () {
        dismissWith(constructor.DismissReason.close);
      };

      if (innerParams.toast) {
        // Closing popup by internal click
        domCache.popup.onclick = function () {
          if (
            innerParams.showConfirmButton ||
            innerParams.showCancelButton ||
            innerParams.showCloseButton ||
            innerParams.input
          ) {
            return;
          }

          dismissWith(constructor.DismissReason.close);
        };
      } else {
        var ignoreOutsideClick = false; // Ignore click events that had mousedown on the popup but mouseup on the container
        // This can happen when the user drags a slider

        domCache.popup.onmousedown = function () {
          domCache.container.onmouseup = function (e) {
            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;
            }
          };
        }; // Ignore click events that had mousedown on the container but mouseup on the popup

        domCache.container.onmousedown = function () {
          domCache.popup.onmouseup = function (e) {
            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;
            }
          };
        };

        domCache.container.onclick = function (e) {
          if (ignoreOutsideClick) {
            ignoreOutsideClick = false;
            return;
          }

          if (e.target !== domCache.container) {
            return;
          }

          if (callIfFunction(innerParams.allowOutsideClick)) {
            dismissWith(constructor.DismissReason.backdrop);
          }
        };
      } // Reverse buttons (Confirm on the right side)

      if (innerParams.reverseButtons) {
        domCache.confirmButton.parentNode.insertBefore(
          domCache.cancelButton,
          domCache.confirmButton
        );
      } else {
        domCache.confirmButton.parentNode.insertBefore(
          domCache.confirmButton,
          domCache.cancelButton
        );
      } // Focus handling

      var setFocus = function setFocus(index, increment) {
        var focusableElements = getFocusableElements(innerParams.focusCancel); // search for visible elements and select the next possible match

        for (var _i = 0; _i < focusableElements.length; _i++) {
          index = index + increment; // rollover to first item

          if (index === focusableElements.length) {
            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

        domCache.popup.focus();
      };

      var keydownHandler = function keydownHandler(e, innerParams) {
        if (innerParams.stopKeydownPropagation) {
          e.stopPropagation();
        }

        var arrowKeys = [
          "ArrowLeft",
          "ArrowRight",
          "ArrowUp",
          "ArrowDown",
          "Left",
          "Right",
          "Up",
          "Down", // IE11
        ];

        if (e.key === "Enter" && !e.isComposing) {
          if (
            e.target &&
            _this.getInput() &&
            e.target.outerHTML === _this.getInput().outerHTML
          ) {
            if (["textarea", "file"].indexOf(innerParams.input) !== -1) {
              return; // do not submit
            }

            constructor.clickConfirm();
            e.preventDefault();
          } // TAB
        } else if (e.key === "Tab") {
          var targetElement = e.target;
          var focusableElements = getFocusableElements(innerParams.focusCancel);
          var btnIndex = -1;

          for (var _i2 = 0; _i2 < focusableElements.length; _i2++) {
            if (targetElement === focusableElements[_i2]) {
              btnIndex = _i2;
              break;
            }
          }

          if (!e.shiftKey) {
            // Cycle to the next button
            setFocus(btnIndex, 1);
          } else {
            // Cycle to the prev button
            setFocus(btnIndex, -1);
          }

          e.stopPropagation();
          e.preventDefault(); // ARROWS - switch focus between buttons
        } else if (arrowKeys.indexOf(e.key) !== -1) {
          // focus Cancel button if Confirm button is currently focused
          if (
            document.activeElement === domCache.confirmButton &&
            isVisible(domCache.cancelButton)
          ) {
            domCache.cancelButton.focus(); // and vice versa
          } else if (
            document.activeElement === domCache.cancelButton &&
            isVisible(domCache.confirmButton)
          ) {
            domCache.confirmButton.focus();
          } // ESC
        } else if (
          (e.key === "Escape" || e.key === "Esc") &&
          callIfFunction(innerParams.allowEscapeKey) === true
        ) {
          e.preventDefault();
          dismissWith(constructor.DismissReason.esc);
        }
      };

      if (globalState.keydownHandlerAdded) {
        globalState.keydownTarget.removeEventListener(
          "keydown",
          globalState.keydownHandler,
          {
            capture: globalState.keydownListenerCapture,
          }
        );
        globalState.keydownHandlerAdded = false;
      }

      if (!innerParams.toast) {
        globalState.keydownHandler = function (e) {
          return keydownHandler(e, innerParams);
        };

        globalState.keydownTarget = innerParams.keydownListenerCapture
          ? window
          : domCache.popup;
        globalState.keydownListenerCapture = innerParams.keydownListenerCapture;
        globalState.keydownTarget.addEventListener(
          "keydown",
          globalState.keydownHandler,
          {
            capture: globalState.keydownListenerCapture,
          }
        );
        globalState.keydownHandlerAdded = true;
      }

      _this.enableButtons();

      _this.hideLoading();

      _this.resetValidationMessage();

      if (
        innerParams.toast &&
        (innerParams.input || innerParams.footer || innerParams.showCloseButton)
      ) {
        addClass(document.body, swalClasses["toast-column"]);
      } else {
        removeClass(document.body, swalClasses["toast-column"]);
      } // inputs

      var inputTypes = [
        "input",
        "file",
        "range",
        "select",
        "radio",
        "checkbox",
        "textarea",
      ];

      var setInputPlaceholder = function setInputPlaceholder(input) {
        if (!input.placeholder || innerParams.inputPlaceholder) {
          input.placeholder = innerParams.inputPlaceholder;
        }
      };

      var input;

      for (var _i3 = 0; _i3 < inputTypes.length; _i3++) {
        var inputClass = swalClasses[inputTypes[_i3]];
        var inputContainer = getChildByClass(domCache.content, inputClass);
        input = _this.getInput(inputTypes[_i3]); // set attributes

        if (input) {
          for (var j in input.attributes) {
            if (input.attributes.hasOwnProperty(j)) {
              var attrName = input.attributes[j].name;

              if (attrName !== "type" && attrName !== "value") {
                input.removeAttribute(attrName);
              }
            }
          }

          for (var attr in innerParams.inputAttributes) {
            // Do not set a placeholder for <input type="range">
            // it'll crash Edge, #1298
            if (inputTypes[_i3] === "range" && attr === "placeholder") {
              continue;
            }

            input.setAttribute(attr, innerParams.inputAttributes[attr]);
          }
        } // set class

        inputContainer.className = inputClass;

        if (innerParams.inputClass) {
          addClass(inputContainer, innerParams.inputClass);
        }

        hide(inputContainer);
      }

      var populateInputOptions;

      switch (innerParams.input) {
        case "text":
        case "email":
        case "password":
        case "number":
        case "tel":
        case "url": {
          input = getChildByClass(domCache.content, swalClasses.input);

          if (
            typeof innerParams.inputValue === "string" ||
            typeof innerParams.inputValue === "number"
          ) {
            input.value = innerParams.inputValue;
          } else if (!isPromise(innerParams.inputValue)) {
            warn(
              'Unexpected type of inputValue! Expected "string", "number" or "Promise", got "'.concat(
                _typeof(innerParams.inputValue),
                '"'
              )
            );
          }

          setInputPlaceholder(input);
          input.type = innerParams.input;
          show(input);
          break;
        }

        case "file": {
          input = getChildByClass(domCache.content, swalClasses.file);
          setInputPlaceholder(input);
          input.type = innerParams.input;
          show(input);
          break;
        }

        case "range": {
          var range = getChildByClass(domCache.content, swalClasses.range);
          var rangeInput = range.querySelector("input");
          var rangeOutput = range.querySelector("output");
          rangeInput.value = innerParams.inputValue;
          rangeInput.type = innerParams.input;
          rangeOutput.value = innerParams.inputValue;
          show(range);
          break;
        }

        case "select": {
          var select = getChildByClass(domCache.content, swalClasses.select);
          select.innerHTML = "";

          if (innerParams.inputPlaceholder) {
            var placeholder = document.createElement("option");
            placeholder.innerHTML = innerParams.inputPlaceholder;
            placeholder.value = "";
            placeholder.disabled = true;
            placeholder.selected = true;
            select.appendChild(placeholder);
          }

          populateInputOptions = function populateInputOptions(inputOptions) {
            inputOptions.forEach(function (inputOption) {
              var optionValue = inputOption[0];
              var optionLabel = inputOption[1];
              var option = document.createElement("option");
              option.value = optionValue;
              option.innerHTML = optionLabel;

              if (
                innerParams.inputValue.toString() === optionValue.toString()
              ) {
                option.selected = true;
              }

              select.appendChild(option);
            });
            show(select);
            select.focus();
          };

          break;
        }

        case "radio": {
          var radio = getChildByClass(domCache.content, swalClasses.radio);
          radio.innerHTML = "";

          populateInputOptions = function populateInputOptions(inputOptions) {
            inputOptions.forEach(function (inputOption) {
              var radioValue = inputOption[0];
              var radioLabel = inputOption[1];
              var radioInput = document.createElement("input");
              var radioLabelElement = document.createElement("label");
              radioInput.type = "radio";
              radioInput.name = swalClasses.radio;
              radioInput.value = radioValue;

              if (innerParams.inputValue.toString() === radioValue.toString()) {
                radioInput.checked = true;
              }

              var label = document.createElement("span");
              label.innerHTML = radioLabel;
              label.className = swalClasses.label;
              radioLabelElement.appendChild(radioInput);
              radioLabelElement.appendChild(label);
              radio.appendChild(radioLabelElement);
            });
            show(radio);
            var radios = radio.querySelectorAll("input");

            if (radios.length) {
              radios[0].focus();
            }
          };

          break;
        }

        case "checkbox": {
          var checkbox = getChildByClass(
            domCache.content,
            swalClasses.checkbox
          );

          var checkboxInput = _this.getInput("checkbox");

          checkboxInput.type = "checkbox";
          checkboxInput.value = 1;
          checkboxInput.id = swalClasses.checkbox;
          checkboxInput.checked = Boolean(innerParams.inputValue);
          var label = checkbox.querySelector("span");
          label.innerHTML = innerParams.inputPlaceholder;
          show(checkbox);
          break;
        }

        case "textarea": {
          var textarea = getChildByClass(
            domCache.content,
            swalClasses.textarea
          );
          textarea.value = innerParams.inputValue;
          setInputPlaceholder(textarea);
          show(textarea);
          break;
        }

        case null: {
          break;
        }

        default:
          error(
            'Unexpected type of input! Expected "text", "email", "password", "number", "tel", "select", "radio", "checkbox", "textarea", "file" or "url", got "'.concat(
              innerParams.input,
              '"'
            )
          );
          break;
      }

      if (innerParams.input === "select" || innerParams.input === "radio") {
        var processInputOptions = function processInputOptions(inputOptions) {
          return populateInputOptions(formatInputOptions(inputOptions));
        };

        if (isPromise(innerParams.inputOptions)) {
          constructor.showLoading();
          innerParams.inputOptions.then(function (inputOptions) {
            _this.hideLoading();

            processInputOptions(inputOptions);
          });
        } else if (_typeof(innerParams.inputOptions) === "object") {
          processInputOptions(innerParams.inputOptions);
        } else {
          error(
            "Unexpected type of inputOptions! Expected object, Map or Promise, got ".concat(
              _typeof(innerParams.inputOptions)
            )
          );
        }
      } else if (
        ["text", "email", "number", "tel", "textarea"].indexOf(
          innerParams.input
        ) !== -1 &&
        isPromise(innerParams.inputValue)
      ) {
        constructor.showLoading();
        hide(input);
        innerParams.inputValue
          .then(function (inputValue) {
            input.value =
              innerParams.input === "number"
                ? parseFloat(inputValue) || 0
                : inputValue + "";
            show(input);
            input.focus();

            _this.hideLoading();
          })
          .catch(function (err) {
            error("Error in inputValue promise: " + err);
            input.value = "";
            show(input);
            input.focus();

            _this.hideLoading();
          });
      }

      openPopup(innerParams);

      if (!innerParams.toast) {
        if (!callIfFunction(innerParams.allowEnterKey)) {
          if (
            document.activeElement &&
            typeof document.activeElement.blur === "function"
          ) {
            document.activeElement.blur();
          }
        } else if (
          innerParams.focusCancel &&
          isVisible(domCache.cancelButton)
        ) {
          domCache.cancelButton.focus();
        } else if (
          innerParams.focusConfirm &&
          isVisible(domCache.confirmButton)
        ) {
          domCache.confirmButton.focus();
        } else {
          setFocus(-1, 1);
        }
      } // fix scroll

      domCache.container.scrollTop = 0;
    });
  }

  /**
   * Updates popup options.
   */

  function update(params) {
    var validUpdatableParams = {}; // assign valid params from `params` to `defaults`

    Object.keys(params).forEach(function (param) {
      if (Swal.isUpdatableParameter(param)) {
        validUpdatableParams[param] = params[param];
      } else {
        warn(
          'Invalid parameter to update: "'.concat(
            param,
            '". Updatable params are listed here: TODO (@limonte) add link'
          )
        );
      }
    });
    var innerParams = privateProps.innerParams.get(this);

    var updatedParams = _extends({}, innerParams, validUpdatableParams); // Actions

    renderActions(updatedParams); // Content

    renderContent(updatedParams); // Icon

    renderIcon(updatedParams); // Image

    renderImage(updatedParams); // Progress steps

    renderProgressSteps(updatedParams); // Title

    renderTitle(updatedParams);
    privateProps.innerParams.set(this, updatedParams);
  }

  var instanceMethods = Object.freeze({
    hideLoading: hideLoading,
    disableLoading: hideLoading,
    getInput: getInput,
    close: close,
    closePopup: close,
    closeModal: close,
    closeToast: close,
    enableButtons: enableButtons,
    disableButtons: disableButtons,
    enableConfirmButton: enableConfirmButton,
    disableConfirmButton: disableConfirmButton,
    enableInput: enableInput,
    disableInput: disableInput,
    showValidationMessage: showValidationMessage,
    resetValidationMessage: resetValidationMessage,
    getProgressSteps: getProgressSteps$1,
    setProgressSteps: setProgressSteps,
    showProgressSteps: showProgressSteps,
    hideProgressSteps: hideProgressSteps,
    _main: _main,
    update: update,
  });

  var currentInstance; // SweetAlert constructor

  function SweetAlert() {
    // Prevent run in Node env

    /* istanbul ignore if */
    if (typeof window === "undefined") {
      return;
    } // Check for the existence of Promise

    /* istanbul ignore if */

    if (typeof Promise === "undefined") {
      error(
        "This package requires a Promise library, please require_once a shim to enable it in this browser (See: https://github.com/sweetalert2/sweetalert2/wiki/Migration-from-SweetAlert-to-SweetAlert2#1-ie-support)"
      );
    }

    currentInstance = this;

    for (
      var _len = arguments.length, args = new Array(_len), _key = 0;
      _key < _len;
      _key++
    ) {
      args[_key] = arguments[_key];
    }

    var outerParams = Object.freeze(this.constructor.argsToParams(args));
    Object.defineProperties(this, {
      params: {
        value: outerParams,
        writable: false,
        enumerable: true,
      },
    });

    var promise = this._main(this.params);

    privateProps.promise.set(this, promise);
  } // `catch` cannot be the name of a module export, so we define our thenable methods here instead

  SweetAlert.prototype.then = function (onFulfilled) {
    var promise = privateProps.promise.get(this);
    return promise.then(onFulfilled);
  };

  SweetAlert.prototype.finally = function (onFinally) {
    var promise = privateProps.promise.get(this);
    return promise.finally(onFinally);
  }; // Assign instance methods from src/instanceMethods/*.js to prototype

  _extends(SweetAlert.prototype, instanceMethods); // Assign static methods from src/staticMethods/*.js to constructor

  _extends(SweetAlert, staticMethods); // Proxy to instance methods to constructor, for now, for backwards compatibility

  Object.keys(instanceMethods).forEach(function (key) {
    SweetAlert[key] = function () {
      if (currentInstance) {
        var _currentInstance;

        return (_currentInstance = currentInstance)[key].apply(
          _currentInstance,
          arguments
        );
      }
    };
  });
  SweetAlert.DismissReason = DismissReason;
  SweetAlert.version = "8.2.4";

  var Swal = SweetAlert;
  Swal.default = Swal;

  return Swal;
});
if (typeof window !== "undefined" && window.Sweetalert2) {
  window.swal =
    window.sweetAlert =
    window.Swal =
    window.SweetAlert =
      window.Sweetalert2;
}