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

1/******/ (() => { // webpackBootstrap
2/******/ 	var __webpack_modules__ = ({
3
4/***/ 757:
5/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
6
7module.exports = __webpack_require__(666);
8
9
10/***/ }),
11
12/***/ 711:
13/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
14
15!function(e,t){ true?module.exports=t():0}(this,function(){"use strict";var e="undefined"!=typeof window?window:"undefined"!=typeof __webpack_require__.g?__webpack_require__.g:"undefined"!=typeof self?self:{},t="Expected a function",n=NaN,o="[object Symbol]",i=/^\s+|\s+$/g,a=/^[-+]0x[0-9a-f]+$/i,r=/^0b[01]+$/i,c=/^0o[0-7]+$/i,s=parseInt,u="object"==typeof e&&e&&e.Object===Object&&e,d="object"==typeof self&&self&&self.Object===Object&&self,l=u||d||Function("return this")(),f=Object.prototype.toString,m=Math.max,p=Math.min,b=function(){return l.Date.now()};function v(e,n,o){var i,a,r,c,s,u,d=0,l=!1,f=!1,v=!0;if("function"!=typeof e)throw new TypeError(t);function y(t){var n=i,o=a;return i=a=void 0,d=t,c=e.apply(o,n)}function h(e){var t=e-u;return void 0===u||t>=n||t<0||f&&e-d>=r}function k(){var e=b();if(h(e))return x(e);s=setTimeout(k,function(e){var t=n-(e-u);return f?p(t,r-(e-d)):t}(e))}function x(e){return s=void 0,v&&i?y(e):(i=a=void 0,c)}function O(){var e=b(),t=h(e);if(i=arguments,a=this,u=e,t){if(void 0===s)return function(e){return d=e,s=setTimeout(k,n),l?y(e):c}(u);if(f)return s=setTimeout(k,n),y(u)}return void 0===s&&(s=setTimeout(k,n)),c}return n=w(n)||0,g(o)&&(l=!!o.leading,r=(f="maxWait"in o)?m(w(o.maxWait)||0,n):r,v="trailing"in o?!!o.trailing:v),O.cancel=function(){void 0!==s&&clearTimeout(s),d=0,i=u=a=s=void 0},O.flush=function(){return void 0===s?c:x(b())},O}function g(e){var t=typeof e;return!!e&&("object"==t||"function"==t)}function w(e){if("number"==typeof e)return e;if(function(e){return"symbol"==typeof e||function(e){return!!e&&"object"==typeof e}(e)&&f.call(e)==o}(e))return n;if(g(e)){var t="function"==typeof e.valueOf?e.valueOf():e;e=g(t)?t+"":t}if("string"!=typeof e)return 0===e?e:+e;e=e.replace(i,"");var u=r.test(e);return u||c.test(e)?s(e.slice(2),u?2:8):a.test(e)?n:+e}var y=function(e,n,o){var i=!0,a=!0;if("function"!=typeof e)throw new TypeError(t);return g(o)&&(i="leading"in o?!!o.leading:i,a="trailing"in o?!!o.trailing:a),v(e,n,{leading:i,maxWait:n,trailing:a})},h="Expected a function",k=NaN,x="[object Symbol]",O=/^\s+|\s+$/g,j=/^[-+]0x[0-9a-f]+$/i,E=/^0b[01]+$/i,N=/^0o[0-7]+$/i,z=parseInt,C="object"==typeof e&&e&&e.Object===Object&&e,A="object"==typeof self&&self&&self.Object===Object&&self,q=C||A||Function("return this")(),L=Object.prototype.toString,T=Math.max,M=Math.min,S=function(){return q.Date.now()};function D(e){var t=typeof e;return!!e&&("object"==t||"function"==t)}function H(e){if("number"==typeof e)return e;if(function(e){return"symbol"==typeof e||function(e){return!!e&&"object"==typeof e}(e)&&L.call(e)==x}(e))return k;if(D(e)){var t="function"==typeof e.valueOf?e.valueOf():e;e=D(t)?t+"":t}if("string"!=typeof e)return 0===e?e:+e;e=e.replace(O,"");var n=E.test(e);return n||N.test(e)?z(e.slice(2),n?2:8):j.test(e)?k:+e}var $=function(e,t,n){var o,i,a,r,c,s,u=0,d=!1,l=!1,f=!0;if("function"!=typeof e)throw new TypeError(h);function m(t){var n=o,a=i;return o=i=void 0,u=t,r=e.apply(a,n)}function p(e){var n=e-s;return void 0===s||n>=t||n<0||l&&e-u>=a}function b(){var e=S();if(p(e))return v(e);c=setTimeout(b,function(e){var n=t-(e-s);return l?M(n,a-(e-u)):n}(e))}function v(e){return c=void 0,f&&o?m(e):(o=i=void 0,r)}function g(){var e=S(),n=p(e);if(o=arguments,i=this,s=e,n){if(void 0===c)return function(e){return u=e,c=setTimeout(b,t),d?m(e):r}(s);if(l)return c=setTimeout(b,t),m(s)}return void 0===c&&(c=setTimeout(b,t)),r}return t=H(t)||0,D(n)&&(d=!!n.leading,a=(l="maxWait"in n)?T(H(n.maxWait)||0,t):a,f="trailing"in n?!!n.trailing:f),g.cancel=function(){void 0!==c&&clearTimeout(c),u=0,o=s=i=c=void 0},g.flush=function(){return void 0===c?r:v(S())},g},W=function(){};function P(e){e&&e.forEach(function(e){var t=Array.prototype.slice.call(e.addedNodes),n=Array.prototype.slice.call(e.removedNodes);if(function e(t){var n=void 0,o=void 0;for(n=0;n<t.length;n+=1){if((o=t[n]).dataset&&o.dataset.aos)return!0;

217    var scroller = createScroller(element);
218    var lastScrollY = scroller.scrollY();
219    var details = {};
220
221    function update() {
222      var scrollY = Math.round(scroller.scrollY());
223      var height = scroller.height();
224      var scrollHeight = scroller.scrollHeight();
225
226      // reuse object for less memory churn
227      details.scrollY = scrollY;
228      details.lastScrollY = lastScrollY;
229      details.direction = scrollY > lastScrollY ? "down" : "up";
230      details.distance = Math.abs(scrollY - lastScrollY);
231      details.isOutOfBounds = scrollY < 0 || scrollY + height > scrollHeight;
232      details.top = scrollY <= options.offset[details.direction];
233      details.bottom = scrollY + height >= scrollHeight;
234      details.toleranceExceeded =
235        details.distance > options.tolerance[details.direction];
236
237      callback(details);
238
239      lastScrollY = scrollY;
240      scrolled = false;
241    }
242
243    function handleScroll() {
244      if (!scrolled) {
245        scrolled = true;
246        rafId = requestAnimationFrame(update);
247      }
248    }
249
250    var eventOptions = isPassiveSupported
251      ? { passive: true, capture: false }
252      : false;
253
254    element.addEventListener("scroll", handleScroll, eventOptions);
255    update();
256
257    return {
258      destroy: function() {
259        cancelAnimationFrame(rafId);
260        element.removeEventListener("scroll", handleScroll, eventOptions);
261      }
262    };
263  }
264
265  function normalizeUpDown(t) {
266    return t === Object(t) ? t : { down: t, up: t };
267  }
268
269  /**
270   * UI enhancement for fixed headers.
271   * Hides header when scrolling down
272   * Shows header when scrolling up
273   * @constructor
274   * @param {DOMElement} elem the header element
275   * @param {Object} options options for the widget
276   */
277  function Headroom(elem, options) {
278    options = options || {};
279    Object.assign(this, Headroom.options, options);
280    this.classes = Object.assign({}, Headroom.options.classes, options.classes);
281
282    this.elem = elem;
283    this.tolerance = normalizeUpDown(this.tolerance);
284    this.offset = normalizeUpDown(this.offset);
285    this.initialised = false;
286    this.frozen = false;
287  }
288  Headroom.prototype = {
289    constructor: Headroom,
290
291    /**
292     * Start listening to scrolling
293     * @public
294     */
295    init: function() {
296      if (Headroom.cutsTheMustard && !this.initialised) {
297        this.addClass("initial");
298        this.initialised = true;
299
300        // defer event registration to handle browser
301        // potentially restoring previous scroll position
302        setTimeout(
303          function(self) {
304            self.scrollTracker = trackScroll(
305              self.scroller,
306              { offset: self.offset, tolerance: self.tolerance },
307              self.update.bind(self)
308            );
309          },
310          100,
311          this
312        );
313      }
314
315      return this;
316    },
317
318    /**
319     * Destroy the widget, clearing up after itself
320     * @public
321     */
322    destroy: function() {
323      this.initialised = false;
324      Object.keys(this.classes).forEach(this.removeClass, this);
325      this.scrollTracker.destroy();
326    },
327
328    /**
329     * Unpin the element
330     * @public
331     */
332    unpin: function() {
333      if (this.hasClass("pinned") || !this.hasClass("unpinned")) {
334        this.addClass("unpinned");
335        this.removeClass("pinned");
336
337        if (this.onUnpin) {
338          this.onUnpin.call(this);
339        }
340      }
341    },
342
343    /**
344     * Pin the element
345     * @public
346     */
347    pin: function() {
348      if (this.hasClass("unpinned")) {
349        this.addClass("pinned");
350        this.removeClass("unpinned");
351
352        if (this.onPin) {
353          this.onPin.call(this);
354        }
355      }
356    },
357
358    /**
359     * Freezes the current state of the widget
360     * @public
361     */
362    freeze: function() {
363      this.frozen = true;
364      this.addClass("frozen");
365    },
366
367    /**
368     * Re-enables the default behaviour of the widget
369     * @public
370     */
371    unfreeze: function() {
372      this.frozen = false;
373      this.removeClass("frozen");
374    },
375
376    top: function() {
377      if (!this.hasClass("top")) {
378        this.addClass("top");
379        this.removeClass("notTop");
380
381        if (this.onTop) {
382          this.onTop.call(this);
383        }
384      }
385    },
386
387    notTop: function() {
388      if (!this.hasClass("notTop")) {
389        this.addClass("notTop");
390        this.removeClass("top");
391
392        if (this.onNotTop) {
393          this.onNotTop.call(this);
394        }
395      }
396    },
397
398    bottom: function() {
399      if (!this.hasClass("bottom")) {
400        this.addClass("bottom");
401        this.removeClass("notBottom");
402
403        if (this.onBottom) {
404          this.onBottom.call(this);
405        }
406      }
407    },
408
409    notBottom: function() {
410      if (!this.hasClass("notBottom")) {
411        this.addClass("notBottom");
412        this.removeClass("bottom");
413
414        if (this.onNotBottom) {
415          this.onNotBottom.call(this);
416        }
417      }
418    },
419
420    shouldUnpin: function(details) {
421      var scrollingDown = details.direction === "down";
422
423      return scrollingDown && !details.top && details.toleranceExceeded;
424    },
425
426    shouldPin: function(details) {
427      var scrollingUp = details.direction === "up";
428
429      return (scrollingUp && details.toleranceExceeded) || details.top;
430    },
431
432    addClass: function(className) {
433      this.elem.classList.add.apply(
434        this.elem.classList,
435        this.classes[className].split(" ")
436      );
437    },
438
439    removeClass: function(className) {
440      this.elem.classList.remove.apply(
441        this.elem.classList,
442        this.classes[className].split(" ")
443      );
444    },
445
446    hasClass: function(className) {
447      return this.classes[className].split(" ").every(function(cls) {
448        return this.classList.contains(cls);
449      }, this.elem);
450    },
451
452    update: function(details) {
453      if (details.isOutOfBounds) {
454        // Ignore bouncy scrolling in OSX
455        return;
456      }
457
458      if (this.frozen === true) {
459        return;
460      }
461
462      if (details.top) {
463        this.top();
464      } else {
465        this.notTop();
466      }
467
468      if (details.bottom) {
469        this.bottom();
470      } else {
471        this.notBottom();
472      }
473
474      if (this.shouldUnpin(details)) {
475        this.unpin();
476      } else if (this.shouldPin(details)) {
477        this.pin();
478      }
479    }
480  };
481
482  /**
483   * Default options
484   * @type {Object}
485   */
486  Headroom.options = {
487    tolerance: {
488      up: 0,
489      down: 0
490    },
491    offset: 0,
492    scroller: isBrowser() ? window : null,
493    classes: {
494      frozen: "headroom--frozen",
495      pinned: "headroom--pinned",
496      unpinned: "headroom--unpinned",
497      top: "headroom--top",
498      notTop: "headroom--not-top",
499      bottom: "headroom--bottom",
500      notBottom: "headroom--not-bottom",
501      initial: "headroom"
502    }
503  };
504
505  Headroom.cutsTheMustard = isSupported();
506
507  return Headroom;
508
509}));
510
511
512/***/ }),
513
514/***/ 443:
515/***/ (function(module, exports, __webpack_require__) {
516
517var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__;/*
518 0BSD
519*/
520(function(F,y){ true?!(__WEBPACK_AMD_DEFINE_FACTORY__ = (y),
521		__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
522		(__WEBPACK_AMD_DEFINE_FACTORY__.call(exports, __webpack_require__, exports, module)) :
523		__WEBPACK_AMD_DEFINE_FACTORY__),

562 {
563
564/**
565 * Copyright (c) 2014-present, Facebook, Inc.
566 *
567 * This source code is licensed under the MIT license found in the
568 * LICENSE file in the root directory of this source tree.
569 */
570
571var runtime = (function (exports) {
572  "use strict";
573
574  var Op = Object.prototype;
575  var hasOwn = Op.hasOwnProperty;
576  var undefined; // More compressible than void 0.
577  var $Symbol = typeof Symbol === "function" ? Symbol : {};
578  var iteratorSymbol = $Symbol.iterator || "@@iterator";
579  var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator";
580  var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
581
582  function define(obj, key, value) {
583    Object.defineProperty(obj, key, {
584      value: value,
585      enumerable: true,
586      configurable: true,
587      writable: true
588    });
589    return obj[key];
590  }
591  try {
592    // IE 8 has a broken Object.defineProperty that only works on DOM objects.
593    define({}, "");
594  } catch (err) {
595    define = function(obj, key, value) {
596      return obj[key] = value;
597    };
598  }
599
600  function wrap(innerFn, outerFn, self, tryLocsList) {
601    // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.
602    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
603    var generator = Object.create(protoGenerator.prototype);
604    var context = new Context(tryLocsList || []);
605
606    // The ._invoke method unifies the implementations of the .next,
607    // .throw, and .return methods.
608    generator._invoke = makeInvokeMethod(innerFn, self, context);
609
610    return generator;
611  }
612  exports.wrap = wrap;
613
614  // Try/catch helper to minimize deoptimizations. Returns a completion
615  // record like context.tryEntries[i].completion. This interface could
616  // have been (and was previously) designed to take a closure to be
617  // invoked without arguments, but in all the cases we care about we
618  // already have an existing method we want to call, so there's no need
619  // to create a new function object. We can even get away with assuming
620  // the method takes exactly one argument, since that happens to be true
621  // in every case, so we don't have to touch the arguments object. The
622  // only additional allocation required is the completion record, which
623  // has a stable shape and so hopefully should be cheap to allocate.
624  function tryCatch(fn, obj, arg) {
625    try {
626      return { type: "normal", arg: fn.call(obj, arg) };
627    } catch (err) {
628      return { type: "throw", arg: err };
629    }
630  }
631
632  var GenStateSuspendedStart = "suspendedStart";
633  var GenStateSuspendedYield = "suspendedYield";
634  var GenStateExecuting = "executing";
635  var GenStateCompleted = "completed";
636
637  // Returning this object from the innerFn has the same effect as
638  // breaking out of the dispatch switch statement.
639  var ContinueSentinel = {};
640
641  // Dummy constructor functions that we use as the .constructor and
642  // .constructor.prototype properties for functions that return Generator
643  // objects. For full spec compliance, you may wish to configure your
644  // minifier not to mangle the names of these two functions.
645  function Generator() {}
646  function GeneratorFunction() {}
647  function GeneratorFunctionPrototype() {}
648
649  // This is a polyfill for %IteratorPrototype% for environments that
650  // don't natively support it.
651  var IteratorPrototype = {};
652  define(IteratorPrototype, iteratorSymbol, function () {
653    return this;
654  });
655
656  var getProto = Object.getPrototypeOf;
657  var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
658  if (NativeIteratorPrototype &&
659      NativeIteratorPrototype !== Op &&
660      hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
661    // This environment has a native %IteratorPrototype%; use it instead
662    // of the polyfill.
663    IteratorPrototype = NativeIteratorPrototype;
664  }
665
666  var Gp = GeneratorFunctionPrototype.prototype =
667    Generator.prototype = Object.create(IteratorPrototype);
668  GeneratorFunction.prototype = GeneratorFunctionPrototype;
669  define(Gp, "constructor", GeneratorFunctionPrototype);
670  define(GeneratorFunctionPrototype, "constructor", GeneratorFunction);
671  GeneratorFunction.displayName = define(
672    GeneratorFunctionPrototype,
673    toStringTagSymbol,
674    "GeneratorFunction"
675  );
676
677  // Helper for defining the .next, .throw, and .return methods of the
678  // Iterator interface in terms of a single ._invoke method.
679  function defineIteratorMethods(prototype) {
680    ["next", "throw", "return"].forEach(function(method) {
681      define(prototype, method, function(arg) {
682        return this._invoke(method, arg);
683      });
684    });
685  }
686
687  exports.isGeneratorFunction = function(genFun) {
688    var ctor = typeof genFun === "function" && genFun.constructor;
689    return ctor
690      ? ctor === GeneratorFunction ||
691        // For the native GeneratorFunction constructor, the best we can
692        // do is to check its .name property.
693        (ctor.displayName || ctor.name) === "GeneratorFunction"
694      : false;
695  };
696
697  exports.mark = function(genFun) {
698    if (Object.setPrototypeOf) {
699      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
700    } else {
701      genFun.__proto__ = GeneratorFunctionPrototype;
702      define(genFun, toStringTagSymbol, "GeneratorFunction");
703    }
704    genFun.prototype = Object.create(Gp);
705    return genFun;
706  };
707
708  // Within the body of any async function, `await x` is transformed to
709  // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test
710  // `hasOwn.call(value, "__await")` to determine if the yielded value is
711  // meant to be awaited.
712  exports.awrap = function(arg) {
713    return { __await: arg };
714  };
715
716  function AsyncIterator(generator, PromiseImpl) {
717    function invoke(method, arg, resolve, reject) {
718      var record = tryCatch(generator[method], generator, arg);
719      if (record.type === "throw") {
720        reject(record.arg);
721      } else {
722        var result = record.arg;
723        var value = result.value;
724        if (value &&
725            typeof value === "object" &&
726            hasOwn.call(value, "__await")) {
727          return PromiseImpl.resolve(value.__await).then(function(value) {
728            invoke("next", value, resolve, reject);
729          }, function(err) {
730            invoke("throw", err, resolve, reject);
731          });
732        }
733
734        return PromiseImpl.resolve(value).then(function(unwrapped) {
735          // When a yielded Promise is resolved, its final value becomes
736          // the .value of the Promise<{value,done}> result for the
737          // current iteration.
738          result.value = unwrapped;
739          resolve(result);
740        }, function(error) {
741          // If a rejected Promise was yielded, throw the rejection back
742          // into the async generator function so it can be handled there.
743          return invoke("throw", error, resolve, reject);
744        });
745      }
746    }
747
748    var previousPromise;
749
750    function enqueue(method, arg) {
751      function callInvokeWithMethodAndArg() {
752        return new PromiseImpl(function(resolve, reject) {
753          invoke(method, arg, resolve, reject);
754        });
755      }
756
757      return previousPromise =
758        // If enqueue has been called before, then we want to wait until
759        // all previous Promises have been resolved before calling invoke,
760        // so that results are always delivered in the correct order. If
761        // enqueue has not been called before, then it is important to
762        // call invoke immediately, without waiting on a callback to fire,
763        // so that the async generator function has the opportunity to do
764        // any necessary setup in a predictable way. This predictability
765        // is why the Promise constructor synchronously invokes its
766        // executor callback, and why async functions synchronously
767        // execute code before the first await. Since we implement simple
768        // async functions in terms of async generators, it is especially
769        // important to get this right, even though it requires care.
770        previousPromise ? previousPromise.then(
771          callInvokeWithMethodAndArg,
772          // Avoid propagating failures to Promises returned by later
773          // invocations of the iterator.
774          callInvokeWithMethodAndArg
775        ) : callInvokeWithMethodAndArg();
776    }
777
778    // Define the unified helper method that is used to implement .next,
779    // .throw, and .return (see defineIteratorMethods).
780    this._invoke = enqueue;
781  }
782
783  defineIteratorMethods(AsyncIterator.prototype);
784  define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
785    return this;
786  });
787  exports.AsyncIterator = AsyncIterator;
788
789  // Note that simple async functions are implemented on top of
790  // AsyncIterator objects; they just return a Promise for the value of
791  // the final result produced by the iterator.
792  exports.async = function(innerFn, outerFn, self, tryLocsList, PromiseImpl) {
793    if (PromiseImpl === void 0) PromiseImpl = Promise;
794
795    var iter = new AsyncIterator(
796      wrap(innerFn, outerFn, self, tryLocsList),
797      PromiseImpl
798    );
799
800    return exports.isGeneratorFunction(outerFn)
801      ? iter // If outerFn is a generator, return the full iterator.
802      : iter.next().then(function(result) {
803          return result.done ? result.value : iter.next();
804        });
805  };
806
807  function makeInvokeMethod(innerFn, self, context) {
808    var state = GenStateSuspendedStart;
809
810    return function invoke(method, arg) {
811      if (state === GenStateExecuting) {
812        throw new Error("Generator is already running");
813      }
814
815      if (state === GenStateCompleted) {
816        if (method === "throw") {
817          throw arg;
818        }
819
820        // Be forgiving, per 25.3.3.3.3 of the spec:
821        // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume
822        return doneResult();
823      }
824
825      context.method = method;
826      context.arg = arg;
827
828      while (true) {
829        var delegate = context.delegate;
830        if (delegate) {
831          var delegateResult = maybeInvokeDelegate(delegate, context);
832          if (delegateResult) {
833            if (delegateResult === ContinueSentinel) continue;
834            return delegateResult;
835          }
836        }
837
838        if (context.method === "next") {
839          // Setting context._sent for legacy support of Babel's
840          // function.sent implementation.
841          context.sent = context._sent = context.arg;
842
843        } else if (context.method === "throw") {
844          if (state === GenStateSuspendedStart) {
845            state = GenStateCompleted;
846            throw context.arg;
847          }
848
849          context.dispatchException(context.arg);
850
851        } else if (context.method === "return") {
852          context.abrupt("return", context.arg);
853        }
854
855        state = GenStateExecuting;
856
857        var record = tryCatch(innerFn, self, context);
858        if (record.type === "normal") {
859          // If an exception is thrown from innerFn, we leave state ===
860          // GenStateExecuting and loop back for another invocation.
861          state = context.done
862            ? GenStateCompleted
863            : GenStateSuspendedYield;
864
865          if (record.arg === ContinueSentinel) {
866            continue;
867          }
868
869          return {
870            value: record.arg,
871            done: context.done
872          };
873
874        } else if (record.type === "throw") {
875          state = GenStateCompleted;
876          // Dispatch the exception by looping back around to the
877          // context.dispatchException(context.arg) call above.
878          context.method = "throw";
879          context.arg = record.arg;
880        }
881      }
882    };
883  }
884
885  // Call delegate.iterator[context.method](context.arg) and handle the
886  // result, either by returning a { value, done } result from the
887  // delegate iterator, or by modifying context.method and context.arg,
888  // setting context.delegate to null, and returning the ContinueSentinel.
889  function maybeInvokeDelegate(delegate, context) {
890    var method = delegate.iterator[context.method];
891    if (method === undefined) {
892      // A .throw or .return when the delegate iterator has no .throw
893      // method always terminates the yield* loop.
894      context.delegate = null;
895
896      if (context.method === "throw") {
897        // Note: ["return"] must be used for ES3 parsing compatibility.
898        if (delegate.iterator["return"]) {
899          // If the delegate iterator has a return method, give it a
900          // chance to clean up.
901          context.method = "return";
902          context.arg = undefined;
903          maybeInvokeDelegate(delegate, context);
904
905          if (context.method === "throw") {
906            // If maybeInvokeDelegate(context) changed context.method from
907            // "return" to "throw", let that override the TypeError below.
908            return ContinueSentinel;
909          }
910        }
911
912        context.method = "throw";
913        context.arg = new TypeError(
914          "The iterator does not provide a 'throw' method");
915      }
916
917      return ContinueSentinel;
918    }
919
920    var record = tryCatch(method, delegate.iterator, context.arg);
921
922    if (record.type === "throw") {
923      context.method = "throw";
924      context.arg = record.arg;
925      context.delegate = null;
926      return ContinueSentinel;
927    }
928
929    var info = record.arg;
930
931    if (! info) {
932      context.method = "throw";
933      context.arg = new TypeError("iterator result is not an object");
934      context.delegate = null;
935      return ContinueSentinel;
936    }
937
938    if (info.done) {
939      // Assign the result of the finished delegate to the temporary
940      // variable specified by delegate.resultName (see delegateYield).
941      context[delegate.resultName] = info.value;
942
943      // Resume execution at the desired location (see delegateYield).
944      context.next = delegate.nextLoc;
945
946      // If context.method was "throw" but the delegate handled the
947      // exception, let the outer generator proceed normally. If
948      // context.method was "next", forget context.arg since it has been
949      // "consumed" by the delegate iterator. If context.method was
950      // "return", allow the original .return call to continue in the
951      // outer generator.
952      if (context.method !== "return") {
953        context.method = "next";
954        context.arg = undefined;
955      }
956
957    } else {
958      // Re-yield the result returned by the delegate method.
959      return info;
960    }
961
962    // The delegate iterator is finished, so forget it and continue with
963    // the outer generator.
964    context.delegate = null;
965    return ContinueSentinel;
966  }
967
968  // Define Generator.prototype.{next,throw,return} in terms of the
969  // unified ._invoke helper method.
970  defineIteratorMethods(Gp);
971
972  define(Gp, toStringTagSymbol, "Generator");
973
974  // A Generator should always return itself as the iterator object when the
975  // @@iterator function is called on it. Some browsers' implementations of the
976  // iterator prototype chain incorrectly implement this, causing the Generator
977  // object to not be returned from this call. This ensures that doesn't happen.
978  // See https://github.com/facebook/regenerator/issues/274 for more details.
979  define(Gp, iteratorSymbol, function() {
980    return this;
981  });
982
983  define(Gp, "toString", function() {
984    return "[object Generator]";
985  });
986
987  function pushTryEntry(locs) {
988    var entry = { tryLoc: locs[0] };
989
990    if (1 in locs) {
991      entry.catchLoc = locs[1];
992    }
993
994    if (2 in locs) {
995      entry.finallyLoc = locs[2];
996      entry.afterLoc = locs[3];
997    }
998
999    this.tryEntries.push(entry);
1000  }
1001
1002  function resetTryEntry(entry) {
1003    var record = entry.completion || {};
1004    record.type = "normal";
1005    delete record.arg;
1006    entry.completion = record;
1007  }
1008
1009  function Context(tryLocsList) {
1010    // The root entry object (effectively a try statement without a catch
1011    // or a finally block) gives us a place to store values thrown from
1012    // locations where there is no enclosing try statement.
1013    this.tryEntries = [{ tryLoc: "root" }];
1014    tryLocsList.forEach(pushTryEntry, this);
1015    this.reset(true);
1016  }
1017
1018  exports.keys = function(object) {
1019    var keys = [];
1020    for (var key in object) {
1021      keys.push(key);
1022    }
1023    keys.reverse();
1024
1025    // Rather than returning an object with a next method, we keep
1026    // things simple and return the next function itself.
1027    return function next() {
1028      while (keys.length) {
1029        var key = keys.pop();
1030        if (key in object) {
1031          next.value = key;
1032          next.done = false;
1033          return next;
1034        }
1035      }
1036
1037      // To avoid creating an additional object, we just hang the .value
1038      // and .done properties off the next function object itself. This
1039      // also ensures that the minifier will not anonymize the function.
1040      next.done = true;
1041      return next;
1042    };
1043  };
1044
1045  function values(iterable) {
1046    if (iterable) {
1047      var iteratorMethod = iterable[iteratorSymbol];
1048      if (iteratorMethod) {
1049        return iteratorMethod.call(iterable);
1050      }
1051
1052      if (typeof iterable.next === "function") {
1053        return iterable;
1054      }
1055
1056      if (!isNaN(iterable.length)) {
1057        var i = -1, next = function next() {
1058          while (++i < iterable.length) {
1059            if (hasOwn.call(iterable, i)) {
1060              next.value = iterable[i];
1061              next.done = false;

1062              return next;
1063            }
1064          }
1065
1066          next.value = undefined;
1067          next.done = true;
1068
1069          return next;
1070        };
1071
1072        return next.next = next;
1073      }
1074    }
1075
1076    // Return an iterator with no values.
1077    return { next: doneResult };
1078  }
1079  exports.values = values;
1080
1081  function doneResult() {
1082    return { value: undefined, done: true };
1083  }
1084
1085  Context.prototype = {
1086    constructor: Context,
1087
1088    reset: function(skipTempReset) {
1089      this.prev = 0;
1090      this.next = 0;
1091      // Resetting context._sent for legacy support of Babel's
1092      // function.sent implementation.
1093      this.sent = this._sent = undefined;
1094      this.done = false;
1095      this.delegate = null;
1096
1097      this.method = "next";
1098      this.arg = undefined;
1099
1100      this.tryEntries.forEach(resetTryEntry);
1101
1102      if (!skipTempReset) {
1103        for (var name in this) {
1104          // Not sure about the optimal order of these conditions:
1105          if (name.charAt(0) === "t" &&
1106              hasOwn.call(this, name) &&
1107              !isNaN(+name.slice(1))) {
1108            this[name] = undefined;
1109          }
1110        }
1111      }
1112    },
1113
1114    stop: function() {
1115      this.done = true;
1116
1117      var rootEntry = this.tryEntries[0];
1118      var rootRecord = rootEntry.completion;
1119      if (rootRecord.type === "throw") {
1120        throw rootRecord.arg;
1121      }
1122
1123      return this.rval;
1124    },
1125
1126    dispatchException: function(exception) {
1127      if (this.done) {
1128        throw exception;
1129      }
1130
1131      var context = this;
1132      function handle(loc, caught) {
1133        record.type = "throw";
1134        record.arg = exception;
1135        context.next = loc;
1136
1137        if (caught) {
1138          // If the dispatched exception was caught by a catch block,
1139          // then let that catch block handle the exception normally.
1140          context.method = "next";
1141          context.arg = undefined;
1142        }
1143
1144        return !! caught;
1145      }
1146
1147      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
1148        var entry = this.tryEntries[i];
1149        var record = entry.completion;
1150
1151        if (entry.tryLoc === "root") {
1152          // Exception thrown outside of any try block that could handle
1153          // it, so set the completion value of the entire function to
1154          // throw the exception.
1155          return handle("end");
1156        }
1157
1158        if (entry.tryLoc <= this.prev) {
1159          var hasCatch = hasOwn.call(entry, "catchLoc");
1160          var hasFinally = hasOwn.call(entry, "finallyLoc");
1161
1162          if (hasCatch && hasFinally) {
1163            if (this.prev < entry.catchLoc) {
1164              return handle(entry.catchLoc, true);
1165            } else if (this.prev < entry.finallyLoc) {
1166              return handle(entry.finallyLoc);
1167            }
1168
1169          } else if (hasCatch) {
1170            if (this.prev < entry.catchLoc) {
1171              return handle(entry.catchLoc, true);
1172            }
1173
1174          } else if (hasFinally) {
1175            if (this.prev < entry.finallyLoc) {
1176              return handle(entry.finallyLoc);
1177            }
1178
1179          } else {
1180            throw new Error("try statement without catch or finally");
1181          }
1182        }
1183      }
1184    },
1185
1186    abrupt: function(type, arg) {
1187      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
1188        var entry = this.tryEntries[i];
1189        if (entry.tryLoc <= this.prev &&
1190            hasOwn.call(entry, "finallyLoc") &&
1191            this.prev < entry.finallyLoc) {
1192          var finallyEntry = entry;
1193          break;
1194        }
1195      }
1196
1197      if (finallyEntry &&
1198          (type === "break" ||
1199           type === "continue") &&
1200          finallyEntry.tryLoc <= arg &&
1201          arg <= finallyEntry.finallyLoc) {
1202        // Ignore the finally entry if control is not jumping to a
1203        // location outside the try/catch block.
1204        finallyEntry = null;
1205      }
1206
1207      var record = finallyEntry ? finallyEntry.completion : {};
1208      record.type = type;
1209      record.arg = arg;
1210
1211      if (finallyEntry) {
1212        this.method = "next";
1213        this.next = finallyEntry.finallyLoc;
1214        return ContinueSentinel;
1215      }
1216
1217      return this.complete(record);
1218    },
1219
1220    complete: function(record, afterLoc) {
1221      if (record.type === "throw") {
1222        throw record.arg;
1223      }
1224
1225      if (record.type === "break" ||
1226          record.type === "continue") {
1227        this.next = record.arg;
1228      } else if (record.type === "return") {
1229        this.rval = this.arg = record.arg;
1230        this.method = "return";
1231        this.next = "end";
1232      } else if (record.type === "normal" && afterLoc) {
1233        this.next = afterLoc;
1234      }
1235
1236      return ContinueSentinel;
1237    },
1238
1239    finish: function(finallyLoc) {
1240      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
1241        var entry = this.tryEntries[i];
1242        if (entry.finallyLoc === finallyLoc) {
1243          this.complete(entry.completion, entry.afterLoc);
1244          resetTryEntry(entry);
1245          return ContinueSentinel;
1246        }
1247      }
1248    },
1249
1250    "catch": function(tryLoc) {
1251      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
1252        var entry = this.tryEntries[i];
1253        if (entry.tryLoc === tryLoc) {
1254          var record = entry.completion;
1255          if (record.type === "throw") {
1256            var thrown = record.arg;
1257            resetTryEntry(entry);
1258          }
1259          return thrown;
1260        }
1261      }
1262
1263      // The context.catch method must only be called with a location
1264      // argument that corresponds to a known catch block.
1265      throw new Error("illegal catch attempt");
1266    },
1267
1268    delegateYield: function(iterable, resultName, nextLoc) {
1269      this.delegate = {
1270        iterator: values(iterable),
1271        resultName: resultName,
1272        nextLoc: nextLoc
1273      };
1274
1275      if (this.method === "next") {
1276        // Deliberately forget the last sent value so that we don't
1277        // accidentally pass it on to the delegate.
1278        this.arg = undefined;
1279      }
1280
1281      return ContinueSentinel;
1282    }
1283  };
1284
1285  // Regardless of whether this script is executing as a CommonJS module
1286  // or not, return the runtime object so that we can declare the variable
1287  // regeneratorRuntime in the outer scope, which allows this module to be
1288  // injected easily by `bin/regenerator --include-runtime script.js`.
1289  return exports;
1290
1291}(
1292  // If this script is executing as a CommonJS module, use module.exports
1293  // as the regeneratorRuntime namespace. Otherwise create a new empty
1294  // object. Either way, the resulting object will be used to initialize
1295  // the regeneratorRuntime variable at the top of this file.
1296  

1337ox = !svg.hasAttribute("viewBox") && target.getAttribute("viewBox");
1338            // conditionally set the viewBox on the svg
1339            viewBox && svg.setAttribute("viewBox", viewBox);
1340            // copy the contents of the clone into the fragment
1341            for (// clone the target
1342            var clone = target.cloneNode(!0); clone.childNodes.length; ) {
1343                fragment.appendChild(clone.firstChild);
1344            }
1345            // append the fragment into the svg
1346            parent.appendChild(fragment);
1347        }
1348    }
1349    function loadreadystatechange(xhr) {
1350        // listen to changes in the request
1351        xhr.onreadystatechange = function() {
1352            // if the request is ready
1353            if (4 === xhr.readyState) {
1354                // get the cached html document
1355                var cachedDocument = xhr._cachedDocument;
1356                // ensure the cached html document based on the xhr response
1357                cachedDocument || (cachedDocument = xhr._cachedDocument = document.implementation.createHTMLDocument(""), 
1358                cachedDocument.body.innerHTML = xhr.responseText, xhr._cachedTarget = {}), // clear the xhr embeds list and embed each item
1359                xhr._embeds.splice(0).map(function(item) {
1360                    // get the cached target
1361                    var target = xhr._cachedTarget[item.id];
1362                    // ensure the cached target
1363                    target || (target = xhr._cachedTarget[item.id] = cachedDocument.getElementById(item.id)), 
1364                    // embed the target into the svg
1365                    embed(item.parent, item.svg, target);
1366                });
1367            }
1368        }, // test the ready state change immediately
1369        xhr.onreadystatechange();
1370    }
1371    function svg4everybody(rawopts) {
1372        function oninterval() {
1373            // while the index exists in the live <use> collection
1374            for (// get the cached <use> index
1375            var index = 0; index < uses.length; ) {
1376                // get the current <use>
1377                var use = uses[index], parent = use.parentNode, svg = getSVGAncestor(parent), src = use.getAttribute("xlink:href") || use.getAttribute("href");
1378                if (!src && opts.attributeName && (src = use.getAttribute(opts.attributeName)), 
1379                svg && src) {
1380                    if (polyfill) {
1381                        if (!opts.validate || opts.validate(src, svg, use)) {
1382                            // remove the <use> element
1383                            parent.removeChild(use);
1384                            // parse the src and get the url and id
1385                            var srcSplit = src.split("#"), url = srcSplit.shift(), id = srcSplit.join("#");
1386                            // if the link is external
1387                            if (url.length) {
1388                                // get the cached xhr request
1389                                var xhr = requests[url];
1390                                // ensure the xhr request exists
1391                                xhr || (xhr = requests[url] = new XMLHttpRequest(), xhr.open("GET", url), xhr.send(), 
1392                                xhr._embeds = []), // add the svg and id as an item to the xhr embeds list
1393                                xhr._embeds.push({
1394                                    parent: parent,
1395                                    svg: svg,
1396                                    id: id
1397                                }), // prepare the xhr ready state change event
1398                                loadreadystatechange(xhr);
1399                            } else {
1400                                // embed the local id into the svg
1401                                embed(parent, svg, document.getElementById(id));
1402                            }
1403                        } else {
1404                            // increase the index when the previous value was not "valid"
1405                            ++index, ++numberOfSvgUseElementsToBypass;
1406                        }
1407                    }
1408                } else {
1409                    // increase the index when the previous value was not "valid"
1410                    ++index;
1411                }
1412            }
1413            // continue the interval
1414            (!uses.length || uses.length - numberOfSvgUseElementsToBypass > 0) && requestAnimationFrame(oninterval, 67);
1415        }
1416        var polyfill, opts = Object(rawopts), newerIEUA = /\bTrident\/[567]\b|\bMSIE (?:9|10)\.0\b/, webkitUA = /\bAppleWebKit\/(\d+)\b/, olderEdgeUA = /\bEdge\/12\.(\d+)\b/, edgeUA = /\bEdge\/.(\d+)\b/, inIframe = window.top !== window.self;
1417        polyfill = "polyfill" in opts ? opts.polyfill : newerIEUA.test(navigator.userAgent) || (navigator.userAgent.match(olderEdgeUA) || [])[1] < 10547 || (navigator.userAgent.match(webkitUA) || [])[1] < 537 || edgeUA.test(navigator.userAgent) && inIframe;
1418        // create xhr requests object
1419        var requests = {}, requestAnimationFrame = window.requestAnimationFrame || setTimeout, uses = document.getElementsByTagName("use"), numberOfSvgUseElementsToBypass = 0;
1420        // conditionally start the interval if the polyfill is active
1421        polyfill && oninterval();
1422    }
1423    function getSVGAncestor(node) {
1424        for (var svg = node; "svg" !== svg.nodeName.toLowerCase() && (svg = svg.parentNode); ) {}
1425        return svg;
1426    }
1427    return svg4everybody;
1428});
1429
1430/***/ }),
1431
1432/***/ 764:
1433/***/ (function(module) {
1434
1435/*!
1436* sweetalert2 v11.4.13
1437* Released under the MIT License.
1438*/
1439(function (global, factory) {
1440   true ? module.exports = factory() :
1441  0;
1442}(this, function () { 'use strict';
1443
1444  const consolePrefix = 'SweetAlert2:';
1445  /**
1446   * Filter the unique values into a new array
1447   * @param arr
1448   */
1449
1450  const uniqueArray = arr => {
1451    const result = [];
1452
1453    for (let i = 0; i < arr.length; i++) {

1454      if (result.indexOf(arr[i]) === -1) {
1455        result.push(arr[i]);
1456      }
1457    }
1458
1459    return result;
1460  };
1461  /**
1462   * Capitalize the first letter of a string
1463   * @param {string} str
1464   * @returns {string}
1465   */
1466
1467  const capitalizeFirstLetter = str => str.charAt(0).toUpperCase() + str.slice(1);
1468  /**
1469   * @param {NodeList | HTMLCollection | NamedNodeMap} nodeList
1470   * @returns {array}
1471   */
1472
1473  const toArray = nodeList => Array.prototype.slice.call(nodeList);
1474  /**
1475   * Standardize console warnings
1476   * @param {string | array} message
1477   */
1478
1479  const warn = message => {
1480    console.warn("".concat(consolePrefix, " ").concat(typeof message === 'object' ? message.join(' ') : message));
1481  };
1482  /**
1483   * Standardize console errors
1484   * @param {string} message
1485   */
1486
1487  const error = message => {
1488    console.error("".concat(consolePrefix, " ").concat(message));
1489  };
1490  /**
1491   * Private global state for `warnOnce`
1492   * @type {Array}
1493   * @private
1494   */
1495
1496  const previousWarnOnceMessages = [];
1497  /**
1498   * Show a console warning, but only if it hasn't already been shown
1499   * @param {string} message
1500   */
1501
1502  const warnOnce = message => {
1503    if (!previousWarnOnceMessages.includes(message)) {
1504      previousWarnOnceMessages.push(message);
1505      warn(message);
1506    }
1507  };
1508  /**
1509   * Show a one-time console warning about deprecated params/methods
1510   */
1511
1512  const warnAboutDeprecation = (deprecatedParam, useInstead) => {
1513    warnOnce("\"".concat(deprecatedParam, "\" is deprecated and will be removed in the next major release. Please use \"").concat(useInstead, "\" instead."));
1514  };
1515  /**
1516   * If `arg` is a function, call it (with no arguments or context) and return the result.
1517   * Otherwise, just pass the value through
1518   * @param arg
1519   */
1520
1521  const callIfFunction = arg => typeof arg === 'function' ? arg() : arg;
1522  const hasToPromiseFn = arg => arg && typeof arg.toPromise === 'function';
1523  const asPromise = arg => hasToPromiseFn(arg) ? arg.toPromise() : Promise.resolve(arg);
1524  const isPromise = arg => arg && Promise.resolve(arg) === arg;
1525  const getRandomElement = arr => arr[Math.floor(Math.random() * arr.length)];
1526
1527  const defaultParams = {
1528    title: '',
1529    titleText: '',
1530    text: '',
1531    html: '',
1532    footer: '',
1533    icon: undefined,
1534    iconColor: undefined,
1535    iconHtml: undefined,
1536    template: undefined,
1537    toast: false,
1538    showClass: {
1539      popup: 'swal2-show',
1540      backdrop: 'swal2-backdrop-show',
1541      icon: 'swal2-icon-show'
1542    },
1543    hideClass: {
1544      popup: 'swal2-hide',
1545      backdrop: 'swal2-backdrop-hide',
1546      icon: 'swal2-icon-hide'
1547    },
1548    customClass: {},
1549    target: 'body',
1550    color: undefined,
1551    backdrop: true,
1552    heightAuto: true,
1553    allowOutsideClick: true,
1554    allowEscapeKey: true,
1555    allowEnterKey: true,
1556    stopKeydownPropagation: true,
1557    keydownListenerCapture: false,
1558    showConfirmButton: true,
1559    showDenyButton: false,
1560    showCancelButton: false,
1561    preConfirm: undefined,
1562    preDeny: undefined,
1563    confirmButtonText: 'OK',
1564    confirmButtonAriaLabel: '',
1565    confirmButtonColor: undefined,
1566    denyButtonText: 'No',
1567    denyButtonAriaLabel: '',
1568    denyButtonColor: undefined,
1569    cancelButtonText: 'Cancel',
1570    cancelButtonAriaLabel: '',
1571    cancelButtonColor: undefined,
1572    buttonsStyling: true,
1573    reverseButtons: false,
1574    focusConfirm: true,
1575    focusDeny: false,
1576    focusCancel: false,
1577    returnFocus: true,
1578    showCloseButton: false,
1579    closeButtonHtml: '×',
1580    closeButtonAriaLabel: 'Close this dialog',
1581    loaderHtml: '',
1582    showLoaderOnConfirm: false,
1583    showLoaderOnDeny: false,
1584    imageUrl: undefined,
1585    imageWidth: undefined,
1586    imageHeight: undefined,
1587    imageAlt: '',
1588    timer: undefined,
1589    timerProgressBar: false,
1590    width: undefined,
1591    padding: undefined,
1592    background: undefined,
1593    input: undefined,
1594    inputPlaceholder: '',
1595    inputLabel: '',
1596    inputValue: '',
1597    inputOptions: {},
1598    inputAutoTrim: true,
1599    inputAttributes: {},
1600    inputValidator: undefined,
1601    returnInputValueOnDeny: false,
1602    validationMessage: undefined,
1603    grow: false,
1604    position: 'center',
1605    progressSteps: [],
1606    currentProgressStep: undefined,
1607    progressStepsDistance: undefined,
1608    willOpen: undefined,
1609    didOpen: undefined,
1610    didRender: undefined,
1611    willClose: undefined,
1612    didClose: undefined,
1613    didDestroy: undefined,
1614    scrollbarPadding: true
1615  };
1616  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'];
1617  const deprecatedParams = {};
1618  const toastIncompatibleParams = ['allowOutsideClick', 'allowEnterKey', 'backdrop', 'focusConfirm', 'focusDeny', 'focusCancel', 'returnFocus', 'heightAuto', 'keydownListenerCapture'];
1619  /**
1620   * Is valid parameter
1621   * @param {string} paramName
1622   */
1623
1624  const isValidParameter = paramName => {
1625    return Object.prototype.hasOwnProperty.call(defaultParams, paramName);
1626  };
1627  /**
1628   * Is valid parameter for Swal.update() method
1629   * @param {string} paramName
1630   */
1631
1632  const isUpdatableParameter = paramName => {
1633    return updatableParams.indexOf(paramName) !== -1;
1634  };
1635  /**
1636   * Is deprecated parameter
1637   * @param {string} paramName
1638   */
1639
1640  const isDeprecatedParameter = paramName => {
1641    return deprecatedParams[paramName];
1642  };
1643
1644  const checkIfParamIsValid = param => {
1645    if (!isValidParameter(param)) {
1646      warn("Unknown parameter \"".concat(param, "\""));
1647    }
1648  };
1649
1650  const checkIfToastParamIsValid = param => {
1651    if (toastIncompatibleParams.includes(param)) {
1652      warn("The parameter \"".concat(param, "\" is incompatible with toasts"));
1653    }
1654  };
1655
1656  const checkIfParamIsDeprecated = param => {
1657    if (isDeprecatedParameter(param)) {
1658      warnAboutDeprecation(param, isDeprecatedParameter(param));
1659    }
1660  };
1661  /**
1662   * Show relevant warnings for given params
1663   *
1664   * @param params
1665   */
1666
1667
1668  const showWarningsForParams = params => {
1669    if (!params.backdrop && params.allowOutsideClick) {
1670      warn('"allowOutsideClick" parameter requires `backdrop` parameter to be set to `true`');
1671    }
1672
1673    for (const param in params) {
1674      checkIfParamIsValid(param);
1675
1676      if (params.toast) {
1677        checkIfToastParamIsValid(param);
1678      }
1679
1680      checkIfParamIsDeprecated(param);
1681    }
1682  };
1683
1684  const swalPrefix = 'swal2-';
1685  const prefix = items => {
1686    const result = {};
1687
1688    for (const i in items) {
1689      result[items[i]] = swalPrefix + items[i];
1690    }
1691
1692    return result;
1693  };
1694  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']);
1695  const iconTypes = prefix(['success', 'warning', 'info', 'question', 'error']);
1696
1697  /**
1698   * Gets the popup container which contains the backdrop and the popup itself.
1699   *
1700   * @returns {HTMLElement | null}
1701   */
1702
1703  const getContainer = () => document.body.querySelector(".".concat(swalClasses.container));
1704  const elementBySelector = selectorString => {
1705    const container = getContainer();
1706    return container ? container.querySelector(selectorString) : null;
1707  };
1708
1709  const elementByClass = className => {
1710    return elementBySelector(".".concat(className));
1711  };
1712
1713  const getPopup = () => elementByClass(swalClasses.popup);
1714  const getIcon = () => elementByClass(swalClasses.icon);
1715  const getTitle = () => elementByClass(swalClasses.title);
1716  const getHtmlContainer = () => elementByClass(swalClasses['html-container']);
1717  const getImage = () => elementByClass(swalClasses.image);
1718  const getProgressSteps = () => elementByClass(swalClasses['progress-steps']);
1719  const getValidationMessage = () => elementByClass(swalClasses['validation-message']);
1720  const getConfirmButton = () => elementBySelector(".".concat(swalClasses.actions, " .").concat(swalClasses.confirm));
1721  const getDenyButton = () => elementBySelector(".".concat(swalClasses.actions, " .").concat(swalClasses.deny));
1722  const getInputLabel = () => elementByClass(swalClasses['input-label']);
1723  const getLoader = () => elementBySelector(".".concat(swalClasses.loader));
1724  const getCancelButton = () => elementBySelector(".".concat(swalClasses.actions, " .").concat(swalClasses.cancel));
1725  const getActions = () => elementByClass(swalClasses.actions);
1726  const getFooter = () => elementByClass(swalClasses.footer);
1727  const getTimerProgressBar = () => elementByClass(swalClasses['timer-progress-bar']);
1728  const getCloseButton = () => elementByClass(swalClasses.close); // https://github.com/jkup/focusable/blob/master/index.js
1729
1730  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";
1731  const getFocusableElements = () => {
1732    const focusableElementsWithTabindex = toArray(getPopup().querySelectorAll('[tabindex]:not([tabindex="-1"]):not([tabindex="0"])')) // sort according to tabindex
1733    .sort((a, b) => {
1734      const tabindexA = parseInt(a.getAttribute('tabindex'));
1735      const tabindexB = parseInt(b.getAttribute('tabindex'));
1736
1737      if (tabindexA > tabindexB) {
1738        return 1;
1739      } else if (tabindexA < tabindexB) {
1740        return -1;
1741      }
1742
1743      return 0;
1744    });
1745    const otherFocusableElements = toArray(getPopup().querySelectorAll(focusable)).filter(el => el.getAttribute('tabindex') !== '-1');
1746    return uniqueArray(focusableElementsWithTabindex.concat(otherFocusableElements)).filter(el => isVisible(el));
1747  };
1748  const isModal = () => {
1749    return hasClass(document.body, swalClasses.shown) && !hasClass(document.body, swalClasses['toast-shown']) && !hasClass(document.body, swalClasses['no-backdrop']);
1750  };
1751  const isToast = () => {
1752    return getPopup() && hasClass(getPopup(), swalClasses.toast);
1753  };
1754  const isLoading = () => {
1755    return getPopup().hasAttribute('data-loading');
1756  };
1757
1758  const states = {
1759    previousBodyPadding: null
1760  };
1761  /**
1762   * Securely set innerHTML of an element
1763   * https://github.com/sweetalert2/sweetalert2/issues/1926
1764   *
1765   * @param {HTMLElement} elem
1766   * @param {string} html
1767   */
1768
1769  const setInnerHtml = (elem, html) => {
1770    elem.textContent = '';
1771
1772    if (html) {
1773      const parser = new DOMParser();
1774      const parsed = parser.parseFromString(html, "text/html");
1775      toArray(parsed.querySelector('head').childNodes).forEach(child => {
1776        elem.appendChild(child);
1777      });
1778      toArray(parsed.querySelector('body').childNodes).forEach(child => {
1779        elem.appendChild(child);
1780      });
1781    }
1782  };
1783  /**
1784   * @param {HTMLElement} elem
1785   * @param {string} className
1786   * @returns {boolean}
1787   */
1788
1789  const hasClass = (elem, className) => {
1790    if (!className) {
1791      return false;
1792    }
1793
1794    const classList = className.split(/\s+/);
1795
1796    for (let i = 0; i < classList.length; i++) {
1797      if (!elem.classList.contains(classList[i])) {
1798        return false;
1799      }
1800    }
1801
1802    return true;
1803  };
1804
1805  const removeCustomClasses = (elem, params) => {
1806    toArray(elem.classList).forEach(className => {
1807      if (!Object.values(swalClasses).includes(className) && !Object.values(iconTypes).includes(className) && !Object.values(params.showClass).includes(className)) {
1808        elem.classList.remove(className);
1809      }
1810    });
1811  };
1812
1813  const applyCustomClass = (elem, params, className) => {
1814    removeCustomClasses(elem, params);
1815
1816    if (params.customClass && params.customClass[className]) {
1817      if (typeof params.customClass[className] !== 'string' && !params.customClass[className].forEach) {
1818        return warn("Invalid type of customClass.".concat(className, "! Expected string or iterable object, got \"").concat(typeof params.customClass[className], "\""));
1819      }
1820
1821      addClass(elem, params.customClass[className]);
1822    }
1823  };
1824  /**
1825   * @param {HTMLElement} popup
1826   * @param {import('./renderers/renderInput').InputClass} inputClass
1827   * @returns {HTMLInputElement | null}
1828   */
1829
1830  const getInput = (popup, inputClass) => {
1831    if (!inputClass) {
1832      return null;
1833    }
1834
1835    switch (inputClass) {
1836      case 'select':
1837      case 'textarea':
1838      case 'file':
1839        return popup.querySelector(".".concat(swalClasses.popup, " > .").concat(swalClasses[inputClass]));
1840
1841      case 'checkbox':
1842        return popup.querySelector(".".concat(swalClasses.popup, " > .").concat(swalClasses.checkbox, " input"));
1843
1844      case 'radio':
1845        return popup.querySelector(".".concat(swalClasses.popup, " > .").concat(swalClasses.radio, " input:checked")) || popup.querySelector(".".concat(swalClasses.popup, " > .").concat(swalClasses.radio, " input:first-child"));
1846
1847      case 'range':
1848        return popup.querySelector(".".concat(swalClasses.popup, " > .").concat(swalClasses.range, " input"));
1849
1850      default:
1851        return popup.querySelector(".".concat(swalClasses.popup, " > .").concat(swalClasses.input));
1852    }
1853  };
1854  /**
1855   * @param {HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement} input
1856   */
1857
1858  const focusInput = input => {
1859    input.focus(); // place cursor at end of text in text input
1860
1861    if (input.type !== 'file') {
1862      // http://stackoverflow.com/a/2345915
1863      const val = input.value;
1864      input.value = '';
1865      input.value = val;
1866    }
1867  };
1868  /**
1869   * @param {HTMLElement | HTMLElement[] | null} target
1870   * @param {string | string[] | readonly string[]} classList
1871   * @param {boolean} condition
1872   */
1873
1874  const toggleClass = (target, classList, condition) => {
1875    if (!target || !classList) {
1876      return;
1877    }
1878
1879    if (typeof classList === 'string') {
1880      classList = classList.split(/\s+/).filter(Boolean);
1881    }
1882
1883    classList.forEach(className => {
1884      if (Array.isArray(target)) {
1885        target.forEach(elem => {
1886          condition ? elem.classList.add(className) : elem.classList.remove(className);
1887        });
1888      } else {
1889        condition ? target.classList.add(className) : target.classList.remove(className);
1890      }
1891    });
1892  };
1893  /**
1894   * @param {HTMLElement | HTMLElement[] | null} target
1895   * @param {string | string[] | readonly string[]} classList
1896   */
1897
1898  const addClass = (target, classList) => {
1899    toggleClass(target, classList, true);
1900  };
1901  /**
1902   * @param {HTMLElement | HTMLElement[] | null} target
1903   * @param {string | string[] | readonly string[]} classList
1904   */
1905
1906  const removeClass = (target, classList) => {
1907    toggleClass(target, classList, false);
1908  };
1909  /**
1910   * Get direct child of an element by class name
1911   *
1912   * @param {HTMLElement} elem
1913   * @param {string} className
1914   * @returns {HTMLElement | null}
1915   */
1916
1917  const getDirectChildByClass = (elem, className) => {
1918    const childNodes = toArray(elem.childNodes);
1919
1920    for (let i = 0; i < childNodes.length; i++) {
1921      if (hasClass(childNodes[i], className)) {
1922        return childNodes[i];
1923      }
1924    }
1925  };
1926  /**
1927   * @param {HTMLElement} elem
1928   * @param {string} property
1929   * @param {*} value
1930   */
1931
1932  const applyNumericalStyle = (elem, property, value) => {
1933    if (value === "".concat(parseInt(value))) {
1934      value = parseInt(value);
1935    }
1936
1937    if (value || parseInt(value) === 0) {
1938      elem.style[property] = typeof value === 'number' ? "".concat(value, "px") : value;
1939    } else {
1940      elem.style.removeProperty(property);
1941    }
1942  };
1943  /**
1944   * @param {HTMLElement} elem
1945   * @param {string} display
1946   */
1947
1948  const show = function (elem) {
1949    let display = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'flex';
1950    elem.style.display = display;
1951  };
1952  /**
1953   * @param {HTMLElement} elem
1954   */
1955
1956  const hide = elem => {
1957    elem.style.display = 'none';
1958  };
1959  const setStyle = (parent, selector, property, value) => {
1960    const el = parent.querySelector(selector);
1961
1962    if (el) {
1963      el.style[property] = value;
1964    }
1965  };
1966  const toggle = (elem, condition, display) => {
1967    condition ? show(elem, display) : hide(elem);
1968  }; // borrowed from jquery $(elem).is(':visible') implementation
1969
1970  const isVisible = elem => !!(elem && (elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length));
1971  const allButtonsAreHidden = () => !isVisible(getConfirmButton()) && !isVisible(getDenyButton()) && !isVisible(getCancelButton());
1972  const isScrollable = elem => !!(elem.scrollHeight > elem.clientHeight); // borrowed from https://stackoverflow.com/a/46352119
1973
1974  const hasCssAnimation = elem => {
1975    const style = window.getComputedStyle(elem);
1976    const animDuration = parseFloat(style.getPropertyValue('animation-duration') || '0');
1977    const transDuration = parseFloat(style.getPropertyValue('transition-duration') || '0');
1978    return animDuration > 0 || transDuration > 0;
1979  };
1980  const animateTimerProgressBar = function (timer) {
1981    let reset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
1982    const timerProgressBar = getTimerProgressBar();
1983
1984    if (isVisible(timerProgressBar)) {
1985      if (reset) {
1986        timerProgressBar.style.transition = 'none';
1987        timerProgressBar.style.width = '100%';
1988      }
1989
1990      setTimeout(() => {
1991        timerProgressBar.style.transition = "width ".concat(timer / 1000, "s linear");
1992        timerProgressBar.style.width = '0%';
1993      }, 10);
1994    }
1995  };
1996  const stopTimerProgressBar = () => {
1997    const timerProgressBar = getTimerProgressBar();
1998    const timerProgressBarWidth = parseInt(window.getComputedStyle(timerProgressBar).width);
1999    timerProgressBar.style.removeProperty('transition');
2000    timerProgressBar.style.width = '100%';
2001    const timerProgressBarFullWidth = parseInt(window.getComputedStyle(timerProgressBar).width);
2002    const timerProgressBarPercent = timerProgressBarWidth / timerProgressBarFullWidth * 100;
2003    timerProgressBar.style.removeProperty('transition');
2004    timerProgressBar.style.width = "".concat(timerProgressBarPercent, "%");
2005  };
2006
2007  /**
2008   * Detect Node env
2009   *
2010   * @returns {boolean}
2011   */
2012  const isNodeEnv = () => typeof window === 'undefined' || typeof document === 'undefined';
2013
2014  const RESTORE_FOCUS_TIMEOUT = 100;
2015
2016  const globalState = {};
2017
2018  const focusPreviousActiveElement = () => {
2019    if (globalState.previousActiveElement && globalState.previousActiveElement.focus) {
2020      globalState.previousActiveElement.focus();
2021      globalState.previousActiveElement = null;
2022    } else if (document.body) {
2023      document.body.focus();
2024    }
2025  }; // Restore previous active (focused) element
2026
2027
2028  const restoreActiveElement = returnFocus => {
2029    return new Promise(resolve => {
2030      if (!returnFocus) {
2031        return resolve();
2032      }
2033
2034      const x = window.scrollX;
2035      const y = window.scrollY;
2036      globalState.restoreFocusTimeout = setTimeout(() => {
2037        focusPreviousActiveElement();
2038        resolve();
2039      }, RESTORE_FOCUS_TIMEOUT); // issues/900
2040
2041      window.scrollTo(x, y);
2042    });
2043  };
2044
2045  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, '');
2046
2047  const resetOldContainer = () => {
2048    const oldContainer = getContainer();
2049
2050    if (!oldContainer) {
2051      return false;
2052    }
2053
2054    oldContainer.remove();
2055    removeClass([document.documentElement, document.body], [swalClasses['no-backdrop'], swalClasses['toast-shown'], swalClasses['has-column']]);
2056    return true;
2057  };
2058
2059  const resetValidationMessage = () => {
2060    globalState.currentInstance.resetValidationMessage();
2061  };
2062
2063  const addInputChangeListeners = () => {
2064    const popup = getPopup();
2065    const input = getDirectChildByClass(popup, swalClasses.input);
2066    const file = getDirectChildByClass(popup, swalClasses.file);
2067    const range = popup.querySelector(".".concat(swalClasses.range, " input"));
2068    const rangeOutput = popup.querySelector(".".concat(swalClasses.range, " output"));
2069    const select = getDirectChildByClass(popup, swalClasses.select);
2070    const checkbox = popup.querySelector(".".concat(swalClasses.checkbox, " input"));
2071    const textarea = getDirectChildByClass(popup, swalClasses.textarea);
2072    input.oninput = resetValidationMessage;
2073    file.onchange = resetValidationMessage;
2074    select.onchange = resetValidationMessage;
2075    checkbox.onchange = resetValidationMessage;
2076    textarea.oninput = resetValidationMessage;
2077
2078    range.oninput = () => {
2079      resetValidationMessage();
2080      rangeOutput.value = range.value;
2081    };
2082
2083    range.onchange = () => {
2084      resetValidationMessage();
2085      range.nextSibling.value = range.value;
2086    };
2087  };
2088
2089  const getTarget = target => typeof target === 'string' ? document.querySelector(target) : target;
2090
2091  const setupAccessibility = params => {
2092    const popup = getPopup();
2093    popup.setAttribute('role', params.toast ? 'alert' : 'dialog');
2094    popup.setAttribute('aria-live', params.toast ? 'polite' : 'assertive');
2095
2096    if (!params.toast) {
2097      popup.setAttribute('aria-modal', 'true');
2098    }
2099  };
2100
2101  const setupRTL = targetElement => {
2102    if (window.getComputedStyle(targetElement).direction === 'rtl') {
2103      addClass(getContainer(), swalClasses.rtl);
2104    }
2105  };
2106  /*
2107   * Add modal + backdrop + no-war message for Russians to DOM
2108   */
2109
2110
2111  const init = params => {
2112    // Clean up the old popup container if it exists
2113    const oldContainerExisted = resetOldContainer();
2114    /* istanbul ignore if */
2115
2116    if (isNodeEnv()) {
2117      error('SweetAlert2 requires document to initialize');
2118      return;
2119    }
2120
2121    const container = document.createElement('div');
2122    container.className = swalClasses.container;
2123
2124    if (oldContainerExisted) {
2125      addClass(container, swalClasses['no-transition']);
2126    }
2127
2128    setInnerHtml(container, sweetHTML);
2129    const targetElement = getTarget(params.target);
2130    targetElement.appendChild(container);
2131    setupAccessibility(params);
2132    setupRTL(targetElement);
2133    addInputChangeListeners();
2134    noWarMessageForRussians(container, params);
2135  };
2136
2137  const noWarMessageForRussians = (container, params) => {
2138    if (params.toast) {
2139      return;
2140    } // This message is targeted at people who are corrupted by propaganda, everybody else
2141    // is already against war either silently or actively.
2142    //
2143    // The point is to wrap the truth-bomb into a patriotic title so they will actually click it
2144    // and listen to the uncomfortable truth about the war from the people they love or respect.
2145
2146
2147    const message = getRandomElement([{
2148      text: 'ШВАРЦЕНЕГГЕР обратился <br> к РУССКОМУ НАРОДУ о войне',
2149      // Arnold is loved in Russia by all people including those who are for this war
2150      // His speech might change the mind of those who are brainwashed by propaganda
2151      youtubeId: 'fWClXZd9c78'
2152    }, {
2153      text: 'РУССКИЙ ПАТРИОТ <br> открыл главную тайну спецоперации',
2154      // In this video one of the most famous Russian nationalist leaders, Dmitry Demushkin,
2155      // explains that this war has no sense and produces the exact opposite result of what
2156      // it was intended to do.
2157      youtubeId: '_RjBNkn88yA'
2158    }, {
2159      text: 'ГЕРОЙ НОВОРОССИИ СТРЕЛКОВ <br> дал оценку ходу спецоперации',
2160      // In this video Igor Girkin, who played a key role in the annexation of Crimea,
2161      // explains that this war has failed already and all possible outcomes are bad for Ru

2161ssia.
2162      youtubeId: 'yUmzQT4C8JY'
2163    }, {
2164      text: 'ФИНСКИЙ ДРУГ РОССИИ <br> говорит ПО-РУССКИ о спецоперации',
2165      youtubeId: 'hkCYb6edUrQ'
2166    }]); // The message will only be shown to Russian users visiting Russian sites
2167
2168    if (navigator.language === 'ru' && location.host.match(/\.(ru|su|xn--p1ai)$/)) {
2169      const noWar = document.createElement('div');
2170      noWar.className = swalClasses['no-war'];
2171      setInnerHtml(noWar, "<a href=\"https://www.youtube.com/watch?v=".concat(message.youtubeId, "\" target=\"_blank\">").concat(message.text, "</a>"));
2172      container.appendChild(noWar);
2173      container.style.paddingTop = '4em';
2174    }
2175  };
2176
2177  /**
2178   * @param {HTMLElement | object | string} param
2179   * @param {HTMLElement} target
2180   */
2181
2182  const parseHtmlToContainer = (param, target) => {
2183    // DOM element
2184    if (param instanceof HTMLElement) {
2185      target.appendChild(param);
2186    } // Object
2187    else if (typeof param === 'object') {
2188      handleObject(param, target);
2189    } // Plain string
2190    else if (param) {
2191      setInnerHtml(target, param);
2192    }
2193  };
2194  /**
2195   * @param {object} param
2196   * @param {HTMLElement} target
2197   */
2198
2199  const handleObject = (param, target) => {
2200    // JQuery element(s)
2201    if (param.jquery) {
2202      handleJqueryElem(target, param);
2203    } // For other objects use their string representation
2204    else {
2205      setInnerHtml(target, param.toString());
2206    }
2207  };
2208
2209  const handleJqueryElem = (target, elem) => {
2210    target.textContent = '';
2211
2212    if (0 in elem) {
2213      for (let i = 0; (i in elem); i++) {
2214        target.appendChild(elem[i].cloneNode(true));
2215      }
2216    } else {
2217      target.appendChild(elem.cloneNode(true));
2218    }
2219  };
2220
2221  const animationEndEvent = (() => {
2222    // Prevent run in Node env
2223
2224    /* istanbul ignore if */
2225    if (isNodeEnv()) {
2226      return false;
2227    }
2228
2229    const testEl = document.createElement('div');
2230    const transEndEventNames = {
2231      WebkitAnimation: 'webkitAnimationEnd',
2232      // Chrome, Safari and Opera
2233      animation: 'animationend' // Standard syntax
2234
2235    };
2236
2237    for (const i in transEndEventNames) {
2238      if (Object.prototype.hasOwnProperty.call(transEndEventNames, i) && typeof testEl.style[i] !== 'undefined') {
2239        return transEndEventNames[i];
2240      }
2241    }
2242
2243    return false;
2244  })();
2245
2246  // https://github.com/twbs/bootstrap/blob/master/js/src/modal.js
2247
2248  const measureScrollbar = () => {
2249    const scrollDiv = document.createElement('div');
2250    scrollDiv.className = swalClasses['scrollbar-measure'];
2251    document.body.appendChild(scrollDiv);
2252    const scrollbarWidth = scrollDiv.getBoundingClientRect().width - scrollDiv.clientWidth;
2253    document.body.removeChild(scrollDiv);
2254    return scrollbarWidth;
2255  };
2256
2257  const renderActions = (instance, params) => {
2258    const actions = getActions();
2259    const loader = getLoader(); // Actions (buttons) wrapper
2260
2261    if (!params.showConfirmButton && !params.showDenyButton && !params.showCancelButton) {
2262      hide(actions);
2263    } else {
2264      show(actions);
2265    } // Custom class
2266
2267
2268    applyCustomClass(actions, params, 'actions'); // Render all the buttons
2269
2270    renderButtons(actions, loader, params); // Loader
2271
2272    setInnerHtml(loader, params.loaderHtml);
2273    applyCustomClass(loader, params, 'loader');
2274  };
2275
2276  function renderButtons(actions, loader, params) {
2277    const confirmButton = getConfirmButton();
2278    const denyButton = getDenyButton();
2279    const cancelButton = getCancelButton(); // Render buttons
2280
2281    renderButton(confirmButton, 'confirm', params);
2282    renderButton(denyButton, 'deny', params);
2283    renderButton(cancelButton, 'cancel', params);
2284    handleButtonsStyling(confirmButton, denyButton, cancelButton, params);
2285
2286    if (params.reverseButtons) {
2287      if (params.toast) {
2288        actions.insertBefore(cancelButton, confirmButton);
2289        actions.insertBefore(denyButton, confirmButton);
2290      } else {
2291        actions.insertBefore(cancelButton, loader);
2292        actions.insertBefore(denyButton, loader);
2293        actions.insertBefore(confirmButton, loader);
2294      }
2295    }
2296  }
2297
2298  function handleButtonsStyling(confirmButton, denyButton, cancelButton, params) {
2299    if (!params.buttonsStyling) {
2300      return removeClass([confirmButton, denyButton, cancelButton], swalClasses.styled);
2301    }
2302
2303    addClass([confirmButton, denyButton, cancelButton], swalClasses.styled); // Buttons background colors
2304
2305    if (params.confirmButtonColor) {
2306      confirmButton.style.backgroundColor = params.confirmButtonColor;
2307      addClass(confirmButton, swalClasses['default-outline']);
2308    }
2309
2310    if (params.denyButtonColor) {
2311      denyButton.style.backgroundColor = params.denyButtonColor;
2312      addClass(denyButton, swalClasses['default-outline']);
2313    }
2314
2315    if (params.cancelButtonColor) {
2316      cancelButton.style.backgroundColor = params.cancelButtonColor;
2317      addClass(cancelButton, swalClasses['default-outline']);
2318    }
2319  }
2320
2321  function renderButton(button, buttonType, params) {
2322    toggle(button, params["show".concat(capitalizeFirstLetter(buttonType), "Button")], 'inline-block');
2323    setInnerHtml(button, params["".concat(buttonType, "ButtonText")]); // Set caption text
2324
2325    button.setAttribute('aria-label', params["".concat(buttonType, "ButtonAriaLabel")]); // ARIA label
2326    // Add buttons custom classes
2327
2328    button.className = swalClasses[buttonType];
2329    applyCustomClass(button, params, "".concat(buttonType, "Button"));
2330    addClass(button, params["".concat(buttonType, "ButtonClass")]);
2331  }
2332
2333  function handleBackdropParam(container, backdrop) {
2334    if (typeof backdrop === 'string') {
2335      container.style.background = backdrop;
2336    } else if (!backdrop) {
2337      addClass([document.documentElement, document.body], swalClasses['no-backdrop']);
2338    }
2339  }
2340
2341  function handlePositionParam(container, position) {
2342    if (position in swalClasses) {
2343      addClass(container, swalClasses[position]);
2344    } else {

2542 Input> */
2543
2544
2545  const renderInputType = {};
2546  /**
2547   * @param {HTMLInputElement} input
2548   * @param {SweetAlertOptions} params
2549   * @returns {HTMLInputElement}
2550   */
2551
2552  renderInputType.text = renderInputType.email = renderInputType.password = renderInputType.number = renderInputType.tel = renderInputType.url = (input, params) => {
2553    checkAndSetInputValue(input, params.inputValue);
2554    setInputLabel(input, input, params);
2555    setInputPlaceholder(input, params);
2556    input.type = params.input;
2557    return input;
2558  };
2559  /**
2560   * @param {HTMLInputElement} input
2561   * @param {SweetAlertOptions} params
2562   * @returns {HTMLInputElement}
2563   */
2564
2565
2566  renderInputType.file = (input, params) => {
2567    setInputLabel(input, input, params);
2568    setInputPlaceholder(input, params);
2569    return input;
2570  };
2571  /**
2572   * @param {HTMLInputElement} range
2573   * @param {SweetAlertOptions} params
2574   * @returns {HTMLInputElement}
2575   */
2576
2577
2578  renderInputType.range = (range, params) => {
2579    const rangeInput = range.querySelector('input');
2580    const rangeOutput = range.querySelector('output');
2581    checkAndSetInputValue(rangeInput, params.inputValue);
2582    rangeInput.type = params.input;
2583    checkAndSetInputValue(rangeOutput, params.inputValue);
2584    setInputLabel(rangeInput, range, params);
2585    return range;
2586  };
2587  /**
2588   * @param {HTMLSelectElement} select
2589   * @param {SweetAlertOptions} params
2590   * @returns {HTMLSelectElement}
2591   */
2592
2593
2594  renderInputType.select = (select, params) => {
2595    select.textContent = '';
2596
2597    if (params.inputPlaceholder) {
2598      const placeholder = document.createElement('option');
2599      setInnerHtml(placeholder, params.inputPlaceholder);
2600      placeholder.value = '';
2601      placeholder.disabled = true;
2602      placeholder.selected = true;
2603      select.appendChild(placeholder);
2604    }
2605
2606    setInputLabel(select, select, params);
2607    return select;
2608  };
2609  /**
2610   * @param {HTMLInputElement} radio
2611   * @returns {HTMLInputElement}
2612   */
2613
2614
2615  renderInputType.radio = radio => {
2616    radio.textContent = '';
2617    return radio;
2618  };
2619  /**
2620   * @param {HTMLLabelElement} checkboxContainer
2621   * @param {SweetAlertOptions} params
2622   * @returns {HTMLInputElement}
2623   */
2624
2625
2626  renderInputType.checkbox = (checkboxContainer, params) => {
2627    const checkbox = getInput(getPopup(), 'checkbox');
2628    checkbox.value = '1';
2629    checkbox.id = swalClasses.checkbox;
2630    checkbox.checked = Boolean(params.inputValue);
2631    const label = checkboxContainer.querySelector('span');
2632    setInnerHtml(label, params.inputPlaceholder);
2633    return checkbox;
2634  };
2635  /**
2636   * @param {HTMLTextAreaElement} textarea
2637   * @param {SweetAlertOptions} params
2638   * @returns {HTMLTextAreaElement}
2639   */
2640
2641
2642  renderInputType.textarea = (textarea, params) => {
2643    checkAndSetInputValue(textarea, params.inputValue);
2644    setInputPlaceholder(textarea, params);
2645    setInputLabel(textarea, textarea, params);
2646    /**
2647     * @param {HTMLElement} el
2648     * @returns {number}
2649     */