https://bfitcrossfit.com/wp-content/themes/barbercrop/js/index.js?ver=7.1.2

1/******/ (() => { // webpackBootstrap
2/******/ 	var __webpack_modules__ = ({
3
4/***/ 764:
5/***/ (function(module) {
6
7/*!
8* sweetalert2 v11.4.13
9* Released under the MIT License.
10*/
11(function (global, factory) {
12   true ? module.exports = factory() :
13  0;
14}(this, function () { 'use strict';
15
16  const consolePrefix = 'SweetAlert2:';
17  /**
18   * Filter the unique values into a new array
19   * @param arr
20   */
21
22  const uniqueArray = arr => {
23    const result = [];
24
25    for (let i = 0; i < arr.length; i++) {
26      if (result.indexOf(arr[i]) === -1) {
27        result.push(arr[i]);
28      }
29    }
30
31    return result;
32  };
33  /**
34   * Capitalize the first letter of a string
35   * @param {string} str
36   * @returns {string}
37   */
38
39  const capitalizeFirstLetter = str => str.charAt(0).toUpperCase() + str.slice(1);
40  /**
41   * @param {NodeList | HTMLCollection | NamedNodeMap} nodeList
42   * @returns {array}
43   */
44
45  const toArray = nodeList => Array.prototype.slice.call(nodeList);
46  /**
47   * Standardize console warnings
48   * @param {string | array} message
49   */
50
51  const warn = message => {
52    console.warn("".concat(consolePrefix, " ").concat(typeof message === 'object' ? message.join(' ') : message));
53  };
54  /**
55   * Standardize console errors
56   * @param {string} message
57   */
58
59  const error = message => {
60    console.error("".concat(consolePrefix, " ").concat(message));
61  };
62  /**
63   * Private global state for `warnOnce`
64   * @type {Array}
65   * @private
66   */
67
68  const previousWarnOnceMessages = [];
69  /**
70   * Show a console warning, but only if it hasn't already been shown
71   * @param {string} message
72   */
73
74  const warnOnce = message => {
75    if (!previousWarnOnceMessages.includes(message)) {
76      previousWarnOnceMessages.push(message);
77      warn(message);
78    }
79  };
80  /**
81   * Show a one-time console warning about deprecated params/methods
82   */
83
84  const warnAboutDeprecation = (deprecatedParam, useInstead) => {
85    warnOnce("\"".concat(deprecatedParam, "\" is deprecated and will be removed in the next major release. Please use \"").concat(useInstead, "\" instead."));
86  };
87  /**
88   * If `arg` is a function, call it (with no arguments or context) and return the result.
89   * Otherwise, just pass the value through
90   * @param arg
91   */
92
93  const callIfFunction = arg => typeof arg === 'function' ? arg() : arg;
94  const hasToPromiseFn = arg => arg && typeof arg.toPromise === 'function';
95  const asPromise = arg => hasToPromiseFn(arg) ? arg.toPromise() : Promise.resolve(arg);
96  const isPromise = arg => arg && Promise.resolve(arg) === arg;
97  const getRandomElement = arr => arr[Math.floor(Math.random() * arr.length)];
98
99  const defaultParams = {
100    title: '',
101    titleText: '',
102    text: '',
103    html: '',
104    footer: '',
105    icon: undefined,
106    iconColor: undefined,
107    iconHtml: undefined,
108    template: undefined,
109    toast: false,
110    showClass: {
111      popup: 'swal2-show',
112      backdrop: 'swal2-backdrop-show',
113      icon: 'swal2-icon-show'
114    },
115    hideClass: {
116      popup: 'swal2-hide',
117      backdrop: 'swal2-backdrop-hide',
118      icon: 'swal2-icon-hide'
119    },
120    customClass: {},
121    target: 'body',
122    color: undefined,
123    backdrop: true,
124    heightAuto: true,
125    allowOutsideClick: true,
126    allowEscapeKey: true,
127    allowEnterKey: true,
128    stopKeydownPropagation: true,
129    keydownListenerCapture: false,
130    showConfirmButton: true,
131    showDenyButton: false,
132    showCancelButton: false,
133    preConfirm: undefined,
134    preDeny: undefined,
135    confirmButtonText: 'OK',
136    confirmButtonAriaLabel: '',
137    confirmButtonColor: undefined,
138    denyButtonText: 'No',
139    denyButtonAriaLabel: '',
140    denyButtonColor: undefined,
141    cancelButtonText: 'Cancel',
142    cancelButtonAriaLabel: '',
143    cancelButtonColor: undefined,
144    buttonsStyling: true,
145    reverseButtons: false,
146    focusConfirm: true,
147    focusDeny: false,
148    focusCancel: false,
149    returnFocus: true,
150    showCloseButton: false,
151    closeButtonHtml: '&times;',
152    closeButtonAriaLabel: 'Close this dialog',
153    loaderHtml: '',
154    showLoaderOnConfirm: false,
155    showLoaderOnDeny: false,
156    imageUrl: undefined,
157    imageWidth: undefined,
158    imageHeight: undefined,
159    imageAlt: '',
160    timer: undefined,
161    timerProgressBar: false,
162    width: undefined,
163    padding: undefined,
164    background: undefined,
165    input: undefined,
166    inputPlaceholder: '',
167    inputLabel: '',
168    inputValue: '',
169    inputOptions: {},
170    inputAutoTrim: true,
171    inputAttributes: {},
172    inputValidator: undefined,
173    returnInputValueOnDeny: false,
174    validationMessage: undefined,
175    grow: false,
176    position: 'center',
177    progressSteps: [],
178    currentProgressStep: undefined,
179    progressStepsDistance: undefined,
180    willOpen: undefined,
181    didOpen: undefined,
182    didRender: undefined,
183    willClose: undefined,
184    didClose: undefined,
185    didDestroy: undefined,
186    scrollbarPadding: true
187  };
188  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'];
189  const deprecatedParams = {};
190  const toastIncompatibleParams = ['allowOutsideClick', 'allowEnterKey', 'backdrop', 'focusConfirm', 'focusDeny', 'focusCancel', 'returnFocus', 'heightAuto', 'keydownListenerCapture'];
191  /**
192   * Is valid parameter
193   * @param {string} paramName
194   */
195
196  const isValidParameter = paramName => {
197    return Object.prototype.hasOwnProperty.call(defaultParams, paramName);
198  };
199  /**
200   * Is valid parameter for Swal.update() method
201   * @param {string} paramName
202   */
203
204  const isUpdatableParameter = paramName => {
205    return updatableParams.indexOf(paramName) !== -1;
206  };
207  /**
208   * Is deprecated parameter
209   * @param {string} paramName
210   */
211
212  const isDeprecatedParameter = paramName => {
213    return deprecatedParams[paramName];
214  };
215
216  const checkIfParamIsValid = param => {
217    if (!isValidParameter(param)) {
218      warn("Unknown parameter \"".concat(param, "\""));
219    }
220  };
221
222  const checkIfToastParamIsValid = param => {
223    if (toastIncompatibleParams.includes(param)) {
224      warn("The parameter \"".concat(param, "\" is incompatible with toasts"));
225    }
226  };
227
228  const checkIfParamIsDeprecated = param => {
229    if (isDeprecatedParameter(param)) {
230      warnAboutDeprecation(param, isDeprecatedParameter(param));
231    }
232  };
233  /**
234   * Show relevant warnings for given params
235   *
236   * @param params
237   */
238
239
240  const showWarningsForParams = params => {
241    if (!params.backdrop && params.allowOutsideClick) {
242      warn('"allowOutsideClick" parameter requires `backdrop` parameter to be set to `true`');
243    }
244
245    for (const param in params) {
246      checkIfParamIsValid(param);
247
248      if (params.toast) {
249        checkIfToastParamIsValid(param);
250      }
251
252      checkIfParamIsDeprecated(param);
253    }
254  };
255
256  const swalPrefix = 'swal2-';
257  const prefix = items => {
258    const result = {};
259
260    for (const i in items) {
261      result[items[i]] = swalPrefix + items[i];
262    }
263
264    return result;
265  };
266  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']);
267  const iconTypes = prefix(['success', 'warning', 'info', 'question', 'error']);
268
269  /**
270   * Gets the popup container which contains the backdrop and the popup itself.
271   *
272   * @returns {HTMLElement | null}
273   */
274
275  const getContainer = () => document.body.querySelector(".".concat(swalClasses.container));
276  const elementBySelector = selectorString => {
277    const container = getContainer();
278    return container ? container.querySelector(selectorString) : null;
279  };
280
281  const elementByClass = className => {
282    return elementBySelector(".".concat(className));
283  };
284
285  const getPopup = () => elementByClass(swalClasses.popup);
286  const getIcon = () => elementByClass(swalClasses.icon);
287  const getTitle = () => elementByClass(swalClasses.title);
288  const getHtmlContainer = () => elementByClass(swalClasses['html-container']);
289  const getImage = () => elementByClass(swalClasses.image);
290  const getProgressSteps = () => elementByClass(swalClasses['progress-steps']);
291  const getValidationMessage = () => elementByClass(swalClasses['validation-message']);
292  const getConfirmButton = () => elementBySelector(".".concat(swalClasses.actions, " .").concat(swalClasses.confirm));
293  const getDenyButton = () => elementBySelector(".".concat(swalClasses.actions, " .").concat(swalClasses.deny));
294  const getInputLabel = () => elementByClass(swalClasses['input-label']);
295  const getLoader = () => elementBySelector(".".concat(swalClasses.loader));
296  const getCancelButton = () => elementBySelector(".".concat(swalClasses.actions, " .").concat(swalClasses.cancel));
297  const getActions = () => elementByClass(swalClasses.actions);
298  const getFooter = () => elementByClass(swalClasses.footer);
299  const getTimerProgressBar = () => elementByClass(swalClasses['timer-progress-bar']);
300  const getCloseButton = () => elementByClass(swalClasses.close); // https://github.com/jkup/focusable/blob/master/index.js
301
302  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";
303  const getFocusableElements = () => {
304    const focusableElementsWithTabindex = toArray(getPopup().querySelectorAll('[tabindex]:not([tabindex="-1"]):not([tabindex="0"])')) // sort according to tabindex
305    .sort((a, b) => {
306      const tabindexA = parseInt(a.getAttribute('tabindex'));
307      const tabindexB = parseInt(b.getAttribute('tabindex'));
308
309      if (tabindexA > tabindexB) {
310        return 1;
311      } else if (tabindexA < tabindexB) {
312        return -1;
313      }
314
315      return 0;
316    });
317    const otherFocusableElements = toArray(getPopup().querySelectorAll(focusable)).filter(el => el.getAttribute('tabindex') !== '-1');
318    return uniqueArray(focusableElementsWithTabindex.concat(otherFocusableElements)).filter(el => isVisible(el));
319  };
320  const isModal = () => {
321    return hasClass(document.body, swalClasses.shown) && !hasClass(document.body, swalClasses['toast-shown']) && !hasClass(document.body, swalClasses['no-backdrop']);
322  };
323  const isToast = () => {
324    return getPopup() && hasClass(getPopup(), swalClasses.toast);
325  };
326  const isLoading = () => {
327    return getPopup().hasAttribute('data-loading');
328  };
329
330  const states = {
331    previousBodyPadding: null
332  };
333  /**
334   * Securely set innerHTML of an element
335   * https://github.com/sweetalert2/sweetalert2/issues/1926
336   *
337   * @param {HTMLElement} elem
338   * @param {string} html
339   */
340
341  const setInnerHtml = (elem, html) => {
342    elem.textContent = '';
343
344    if (html) {
345      const parser = new DOMParser();
346      const parsed = parser.parseFromString(html, "text/html");
347      toArray(parsed.querySelector('head').childNodes).forEach(child => {
348        elem.appendChild(child);
349      });
350      toArray(parsed.querySelector('body').childNodes).forEach(child => {
351        elem.appendChild(child);
352      });
353    }
354  };
355  /**
356   * @param {HTMLElement} elem
357   * @param {string} className
358   * @returns {boolean}
359   */
360
361  const hasClass = (elem, className) => {
362    if (!className) {
363      return false;
364    }
365
366    const classList = className.split(/\s+/);
367
368    for (let i = 0; i < classList.length; i++) {
369      if (!elem.classList.contains(classList[i])) {
370        return false;
371      }
372    }
373
374    return true;
375  };
376
377  const removeCustomClasses = (elem, params) => {
378    toArray(elem.classList).forEach(className => {
379      if (!Object.values(swalClasses).includes(className) && !Object.values(iconTypes).includes(className) && !Object.values(params.showClass).includes(className)) {
380        elem.classList.remove(className);
381      }
382    });
383  };
384
385  const applyCustomClass = (elem, params, className) => {
386    removeCustomClasses(elem, params);
387
388    if (params.customClass && params.customClass[className]) {
389      if (typeof params.customClass[className] !== 'string' && !params.customClass[className].forEach) {
390        return warn("Invalid type of customClass.".concat(className, "! Expected string or iterable object, got \"").concat(typeof params.customClass[className], "\""));
391      }
392
393      addClass(elem, params.customClass[className]);
394    }
395  };
396  /**
397   * @param {HTMLElement} popup
398   * @param {import('./renderers/renderInput').InputClass} inputClass
399   * @returns {HTMLInputElement | null}
400   */
401
402  const getInput = (popup, inputClass) => {
403    if (!inputClass) {
404      return null;
405    }
406
407    switch (inputClass) {
408      case 'select':
409      case 'textarea':
410      case 'file':
411        return popup.querySelector(".".concat(swalClasses.popup, " > .").concat(swalClasses[inputClass]));
412
413      case 'checkbox':
414        return popup.querySelector(".".concat(swalClasses.popup, " > .").concat(swalClasses.checkbox, " input"));
415
416      case 'radio':
417        return popup.querySelector(".".concat(swalClasses.popup, " > .").concat(swalClasses.radio, " input:checked")) || popup.querySelector(".".concat(swalClasses.popup, " > .").concat(swalClasses.radio, " input:first-child"));
418
419      case 'range':
420        return popup.querySelector(".".concat(swalClasses.popup, " > .").concat(swalClasses.range, " input"));
421
422      default:
423        return popup.querySelector(".".concat(swalClasses.popup, " > .").concat(swalClasses.input));
424    }
425  };
426  /**
427   * @param {HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement} input
428   */
429
430  const focusInput = input => {
431    input.focus(); // place cursor at end of text in text input
432
433    if (input.type !== 'file') {
434      // http://stackoverflow.com/a/2345915
435      const val = input.value;
436      input.value = '';
437      input.value = val;
438    }
439  };
440  /**
441   * @param {HTMLElement | HTMLElement[] | null} target
442   * @param {string | string[] | readonly string[]} classList
443   * @param {boolean} condition
444   */
445
446  const toggleClass = (target, classList, condition) => {
447    if (!target || !classList) {
448      return;
449    }
450
451    if (typeof classList === 'string') {
452      classList = classList.split(/\s+/).filter(Boolean);
453    }
454
455    classList.forEach(className => {
456      if (Array.isArray(target)) {
457        target.forEach(elem => {
458          condition ? elem.classList.add(className) : elem.classList.remove(className);
459        });
460      } else {
461        condition ? target.classList.add(className) : target.classList.remove(className);
462      }
463    });
464  };
465  /**
466   * @param {HTMLElement | HTMLElement[] | null} target
467   * @param {string | string[] | readonly string[]} classList
468   */
469
470  const addClass = (target, classList) => {
471    toggleClass(target, classList, true);
472  };
473  /**
474   * @param {HTMLElement | HTMLElement[] | null} target
475   * @param {string | string[] | readonly string[]} classList
476   */
477
478  const removeClass = (target, classList) => {
479    toggleClass(target, classList, false);
480  };
481  /**
482   * Get direct child of an element by class name
483   *
484   * @param {HTMLElement} elem
485   * @param {string} className
486   * @returns {HTMLElement | null}
487   */
488
489  const getDirectChildByClass = (elem, className) => {
490    const childNodes = toArray(elem.childNodes);
491
492    for (let i = 0; i < childNodes.length; i++) {
493      if (hasClass(childNodes[i], className)) {
494        return childNodes[i];
495      }
496    }
497  };
498  /**
499   * @param {HTMLElement} elem
500   * @param {string} property
501   * @param {*} value
502   */
503
504  const applyNumericalStyle = (elem, property, value) => {
505    if (value === "".concat(parseInt(value))) {
506      value = parseInt(value);
507    }
508
509    if (value || parseInt(value) === 0) {
510      elem.style[property] = typeof value === 'number' ? "".concat(value, "px") : value;
511    } else {
512      elem.style.removeProperty(property);
513    }
514  };
515  /**
516   * @param {HTMLElement} elem
517   * @param {string} display
518   */
519
520  const show = function (elem) {
521    let display = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'flex';
522    elem.style.display = display;
523  };
524  /**
525   * @param {HTMLElement} elem
526   */
527
528  const hide = elem => {
529    elem.style.display = 'none';
530  };
531  const setStyle = (parent, selector, property, value) => {
532    const el = parent.querySelector(selector);
533
534    if (el) {
535      el.style[property] = value;
536    }
537  };
538  const toggle = (elem, condition, display) => {
539    condition ? show(elem, display) : hide(elem);
540  }; // borrowed from jquery $(elem).is(':visible') implementation
541
542  const isVisible = elem => !!(elem && (elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length));
543  const allButtonsAreHidden = () => !isVisible(getConfirmButton()) && !isVisible(getDenyButton()) && !isVisible(getCancelButton());
544  const isScrollable = elem => !!(elem.scrollHeight > elem.clientHeight); // borrowed from https://stackoverflow.com/a/46352119
545
546  const hasCssAnimation = elem => {
547    const style = window.getComputedStyle(elem);
548    const animDuration = parseFloat(style.getPropertyValue('animation-duration') || '0');
549    const transDuration = parseFloat(style.getPropertyValue('transition-duration') || '0');
550    return animDuration > 0 || transDuration > 0;
551  };
552  const animateTimerProgressBar = function (timer) {
553    let reset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
554    const timerProgressBar = getTimerProgressBar();
555
556    if (isVisible(timerProgressBar)) {
557      if (reset) {
558        timerProgressBar.style.transition = 'none';
559        timerProgressBar.style.width = '100%';
560      }
561
562      setTimeout(() => {
563        timerProgressBar.style.transition = "width ".concat(timer / 1000, "s linear");
564        timerProgressBar.style.width = '0%';
565      }, 10);
566    }
567  };
568  const stopTimerProgressBar = () => {
569    const timerProgressBar = getTimerProgressBar();
570    const timerProgressBarWidth = parseInt(window.getComputedStyle(timerProgressBar).width);
571    timerProgressBar.style.removeProperty('transition');
572    timerProgressBar.style.width = '100%';
573    const timerProgressBarFullWidth = parseInt(window.getComputedStyle(timerProgressBar).width);
574    const timerProgressBarPercent = timerProgressBarWidth / timerProgressBarFullWidth * 100;
575    timerProgressBar.style.removeProperty('transition');
576    timerProgressBar.style.width = "".concat(timerProgressBarPercent, "%");
577  };
578
579  /**
580   * Detect Node env
581   *
582   * @returns {boolean}
583   */
584  const isNodeEnv = () => typeof window === 'undefined' || typeof document === 'undefined';
585
586  const RESTORE_FOCUS_TIMEOUT = 100;
587
588  const globalState = {};
589
590  const focusPreviousActiveElement = () => {
591    if (globalState.previousActiveElement && globalState.previousActiveElement.focus) {
592      globalState.previousActiveElement.focus();
593      globalState.previousActiveElement = null;
594    } else if (document.body) {
595      document.body.focus();
596    }
597  }; // Restore previous active (focused) element
598
599
600  const restoreActiveElement = returnFocus => {
601    return new Promise(resolve => {
602      if (!returnFocus) {
603        return resolve();
604      }
605
606      const x = window.scrollX;
607      const y = window.scrollY;
608      globalState.restoreFocusTimeout = setTimeout(() => {
609        focusPreviousActiveElement();
610        resolve();
611      }, RESTORE_FOCUS_TIMEOUT); // issues/900
612
613      window.scrollTo(x, y);
614    });
615  };
616
617  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, '');
618
619  const resetOldContainer = () => {
620    const oldContainer = getContainer();
621
622    if (!oldContainer) {
623      return false;
624    }
625
626    oldContainer.remove();
627    removeClass([document.documentElement, document.body], [swalClasses['no-backdrop'], swalClasses['toast-shown'], swalClasses['has-column']]);
628    return true;
629  };
630
631  const resetValidationMessage = () => {
632    globalState.currentInstance.resetValidationMessage();
633  };
634
635  const addInputChangeListeners = () => {
636    const popup = getPopup();
637    const input = getDirectChildByClass(popup, swalClasses.input);
638    const file = getDirectChildByClass(popup, swalClasses.file);
639    const range = popup.querySelector(".".concat(swalClasses.range, " input"));
640    const rangeOutput = popup.querySelector(".".concat(swalClasses.range, " output"));
641    const select = getDirectChildByClass(popup, swalClasses.select);
642    const checkbox = popup.querySelector(".".concat(swalClasses.checkbox, " input"));
643    const textarea = getDirectChildByClass(popup, swalClasses.textarea);
644    input.oninput = resetValidationMessage;
645    file.onchange = resetValidationMessage;
646    select.onchange = resetValidationMessage;
647    checkbox.onchange = resetValidationMessage;
648    textarea.oninput = resetValidationMessage;
649
650    range.oninput = () => {
651      resetValidationMessage();
652      rangeOutput.value = range.value;
653    };
654
655    range.onchange = () => {
656      resetValidationMessage();
657      range.nextSibling.value = range.value;
658    };
659  };
660
661  const getTarget = target => typeof target === 'string' ? document.querySelector(target) : target;
662
663  const setupAccessibility = params => {
664    const popup = getPopup();
665    popup.setAttribute('role', params.toast ? 'alert' : 'dialog');
666    popup.setAttribute('aria-live', params.toast ? 'polite' : 'assertive');
667
668    if (!params.toast) {
669      popup.setAttribute('aria-modal', 'true');
670    }
671  };
672
673  const setupRTL = targetElement => {
674    if (window.getComputedStyle(targetElement).direction === 'rtl') {
675      addClass(getContainer(), swalClasses.rtl);
676    }
677  };
678  /*
679   * Add modal + backdrop + no-war message for Russians to DOM
680   */
681
682
683  const init = params => {
684    // Clean up the old popup container if it exists
685    const oldContainerExisted = resetOldContainer();
686    /* istanbul ignore if */
687
688    if (isNodeEnv()) {
689      error('SweetAlert2 requires document to initialize');
690      return;
691    }
692
693    const container = document.createElement('div');
694    container.className = swalClasses.container;
695
696    if (oldContainerExisted) {
697      addClass(container, swalClasses['no-transition']);
698    }
699
700    setInnerHtml(container, sweetHTML);
701    const targetElement = getTarget(params.target);
702    targetElement.appendChild(container);
703    setupAccessibility(params);
704    setupRTL(targetElement);
705    addInputChangeListeners();
706    noWarMessageForRussians(container, params);
707  };
708
709  const noWarMessageForRussians = (container, params) => {
710    if (params.toast) {
711      return;
712    } // This message is targeted at people who are corrupted by propaganda, everybody else
713    // is already against war either silently or actively.
714    //
715    // The point is to wrap the truth-bomb into a patriotic title so they will actually click it
716    // and listen to the uncomfortable truth about the war from the people they love or respect.
717
718
719    const message = getRandomElement([{
720      text: 'ШВАРЦЕНЕГГЕР обратился <br> к РУССКОМУ НАРОДУ о войне',
721      // Arnold is loved in Russia by all people including those who are for this war
722      // His speech might change the mind of those who are brainwashed by propaganda
723      youtubeId: 'fWClXZd9c78'
724    }, {
725      text: 'РУССКИЙ ПАТРИОТ <br> открыл главную тайну спецоперации',
726      // In this video one of the most famous Russian nationalist leaders, Dmitry Demushkin,
727      // explains that this war has no sense and produces the exact opposite result of what
728      // it was intended to do.
729      youtubeId: '_RjBNkn88yA'
730    }, {
731      text: 'ГЕРОЙ НОВОРОССИИ СТРЕЛКОВ <br> дал оценку ходу спецоперации',
732      // In this video Igor Girkin, who played a key role in the annexation of Crimea,
733      // explains that this war has failed already and all possible outcomes are bad for Ru

733ssia.
734      youtubeId: 'yUmzQT4C8JY'
735    }, {
736      text: 'ФИНСКИЙ ДРУГ РОССИИ <br> говорит ПО-РУССКИ о спецоперации',
737      youtubeId: 'hkCYb6edUrQ'
738    }]); // The message will only be shown to Russian users visiting Russian sites
739
740    if (navigator.language === 'ru' && location.host.match(/\.(ru|su|xn--p1ai)$/)) {
741      const noWar = document.createElement('div');
742      noWar.className = swalClasses['no-war'];
743      setInnerHtml(noWar, "<a href=\"https://www.youtube.com/watch?v=".concat(message.youtubeId, "\" target=\"_blank\">").concat(message.text, "</a>"));
744      container.appendChild(noWar);
745      container.style.paddingTop = '4em';
746    }
747  };
748
749  /**
750   * @param {HTMLElement | object | string} param
751   * @param {HTMLElement} target
752   */
753
754  const parseHtmlToContainer = (param, target) => {
755    // DOM element
756    if (param instanceof HTMLElement) {
757      target.appendChild(param);
758    } // Object
759    else if (typeof param === 'object') {
760      handleObject(param, target);
761    } // Plain string
762    else if (param) {
763      setInnerHtml(target, param);
764    }
765  };
766  /**
767   * @param {object} param
768   * @param {HTMLElement} target
769   */
770
771  const handleObject = (param, target) => {
772    // JQuery element(s)
773    if (param.jquery) {
774      handleJqueryElem(target, param);
775    } // For other objects use their string representation
776    else {
777      setInnerHtml(target, param.toString());
778    }
779  };
780
781  const handleJqueryElem = (target, elem) => {
782    target.textContent = '';
783
784    if (0 in elem) {
785      for (let i = 0; (i in elem); i++) {
786        target.appendChild(elem[i].cloneNode(true));
787      }
788    } else {
789      target.appendChild(elem.cloneNode(true));
790    }
791  };
792
793  const animationEndEvent = (() => {
794    // Prevent run in Node env
795
796    /* istanbul ignore if */
797    if (isNodeEnv()) {
798      return false;
799    }
800
801    const testEl = document.createElement('div');
802    const transEndEventNames = {
803      WebkitAnimation: 'webkitAnimationEnd',
804      // Chrome, Safari and Opera
805      animation: 'animationend' // Standard syntax
806
807    };
808
809    for (const i in transEndEventNames) {
810      if (Object.prototype.hasOwnProperty.call(transEndEventNames, i) && typeof testEl.style[i] !== 'undefined') {
811        return transEndEventNames[i];
812      }
813    }
814
815    return false;
816  })();
817
818  // https://github.com/twbs/bootstrap/blob/master/js/src/modal.js
819
820  const measureScrollbar = () => {
821    const scrollDiv = document.createElement('div');
822    scrollDiv.className = swalClasses['scrollbar-measure'];
823    document.body.appendChild(scrollDiv);
824    const scrollbarWidth = scrollDiv.getBoundingClientRect().width - scrollDiv.clientWidth;
825    document.body.removeChild(scrollDiv);
826    return scrollbarWidth;
827  };
828
829  const renderActions = (instance, params) => {
830    const actions = getActions();
831    const loader = getLoader(); // Actions (buttons) wrapper
832
833    if (!params.showConfirmButton && !params.showDenyButton && !params.showCancelButton) {
834      hide(actions);
835    } else {
836      show(actions);
837    } // Custom class
838
839
840    applyCustomClass(actions, params, 'actions'); // Render all the buttons
841
842    renderButtons(actions, loader, params); // Loader
843
844    setInnerHtml(loader, params.loaderHtml);
845    applyCustomClass(loader, params, 'loader');
846  };
847
848  function renderButtons(actions, loader, params) {
849    const confirmButton = getConfirmButton();
850    const denyButton = getDenyButton();
851    const cancelButton = getCancelButton(); // Render buttons
852
853    renderButton(confirmButton, 'confirm', params);
854    renderButton(denyButton, 'deny', params);
855    renderButton(cancelButton, 'cancel', params);
856    handleButtonsStyling(confirmButton, denyButton, cancelButton, params);
857
858    if (params.reverseButtons) {
859      if (params.toast) {
860        actions.insertBefore(cancelButton, confirmButton);
861        actions.insertBefore(denyButton, confirmButton);
862      } else {
863        actions.insertBefore(cancelButton, loader);
864        actions.insertBefore(denyButton, loader);
865        actions.insertBefore(confirmButton, loader);
866      }
867    }
868  }
869
870  function handleButtonsStyling(confirmButton, denyButton, cancelButton, params) {
871    if (!params.buttonsStyling) {
872      return removeClass([confirmButton, denyButton, cancelButton], swalClasses.styled);
873    }
874
875    addClass([confirmButton, denyButton, cancelButton], swalClasses.styled); // Buttons background colors
876
877    if (params.confirmButtonColor) {
878      confirmButton.style.backgroundColor = params.confirmButtonColor;
879      addClass(confirmButton, swalClasses['default-outline']);
880    }
881
882    if (params.denyButtonColor) {
883      denyButton.style.backgroundColor = params.denyButtonColor;
884      addClass(denyButton, swalClasses['default-outline']);
885    }
886
887    if (params.cancelButtonColor) {
888      cancelButton.style.backgroundColor = params.cancelButtonColor;
889      addClass(cancelButton, swalClasses['default-outline']);
890    }
891  }
892
893  function renderButton(button, buttonType, params) {
894    toggle(button, params["show".concat(capitalizeFirstLetter(buttonType), "Button")], 'inline-block');
895    setInnerHtml(button, params["".concat(buttonType, "ButtonText")]); // Set caption text
896
897    button.setAttribute('aria-label', params["".concat(buttonType, "ButtonAriaLabel")]); // ARIA label
898    // Add buttons custom classes
899
900    button.className = swalClasses[buttonType];
901    applyCustomClass(button, params, "".concat(buttonType, "Button"));
902    addClass(button, params["".concat(buttonType, "ButtonClass")]);
903  }
904
905  function handleBackdropParam(container, backdrop) {
906    if (typeof backdrop === 'string') {
907      container.style.background = backdrop;
908    } else if (!backdrop) {
909      addClass([document.documentElement, document.body], swalClasses['no-backdrop']);
910    }
911  }
912
913  function handlePositionParam(container, position) {
914    if (position in swalClasses) {
915      addClass(container, swalClasses[position]);
916    } else {

1114 Input> */
1115
1116
1117  const renderInputType = {};
1118  /**
1119   * @param {HTMLInputElement} input
1120   * @param {SweetAlertOptions} params
1121   * @returns {HTMLInputElement}
1122   */
1123
1124  renderInputType.text = renderInputType.email = renderInputType.password = renderInputType.number = renderInputType.tel = renderInputType.url = (input, params) => {
1125    checkAndSetInputValue(input, params.inputValue);
1126    setInputLabel(input, input, params);
1127    setInputPlaceholder(input, params);
1128    input.type = params.input;
1129    return input;
1130  };
1131  /**
1132   * @param {HTMLInputElement} input
1133   * @param {SweetAlertOptions} params
1134   * @returns {HTMLInputElement}
1135   */
1136
1137
1138  renderInputType.file = (input, params) => {
1139    setInputLabel(input, input, params);
1140    setInputPlaceholder(input, params);
1141    return input;
1142  };
1143  /**
1144   * @param {HTMLInputElement} range
1145   * @param {SweetAlertOptions} params
1146   * @returns {HTMLInputElement}
1147   */
1148
1149
1150  renderInputType.range = (range, params) => {
1151    const rangeInput = range.querySelector('input');
1152    const rangeOutput = range.querySelector('output');
1153    checkAndSetInputValue(rangeInput, params.inputValue);
1154    rangeInput.type = params.input;
1155    checkAndSetInputValue(rangeOutput, params.inputValue);
1156    setInputLabel(rangeInput, range, params);
1157    return range;
1158  };
1159  /**
1160   * @param {HTMLSelectElement} select
1161   * @param {SweetAlertOptions} params
1162   * @returns {HTMLSelectElement}
1163   */
1164
1165
1166  renderInputType.select = (select, params) => {
1167    select.textContent = '';
1168
1169    if (params.inputPlaceholder) {
1170      const placeholder = document.createElement('option');
1171      setInnerHtml(placeholder, params.inputPlaceholder);
1172      placeholder.value = '';
1173      placeholder.disabled = true;
1174      placeholder.selected = true;
1175      select.appendChild(placeholder);
1176    }
1177
1178    setInputLabel(select, select, params);
1179    return select;
1180  };
1181  /**
1182   * @param {HTMLInputElement} radio
1183   * @returns {HTMLInputElement}
1184   */
1185
1186
1187  renderInputType.radio = radio => {
1188    radio.textContent = '';
1189    return radio;
1190  };
1191  /**
1192   * @param {HTMLLabelElement} checkboxContainer
1193   * @param {SweetAlertOptions} params
1194   * @returns {HTMLInputElement}
1195   */
1196
1197
1198  renderInputType.checkbox = (checkboxContainer, params) => {
1199    const checkbox = getInput(getPopup(), 'checkbox');
1200    checkbox.value = '1';
1201    checkbox.id = swalClasses.checkbox;
1202    checkbox.checked = Boolean(params.inputValue);
1203    const label = checkboxContainer.querySelector('span');
1204    setInnerHtml(label, params.inputPlaceholder);
1205    return checkbox;
1206  };
1207  /**
1208   * @param {HTMLTextAreaElement} textarea
1209   * @param {SweetAlertOptions} params
1210   * @returns {HTMLTextAreaElement}
1211   */
1212
1213
1214  renderInputType.textarea = (textarea, params) => {
1215    checkAndSetInputValue(textarea, params.inputValue);
1216    setInputPlaceholder(textarea, params);
1217    setInputLabel(textarea, textarea, params);
1218    /**
1219     * @param {HTMLElement} el
1220     * @returns {number}
1221     */

1221
1222
1223    const getMargin = el => parseInt(window.getComputedStyle(el).marginLeft) + parseInt(window.getComputedStyle(el).marginRight); // https://github.com/sweetalert2/sweetalert2/issues/2291
1224
1225
1226    setTimeout(() => {
1227      // https://github.com/sweetalert2/sweetalert2/issues/1699
1228      if ('MutationObserver' in window) {
1229        const initialPopupWidth = parseInt(window.getComputedStyle(getPopup()).width);
1230
1231        const textareaResizeHandler = () => {
1232          const textareaWidth = textarea.offsetWidth + getMargin(textarea);
1233
1234          if (textareaWidth > initialPopupWidth) {
1235            getPopup().style.width = "".concat(textareaWidth, "px");
1236          } else {
1237            getPopup().style.width = null;
1238          }
1239        };
1240
1241        new MutationObserver(textareaResizeHandler).observe(textarea, {
1242          attributes: true,
1243          attributeFilter: ['style']
1244        });
1245      }
1246    });
1247    return textarea;
1248  };
1249
1250  const renderContent = (instance, params) => {
1251    const htmlContainer = getHtmlContainer();
1252    applyCustomClass(htmlContainer, params, 'htmlContainer'); // Content as HTML
1253
1254    if (params.html) {
1255      parseHtmlToContainer(params.html, htmlContainer);
1256      show(htmlContainer, 'block');
1257    } // Content as plain text
1258    else if (params.text) {
1259      htmlContainer.textContent = params.text;
1260      show(htmlContainer, 'block');
1261    } // No content
1262    else {
1263      hide(htmlContainer);
1264    }
1265
1266    renderInput(instance, params);
1267  };
1268
1269  const renderFooter = (instance, params) => {
1270    const footer = getFooter();
1271    toggle(footer, params.footer);
1272
1273    if (params.footer) {
1274      parseHtmlToContainer(params.footer, footer);
1275    } // Custom class
1276
1277
1278    applyCustomClass(footer, params, 'footer');
1279  };
1280
1281  const renderCloseButton = (instance, params) => {
1282    const closeButton = getCloseButton();
1283    setInnerHtml(closeButton, params.closeButtonHtml); // Custom class
1284
1285    applyCustomClass(closeButton, params, 'closeButton');
1286    toggle(closeButton, params.showCloseButton);
1287    closeButton.setAttribute('aria-label', params.closeButtonAriaLabel);
1288  };
1289
1290  const renderIcon = (instance, params) => {
1291    const innerParams = privateProps.innerParams.get(instance);
1292    const icon = getIcon(); // if the given icon already rendered, apply the styling without re-rendering the icon
1293
1294    if (innerParams && params.icon === innerParams.icon) {
1295      // Custom or default content
1296      setContent(icon, params);
1297      applyStyles(icon, params);
1298      return;
1299    }
1300
1301    if (!params.icon && !params.iconHtml) {
1302      return hide(icon);
1303    }
1304
1305    if (params.icon && Object.keys(iconTypes).indexOf(params.icon) === -1) {
1306      error("Unknown icon! Expected \"success\", \"error\", \"warning\", \"info\" or \"question\", got \"".concat(params.icon, "\""));
1307      return hide(icon);
1308    }
1309
1310    show(icon); // Custom or default content
1311
1312    setContent(icon, params);
1313    applyStyles(icon, params); // Animate icon
1314
1315    addClass(icon, params.showClass.icon);
1316  };
1317
1318  const applyStyles = (icon, params) => {
1319    for (const iconType in iconTypes) {
1320      if (params.icon !== iconType) {
1321        removeClass(icon, iconTypes[iconType]);
1322      }
1323    }
1324
1325    addClass(icon, iconTypes[params.icon]); // Icon color
1326
1327    setColor(icon, params); // Success icon background color
1328
1329    adjustSuccessIconBackgroundColor(); // Custom class
1330
1331    applyCustomClass(icon, params, 'icon');
1332  }; // Adjust success icon background color to match the popup background color
1333
1334
1335  const adjustSuccessIconBackgroundColor = () => {
1336    const popup = getPopup();
1337    const popupBackgroundColor = window.getComputedStyle(popup).getPropertyValue('background-color');
1338    const successIconParts = popup.querySelectorAll('[class^=swal2-success-circular-line], .swal2-success-fix');
1339
1340    for (let i = 0; i < successIconParts.length; i++) {
1341      successIconParts[i].style.backgroundColor = popupBackgroundColor;
1342    }
1343  };
1344
1345  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";
1346  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";
1347
1348  const setContent = (icon, params) => {
1349    icon.textContent = '';
1350
1351    if (params.iconHtml) {
1352      setInnerHtml(icon, iconContent(params.iconHtml));
1353    } else if (params.icon === 'success') {
1354      setInnerHtml(icon, successIconHtml);
1355    } else if (params.icon === 'error') {
1356      setInnerHtml(icon, errorIconHtml);
1357    } else {
1358      const defaultIconHtml = {
1359        question: '?',
1360        warning: '!',
1361        info: 'i'
1362      };
1363      setInnerHtml(icon, iconContent(defaultIconHtml[params.icon]));
1364    }
1365  };
1366
1367  const setColor = (icon, params) => {
1368    if (!params.iconColor) {
1369      return;
1370    }
1371
1372    icon.style.color = params.iconColor;
1373    icon.style.borderColor = params.iconColor;
1374
1375    for (const sel of ['.swal2-success-line-tip', '.swal2-success-line-long', '.swal2-x-mark-line-left', '.swal2-x-mark-line-right']) {
1376      setStyle(icon, sel, 'backgroundColor', params.iconColor);
1377    }
1378
1379    setStyle(icon, '.swal2-success-ring', 'borderColor', params.iconColor);
1380  };
1381
1382  const iconContent = content => "<div class=\"".concat(swalClasses['icon-content'], "\">").concat(content, "</div>");
1383
1384  const renderImage = (instance, params) => {
1385    const image = getImage();
1386
1387    if (!params.imageUrl) {
1388      return hide(image);
1389    }
1390
1391    show(image, ''); // Src, alt
1392
1393    image.setAttribute('src', params.imageUrl);
1394    image.setAttribute('alt', params.imageAlt); // Width, height
1395
1396    applyNumericalStyle(image, 'width', params.imageWidth);
1397    applyNumericalStyle(image, 'height', params.imageHeight); // Class
1398
1399    image.className = swalClasses.image;
1400    applyCustomClass(image, params, 'image');
1401  };
1402
1403  const createStepElement = step => {
1404    const stepEl = document.createElement('li');
1405    addClass(stepEl, swalClasses['progress-step']);
1406    setInnerHtml(stepEl, step);
1407    return stepEl;
1408  };
1409
1410  const createLineElement = params => {
1411    const lineEl = document.createElement('li');
1412    addClass(lineEl, swalClasses['progress-step-line']);
1413
1414    if (params.progressStepsDistance) {
1415      lineEl.style.width = params.progressStepsDistance;
1416    }
1417
1418    return lineEl;
1419  };
1420
1421  const renderProgressSteps = (instance, params) => {
1422    const progressStepsContainer = getProgressSteps();
1423
1424    if (!params.progressSteps || params.progressSteps.length === 0) {
1425      return hide(progressStepsContainer);
1426    }
1427
1428    show(progressStepsContainer);
1429    progressStepsContainer.textContent = '';
1430
1431    if (params.currentProgressStep >= params.progressSteps.length) {
1432      warn('Invalid currentProgressStep parameter, it should be less than progressSteps.length ' + '(currentProgressStep like JS arrays starts from 0)');
1433    }
1434
1435    params.progressSteps.forEach((step, index) => {
1436      const stepEl = createStepElement(step);
1437      progressStepsContainer.appendChild(stepEl);
1438
1439      if (index === params.currentProgressStep) {
1440        addClass(stepEl, swalClasses['active-progress-step']);
1441      }
1442
1443      if (index !== params.progressSteps.length - 1) {
1444        const lineEl = createLineElement(params);
1445        progressStepsContainer.appendChild(lineEl);
1446      }
1447    });
1448  };
1449
1450  const renderTitle = (instance, params) => {
1451    const title = getTitle();
1452    toggle(title, params.title || params.titleText, 'block');
1453
1454    if (params.title) {
1455      parseHtmlToContainer(params.title, title);
1456    }
1457
1458    if (params.titleText) {
1459      title.innerText = params.titleText;
1460    } // Custom class
1461
1462
1463    applyCustomClass(title, params, 'title');
1464  };
1465
1466  const renderPopup = (instance, params) => {
1467    const container = getContainer();
1468    const popup = getPopup(); // Width
1469    // https://github.com/sweetalert2/sweetalert2/issues/2170
1470
1471    if (params.toast) {
1472      applyNumericalStyle(container, 'width', params.width);
1473      popup.style.width = '100%';
1474      popup.insertBefore(getLoader(), getIcon());
1475    } else {
1476      applyNumericalStyle(popup, 'width', params.width);
1477    } // Padding
1478
1479
1480    applyNumericalStyle(popup, 'padding', params.padding); // Color
1481
1482    if (params.color) {
1483      popup.style.color = params.color;
1484    } // Background
1485
1486
1487    if (params.background) {
1488      popup.style.background = params.background;
1489    }
1490
1491    hide(getValidationMessage()); // Classes
1492
1493    addClasses(popup, params);
1494  };
1495
1496  const addClasses = (popup, params) => {
1497    // Default Class + showClass when updating Swal.update({})
1498    popup.className = "".concat(swalClasses.popup, " ").concat(isVisible(popup) ? params.showClass.popup : '');
1499
1500    if (params.toast) {
1501      addClass([document.documentElement, document.body], swalClasses['toast-shown']);
1502      addClass(popup, swalClasses.toast);
1503    } else {
1504      addClass(popup, swalClasses.modal);
1505    } // Custom class
1506
1507
1508    applyCustomClass(popup, params, 'popup');
1509
1510    if (typeof params.customClass === 'string') {
1511      addClass(popup, params.customClass);
1512    } // Icon class (#1842)
1513
1514
1515    if (params.icon) {
1516      addClass(popup, swalClasses["icon-".concat(params.icon)]);
1517    }
1518  };
1519
1520  const render = (instance, params) => {
1521    renderPopup(instance, params);
1522    renderContainer(instance, params);
1523    renderProgressSteps(instance, params);
1524    renderIcon(instance, params);
1525    renderImage(instance, params);
1526    renderTitle(instance, params);
1527    renderCloseButton(instance, params);
1528    renderContent(instance, params);
1529    renderActions(instance, params);
1530    renderFooter(instance, params);
1531
1532    if (typeof params.didRender === 'function') {
1533      params.didRender(getPopup());
1534    }
1535  };
1536
1537  const DismissReason = Object.freeze({
1538    cancel: 'cancel',
1539    backdrop: 'backdrop',
1540    close: 'close',
1541    esc: 'esc',
1542    timer: 'timer'
1543  });
1544
1545  // Adding aria-hidden="true" to elements outside of the active modal dialog ensures that
1546  // elements not within the active modal dialog will not be surfaced if a user opens a screen
1547  // reader’s list of elements (headings, form controls, landmarks, etc.) in the document.
1548
1549  const setAriaHidden = () => {
1550    const bodyChildren = toArray(document.body.children);
1551    bodyChildren.forEach(el => {
1552      if (el === getContainer() || el.contains(getContainer())) {
1553        return;
1554      }
1555
1556      if (el.hasAttribute('aria-hidden')) {
1557        el.setAttribute('data-previous-aria-hidden', el.getAttribute('aria-hidden'));
1558      }
1559
1560      el.setAttribute('aria-hidden', 'true');
1561    });
1562  };
1563  const unsetAriaHidden = () => {
1564    const bodyChildren = toArray(document.body.children);
1565    bodyChildren.forEach(el => {
1566      if (el.hasAttribute('data-previous-aria-hidden')) {
1567        el.setAttribute('aria-hidden', el.getAttribute('data-previous-aria-hidden'));
1568        el.removeAttribute('data-previous-aria-hidden');
1569      } else {
1570        el.removeAttribute('aria-hidden');
1571      }
1572    });
1573  };
1574
1575  const swalStringParams = ['swal-title', 'swal-html', 'swal-footer'];
1576  const getTemplateParams = params => {
1577    const template = typeof params.template === 'string' ? document.querySelector(params.template) : params.template;
1578
1579    if (!template) {
1580      return {};
1581    }
1582    /** @type {DocumentFragment} */
1583
1584
1585    const templateContent = template.content;
1586    showWarningsForElements(templateContent);
1587    const result = Object.assign(getSwalParams(templateContent), getSwalButtons(templateContent), getSwalImage(templateContent), getSwalIcon(templateContent), getSwalInput(templateContent), getSwalStringParams(templateContent, swalStringParams));
1588    return result;
1589  };
1590  /**
1591   * @param {DocumentFragment} templateContent
1592   */
1593
1594  const getSwalParams = templateContent => {
1595    const result = {};
1596    toArray(templateContent.querySelectorAll('swal-param')).forEach(param => {
1597      showWarningsForAttributes(param, ['name', 'value']);
1598      const paramName = param.getAttribute('name');
1599      const value = param.getAttribute('value');
1600
1601      if (typeof defaultParams[paramName] === 'boolean' && value === 'false') {
1602        result[paramName] = false;
1603      }
1604
1605      if (typeof defaultParams[paramName] === 'object') {
1606        result[paramName] = JSON.parse(value);
1607      }
1608    });
1609    return result;
1610  };
1611  /**
1612   * @param {DocumentFragment} templateContent
1613   */
1614
1615
1616  const getSwalButtons = templateContent => {
1617    const result = {};
1618    toArray(templateContent.querySelectorAll('swal-button')).forEach(button => {
1619      showWarningsForAttributes(button, ['type', 'color', 'aria-label']);
1620      const type = button.getAttribute('type');
1621      result["".concat(type, "ButtonText")] = button.innerHTML;
1622      result["show".concat(capitalizeFirstLetter(type), "Button")] = true;
1623
1624      if (button.hasAttribute('color')) {
1625        result["".concat(type, "ButtonColor")] = button.getAttribute('color');
1626      }
1627
1628      if (button.hasAttribute('aria-label')) {
1629        result["".concat(type, "ButtonAriaLabel")] = button.getAttribute('aria-label');
1630      }
1631    });
1632    return result;
1633  };
1634  /**
1635   * @param {DocumentFragment} templateContent
1636   */
1637
1638
1639  const getSwalImage = templateContent => {
1640    const result = {};
1641    /** @type {HTMLElement} */
1642
1643    const image = templateContent.querySelector('swal-image');
1644
1645    if (image) {
1646      showWarningsForAttributes(image, ['src', 'width', 'height', 'alt']);
1647
1648      if (image.hasAttribute('src')) {
1649        result.imageUrl = image.getAttribute('src');
1650      }
1651
1652      if (image.hasAttribute('width')) {
1653        result.imageWidth = image.getAttribute('width');
1654      }
1655
1656      if (image.hasAttribute('height')) {
1657        result.imageHeight = image.getAttribute('height');
1658      }
1659
1660      if (image.hasAttribute('alt')) {
1661        result.imageAlt = image.getAttribute('alt');
1662      }
1663    }
1664
1665    return result;
1666  };
1667  /**
1668   * @param {DocumentFragment} templateContent
1669   */
1670
1671
1672  const getSwalIcon = templateContent => {
1673    const result = {};
1674    /** @type {HTMLElement} */
1675
1676    const icon = templateContent.querySelector('swal-icon');
1677
1678    if (icon) {
1679      showWarningsForAttributes(icon, ['type', 'color']);
1680
1681      if (icon.hasAttribute('type')) {
1682        result.icon = icon.getAttribute('type');
1683      }
1684
1685      if (icon.hasAttribute('color')) {
1686        result.iconColor = icon.getAttribute('color');
1687      }
1688
1689      result.iconHtml = icon.innerHTML;
1690    }
1691
1692    return result;
1693  };
1694  /**
1695   * @param {DocumentFragment} templateContent
1696   */
1697
1698
1699  const getSwalInput = templateContent => {
1700    const result = {};
1701    /** @type {HTMLElement} */
1702
1703    const input = templateContent.querySelector('swal-input');
1704
1705    if (input) {
1706      showWarningsForAttributes(input, ['type', 'label', 'placeholder', 'value']);
1707      result.input = input.getAttribute('type') || 'text';
1708
1709      if (input.hasAttribute('label')) {
1710        result.inputLabel = input.getAttribute('label');
1711      }
1712
1713      if (input.hasAttribute('placeholder')) {
1714        result.inputPlaceholder = input.getAttribute('placeholder');
1715      }
1716
1717      if (input.hasAttribute('value')) {
1718        result.inputValue = input.getAttribute('value');
1719      }
1720    }
1721
1722    const inputOptions = templateContent.querySelectorAll('swal-input-option');
1723
1724    if (inputOptions.length) {
1725      result.inputOptions = {};
1726      toArray(inputOptions).forEach(option => {
1727        showWarningsForAttributes(option, ['value']);
1728        const optionValue = option.getAttribute('value');
1729        const optionName = option.innerHTML;
1730        result.inputOptions[optionValue] = optionName;
1731      });
1732    }
1733
1734    return result;
1735  };
1736  /**
1737   * @param {DocumentFragment} templateContent
1738   * @param {string[]} paramNames
1739   */
1740
1741
1742  const getSwalStringParams = (templateContent, paramNames) => {
1743    const result = {};
1744
1745    for (const i in paramNames) {
1746      const paramName = paramNames[i];
1747      /** @type {HTMLElement} */
1748
1749      const tag = templateContent.querySelector(paramName);
1750
1751      if (tag) {
1752        showWarningsForAttributes(tag, []);
1753        result[paramName.replace(/^swal-/, '')] = tag.innerHTML.trim();
1754      }
1755    }
1756
1757    return result;
1758  };
1759  /**
1760   * @param {DocumentFragment} templateContent
1761   */
1762
1763
1764  const showWarningsForElements = templateContent => {
1765    const allowedElements = swalStringParams.concat(['swal-param', 'swal-button', 'swal-image', 'swal-icon', 'swal-input', 'swal-input-option']);
1766    toArray(templateContent.children).forEach(el => {
1767      const tagName = el.tagName.toLowerCase();
1768
1769      if (allowedElements.indexOf(tagName) === -1) {
1770        warn("Unrecognized element <".concat(tagName, ">"));
1771      }
1772    });
1773  };
1774  /**
1775   * @param {HTMLElement} el
1776   * @param {string[]} allowedAttributes
1777   */
1778
1779
1780  const showWarningsForAttributes = (el, allowedAttributes) => {
1781    toArray(el.attributes).forEach(attribute => {
1782      if (allowedAttributes.indexOf(attribute.name) === -1) {
1783        warn(["Unrecognized attribute \"".concat(attribute.name, "\" on <").concat(el.tagName.toLowerCase(), ">."), "".concat(allowedAttributes.length ? "Allowed attributes are: ".concat(allowedAttributes.join(', ')) : 'To set the value, use HTML within the element.')]);
1784      }
1785    });
1786  };
1787
1788  var defaultInputValidators = {
1789    email: (string, validationMessage) => {
1790      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');
1791    },
1792    url: (string, validationMessage) => {
1793      // taken from https://stackoverflow.com/a/3809435 with a small change from #1306 and #2013
1794      return /^https?:\/\/(www\.)?[-a-zA-Z0-9@:%._+~#=]{1,256}\.[a-z]{2,63}\b([-a-zA-Z0-9@:%_+.~#?&/=]*)$/.test(string) ? Promise.resolve() : Promise.resolve(validationMessage || 'Invalid URL');
1795    }
1796  };
1797
1798  function setDefaultInputValidators(params) {
1799    // Use default `inputValidator` for supported input types if not provided
1800    if (!params.inputValidator) {
1801      Object.keys(defaultInputValidators).forEach(key => {
1802        if (params.input === key) {
1803          params.inputValidator = defaultInputValidators[key];
1804        }
1805      });
1806    }
1807  }
1808
1809  function validateCustomTargetElement(params) {
1810    // Determine if the custom target element is valid
1811    if (!params.target || typeof params.target === 'string' && !document.querySelector(params.target) || typeof params.target !== 'string' && !params.target.appendChild) {
1812      warn('Target parameter is not valid, defaulting to "body"');
1813      params.target = 'body';
1814    }
1815  }
1816  /**
1817   * Set type, text and actions on popup
1818   *
1819   * @param params
1820   */
1821
1822
1823  function setParameters(params) {
1824    setDefaultInputValidators(params); // showLoaderOnConfirm && preConfirm
1825
1826    if (params.showLoaderOnConfirm && !params.preConfirm) {
1827      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');
1828    }
1829
1830    validateCustomTargetElement(params); // Replace newlines with <br> in title
1831
1832    if (typeof params.title === 'string') {
1833      params.title = params.title.split('\n').join('<br />');
1834    }
1835
1836    init(params);
1837  }
1838
1839  class Timer {
1840    constructor(callback, delay) {
1841      this.callback = callback;
1842      this.remaining = delay;
1843      this.running = false;
1844      this.start();
1845    }
1846
1847    start() {
1848      if (!this.running) {
1849        this.running = true;
1850        this.started = new Date();
1851        this.id = setTimeout(this.callback, this.remaining);
1852      }
1853
1854      return this.remaining;
1855    }
1856
1857    stop() {
1858      if (this.running) {
1859        this.running = false;
1860        clearTimeout(this.id);
1861        this.remaining -= new Date().getTime() - this.started.getTime();
1862      }
1863
1864      return this.remaining;
1865    }
1866
1867    increase(n) {
1868      const running = this.running;
1869
1870      if (running) {
1871        this.stop();
1872      }
1873
1874      this.remaining += n;
1875
1876      if (running) {
1877        this.start();
1878      }
1879
1880      return this.remaining;
1881    }
1882
1883    getTimerLeft() {
1884      if (this.running) {
1885        this.stop();
1886        this.start();
1887      }
1888
1889      return this.remaining;
1890    }
1891
1892    isRunning() {
1893      return this.running;
1894    }
1895
1896  }
1897
1898  const fixScrollbar = () => {
1899    // for queues, do not do this more than once
1900    if (states.previousBodyPadding !== null) {
1901      return;
1902    } // if the body has overflow
1903
1904
1905    if (document.body.scrollHeight > window.innerHeight) {
1906      // add padding so the content doesn't shift after removal of scrollbar
1907      states.previousBodyPadding = parseInt(window.getComputedStyle(document.body).getPropertyValue('padding-right'));
1908      document.body.style.paddingRight = "".concat(states.previousBodyPadding + measureScrollbar(), "px");
1909    }
1910  };
1911  const undoScrollbar = () => {
1912    if (states.previousBodyPadding !== null) {
1913      document.body.style.paddingRight = "".concat(states.previousBodyPadding, "px");
1914      states.previousBodyPadding = null;
1915    }
1916  };
1917
1918  /* istanbul ignore file */
1919
1920  const iOSfix = () => {
1921    const iOS = // @ts-ignore
1922    /iPad|iPhone|iPod/.test(navigator.userAgent) && !window.MSStream || navigator.platform === 'MacIntel' && navigator.maxTouchPoints > 1;
1923
1924    if (iOS && !hasClass(document.body, swalClasses.iosfix)) {
1925      const offset = document.body.scrollTop;
1926      document.body.style.top = "".concat(offset * -1, "px");
1927      addClass(document.body, swalClasses.iosfix);
1928      lockBodyScroll();
1929      addBottomPaddingForTallPopups();
1930    }
1931  };
1932  /**
1933   * https://github.com/sweetalert2/sweetalert2/issues/1948
1934   */
1935
1936  const addBottomPaddingForTallPopups = () => {
1937    const ua = navigator.userAgent;
1938    const iOS = !!ua.match(/iPad/i) || !!ua.match(/iPhone/i);
1939    const webkit = !!ua.match(/WebKit/i);
1940    const iOSSafari = iOS && webkit && !ua.match(/CriOS/i);
1941
1942    if (iOSSafari) {
1943      const bottomPanelHeight = 44;
1944
1945      if (getPopup().scrollHeight > window.innerHeight - bottomPanelHeight) {
1946        getContainer().style.paddingBottom = "".concat(bottomPanelHeight, "px");
1947      }
1948    }
1949  };
1950  /**
1951   * https://github.com/sweetalert2/sweetalert2/issues/1246
1952   */
1953
1954
1955  const lockBodyScroll = () => {
1956    const container = getContainer();
1957    let preventTouchMove;
1958
1959    container.ontouchstart = e => {
1960      preventTouchMove = shouldPreventTouchMove(e);
1961    };
1962
1963    container.ontouchmove = e => {
1964      if (preventTouchMove) {
1965        e.preventDefault();
1966        e.stopPropagation();
1967      }
1968    };
1969  };
1970
1971  const shouldPreventTouchMove = event => {
1972    const target = event.target;
1973    const container = getContainer();
1974
1975    if (isStylus(event) || isZoom(event)) {
1976      return false;
1977    }
1978
1979    if (target === container) {
1980      return true;
1981    }
1982
1983    if (!isScrollable(container) && target.tagName !== 'INPUT' && // #1603
1984    target.tagName !== 'TEXTAREA' && // #2266
1985    !(isScrollable(getHtmlContainer()) && // #1944
1986    getHtmlContainer().contains(target))) {
1987      return true;
1988    }
1989
1990    return false;
1991  };
1992  /**
1993   * https://github.com/sweetalert2/sweetalert2/issues/1786
1994   *
1995   * @param {*} event
1996   * @returns {boolean}
1997   */
1998
1999
2000  const isStylus = event => {
2001    return event.touches && event.touches.length && event.touches[0].touchType === 'stylus';
2002  };
2003  /**
2004   * https://github.com/sweetalert2/sweetalert2/issues/1891
2005   *
2006   * @param {TouchEvent} event
2007   * @returns {boolean}
2008   */
2009
2010
2011  const isZoom = event => {
2012    return event.touches && event.touches.length > 1;
2013  };
2014
2015  const undoIOSfix = () => {
2016    if (hasClass(document.body, swalClasses.iosfix)) {
2017      const offset = parseInt(document.body.style.top, 10);
2018      removeClass(document.body, swalClasses.iosfix);
2019      document.body.style.top = '';
2020      document.body.scrollTop = offset * -1;
2021    }
2022  };
2023
2024  const SHOW_CLASS_TIMEOUT = 10;
2025  /**
2026   * Open popup, add necessary classes and styles, fix scrollbar
2027   *
2028   * @param params
2029   */
2030
2031  const openPopup = params => {
2032    const container = getContainer();
2033    const popup = getPopup();
2034
2035    if (typeof params.willOpen === 'function') {
2036      params.willOpen(popup);
2037    }
2038
2039    const bodyStyles = window.getComputedStyle(document.body);
2040    const initialBodyOverflow = bodyStyles.overflowY;
2041    addClasses$1(container, popup, params); // scrolling is 'hidden' until animation is done, after that 'auto'
2042
2043    setTimeout(() => {
2044      setScrollingVisibility(container, popup);
2045    }, SHOW_CLASS_TIMEOUT);
2046
2047    if (isModal()) {
2048      fixScrollContainer(container, params.scrollbarPadding, initialBodyOverflow);
2049      setAriaHidden();
2050    }
2051
2052    if (!isToast() && !globalState.previousActiveElement) {
2053      globalState.previousActiveElement = document.activeElement;
2054    }
2055
2056    if (typeof params.didOpen === 'function') {
2057      setTimeout(() => params.didOpen(popup));
2058    }
2059
2060    removeClass(container, swalClasses['no-transition']);
2061  };
2062
2063  const swalOpenAnimationFinished = event => {
2064    const popup = getPopup();
2065
2066    if (event.target !== popup) {
2067      return;
2068    }
2069
2070    const container = getContainer();
2071    popup.removeEventListener(animationEndEvent, swalOpenAnimationFinished);
2072    container.style.overflowY = 'auto';
2073  };
2074
2075  const setScrollingVisibility = (container, popup) => {
2076    if (animationEndEvent && hasCssAnimation(popup)) {
2077      container.style.overflowY = 'hidden';
2078      popup.addEventListener(animationEndEvent, swalOpenAnimationFinished);
2079    } else {
2080      container.style.overflowY = 'auto';
2081    }
2082  };
2083
2084  const fixScrollContainer = (container, scrollbarPadding, initialBodyOverflow) => {
2085    iOSfix();
2086
2087    if (scrollbarPadding && initialBodyOverflow !== 'hidden') {
2088      fixScrollbar();
2089    } // sweetalert2/issues/1247
2090
2091
2092    setTimeout(() => {
2093      container.scrollTop = 0;
2094    });
2095  };
2096
2097  const addClasses$1 = (container, popup, params) => {
2098    addClass(container, params.showClass.backdrop); // this workaround with opacity is needed for https://github.com/sweetalert2/sweetalert2/issues/2059
2099
2100    popup.style.setProperty('opacity', '0', 'important');
2101    show(popup, 'grid');
2102    setTimeout(() => {
2103      // Animate popup right after showing it
2104      addClass(popup, params.showClass.popup); // and remove the opacity workaround
2105
2106      popup.style.removeProperty('opacity');
2107    }, SHOW_CLASS_TIMEOUT); // 10ms in order to fix #2062
2108
2109    addClass([document.documentElement, document.body], swalClasses.shown);
2110
2111    if (params.heightAuto && params.backdrop && !params.toast) {
2112      addClass([document.documentElement, document.body], swalClasses['height-auto']);
2113    }
2114  };
2115
2116  /**
2117   * Shows loader (spinner), this is useful with AJAX requests.
2118   * By default the loader be shown instead of the "Confirm" button.
2119   */
2120
2121  const showLoading = buttonToReplace => {
2122    let popup = getPopup();
2123
2124    if (!popup) {
2125      new Swal(); // eslint-disable-line no-new
2126    }
2127
2128    popup = getPopup();
2129    const loader = getLoader();
2130
2131    if (isToast()) {
2132      hide(getIcon());
2133    } else {
2134      replaceButton(popup, buttonToReplace);
2135    }
2136
2137    show(loader);
2138    popup.setAttribute('data-loading', true);
2139    popup.setAttribute('aria-busy', true);
2140    popup.focus();
2141  };
2142
2143  const replaceButton = (popup, buttonToReplace) => {
2144    const actions = getActions();
2145    const loader = getLoader();
2146
2147    if (!buttonToReplace && isVisible(getConfirmButton())) {
2148      buttonToReplace = getConfirmButton();
2149    }
2150
2151    show(actions);
2152
2153    if (buttonToReplace) {
2154      hide(buttonToReplace);
2155      loader.setAttribute('data-button-to-replace', buttonToReplace.className);
2156    }
2157
2158    loader.parentNode.insertBefore(loader, buttonToReplace);
2159    addClass([popup, actions], swalClasses.loading);
2160  };
2161
2162  const handleInputOptionsAndValue = (instance, params) => {
2163    if (params.input === 'select' || params.input === 'radio') {
2164      handleInputOptions(instance, params);
2165    } else if (['text', 'email', 'number', 'tel', 'textarea'].includes(params.input) && (hasToPromiseFn(params.inputValue) || isPromise(params.inputValue))) {
2166      showLoading(getConfirmButton());
2167      handleInputValue(instance, params);
2168    }
2169  };
2170  const getInputValue = (instance, innerParams) => {
2171    const input = instance.getInput();
2172
2173    if (!input) {
2174      return null;
2175    }
2176
2177    switch (innerParams.input) {
2178      case 'checkbox':
2179        return getCheckboxValue(input);
2180
2181      case 'radio':
2182        return getRadioValue(input);
2183
2184      case 'file':
2185        return getFileValue(input);
2186
2187      default:
2188        return innerParams.inputAutoTrim ? input.value.trim() : input.value;
2189    }
2190  };
2191
2192  const getCheckboxValue = input => input.checked ? 1 : 0;
2193
2194  const getRadioValue = input => input.checked ? input.value : null;
2195
2196  const getFileValue = input => input.files.length ? input.getAttribute('multiple') !== null ? input.files : input.files[0] : null;
2197
2198  const handleInputOptions = (instance, params) => {
2199    const popup = getPopup();
2200
2201    const processInputOptions = inputOptions => populateInputOptions[params.input](popup, formatInputOptions(inputOptions), params);
2202
2203    if (hasToPromiseFn(params.inputOptions) || isPromise(params.inputOptions)) {
2204      showLoading(getConfirmButton());
2205      asPromise(params.inputOptions).then(inputOptions => {
2206        instance.hideLoading();
2207        processInputOptions(inputOptions);
2208      });
2209    } else if (typeof params.inputOptions === 'object') {
2210      processInputOptions(params.inputOptions);
2211    } else {
2212      error("Unexpected type of inputOptions! Expected object, Map or Promise, got ".concat(typeof params.inputOptions));
2213    }
2214  };
2215
2216  const handleInputValue = (instance, params) => {
2217    const input = instance.getInput();
2218    hide(input);
2219    asPromise(params.inputValue).then(inputValue => {
2220      input.value = params.input === 'number' ? parseFloat(inputValue) || 0 : "".concat(inputValue);
2221      show(input);
2222      input.focus();
2223      instance.hideLoading();
2224    }).catch(err => {
2225      error("Error in inputValue promise: ".concat(err));
2226      input.value = '';
2227      show(input);
2228      input.focus();
2229      instance.hideLoading();
2230    });
2231  };
2232
2233  const populateInputOptions = {
2234    select: (popup, inputOptions, params) => {
2235      const select = getDirectChildByClass(popup, swalClasses.select);
2236
2237      const renderOption = (parent, optionLabel, optionValue) => {
2238        const option = document.createElement('option');
2239        option.value = optionValue;
2240        setInnerHtml(option, optionLabel);
2241        option.selected = isSelected(optionValue, params.inputValue);
2242        parent.appendChild(option);
2243      };
2244
2245      inputOptions.forEach(inputOption => {
2246        const optionValue = inputOption[0];
2247        const optionLabel = inputOption[1]; // <optgroup> spec:
2248        // https://www.w3.org/TR/html401/interact/forms.html#h-17.6
2249        // "...all OPTGROUP elements must be specified directly within a SELECT element (i.e., groups may not be nested)..."
2250        // check whether this is a <optgroup>
2251
2252        if (Array.isArray(optionLabel)) {
2253          // if it is an array, then it is an <optgroup>
2254          const optgroup = document.createElement('optgroup');
2255          optgroup.label = optionValue;
2256          optgroup.disabled = false; // not configurable for now
2257
2258          select.appendChild(optgroup);
2259          optionLabel.forEach(o => renderOption(optgroup, o[1], o[0]));
2260        } else {
2261          // case of <option>
2262          renderOption(select, optionLabel, optionValue);
2263        }
2264      });
2265      select.focus();
2266    },
2267    radio: (popup, inputOptions, params) => {
2268      const radio = getDirectChildByClass(popup, swalClasses.radio);
2269      inputOptions.forEach(inputOption => {
2270        const radioValue = inputOption[0];
2271        const radioLabel = inputOption[1];
2272        const radioInput = document.createElement('input');
2273        const radioLabelElement = document.createElement('label');
2274        radioInput.type = 'radio';
2275        radioInput.name = swalClasses.radio;
2276        radioInput.value = radioValue;
2277
2278        if (isSelected(radioValue, params.inputValue)) {
2279          radioInput.checked = true;
2280        }
2281
2282        const label = document.createElement('span');
2283        setInnerHtml(label, radioLabel);
2284        label.className = swalClasses.label;
2285        radioLabelElement.appendChild(radioInput);
2286        radioLabelElement.appendChild(label);
2287        radio.appendChild(radioLabelElement);
2288      });
2289      const radios = radio.querySelectorAll('input');
2290
2291      if (radios.length) {
2292        radios[0].focus();
2293      }
2294    }
2295  };
2296  /**
2297   * Converts `inputOptions` into an array of `[value, label]`s
2298   * @param inputOptions
2299   */
2300
2301  const formatInputOptions = inputOptions => {
2302    const result = [];
2303
2304    if (typeof Map !== 'undefined' && inputOptions instanceof Map) {
2305      inputOptions.forEach((value, key) => {
2306        let valueFormatted = value;
2307
2308        if (typeof valueFormatted === 'object') {
2309          // case of <optgroup>
2310          valueFormatted = formatInputOptions(valueFormatted);
2311        }
2312
2313        result.push([key, valueFormatted]);
2314      });
2315    } else {
2316      Object.keys(inputOptions).forEach(key => {
2317        let valueFormatted = inputOptions[key];
2318
2319        if (typeof valueFormatted === 'object') {
2320          // case of <optgroup>
2321          valueFormatted = formatInputOptions(valueFormatted);
2322        }
2323
2324        result.push([key, valueFormatted]);
2325      });
2326    }
2327
2328    return result;
2329  };
2330
2331  const isSelected = (optionValue, inputValue) => {
2332    return inputValue && inputValue.toString() === optionValue.toString();
2333  };
2334
2335  /**
2336   * Hides loader and shows back the button which was hidden by .showLoading()
2337   */
2338
2339  function hideLoading() {
2340    // do nothing if popup is closed
2341    const innerParams = privateProps.innerParams.get(this);
2342
2343    if (!innerParams) {
2344      return;
2345    }
2346
2347    const domCache = privateProps.domCache.get(this);
2348    hide(domCache.loader);
2349
2350    if (isToast()) {
2351      if (innerParams.icon) {
2352        show(getIcon());
2353      }
2354    } else {
2355      showRelatedButton(domCache);
2356    }
2357
2358    removeClass([domCache.popup, domCache.actions], swalClasses.loading);
2359    domCache.popup.removeAttribute('aria-busy');
2360    domCache.popup.removeAttribute('data-loading');
2361    domCache.confirmButton.disabled = false;
2362    domCache.denyButton.disabled = false;
2363    domCache.cancelButton.disabled = false;
2364  }
2365
2366  const showRelatedButton = domCache => {
2367    const buttonToReplace = domCache.popup.getElementsByClassName(domCache.loader.getAttribute('data-button-to-replace'));
2368
2369    if (buttonToReplace.length) {
2370      show(buttonToReplace[0], 'inline-block');
2371    } else if (allButtonsAreHidden()) {
2372      hide(domCache.actions);
2373    }
2374  };
2375
2376  /**
2377   * Gets the input DOM node, this method works with input parameter.
2378   * @returns {HTMLElement | null}
2379   */
2380
2381  function getInput$1(instance) {
2382    const innerParams = privateProps.innerParams.get(instance || this);
2383    const domCache = privateProps.domCache.get(instance || this);
2384
2385    if (!domCache) {
2386      return null;
2387    }
2388
2389    return getInput(domCache.popup, innerParams.input);
2390  }
2391
2392  /**
2393   * This module contains `WeakMap`s for each effectively-"private  property" that a `Swal` has.
2394   * For example, to set the private property "foo" of `this` to "bar", you can `privateProps.foo.set(this, 'bar')`
2395   * This is the approach that Babel will probably take to implement private methods/fields
2396   *   https://github.com/tc39/proposal-private-methods
2397   *   https://github.com/babel/babel/pull/7555
2398   * Once we have the changes from that PR in Babel, and our core class fits reasonable in *one module*
2399   *   then we can use that language feature.
2400   */
2401  var privateMethods = {
2402    swalPromiseResolve: new WeakMap(),
2403    swalPromiseReject: new WeakMap()
2404  };
2405
2406  /*
2407   * 

2438
2439
2440    if (!innerParams.toast) {
2441      globalState.keydownHandler = e => keydownHandler(instance, e, dismissWith);
2442
2443      globalState.keydownTarget = innerParams.keydownListenerCapture ? window : getPopup();
2444      globalState.keydownListenerCapture = innerParams.keydownListenerCapture;
2445      globalState.keydownTarget.addEventListener('keydown', globalState.keydownHandler, {
2446        capture: globalState.keydownListenerCapture
2447      });
2448      globalState.keydownHandlerAdded = true;
2449    }
2450  }; // Focus handling
2451
2452  const setFocus = (innerParams, index, increment) => {
2453    const focusableElements = getFocusableElements(); // search for visible elements and select the next possible match
2454
2455    if (focusableElements.length) {
2456      index = index + increment; // rollover to first item
2457
2458      if (index === focusableElements.length) {
2459        index = 0; // go to last item
2460      } else if (index === -1) {
2461        index = focusableElements.length - 1;
2462      }
2463
2464      return focusableElements[index].focus();
2465    } // no visible focusable elements, focus the popup
2466
2467
2468    getPopup().focus();
2469  };
2470  const arrowKeysNextButton = ['ArrowRight', 'ArrowDown'];
2471  const arrowKeysPreviousButton = ['ArrowLeft', 'ArrowUp'];
2472
2473  const keydownHandler = (instance, e, dismissWith) => {
2474    const innerParams = privateProps.innerParams.get(instance);
2475
2476    if (!innerParams) {
2477      return; // This instance has already been destroyed
2478    } // Ignore keydown during IME composition
2479    // https://developer.mozilla.org/en-US/docs/Web/API/Document/keydown_event#ignoring_keydown_during_ime_composition
2480    // https://github.com/sweetalert2/sweetalert2/issues/720
2481    // https://github.com/sweetalert2/sweetalert2/issues/2406
2482
2483
2484    if (e.isComposing || e.keyCode === 229) {
2485      return;
2486    }
2487
2488    if (innerParams.stopKeydownPropagation) {
2489      e.stopPropagation();
2490    } // ENTER
2491
2492
2493    if (e.key === 'Enter') {
2494      handleEnter(instance, e, innerParams);
2495    } // TAB
2496    else if (e.key === 'Tab') {
2497      handleTab(e, innerParams);
2498    } // ARROWS - switch focus between buttons
2499    else if ([...arrowKeysNextButton, ...arrowKeysPreviousButton].includes(e.key)) {
2500      handleArrows(e.key);
2501    } // ESC
2502    else if (e.key === 'Escape') {
2503      handleEsc(e, innerParams, dismissWith);
2504    }
2505  };
2506
2507  const handleEnter = (instance, e, innerParams) => {
2508    // https://github.com/sweetalert2/sweetalert2/issues/2386
2509    if (!callIfFunction(innerParams.allowEnterKey)) {
2510      return;
2511    }
2512
2513    if (e.target && instance.getInput() && e.target.outerHTML === instance.getInput().outerHTML) {
2514      if (['textarea', 'file'].includes(innerParams.input)) {
2515        return; // do not submit
2516      }
2517
2518      clickConfirm();
2519      e.preventDefault();
2520    }
2521  };
2522
2523  const handleTab = (e, innerParams) => {
2524    const targetElement = e.target;
2525    const focusableElements = getFocusableElements();
2526    let btnIndex = -1;
2527
2528    for (let i = 0; i < focusableElements.length; i++) {
2529      if (targetElement === focusableElements[i]) {
2530        btnIndex = i;
2531        break;
2532      }
2533    } // Cycle to the next button
2534
2535
2536    if (!e.shiftKey) {
2537      setFocus(innerParams, btnIndex, 1);
2538    } // Cycle to the prev button
2539    else {
2540      setFocus(innerParams, btnIndex, -1);
2541    }
2542
2543    e.stopPropagation();
2544    e.preventDefault();
2545  };
2546
2547  const handleArrows = key => {
2548    const confirmButton = getConfirmButton();
2549    const denyButton = getDenyButton();
2550    const cancelButton = getCancelButton();
2551
2552    if (![confirmButton, denyButton, cancelButton].includes(document.activeElement)) {
2553      return;
2554    }
2555
2556    const sibling = arrowKeysNextButton.includes(key) ? 'nextElementSibling' : 'previousElementSibling';
2557    let buttonToFocus = document.activeElement;
2558
2559    for (let i = 0; i < getActions().children.length; i++) {
2560      buttonToFocus = buttonToFocus[sibling];
2561
2562      if (!buttonToFocus) {
2563        return;
2564      }
2565
2566      if (isVisible(buttonToFocus) && buttonToFocus instanceof HTMLButtonElement) {
2567        break;
2568      }
2569    }
2570
2571    if (buttonToFocus instanceof HTMLButtonElement) {
2572      buttonToFocus.focus();
2573    }
2574  };
2575
2576  const handleEsc = (e, innerParams, dismissWith) => {
2577    if (callIfFunction(innerParams.allowEscapeKey)) {
2578      e.preventDefault();
2579      dismissWith(DismissReason.esc);
2580    }
2581  };
2582
2583  

2583/*
2584   * Instance method to close sweetAlert
2585   */
2586
2587  function removePopupAndResetState(instance, container, returnFocus, didClose) {
2588    if (isToast()) {
2589      triggerDidCloseAndDispose(instance, didClose);
2590    } else {
2591      restoreActiveElement(returnFocus).then(() => triggerDidCloseAndDispose(instance, didClose));
2592      removeKeydownHandler(globalState);
2593    }
2594
2595    const isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent); // workaround for #2088
2596    // for some reason removing the container in Safari will scroll the document to bottom
2597
2598    if (isSafari) {
2599      container.setAttribute('style', 'display:none !important');
2600      container.removeAttribute('class');
2601      container.innerHTML = '';
2602    } else {
2603      container.remove();
2604    }
2605
2606    if (isModal()) {
2607      undoScrollbar();
2608      undoIOSfix();
2609      unsetAriaHidden();
2610    }
2611
2612    removeBodyClasses();
2613  }
2614
2615  function removeBodyClasses() {
2616    removeClass([document.documentElement, document.body], [swalClasses.shown, swalClasses['height-auto'], swalClasses['no-backdrop'], swalClasses['toast-shown']]);
2617  }
2618
2619  function close(resolveValue) {
2620    resolveValue = prepareResolveValue(resolveValue);
2621    const swalPromiseResolve = privateMethods.swalPromiseResolve.get(this);
2622    const didClose = triggerClosePopup(this);
2623
2624    if (this.isAwaitingPromise()) {
2625      // A swal awaiting for a promise (after a click on Confirm or Deny) cannot be dismissed anymore #2335
2626      if (!resolveValue.isDismissed) {
2627        handleAwaitingPromise(this);
2628        swalPromiseResolve(resolveValue);
2629      }
2630    } else if (didClose) {
2631      // Resolve Swal promise
2632      swalPromiseResolve(resolveValue);
2633    }
2634  }
2635  function isAwaitingPromise() {
2636    return !!privateProps.awaitingPromise.get(this);
2637  }
2638
2639  const triggerClosePopup = instance => {
2640    const popup = getPopup();
2641
2642    if (!popup) {
2643      return false;
2644    }
2645
2646    const innerParams = privateProps.innerParams.get(instance);
2647
2648    if (!innerParams || hasClass(popup, innerParams.hideClass.popup)) {
2649      return false;
2650    }
2651
2652    removeClass(popup, innerParams.showClass.popup);
2653    addClass(popup, innerParams.hideClass.popup);
2654    const backdrop = getContainer();
2655    removeClass(backdrop, innerParams.showClass.backdrop);
2656    addClass(backdrop, innerParams.hideClass.backdrop);
2657    handlePopupAnimation(instance, popup, innerParams);
2658    return true;
2659  };
2660
2661  function rejectPromise(error) {
2662    const rejectPromise = privateMethods.swalPromiseReject.get(this);
2663    handleAwaitingPromise(this);
2664
2665    if (rejectPromise) {
2666      // Reject Swal promise
2667      rejectPromise(error);
2668    }
2669  }
2670  const handleAwaitingPromise = instance => {
2671    if (instance.isAwaitingPromise()) {
2672      privateProps.awaitingPromise.delete(instance); // The instance might have been previously partly destroyed, we must resume the destroy process in this case #2335
2673
2674      if (!privateProps.innerParams.get(instance)) {
2675        instance._destroy();
2676      }
2677    }
2678  };
2679
2680  const prepareResolveValue = resolveValue => {
2681    // When user calls Swal.close()
2682    if (typeof resolveValue === 'undefined') {
2683      return {
2684        isConfirmed: false,
2685        isDenied: false,
2686        isDismissed: true
2687      };
2688    }
2689
2690    return Object.assign({
2691      isConfirmed: false,
2692      isDenied: false,
2693      isDismissed: false
2694    }, resolveValue);
2695  };
2696
2697  const handlePopupAnimation = (instance, popup, innerParams) => {
2698    const container = getContainer(); // If animation is supported, animate
2699
2700    const animationIsSupported = animationEndEvent && hasCssAnimation(popup);
2701
2702    if (typeof innerParams.willClose === 'function') {
2703      innerParams.willClose(popup);
2704    }
2705
2706    if (animationIsSupported) {
2707      animatePopup(instance, popup, container, innerParams.returnFocus, innerParams.didClose);
2708    } else {
2709      // Otherwise, remove immediately
2710      removePopupAndResetState(instance, container, innerParams.returnFocus, innerParams.didClose);
2711    }
2712  };
2713
2714  const animatePopup = (instance, popup, container, returnFocus, didClose) => {
2715    globalState.swalCloseEventFinishedCallback = removePopupAndResetState.bind(null, instance, container, returnFocus, didClose);
2716    popup.addEventListener(animationEndEvent, function (e) {
2717      if (e.target === popup) {
2718        globalState.swalCloseEventFinishedCallback();
2719        delete globalState.swalCloseEventFinishedCallback;
2720      }
2721    });
2722  };
2723
2724  const triggerDidCloseAndDispose = (instance, didClose) => {
2725    setTimeout(() => {
2726      if (typeof didClose === 'function') {
2727        didClose.bind(instance.params)();
2728      }
2729
2730      instance._destroy();
2731    });
2732  };
2733
2734  function setButtonsDisabled(instance, buttons, disabled) {
2735    const domCache = privateProps.domCache.get(instance);
2736    buttons.forEach(button => {
2737      domCache[button].disabled = disabled;
2738    });
2739  }
2740
2741  function setInputDisabled(input, disabled) {
2742    if (!input) {
2743      return false;
2744    }
2745
2746    if (input.type === 'radio') {
2747      const radiosContainer = input.parentNode.parentNode;
2748      const radios = radiosContainer.querySelectorAll('input');
2749
2750      for (let i = 0; i < radios.length; i++) {
2751        radios[i].disabled = disabled;
2752      }
2753    } else {
2754      input.disabled = disabled;
2755    }
2756  }
2757
2758  function enableButtons() {
2759    setButtonsDisabled(this, ['confirmButton', 'denyButton', 'cancelButton'], false);
2760  }
2761  function disableButtons() {
2762    setButtonsDisabled(this, ['confirmButton', 'denyButton', 'cancelButton'], true);
2763  }
2764  function enableInput() {
2765    return setInputDisabled(this.getInput(), false);
2766  }
2767  function disableInput() {
2768    return setInputDisabled(this.getInput(), true);
2769  }
2770
2771  function showValidationMessage(error) {
2772    const domCache = privateProps.domCache.get(this);
2773    const params = privateProps.innerParams.get(this);
2774    setInnerHtml(domCache.validationMessage, error);
2775    domCache.validationMessage.className = swalClasses['validation-message'];
2776
2777    if (params.customClass && params.customClass.validationMessage) {
2778      addClass(domCache.validationMessage, params.customClass.validationMessage);
2779    }
2780
2781    show(domCache.validationMessage);
2782    const input = this.getInput();
2783
2784    if (input) {
2785      input.setAttribute('aria-invalid', true);
2786      input.setAttribute('aria-describedby', swalClasses['validation-message']);
2787      focusInput(input);
2788      addClass(input, swalClasses.inputerror);
2789    }
2790  } // Hide block with validation message
2791
2792  function resetValidationMessage$1() {
2793    const domCache = privateProps.domCache.get(this);
2794
2795    if (domCache.validationMessage) {
2796      hide(domCache.validationMessage);
2797    }
2798
2799    const input = this.getInput();
2800
2801    if (input) {
2802      input.removeAttribute('aria-invalid');
2803      input.removeAttribute('aria-describedby');
2804      removeClass(input, swalClasses.inputerror);
2805    }
2806  }
2807
2808  function getProgressSteps$1() {
2809    const domCache = privateProps.domCache.get(this);
2810    return domCache.progressSteps;
2811  }
2812
2813  /**
2814   * Updates popup parameters.
2815   */
2816
2817  function update(params) {
2818    const popup = getPopup();
2819    const innerParams = privateProps.innerParams.get(this);
2820
2821    if (!popup || hasClass(popup, innerParams.hideClass.popup)) {
2822      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.");
2823    }
2824
2825    const validUpdatableParams = filterValidParams(params);
2826    const updatedParams = Object.assign({}, innerParams, validUpdatableParams);
2827    render(this, updatedParams);
2828    privateProps.innerParams.set(this, updatedParams);
2829    Object.defineProperties(this, {
2830      params: {
2831        value: Object.assign({}, this.params, params),
2832        writable: false,
2833        enumerable: true
2834      }
2835    });
2836  }
2837
2838  const filterValidParams = params => {
2839    const validUpdatableParams = {};
2840    Object.keys(params).forEach(param => {
2841      if (isUpdatableParameter(param)) {
2842        validUpdatableParams[param] = params[param];
2843      } else {
2844        warn("Invalid parameter to update: ".concat(param));
2845      }
2846    });
2847    return validUpdatableParams;
2848  };
2849
2850  function _destroy() {
2851    const domCache = privateProps.domCache.get(this);
2852    const innerParams = privateProps.innerParams.get(this);
2853
2854    if (!innerParams) {
2855      disposeWeakMaps(this); // The WeakMaps might have been partly destroyed, we must recall it to dispose any remaining WeakMaps #2335
2856
2857      return; // This instance has already been destroyed
2858    } // Check if there is another Swal closing
2859
2860
2861    if (domCache.popup && globalState.swalCloseEventFinishedCallback) {
2862      globalState.swalCloseEventFinishedCallback();
2863      delete globalState.swalCloseEventFinishedCallback;
2864    } // Check if there is a swal disposal defer timer
2865
2866
2867    if (globalState.deferDisposalTimer) {
2868      clearTimeout(globalState.deferDisposalTimer);
2869      delete globalState.deferDisposalTimer;
2870    }
2871
2872    if (typeof innerParams.didDestroy === 'function') {
2873      innerParams.didDestroy();
2874    }
2875
2876    disposeSwal(this);
2877  }
2878
2879  const disposeSwal = instance => {
2880    disposeWeakMaps(instance); // Unset this.params so GC will dispose it (#1569)
2881
2882    delete instance.params; // Unset globalState props so GC will dispose globalState (#1569)
2883
2884    delete globalState.keydownHandler;
2885    delete globalState.keydownTarget; // Unset currentInstance
2886
2887    delete globalState.currentInstance;
2888  };
2889
2890  const disposeWeakMaps = instance => {
2891    // If the current instance is awaiting a promise result, we keep the privateMethods to call them once the promise result is retrieved #2335
2892    if (instance.isAwaitingPromise()) {
2893      unsetWeakMaps(privateProps, instance);
2894      privateProps.awaitingPromise.set(instance, true);
2895    } else {
2896      unsetWeakMaps(privateMethods, instance);
2897      unsetWeakMaps(privateProps, instance);
2898    }
2899  };
2900
2901  const unsetWeakMaps = (obj, instance) => {
2902    for (const i in obj) {
2903      obj[i].delete(instance);
2904    }
2905  };
2906
2907
2908
2909  var instanceMethods = /*#__PURE__*/Object.freeze({
2910    hideLoading: hideLoading,
2911    disableLoading: hideLoading,
2912    getInput: getInput$1,
2913    close: close,
2914    isAwaitingPromise: isAwaitingPromise,
2915    rejectPromise: rejectPromise,
2916    handleAwaitingPromise: handleAwaitingPromise,
2917    closePopup: close,
2918    closeModal: close,
2919    closeToast: close,
2920    enableButtons: enableButtons,
2921    disableButtons: disableButtons,
2922    enableInput: enableInput,
2923    disableInput: disableInput,
2924    showValidationMessage: showValidationMessage,
2925    resetValidationMessage: resetValidationMessage$1,
2926    getProgressSteps: getProgressSteps$1,
2927    update: update,
2928    _destroy: _destroy
2929  });
2930
2931  const handleConfirmButtonClick = instance => {
2932    const innerParams = privateProps.innerParams.get(instance);
2933    instance.disableButtons();
2934
2935    if (innerParams.input) {
2936      handleConfirmOrDenyWithInput(instance, 'confirm');
2937    } else {
2938      confirm(instance, true);
2939    }
2940  };
2941  const handleDenyButtonClick = instance => {
2942    const innerParams = privateProps.innerParams.get(instance);
2943    instance.disableButtons();
2944
2945    if (innerParams.returnInputValueOnDeny) {
2946      handleConfirmOrDenyWithInput(instance, 'deny');
2947    } else {
2948      deny(instance, false);
2949    }
2950  };
2951  const handleCancelButtonClick = (instance, dismissWith) => {
2952    instance.disableButtons();
2953    dismissWith(DismissReason.cancel);
2954  };
2955
2956  const handleConfirmOrDenyWithInput = (instance, type
2957  /* 'confirm' | 'deny' */
2958  ) => {
2959    const innerParams = privateProps.innerParams.get(instance);
2960
2961    if (!innerParams.input) {
2962      return error("The \"input\" parameter is needed to be set when using returnInputValueOn".concat(capitalizeFirstLetter(type)));
2963    }
2964
2965    const inputValue = getInputValue(instance, innerParams);
2966
2967    if (innerParams.inputValidator) {
2968      handleInputValidator(instance, inputValue, type);
2969    } else if (!instance.getInput().checkValidity()) {
2970      instance.enableButtons();
2971      instance.showValidationMessage(innerParams.validationMessage);
2972    } else if (type === 'deny') {
2973      deny(instance, inputValue);
2974    } else {
2975      confirm(instance, inputValue);
2976    }
2977  };
2978
2979  const handleInputValidator = (instance, inputValue, type
2980  /* 'confirm' | 'deny' */
2981  ) => {
2982    const innerParams = privateProps.innerParams.get(instance);
2983    instance.disableInput();
2984    const validationPromise = Promise.resolve().then(() => asPromise(innerParams.inputValidator(inputValue, innerParams.validationMessage)));
2985    validationPromise.then(validationMessage => {
2986      instance.enableButtons();
2987      instance.enableInput();
2988
2989      if (validationMessage) {
2990        instance.showValidationMessage(validationMessage);
2991      } else if (type === 'deny') {
2992        deny(instance, inputValue);
2993      } else {
2994        confirm(instance, inputValue);
2995      }
2996    });
2997  };
2998
2999  const deny = (instance, value) => {
3000    const innerParams = privateProps.innerParams.get(instance || undefined);
3001
3002    if (innerParams.showLoaderOnDeny) {
3003      showLoading(getDenyButton());
3004    }
3005
3006    if (innerParams.preDeny) {
3007      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
3008
3009      const preDenyPromise = Promise.resolve().then(() => asPromise(innerParams.preDeny(value, innerParams.validationMessage)));
3010      preDenyPromise.then(preDenyValue => {
3011        if (preDenyValue === false) {
3012          instance.hideLoading();
3013          handleAwaitingPromise(instance);
3014        } else {
3015          instance.closePopup({
3016            isDenied: true,
3017            value: typeof preDenyValue === 'undefined' ? value : preDenyValue
3018          });
3019        }
3020      }).catch(error$$1 => rejectWith(instance || undefined, error$$1));
3021    } else {
3022      instance.closePopup({
3023        isDenied: true,
3024        value
3025      });
3026    }
3027  };
3028
3029  const succeedWith = (instance, value) => {
3030    instance.closePopup({
3031      isConfirmed: true,
3032      value
3033    });
3034  };
3035
3036  const rejectWith = (instance, error$$1) => {
3037    instance.rejectPromise(error$$1);
3038  };
3039
3040  const confirm = (instance, value) => {
3041    const innerParams = privateProps.innerParams.get(instance || undefined);
3042
3043    if (innerParams.showLoaderOnConfirm) {
3044      showLoading();
3045    }
3046
3047    if (innerParams.preConfirm) {
3048      instance.resetValidationMessage();
3049      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
3050
3051      const preConfirmPromise = Promise.resolve().then(() => asPromise(innerParams.preConfirm(value, innerParams.validationMessage)));
3052      preConfirmPromise.then(preConfirmValue => {
3053        if (isVisible(getValidationMessage()) || preConfirmValue === false) {
3054          instance.hideLoading();
3055          handleAwaitingPromise(instance);
3056        } else {
3057          succeedWith(instance, typeof preConfirmValue === 'undefined' ? value : preConfirmValue);
3058        }
3059      }).catch(error$$1 => rejectWith(instance || undefined, error$$1));
3060    } else {
3061      succeedWith(instance, value);
3062    }
3063  };
3064
3065  const handlePopupClick = (instance, domCache, dismissWith) => {
3066    const innerParams = privateProps.innerParams.get(instance);
3067
3068    if (innerParams.toast) {
3069      handleToastClick(instance, domCache, dismissWith);
3070    } else {
3071      // Ignore click events that had mousedown on the popup but mouseup on the container
3072      // This can happen when the user drags a slider
3073      handleModalMousedown(domCache); // Ignore click events that had mousedown on the container but mouseup on the popup
3074
3075      handleContainerMousedown(domCache);
3076      handleModalClick(instance, domCache, dismissWith);
3077    }
3078  };
3079
3080  const handleToastClick = (instance, domCache, dismissWith) => {