https://comfortsecurities.co.in/assets/js/vendor/bootstrap.min.js

1/*!
2 * Bootstrap v5.0.2 (https://getbootstrap.com/)
3 * Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)
4 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
5 */
6!(function (t, e) {
7  "object" == typeof exports && "undefined" != typeof module
8    ? (module.exports = e())
9    : "function" == typeof define && define.amd
10    ? define(e)
11    : ((t =
12        "undefined" != typeof globalThis ? globalThis : t || self).bootstrap =
13        e());
14})(this, function () {
15  "use strict";
16  const t = {
17      find: (t, e = document.documentElement) =>
18        [].concat(...Element.prototype.querySelectorAll.call(e, t)),
19      findOne: (t, e = document.documentElement) =>
20        Element.prototype.querySelector.call(e, t),
21      children: (t, e) => [].concat(...t.children).filter((t) => t.matches(e)),
22      parents(t, e) {
23        const i = [];
24        let n = t.parentNode;
25        for (; n && n.nodeType === Node.ELEMENT_NODE && 3 !== n.nodeType; )
26          n.matches(e) && i.push(n), (n = n.parentNode);
27        return i;
28      },
29      prev(t, e) {
30        let i = t.previousElementSibling;
31        for (; i; ) {
32          if (i.matches(e)) return [i];
33          i = i.previousElementSibling;
34        }
35        return [];
36      },
37      next(t, e) {
38        let i = t.nextElementSibling;
39        for (; i; ) {
40          if (i.matches(e)) return [i];
41          i = i.nextElementSibling;
42        }
43        return [];
44      },
45    },
46    e = (t) => {
47      do {
48        t += Math.floor(1e6 * Math.random());
49      } while (document.getElementById(t));
50      return t;
51    },
52    i = (t) => {
53      let e = t.getAttribute("data-bs-target");
54      if (!e || "#" === e) {
55        let i = t.getAttribute("href");
56        if (!i || (!i.includes("#") && !i.startsWith("."))) return null;
57        i.includes("#") && !i.startsWith("#") && (i = "#" + i.split("#")[1]),
58          (e = i && "#" !== i ? i.trim() : null);
59      }
60      return e;
61    },
62    n = (t) => {
63      const e = i(t);
64      return e && document.querySelector(e) ? e : null;
65    },
66    s = (t) => {
67      const e = i(t);
68      return e ? document.querySelector(e) : null;
69    },
70    o = (t) => {
71      t.dispatchEvent(new Event("transitionend"));
72    },
73    r = (t) =>
74      !(!t || "object" != typeof t) &&
75      (void 0 !== t.jquery && (t = t[0]), void 0 !== t.nodeType),
76    a = (e) =>
77      r(e)
78        ? e.jquery
79          ? e[0]
80          : e
81        : "string" == typeof e && e.length > 0
82        ? t.findOne(e)
83        : null,
84    l = (t, e, i) => {
85      Object.keys(i).forEach((n) => {
86        const s = i[n],
87          o = e[n],
88          a =
89            o && r(o)
90              ? "element"
91              : null == (l = o)
92              ? "" + l
93              : {}.toString
94                  .call(l)
95                  .match(/\s([a-z]+)/i)[1]
96                  .toLowerCase();
97        var l;
98        if (!new RegExp(s).test(a))
99          throw new TypeError(
100            `${t.toUpperCase()}: Option "${n}" provided type "${a}" but expected type "${s}".`
101          );
102      });
103    },
104    c = (t) =>
105      !(!r(t) || 0 === t.getClientRects().length) &&
106      "visible" === getComputedStyle(t).getPropertyValue("visibility"),
107    h = (t) =>
108      !t ||
109      t.nodeType !== Node.ELEMENT_NODE ||
110      !!t.classList.contains("disabled") ||
111      (void 0 !== t.disabled
112        ? t.disabled
113        : t.hasAttribute("disabled") && "false" !== t.getAttribute("disabled")),
114    d = (t) => {
115      if (!document.documentElement.attachShadow) return null;
116      if ("function" == typeof t.getRootNode) {
117        const e = t.getRootNode();
118        return e instanceof ShadowRoot ? e : null;
119      }
120      return t instanceof ShadowRoot
121        ? t
122        : t.parentNode
123        ? d(t.parentNode)
124        : null;
125    },
126    u = () => {},
127    f = (t) => t.offsetHeight,
128    p = () => {
129      const { jQuery: t } = window;
130      return t && !document.body.hasAttribute("data-bs-no-jquery") ? t : null;
131    },
132    m = [],
133    g = () => "rtl" === document.documentElement.dir,
134    _ = (t) => {
135      var e;
136      (e = () => {
137        const e = p();
138        if (e) {
139          const i = t.NAME,
140            n = e.fn[i];
141          (e.fn[i] = t.jQueryInterface),
142            (e.fn[i].Constructor = t),
143            (e.fn[i].noConflict = () => ((e.fn[i] = n), t.jQueryInterface));
144        }
145      }),
146        "loading" === document.readyState
147          ? (m.length ||
148              document.addEventListener("DOMContentLoaded", () => {
149                m.forEach((t) => t());
150              }),
151            m.push(e))
152          : e();
153    },
154    b = (t) => {
155      "function" == typeof t && t();
156    },
157    v = (t, e, i = !0) => {
158      if (!i) return void b(t);
159      const n =
160        ((t) => {
161          if (!t) return 0;
162          let { transitionDuration: e, transitionDelay: i } =
163            window.getComputedStyle(t);
164          const n = Number.parseFloat(e),
165            s = Number.parseFloat(i);
166          return n || s
167            ? ((e = e.split(",")[0]),
168              (i = i.split(",")[0]),
169              1e3 * (Number.parseFloat(e) + Number.parseFloat(i)))
170            : 0;
171        })(e) + 5;
172      let s = !1;
173      const r = ({ target: i }) => {
174        i === e && ((s = !0), e.removeEventListener("transitionend", r), b(t));
175      };
176      e.addEventListener("transitionend", r),
177        setTimeout(() => {
178          s || o(e);
179        }, n);
180    },
181    y = (t, e, i, n) => {
182      let s = t.indexOf(e);
183      if (-1 === s) return t[!i && n ? t.length - 1 : 0];
184      const o = t.length;
185      return (
186        (s += i ? 1 : -1),
187        n && (s = (s + o) % o),
188        t[Math.max(0, Math.min(s, o - 1))]
189      );
190    },
191    w = /[^.]*(?=\..*)\.|.*/,
192    E = /\..*/,
193    A = /::\d+$/,
194    T = {};
195  let O = 1;
196  const C = { mouseenter: "mouseover", mouseleave: "mouseout" },
197    k = /^(mouseenter|mouseleave)/i,
198    L = new Set([
199      "click",
200      "dblclick",
201      "mouseup",
202      "mousedown",
203      "contextmenu",
204      "mousewheel",
205      "DOMMouseScroll",
206      "mouseover",
207      "mouseout",
208      "mousemove",
209      "selectstart",
210      "selectend",
211      "keydown",
212      "keypress",
213      "keyup",
214      "orientationchange",
215      "touchstart",
216      "touchmove",
217      "touchend",
218      "touchcancel",
219      "pointerdown",
220      "pointermove",
221      "pointerup",
222      "pointerleave",
223      "pointercancel",
224      "gesturestart",
225      "gesturechange",
226      "gestureend",
227      "focus",
228      "blur",
229      "change",
230      "reset",
231      "select",
232      "submit",
233      "focusin",
234      "focusout",
235      "load",
236      "unload",
237      "beforeunload",
238      "resize",
239      "move",
240      "DOMContentLoaded",
241      "readystatechange",
242      "error",
243      "abort",
244      "scroll",
245    ]);
246  function x(t, e) {
247    return (e && `${e}::${O++}`) || t.uidEvent || O++;
248  }
249  function D(t) {
250    const e = x(t);
251    return (t.uidEvent = e), (T[e] = T[e] || {}), T[e];
252  }
253  function S(t, e, i = null) {
254    const n = Object.keys(t);
255    for (let s = 0, o = n.length; s < o; s++) {
256      const o = t[n[s]];
257      if (o.originalHandler === e && o.delegationSelector === i) return o;
258    }
259    return null;
260  }
261  function I(t, e, i) {
262    const n = "string" == typeof e,
263      s = n ? i : e;
264    let o = M(t);
265    return L.has(o) || (o = t), [n, s, o];
266  }
267  function N(t, e, i, n, s) {
268    if ("string" != typeof e || !t) return;
269    if ((i || ((i = n), (n = null)), k.test(e))) {
270      const t = (t) =>
271        function (e) {
272          if (
273            !e.relatedTarget ||
274            (e.relatedTarget !== e.delegateTarget &&
275              !e.delegateTarget.contains(e.relatedTarget))
276          )
277            return t.call(this, e);
278        };
279      n ? (n = t(n)) : (i = t(i));
280    }
281    const [o, r, a] = I(e, i, n),
282      l = D(t),
283      c = l[a] || (l[a] = {}),
284      h = S(c, r, o ? i : null);
285    if (h) return void (h.oneOff = h.oneOff && s);
286    const d = x(r, e.replace(w, "")),
287      u = o
288        ? (function (t, e, i) {
289            return function n(s) {
290              const o = t.querySelectorAll(e);
291              for (let { target: r } = s; r && r !== this; r = r.parentNode)
292                for (let a = o.length; a--; )
293                  if (o[a] === r)
294                    return (
295                      (s.delegateTarget = r),
296                      n.oneOff && P.off(t, s.type, e, i),
297                      i.apply(r, [s])
298                    );
299              return null;
300            };
301          })(t, i, n)
302        : (function (t, e) {
303            return function i(n) {
304              return (
305                (n.delegateTarget = t),
306                i.oneOff && P.off(t, n.type, e),
307                e.apply(t, [n])
308              );
309            };
310          })(t, i);
311    (u.delegationSelector = o ? i : null),
312      (u.originalHandler = r),
313      (u.oneOff = s),
314      (u.uidEvent = d),
315      (c[d] = u),
316      t.addEventListener(a, u, o);
317  }
318  function j(t, e, i, n, s) {
319    const o = S(e[i], n, s);
320    o && (t.removeEventListener(i, o, Boolean(s)), delete e[i][o.uidEvent]);
321  }
322  function M(t) {
323    return (t = t.replace(E, "")), C[t] || t;
324  }
325  const P = {
326      on(t, e, i, n) {
327        N(t, e, i, n, !1);
328      },
329      one(t, e, i, n) {
330        N(t, e, i, n, !0);
331      },
332      off(t, e, i, n) {
333        if ("string" != typeof e || !t) return;
334        const [s, o, r] = I(e, i, n),
335          a = r !== e,
336          l = D(t),
337          c = e.startsWith(".");
338        if (void 0 !== o) {
339          if (!l || !l[r]) return;
340          return void j(t, l, r, o, s ? i : null);
341        }
342        c &&
343          Object.keys(l).forEach((i) => {
344            !(function (t, e, i, n) {
345              const s = e[i] || {};
346              Object.keys(s).forEach((o) => {
347                if (o.includes(n)) {
348                  const n = s[o];
349                  j(t, e, i, n.originalHandler, n.delegationSelector);
350                }
351              });
352            })(t, l, i, e.slice(1));
353          });
354        const h = l[r] || {};
355        Object.keys(h).forEach((i) => {
356          const n = i.replace(A, "");
357          if (!a || e.includes(n)) {
358            const e = h[i];
359            j(t, l, r, e.originalHandler, e.delegationSelector);
360          }
361        });
362      },
363      trigger(t, e, i) {
364        if ("string" != typeof e || !t) return null;
365        const n = p(),
366          s = M(e),
367          o = e !== s,
368          r = L.has(s);
369        let a,
370          l = !0,
371          c = !0,
372          h = !1,
373          d = null;
374        return (
375          o &&
376            n &&
377            ((a = n.Event(e, i)),
378            n(t).trigger(a),
379            (l = !a.isPropagationStopped()),
380            (c = !a.isImmediatePropagationStopped()),
381            (h = a.isDefaultPrevented())),
382          r
383            ? ((d = document.createEvent("HTMLEvents")), d.initEvent(s, l, !0))
384            : (d = new CustomEvent(e, { bubbles: l, cancelable: !0 })),
385          void 0 !== i &&
386            Object.keys(i).forEach((t) => {
387              Object.defineProperty(d, t, { get: () => i[t] });
388            }),
389          h && d.preventDefault(),
390          c && t.dispatchEvent(d),
391          d.defaultPrevented && void 0 !== a && a.preventDefault(),
392          d
393        );
394      },
395    },
396    H = new Map();
397  var R = {
398    set(t, e, i) {
399      H.has(t) || H.set(t, new Map());
400      const n = H.get(t);
401      n.has(e) || 0 === n.size
402        ? n.set(e, i)
403        : console.error(
404            `Bootstrap doesn't allow more than one instance per element. Bound instance: ${
405              Array.from(n.keys())[0]
406            }.`
407          );
408    },
409    get: (t, e) => (H.has(t) && H.get(t).get(e)) || null,
410    remove(t, e) {
411      if (!H.has(t)) return;
412      const i = H.get(t);
413      i.delete(e), 0 === i.size && H.delete(t);
414    },
415  };
416  class B {
417    constructor(t) {
418      (t = a(t)) &&
419        ((this._element = t),
420        R.set(this._element, this.constructor.DATA_KEY, this));
421    }
422    dispose() {
423      R.remove(this._element, this.constructor.DATA_KEY),
424        P.off(this._element, this.constructor.EVENT_KEY),
425        Object.getOwnPropertyNames(this).forEach((t) => {
426          this[t] = null;
427        });
428    }
429    _queueCallback(t, e, i = !0) {
430      v(t, e, i);
431    }
432    static getInstance(t) {
433      return R.get(t, this.DATA_KEY);
434    }
435    static getOrCreateInstance(t, e = {}) {
436      return (
437        this.getInstance(t) || new this(t, "object" == typeof e ? e : null)
438      );
439    }
440    static get VERSION() {
441      return "5.0.2";
442    }
443    static get NAME() {
444      throw new Error(
445        'You have to implement the static method "NAME", for each component!'
446      );
447    }
448    static get DATA_KEY() {
449      return "bs." + this.NAME;
450    }
451    static get EVENT_KEY() {
452      return "." + this.DATA_KEY;
453    }
454  }
455  class W extends B {
456    static get NAME() {
457      return "alert";
458    }
459    close(t) {
460      const e = t ? this._getRootElement(t) : this._element,
461        i = this._triggerCloseEvent(e);
462      null === i || i.defaultPrevented || this._removeElement(e);
463    }
464    _getRootElement(t) {
465      return s(t) || t.closest(".alert");
466    }
467    _triggerCloseEvent(t) {
468      return P.trigger(t, "close.bs.alert");
469    }
470    _removeElement(t) {
471      t.classList.remove("show");
472      const e = t.classList.contains("fade");
473      this._queueCallback(() => this._destroyElement(t), t, e);
474    }
475    _destroyElement(t) {
476      t.remove(), P.trigger(t, "closed.bs.alert");
477    }
478    static jQueryInterface(t) {
479      return this.each(function () {
480        const e = W.getOrCreateInstance(this);
481        "close" === t && e[t](this);
482      });
483    }
484    static handleDismiss(t) {
485      return function (e) {
486        e && e.preventDefault(), t.close(this);
487      };
488    }
489  }
490  P.on(
491    document,
492    "click.bs.alert.data-api",
493    '[data-bs-dismiss="alert"]',
494    W.handleDismiss(new W())
495  ),
496    _(W);
497  class q extends B {
498    static get NAME() {
499      return "button";
500    }
501    toggle() {
502      this._element.setAttribute(
503        "aria-pressed",
504        this._element.classList.toggle("active")
505      );
506    }
507    static jQueryInterface(t) {
508      return this.each(function () {
509        const e = q.getOrCreateInstance(this);
510        "toggle" === t && e[t]();
511      });
512    }
513  }
514  function z(t) {
515    return (
516      "true" === t ||
517      ("false" !== t &&
518        (t === Number(t).toString()
519          ? Number(t)
520          : "" === t || "null" === t
521          ? null
522          : t))
523    );
524  }
525  function $(t) {
526    return t.replace(/[A-Z]/g, (t) => "-" + t.toLowerCase());
527  }
528  P.on(
529    document,
530    "click.bs.button.data-api",
531    '[data-bs-toggle="button"]',
532    (t) => {
533      t.preventDefault();
534      const e = t.target.closest('[data-bs-toggle="button"]');
535      q.getOrCreateInstance(e).toggle();
536    }
537  ),
538    _(q);
539  const U = {
540      setDataAttribute(t, e, i) {
541        t.setAttribute("data-bs-" + $(e), i);
542      },
543      removeDataAttribute(t, e) {
544        t.removeAttribute("data-bs-" + $(e));
545      },
546      getDataAttributes(t) {
547        if (!t) return {};
548        const e = {};
549        return (
550          Object.keys(t.dataset)
551            .filter((t) => t.startsWith("bs"))
552            .forEach((i) => {
553              let n = i.replace(/^bs/, "");
554              (n = n.charAt(0).toLowerCase() + n.slice(1, n.length)),
555                (e[n] = z(t.dataset[i]));
556            }),
557          e
558        );
559      },
560      getDataAttribute: (t, e) => z(t.getAttribute("data-bs-" + $(e))),
561      offset(t) {
562        const e = t.getBoundingClientRect();
563        return {
564          top: e.top + document.body.scrollTop,
565          left: e.left + document.body.scrollLeft,
566        };
567      },
568      position: (t) => ({ top: t.offsetTop, left: t.offsetLeft }),
569    },
570    F = {
571      interval: 5e3,
572      keyboard: !0,
573      slide: !1,
574      pause: "hover",
575      wrap: !0,
576      touch: !0,
577    },
578    V = {
579      interval: "(number|boolean)",
580      keyboard: "boolean",
581      slide: "(boolean|string)",
582      pause: "(string|boolean)",
583      wrap: "boolean",
584      touch: "boolean",
585    },
586    K = "next",
587    X = "prev",
588    Y = "left",
589    Q = "right",
590    G = { ArrowLeft: Q, ArrowRight: Y };
591  class Z extends B {
592    constructor(e, i) {
593      super(e),
594        (this._items = null),
595        (this._interval = null),
596        (this._activeElement = null),
597        (this._isPaused = !1),
598        (this._isSliding = !1),
599        (this.touchTimeout = null),
600        (this.touchStartX = 0),
601        (this.touchDeltaX = 0),
602        (this._config = this._getConfig(i)),
603        (this._indicatorsElement = t.findOne(
604          ".carousel-indicators",
605          this._element
606        )),
607        (this._touchSupported =
608          "ontouchstart" in document.documentElement ||
609          navigator.maxTouchPoints > 0),
610        (this._pointerEvent = Boolean(window.PointerEvent)),
611        this._addEventListeners();
612    }
613    static get Default() {
614      return F;
615    }
616    static get NAME() {
617      return "carousel";
618    }
619    next() {
620      this._slide(K);
621    }
622    nextWhenVisible() {
623      !document.hidden && c(this._element) && this.next();
624    }
625    prev() {
626      this._slide(X);
627    }
628    pause(e) {
629      e || (this._isPaused = !0),
630        t.findOne(".carousel-item-next, .carousel-item-prev", this._element) &&
631          (o(this._element), this.cycle(!0)),
632        clearInterval(this._interval),
633        (this._interval = null);
634    }
635    cycle(t) {
636      t || (this._isPaused = !1),
637        this._interval &&
638          (clearInterval(this._interval), (this._interval = null)),
639        this._config &&
640          this._config.interval &&
641          !this._isPaused &&
642          (this._updateInterval(),
643          (this._interval = setInterval(
644            (document.visibilityState ? this.nextWhenVisible : this.next).bind(
645              this
646            ),
647            this._config.interval
648          )));
649    }
650    to(e) {
651      this._activeElement = t.findOne(".active.carousel-item", this._element);
652      const i = this._getItemIndex(this._activeElement);
653      if (e > this._items.length - 1 || e < 0) return;
654      if (this._isSliding)
655        return void P.one(this._element, "slid.bs.carousel", () => this.to(e));
656      if (i === e) return this.pause(), void this.cycle();
657      const n = e > i ? K : X;
658      this._slide(n, this._items[e]);
659    }
660    _getConfig(t) {
661      return (
662        (t = {
663          ...F,
664          ...U.getDataAttributes(this._element),
665          ...("object" == typeof t ? t : {}),
666        }),
667        l("carousel", t, V),
668        t
669      );
670    }
671    _handleSwipe() {
672      const t = Math.abs(this.touchDeltaX);
673      if (t <= 40) return;
674      const e = t / this.touchDeltaX;
675      (this.touchDeltaX = 0), e && this._slide(e > 0 ? Q : Y);
676    }
677    _addEventListeners() {
678      this._config.keyboard &&
679        P.on(this._element, "keydown.bs.carousel", (t) => this._keydown(t)),
680        "hover" === this._config.pause &&
681          (P.on(this._element, "mouseenter.bs.carousel", (t) => this.pause(t)),
682          P.on(this._element, "mouseleave.bs.carousel", (t) => this.cycle(t))),
683        this._config.touch &&
684          this._touchSupported &&
685          this._addTouchEventListeners();
686    }
687    _addTouchEventListeners() {
688      const e = (t) => {
689          !this._pointerEvent ||
690          ("pen" !== t.pointerType && "touch" !== t.pointerType)
691            ? this._pointerEvent || (this.touchStartX = t.touches[0].clientX)
692            : (this.touchStartX = t.clientX);
693        },
694        i = (t) => {
695          this.touchDeltaX =
696            t.touches && t.touches.length > 1
697              ? 0
698              : t.touches[0].clientX - this.touchStartX;
699        },
700        n = (t) => {
701          !this._pointerEvent ||
702            ("pen" !== t.pointerType && "touch" !== t.pointerType) ||
703            (this.touchDeltaX = t.clientX - this.touchStartX),
704            this._handleSwipe(),
705            "hover" === this._config.pause &&
706              (this.pause(),
707              this.touchTimeout && clearTimeout(this.touchTimeout),
708              (this.touchTimeout = setTimeout(
709                (t) => this.cycle(t),
710                500 + this._config.interval
711              )));
712        };
713      t.find(".carousel-item img", this._element).forEach((t) => {
714        P.on(t, "dragstart.bs.carousel", (t) => t.preventDefault());
715      }),
716        this._pointerEvent
717          ? (P.on(this._element, "pointerdown.bs.carousel", (t) => e(t)),
718            P.on(this._element, "pointerup.bs.carousel", (t) => n(t)),
719            this._element.classList.add("pointer-event"))
720          : (P.on(this._element, "touchstart.bs.carousel", (t) => e(t)),
721            P.on(this._element, "touchmove.bs.carousel", (t) => i(t)),
722            P.on(this._element, "touchend.bs.carousel", (t) => n(t)));
723    }
724    _keydown(t) {
725      if (/input|textarea/i.test(t.target.tagName)) return;
726      const e = G[t.key];
727      e && (t.preventDefault(), this._slide(e));
728    }
729    _getItemIndex(e) {
730      return (
731        (this._items =
732          e && e.parentNode ? t.find(".carousel-item", e.parentNode) : []),
733        this._items.indexOf(e)
734      );
735    }
736    _getItemByOrder(t, e) {
737      const i = t === K;
738      return y(this._items, e, i, this._config.wrap);
739    }
740    _triggerSlideEvent(e, i) {
741      const n = this._getItemIndex(e),
742        s = this._getItemIndex(
743          t.findOne(".active.carousel-item", this._element)
744        );
745      return P.trigger(this._element, "slide.bs.carousel", {
746        relatedTarget: e,
747        direction: i,
748        from: s,
749        to: n,
750      });
751    }
752    _setActiveIndicatorElement(e) {
753      if (this._indicatorsElement) {
754        const i = t.findOne(".active", this._indicatorsElement);
755        i.classList.remove("active"), i.removeAttribute("aria-current");
756        const n = t.find("[data-bs-target]", this._indicatorsElement);
757        for (let t = 0; t < n.length; t++)
758          if (
759            Number.parseInt(n[t].getAttribute("data-bs-slide-to"), 10) ===
760            this._getItemIndex(e)
761          ) {
762            n[t].classList.add("active"),
763              n[t].setAttribute("aria-current", "true");
764            break;
765          }
766      }
767    }
768    _updateInterval() {
769      const e =
770        this._activeElement ||
771        t.findOne(".active.carousel-item", this._element);
772      if (!e) return;
773      const i = Number.parseInt(e.getAttribute("data-bs-interval"), 10);
774      i
775        ? ((this._config.defaultInterval =
776            this._config.defaultInterval || this._config.interval),
777          (this._config.interval = i))
778        : (this._config.interval =
779            this._config.defaultInterval || this._config.interval);
780    }
781    _slide(e, i) {
782      const n = this._directionToOrder(e),
783        s = t.findOne(".active.carousel-item", this._element),
784        o = this._getItemIndex(s),
785        r = i || this._getItemByOrder(n, s),
786        a = this._getItemIndex(r),
787        l = Boolean(this._interval),
788        c = n === K,
789        h = c ? "carousel-item-start" : "carousel-item-end",
790        d = c ? "carousel-item-next" : "carousel-item-prev",
791        u = this._orderToDirection(n);
792      if (r && r.classList.contains("active"))
793        return void (this._isSliding = !1);
794      if (this._isSliding) return;
795      if (this._triggerSlideEvent(r, u).defaultPrevented) return;
796      if (!s || !r) return;
797      (this._isSliding = !0),
798        l && this.pause(),
799        this._setActiveIndicatorElement(r),
800        (this._activeElement = r);
801      const p = () => {
802        P.trigger(this._element, "slid.bs.carousel", {
803          relatedTarget: r,
804          direction: u,
805          from: o,
806          to: a,
807        });
808      };
809      if (this._element.classList.contains("slide")) {
810        r.classList.add(d), f(r), s.classList.add(h), r.classList.add(h);
811        const t = () => {
812          r.classList.remove(h, d),
813            r.classList.add("active"),
814            s.classList.remove("active", d, h),
815            (this._isSliding = !1),
816            setTimeout(p, 0);
817        };
818        this._queueCallback(t, s, !0);
819      } else s.classList.remove("active"), r.classList.add("active"), (this._isSliding = !1), p();
820      l && this.cycle();
821    }
822    _directionToOrder(t) {
823      return [Q, Y].includes(t)
824        ? g()
825          ? t === Y
826            ? X
827            : K
828          : t === Y
829          ? K
830          : X
831        : t;
832    }
833    _orderToDirection(t) {
834      return [K, X].includes(t)
835        ? g()
836          ? t === X
837            ? Y
838            : Q
839          : t === X
840          ? Q
841          : Y
842        : t;
843    }
844    static carouselInterface(t, e) {
845      const i = Z.getOrCreateInstance(t, e);
846      let { _config: n } = i;
847      "object" == typeof e && (n = { ...n, ...e });
848      const s = "string" == typeof e ? e : n.slide;
849      if ("number" == typeof e) i.to(e);
850      else if ("string" == typeof s) {
851        if (void 0 === i[s]) throw new TypeError(`No method named "${s}"`);
852        i[s]();
853      } else n.interval && n.ride && (i.pause(), i.cycle());
854    }
855    static jQueryInterface(t) {
856      return this.each(function () {
857        Z.carouselInterface(this, t);
858      });
859    }
860    static dataApiClickHandler(t) {
861      const e = s(this);
862      if (!e || !e.classList.contains("carousel")) return;
863      const i = { ...U.getDataAttributes(e), ...U.getDataAttributes(this) },
864        n = this.getAttribute("data-bs-slide-to");
865      n && (i.interval = !1),
866        Z.carouselInterface(e, i),
867        n && Z.getInstance(e).to(n),
868        t.preventDefault();
869    }
870  }
871  P.on(
872    document,
873    "click.bs.carousel.data-api",
874    "[data-bs-slide], [data-bs-slide-to]",
875    Z.dataApiClickHandler
876  ),
877    P.on(window, "load.bs.carousel.data-api", () => {
878      const e = t.find('[data-bs-ride="carousel"]');
879      for (let t = 0, i = e.length; t < i; t++)
880        Z.carouselInterface(e[t], Z.getInstance(e[t]));
881    }),
882    _(Z);
883  const J = { toggle: !0, parent: "" },
884    tt = { toggle: "boolean", parent: "(string|element)" };
885  class et extends B {
886    constructor(e, i) {
887      super(e),
888        (this._isTransitioning = !1),
889        (this._config = this._getConfig(i)),
890        (this._triggerArray = t.find(
891          `[data-bs-toggle="collapse"][href="#${this._element.id}"],[data-bs-toggle="collapse"][data-bs-target="#${this._element.id}"]`
892        ));
893      const s = t.find('[data-bs-toggle="collapse"]');
894      for (let e = 0, i = s.length; e < i; e++) {
895        const i = s[e],
896          o = n(i),
897          r = t.find(o).filter((t) => t === this._element);
898        null !== o &&
899          r.length &&
900          ((this._selector = o), this._triggerArray.push(i));
901      }
902      (this._parent = this._config.parent ? this._getParent() : null),
903        this._config.parent ||
904          this._addAriaAndCollapsedClass(this._element, this._triggerArray),
905        this._config.toggle && this.toggle();
906    }
907    static get Default() {
908      return J;
909    }
910    static get NAME() {
911      return "collapse";
912    }
913    toggle() {
914      this._element.classList.contains("show") ? this.hide() : this.show();
915    }
916    show() {
917      if (this._isTransitioning || this._element.classList.contains("show"))
918        return;
919      let e, i;
920      this._parent &&
921        ((e = t
922          .find(".show, .collapsing", this._parent)
923          .filter((t) =>
924            "string" == typeof this._config.parent
925              ? t.getAttribute("data-bs-parent") === this._config.parent
926              : t.classList.contains("collapse")
927          )),
928        0 === e.length && (e = null));
929      const n = t.findOne(this._selector);
930      if (e) {
931        const t = e.find((t) => n !== t);
932        if (((i = t ? et.getInstance(t) : null), i && i._isTransitioning))
933          return;
934      }
935      if (P.trigger(this._element, "show.bs.collapse").defaultPrevented) return;
936      e &&
937        e.forEach((t) => {
938          n !== t && et.collapseInterface(t, "hide"),
939            i || R.set(t, "bs.collapse", null);
940        });
941      const s = this._getDimension();
942      this._element.classList.remove("collapse"),
943        this._element.classList.add("collapsing"),
944        (this._element.style[s] = 0),
945        this._triggerArray.length &&
946          this._triggerArray.forEach((t) => {
947            t.classList.remove("collapsed"),
948              t.setAttribute("aria-expanded", !0);
949          }),
950        this.setTransitioning(!0);
951      const o = "scroll" + (s[0].toUpperCase() + s.slice(1));
952      this._queueCallback(
953        () => {
954          this._element.classList.remove("collapsing"),
955            this._element.classList.add("collapse", "show"),
956            (this._element.style[s] = ""),
957            this.setTransitioning(!1),
958            P.trigger(this._element, "shown.bs.collapse");
959        },
960        this._element,
961        !0
962      ),
963        (this._element.style[s] = this._element[o] + "px");
964    }
965    hide() {
966      if (this._isTransitioning || !this._element.classList.contains("show"))
967        return;
968      if (P.trigger(this._element, "hide.bs.collapse").defaultPrevented) return;
969      const t = this._getDimension();
970      (this._element.style[t] =
971        this._element.getBoundingClientRect()[t] + "px"),
972        f(this._element),
973        this._element.classList.add("collapsing"),
974        this._element.classList.remove("collapse", "show");
975      const e = this._triggerArray.length;
976      if (e > 0)
977        for (let t = 0; t < e; t++) {
978          const e = this._triggerArray[t],
979            i = s(e);
980          i &&
981            !i.classList.contains("show") &&
982            (e.classList.add("collapsed"), e.setAttribute("aria-expanded", !1));
983        }
984      this.setTransitioning(!0),
985        (this._element.style[t] = ""),
986        this._queueCallback(
987          () => {
988            this.setTransitioning(!1),
989              this._element.classList.remove("collapsing"),
990              this._element.classList.add("collapse"),
991              P.trigger(this._element, "hidden.bs.collapse");
992          },
993          this._element,
994          !0
995        );
996    }
997    setTransitioning(t) {
998      this._isTransitioning = t;
999    }
1000    _getConfig(t) {
1001      return (
1002        ((t = { ...J, ...t }).toggle = Boolean(t.toggle)),
1003        l("collapse", t, tt),
1004        t
1005      );
1006    }
1007    _getDimension() {
1008      return this._element.classList.contains("width") ? "width" : "height";
1009    }
1010    _getParent() {
1011      let { parent: e } = this._config;
1012      e = a(e);
1013      const i = `[data-bs-toggle="collapse"][data-bs-parent="${e}"]`;
1014      return (
1015        t.find(i, e).forEach((t) => {
1016          const e = s(t);
1017          this._addAriaAndCollapsedClass(e, [t]);
1018        }),
1019        e
1020      );
1021    }
1022    _addAriaAndCollapsedClass(t, e) {
1023      if (!t || !e.length) return;
1024      const i = t.classList.contains("show");
1025      e.forEach((t) => {
1026        i ? t.classList.remove("collapsed") : t.classList.add("collapsed"),
1027          t.setAttribute("aria-expanded", i);
1028      });
1029    }
1030    static collapseInterface(t, e) {
1031      let i = et.getInstance(t);
1032      const n = {
1033        ...J,
1034        ...U.getDataAttributes(t),
1035        ...("object" == typeof e && e ? e : {}),
1036      };
1037      if (
1038        (!i &&
1039          n.toggle &&
1040          "string" == typeof e &&
1041          /show|hide/.test(e) &&
1042          (n.toggle = !1),
1043        i || (i = new et(t, n)),
1044        "string" == typeof e)
1045      ) {

2393          !t.closest(".navbar-nav") &&
2394          []
2395            .concat(...document.body.children)
2396            .forEach((t) => P.on(t, "mouseover", u)),
2397          this._element.focus(),
2398          this._element.setAttribute("aria-expanded", !0),
2399          this._menu.classList.toggle("show"),
2400          this._element.classList.toggle("show"),
2401          P.trigger(this._element, "shown.bs.dropdown", e);
2402      }
2403    }
2404    hide() {
2405      if (h(this._element) || !this._menu.classList.contains("show")) return;
2406      const t = { relatedTarget: this._element };
2407      this._completeHide(t);
2408    }
2409    dispose() {
2410      this._popper && this._popper.destroy(), super.dispose();
2411    }
2412    update() {
2413      (this._inNavbar = this._detectNavbar()),
2414        this._popper && this._popper.update();
2415    }
2416    _addEventListeners() {
2417      P.on(this._element, "click.bs.dropdown", (t) => {
2418        t.preventDefault(), this.toggle();
2419      });
2420    }
2421    _completeHide(t) {
2422      P.trigger(this._element, "hide.bs.dropdown", t).defaultPrevented ||
2423        ("ontouchstart" in document.documentElement &&
2424          []
2425            .concat(...document.body.children)
2426            .forEach((t) => P.off(t, "mouseover", u)),
2427        this._popper && this._popper.destroy(),
2428        this._menu.classList.remove("show"),
2429        this._element.classList.remove("show"),
2430        this._element.setAttribute("aria-expanded", "false"),
2431        U.removeDataAttribute(this._menu, "popper"),
2432        P.trigger(this._element, "hidden.bs.dropdown", t));
2433    }
2434    _getConfig(t) {
2435      if (
2436        ((t = {
2437          ...this.constructor.Default,
2438          ...U.getDataAttributes(this._element),
2439          ...t,
2440        }),
2441        l("dropdown", t, this.constructor.DefaultType),
2442        "object" == typeof t.reference &&
2443          !r(t.reference) &&
2444          "function" != typeof t.reference.getBoundingClientRect)
2445      )
2446        throw new TypeError(
2447          "dropdown".toUpperCase() +
2448            ': Option "reference" provided type "object" without a required "getBoundingClientRect" method.'
2449        );
2450      return t;
2451    }
2452    _getMenuElement() {
2453      return t.next(this._element, ".dropdown-menu")[0];
2454    }
2455    _getPlacement() {
2456      const t = this._element.parentNode;
2457      if (t.classList.contains("dropend")) return ve;
2458      if (t.classList.contains("dropstart")) return ye;
2459      const e =
2460        "end" ===
2461        getComputedStyle(this._menu).getPropertyValue("--bs-position").trim();
2462      return t.classList.contains("dropup") ? (e ? ge : me) : e ? be : _e;
2463    }
2464    _detectNavbar() {
2465      return null !== this._element.closest(".navbar");
2466    }
2467    _getOffset() {
2468      const { offset: t } = this._config;
2469      return "string" == typeof t
2470        ? t.split(",").map((t) => Number.parseInt(t, 10))
2471        : "function" == typeof t
2472        ? (e) => t(e, this._element)
2473        : t;
2474    }
2475    _getPopperConfig() {
2476      const t = {
2477        placement: this._getPlacement(),
2478        modifiers: [
2479          {
2480            name: "preventOverflow",
2481            options: { boundary: this._config.boundary },
2482          },
2483          { name: "offset", options: { offset: this._getOffset() } },
2484        ],
2485      };
2486      return (
2487        "static" === this._config.display &&
2488          (t.modifiers = [{ name: "applyStyles", enabled: !1 }]),
2489        {
2490          ...t,
2491          ...("function" == typeof this._config.popperConfig
2492            ? this._config.popperConfig(t)
2493            : this._config.popperConfig),
2494        }
2495      );
2496    }
2497    _selectMenuItem({ key: e, target: i }) {
2498      const n = t
2499        .find(
2500          ".dropdown-menu .dropdown-item:not(.disabled):not(:disabled)",
2501          this._menu
2502        )
2503        .filter(c);
2504      n.length && y(n, i, "ArrowDown" === e, !n.includes(i)).focus();
2505    }
2506    static dropdownInterface(t, e) {
2507      const i = Ae.getOrCreateInstance(t, e);
2508      if ("string" == typeof e) {
2509        if (void 0 === i[e]) throw new TypeError(`No method named "${e}"`);
2510        i[e]();
2511      }
2512    }
2513    static jQueryInterface(t) {
2514      return this.each(function () {
2515        Ae.dropdownInterface(this, t);
2516      });
2517    }
2518    static clearMenus(e) {
2519      if (e && (2 === e.button || ("keyup" === e.type && "Tab" !== e.key)))
2520        return;
2521      const i = t.find('[data-bs-toggle="dropdown"]');
2522      for (let t = 0, n = i.length; t < n; t++) {
2523        const n = Ae.getInstance(i[t]);
2524        if (!n || !1 === n._config.autoClose) continue;
2525        if (!n._element.classList.contains("show")) continue;
2526        const s = { relatedTarget: n._element };
2527        if (e) {
2528          const t = e.composedPath(),
2529            i = t.includes(n._menu);
2530          if (
2531            t.includes(n._element) ||
2532            ("inside" === n._config.autoClose && !i) ||
2533            ("outside" === n._config.autoClose && i)
2534          )
2535            continue;
2536          if (
2537            n._menu.contains(e.target) &&
2538            (("keyup" === e.type && "Tab" === e.key) ||
2539              /input|select|option|textarea|form/i.test(e.target.tagName))
2540          )
2541            continue;
2542          "click" === e.type && (s.clickEvent = e);
2543        }
2544        n._completeHide(s);
2545      }
2546    }
2547    static getParentFromElement(t) {
2548      return s(t) || t.parentNode;
2549    }
2550    static dataApiKeydownHandler(e) {
2551      if (
2552        /input|textarea/i.test(e.target.tagName)
2553          ? "Space" === e.key ||
2554            ("Escape" !== e.key &&
2555              (("ArrowDown" !== e.key && "ArrowUp" !== e.key) ||
2556                e.target.closest(".dropdown-menu")))
2557          : !pe.test(e.key)
2558      )
2559        return;
2560      const i = this.classList.contains("show");
2561      if (!i && "Escape" === e.key) return;
2562      if ((e.preventDefault(), e.stopPropagation(), h(this))) return;
2563      const n = () =>
2564        this.matches('[data-bs-toggle="dropdown"]')
2565          ? this
2566          : t.prev(this, '[data-bs-toggle="dropdown"]')[0];
2567      return "Escape" === e.key
2568        ? (n().focus(), void Ae.clearMenus())
2569        : "ArrowUp" === e.key || "ArrowDown" === e.key
2570        ? (i || n().click(), void Ae.getInstance(n())._selectMenuItem(e))
2571        : void ((i && "Space" !== e.key) || Ae.clearMenus());
2572    }
2573  }
2574  P.on(
2575    document,
2576    "keydown.bs.dropdown.data-api",
2577    '[data-bs-toggle="dropdown"]',
2578    Ae.dataApiKeydownHandler
2579  ),
2580    P.on(
2581      document,
2582      "keydown.bs.dropdown.data-api",
2583      ".dropdown-menu",
2584      Ae.dataApiKeydownHandler
2585    ),
2586    P.on(document, "click.bs.dropdown.data-api", Ae.clearMenus),
2587    P.on(document, "keyup.bs.dropdown.data-api", Ae.clearMenus),
2588    P.on(
2589      document,
2590      "click.bs.dropdown.data-api",
2591      '[data-bs-toggle="dropdown"]',
2592      function (t) {
2593        t.preventDefault(), Ae.dropdownInterface(this);
2594      }
2595    ),
2596    _(Ae);
2597  class Te {
2598    constructor() {
2599      this._element = document.body;
2600    }
2601    getWidth() {
2602      const t = document.documentElement.clientWidth;
2603      return Math.abs(window.innerWidth - t);
2604    }
2605    hide() {
2606      const t = this.getWidth();
2607      this._disableOverFlow(),
2608        this._setElementAttributes(this._element, "paddingRight", (e) => e + t),
2609        this._setElementAttributes(
2610          ".fixed-top, .fixed-bottom, .is-fixed, .sticky-top",
2611          "paddingRight",
2612          (e) => e + t
2613        ),
2614        this._setElementAttributes(".sticky-top", "marginRight", (e) => e - t);
2615    }
2616    _disableOverFlow() {
2617      this._saveInitialAttribute(this._element, "overflow"),
2618        (this._element.style.overflow = "hidden");
2619    }
2620    _setElementAttributes(t, e, i) {
2621      const n = this.getWidth();
2622      this._applyManipulationCallback(t, (t) => {
2623        if (t !== this._element && window.innerWidth > t.clientWidth + n)
2624          return;
2625        this._saveInitialAttribute(t, e);
2626        const s = window.getComputedStyle(t)[e];
2627        t.style[e] = i(Number.parseFloat(s)) + "px";
2628      });
2629    }
2630    reset() {
2631      this._resetElementAttributes(this._element, "overflow"),
2632        this._resetElementAttributes(this._element, "paddingRight"),
2633        this._resetElementAttributes(
2634          ".fixed-top, .fixed-bottom, .is-fixed, .sticky-top",
2635          "paddingRight"
2636        ),
2637        this._resetElementAttributes(".sticky-top", "marginRight");
2638    }
2639    _saveInitialAttribute(t, e) {
2640      const i = t.style[e];
2641      i && U.setDataAttribute(t, e, i);
2642    }
2643    _resetElementAttributes(t, e) {
2644      this._applyManipulationCallback(t, (t) => {
2645        const i = U.getDataAttribute(t, e);
2646        void 0 === i
2647          ? t.style.removeProperty(e)
2648          : (U.removeDataAttribute(t, e), (t.style[e] = i));
2649      });
2650    }
2651    _applyManipulationCallback(e, i) {
2652      r(e) ? i(e) : t.find(e, this._element).forEach(i);
2653    }
2654    isOverflowing() {
2655      return this.getWidth() > 0;
2656    }
2657  }
2658  const Oe = {
2659      isVisible: !0,
2660      isAnimated: !1,
2661      rootElement: "body",
2662      clickCallback: null,
2663    },
2664    Ce = {
2665      isVisible: "boolean",
2666      isAnimated: "boolean",
2667      rootElement: "(element|string)",
2668      clickCallback: "(function|null)",
2669    };
2670  class ke {
2671    constructor(t) {
2672      (this._config = this._getConfig(t)),
2673        (this._isAppended = !1),
2674        (this._element = null);
2675    }
2676    show(t) {
2677      this._config.isVisible
2678        ? (this._append(),
2679          this._config.isAnimated && f(this._getElement()),
2680          this._getElement().classList.add("show"),
2681          this._emulateAnimation(() => {
2682            b(t);
2683          }))
2684        : b(t);
2685    }
2686    hide(t) {
2687      this._config.isVisible
2688        ? (this._getElement().classList.remove("show"),
2689          this._emulateAnimation(() => {
2690            this.dispose(), b(t);
2691          }))
2692        : b(t);
2693    }
2694    _getElement() {
2695      if (!this._element) {
2696        const t = document.createElement("div");
2697        (t.className = "modal-backdrop"),
2698          this._config.isAnimated && t.classList.add("fade"),
2699          (this._element = t);
2700      }
2701      return this._element;
2702    }
2703    _getConfig(t) {
2704      return (
2705        ((t = { ...Oe, ...("object" == typeof t ? t : {}) }).rootElement = a(
2706          t.rootElement
2707        )),
2708        l("backdrop", t, Ce),
2709        t
2710      );
2711    }
2712    _append() {
2713      this._isAppended ||
2714        (this._config.rootElement.appendChild(this._getElement()),
2715        P.on(this._getElement(), "mousedown.bs.backdrop", () => {
2716          b(this._config.clickCallback);
2717        }),
2718        (this._isAppended = !0));
2719    }
2720    dispose() {
2721      this._isAppended &&
2722        (P.off(this._element, "mousedown.bs.backdrop"),
2723        this._element.remove(),
2724        (this._isAppended = !1));
2725    }
2726    _emulateAnimation(t) {
2727      v(t, this._getElement(), this._config.isAnimated);
2728    }
2729  }
2730  const Le = { backdrop: !0, keyboard: !0, focus: !0 },
2731    xe = {
2732      backdrop: "(boolean|string)",
2733      keyboard: "boolean",
2734      focus: "boolean",
2735    };
2736  class De extends B {
2737    constructor(e, i) {
2738      super(e),
2739        (this._config = this._getConfig(i)),
2740        (this._dialog = t.findOne(".modal-dialog", this._element)),
2741        (this._backdrop = this._initializeBackDrop()),
2742        (this._isShown = !1),
2743        (this._ignoreBackdropClick = !1),
2744        (this._isTransitioning = !1),
2745        (this._scrollBar = new Te());
2746    }
2747    static get Default() {
2748      return Le;
2749    }
2750    static get NAME() {
2751      return "modal";
2752    }
2753    toggle(t) {
2754      return this._isShown ? this.hide() : this.show(t);
2755    }
2756    show(t) {
2757      this._isShown ||
2758        this._isTransitioning ||
2759        P.trigger(this._element, "show.bs.modal", { relatedTarget: t })
2760          .defaultPrevented ||
2761        ((this._isShown = !0),
2762        this._isAnimated() && (this._isTransitioning = !0),
2763        this._scrollBar.hide(),
2764        document.body.classList.add("modal-open"),
2765        this._adjustDialog(),
2766        this._setEscapeEvent(),
2767        this._setResizeEvent(),
2768        P.on(
2769          this._element,
2770          "click.dismiss.bs.modal",
2771          '[data-bs-dismiss="modal"]',
2772          (t) => this.hide(t)
2773        ),
2774        P.on(this._dialog, "mousedown.dismiss.bs.modal", () => {
2775          P.one(this._element, "mouseup.dismiss.bs.modal", (t) => {
2776            t.target === this._element && (this._ignoreBackdropClick = !0);
2777          });
2778        }),
2779        this._showBackdrop(() => this._showElement(t)));
2780    }
2781    hide(t) {
2782      if (
2783        (t && ["A", "AREA"].includes(t.target.tagName) && t.preventDefault(),
2784        !this._isShown || this._isTransitioning)
2785      )
2786        return;
2787      if (P.trigger(this._element, "hide.bs.modal").defaultPrevented) return;
2788      this._isShown = !1;
2789      const e = this._isAnimated();
2790      e && (this._isTransitioning = !0),
2791        this._setEscapeEvent(),
2792        this._setResizeEvent(),
2793        P.off(document, "focusin.bs.modal"),
2794        this._element.classList.remove("show"),
2795        P.off(this._element, "click.dismiss.bs.modal"),
2796        P.off(this._dialog, "mousedown.dismiss.bs.modal"),
2797        this._queueCallback(() => this._hideModal(), this._element, e);
2798    }
2799    dispose() {
2800      [window, this._dialog].forEach((t) => P.off(t, ".bs.modal")),
2801        this._backdrop.dispose(),
2802        super.dispose(),
2803        P.off(document, "focusin.bs.modal");
2804    }
2805    handleUpdate() {
2806      this._adjustDialog();
2807    }
2808    _initializeBackDrop() {
2809      return new ke({
2810        isVisible: Boolean(this._config.backdrop),
2811        isAnimated: this._isAnimated(),
2812      });
2813    }
2814    _getConfig(t) {
2815      return (
2816        (t = {
2817          ...Le,
2818          ...U.getDataAttributes(this._element),
2819          ...("object" == typeof t ? t : {}),
2820        }),
2821        l("modal", t, xe),
2822        t
2823      );
2824    }
2825    _showElement(e) {
2826      const i = this._isAnimated(),
2827        n = t.findOne(".modal-body", this._dialog);
2828      (this._element.parentNode &&
2829        this._element.parentNode.nodeType === Node.ELEMENT_NODE) ||
2830        document.body.appendChild(this._element),
2831        (this._element.style.display = "block"),
2832        this._element.removeAttribute("aria-hidden"),
2833        this._element.setAttribute("aria-modal", !0),
2834        this._element.setAttribute("role", "dialog"),
2835        (this._element.scrollTop = 0),
2836        n && (n.scrollTop = 0),
2837        i && f(this._element),
2838        this._element.classList.add("show"),
2839        this._config.focus && this._enforceFocus(),
2840        this._queueCallback(
2841          () => {
2842            this._config.focus && this._element.focus(),
2843              (this._isTransitioning = !1),
2844              P.trigger(this._element, "shown.bs.modal", { relatedTarget: e });
2845          },
2846          this._dialog,
2847          i
2848        );
2849    }
2850    _enforceFocus() {
2851      P.off(document, "focusin.bs.modal"),
2852        P.on(document, "focusin.bs.modal", (t) => {
2853          document === t.target ||
2854            this._element === t.target ||
2855            this._element.contains(t.target) ||
2856            this._element.focus();
2857        });
2858    }
2859    _setEscapeEvent() {
2860      this._isShown
2861        ? P.on(this._element, "keydown.dismiss.bs.modal", (t) => {
2862            this._config.keyboard && "Escape" === t.key
2863              ? (t.preventDefault(), this.hide())
2864              : this._config.keyboard ||
2865                "Escape" !== t.key ||
2866                this._triggerBackdropTransition();
2867          })
2868        : P.off(this._element, "keydown.dismiss.bs.modal");
2869    }
2870    _setResizeEvent() {
2871      this._isShown
2872        ? P.on(window, "resize.bs.modal", () => this._adjustDialog())
2873        : P.off(window, "resize.bs.modal");
2874    }
2875    _hideModal() {
2876      (this._element.style.display = "none"),
2877        this._element.setAttribute("aria-hidden", !0),
2878        this._element.removeAttribute("aria-modal"),
2879        this._element.removeAttribute("role"),
2880        (this._isTransitioning = !1),
2881        this._backdrop.hide(() => {
2882          document.body.classList.remove("modal-open"),
2883            this._resetAdjustments(),
2884            this._scrollBar.reset(),
2885            P.trigger(this._element, "hidden.bs.modal");
2886        });
2887    }
2888    _showBackdrop(t) {
2889      P.on(this._element, "click.dismiss.bs.modal", (t) => {
2890        this._ignoreBackdropClick
2891          ? (this._ignoreBackdropClick = !1)
2892          : t.target === t.currentTarget &&
2893            (!0 === this._config.backdrop
2894              ? this.hide()
2895              : "static" === this._config.backdrop &&
2896                this._triggerBackdropTransition());
2897      }),
2898        this._backdrop.show(t);
2899    }
2900    _isAnimated() {
2901      return this._element.classList.contains("fade");
2902    }
2903    _triggerBackdropTransition() {
2904      if (P.trigger(this._element, "hidePrevented.bs.modal").defaultPrevented)
2905        return;
2906      const { classList: t, scrollHeight: e, style: i } = this._element,
2907        n = e > document.documentElement.clientHeight;
2908      (!n && "hidden" === i.overflowY) ||
2909        t.contains("modal-static") ||
2910        (n || (i.overflowY = "hidden"),
2911        t.add("modal-static"),
2912        this._queueCallback(() => {
2913          t.remove("modal-static"),
2914            n ||
2915              this._queueCallback(() => {
2916                i.overflowY = "";
2917              }, this._dialog);
2918        }, this._dialog),
2919        this._element.focus());
2920    }
2921    _adjustDialog() {
2922      const t =
2923          this._element.scrollHeight > document.documentElement.clientHeight,
2924        e = this._scrollBar.getWidth(),
2925        i = e > 0;
2926      ((!i && t && !g()) || (i && !t && g())) &&
2927        (this._element.style.paddingLeft = e + "px"),
2928        ((i && !t && !g()) || (!i && t && g())) &&
2929          (this._element.style.paddingRight = e + "px");
2930    }
2931    _resetAdjustments() {
2932      (this._element.style.paddingLeft = ""),
2933        (this._element.style.paddingRight = "");
2934    }
2935    static jQueryInterface(t, e) {
2936      return this.each(function () {
2937        const i = De.getOrCreateInstance(this, t);
2938        if ("string" == typeof t) {
2939          if (void 0 === i[t]) throw new TypeError(`No method named "${t}"`);
2940          i[t](e);
2941        }
2942      });
2943    }
2944  }
2945  P.on(
2946    document,
2947    "click.bs.modal.data-api",
2948    '[data-bs-toggle="modal"]',
2949    function (t) {
2950      const e = s(this);
2951      ["A", "AREA"].includes(this.tagName) && t.preventDefault(),
2952        P.one(e, "show.bs.modal", (t) => {
2953          t.defaultPrevented ||
2954            P.one(e, "hidden.bs.modal", () => {
2955              c(this) && this.focus();
2956            });
2957        }),
2958        De.getOrCreateInstance(e).toggle(this);
2959    }
2960  ),
2961    _(De);
2962  const Se = { backdrop: !0, keyboard: !0, scroll: !1 },
2963    Ie = { backdrop: "boolean", keyboard: "boolean", scroll: "boolean" };
2964  class Ne extends B {
2965    constructor(t, e) {
2966      super(t),
2967        (this._config = this._getConfig(e)),
2968        (this._isShown = !1),
2969        (this._backdrop = this._initializeBackDrop()),
2970        this._addEventListeners();
2971    }
2972    static get NAME() {
2973      return "offcanvas";
2974    }
2975    static get Default() {
2976      return Se;
2977    }
2978    toggle(t) {
2979      return this._isShown ? this.hide() : this.show(t);
2980    }
2981    show(t) {
2982      this._isShown ||
2983        P.trigger(this._element, "show.bs.offcanvas", { relatedTarget: t })
2984          .defaultPrevented ||
2985        ((this._isShown = !0),
2986        (this._element.style.visibility = "visible"),
2987        this._backdrop.show(),
2988        this._config.scroll ||
2989          (new Te().hide(), this._enforceFocusOnElement(this._element)),
2990        this._element.removeAttribute("aria-hidden"),
2991        this._element.setAttribute("aria-modal", !0),
2992        this._element.setAttribute("role", "dialog"),
2993        this._element.classList.add("show"),
2994        this._queueCallback(
2995          () => {
2996            P.trigger(this._element, "shown.bs.offcanvas", {
2997              relatedTarget: t,
2998            });
2999          },
3000          this._element,
3001          !0
3002        ));
3003    }
3004    hide() {
3005      this._isShown &&
3006        (P.trigger(this._element, "hide.bs.offcanvas").defaultPrevented ||
3007          (P.off(document, "focusin.bs.offcanvas"),
3008          this._element.blur(),
3009          (this._isShown = !1),
3010          this._element.classList.remove("show"),
3011          this._backdrop.hide(),
3012          this._queueCallback(
3013            () => {
3014              this._element.setAttribute("aria-hidden", !0),
3015                this._element.removeAttribute("aria-modal"),
3016                this._element.removeAttribute("role"),
3017                (this._element.style.visibility = "hidden"),
3018                this._config.scroll || new Te().reset(),
3019                P.trigger(this._element, "hidden.bs.offcanvas");
3020            },
3021            this._element,
3022            !0
3023          )));
3024    }
3025    dispose() {
3026      this._backdrop.dispose(),
3027        super.dispose(),
3028        P.off(document, "focusin.bs.offcanvas");
3029    }
3030    _getConfig(t) {
3031      return (
3032        (t = {
3033          ...Se,
3034          ...U.getDataAttributes(this._element),
3035          ...("object" == typeof t ? t : {}),
3036        }),
3037        l("offcanvas", t, Ie),
3038        t
3039      );
3040    }
3041    _initializeBackDrop() {
3042      return new ke({
3043        isVisible: this._config.backdrop,
3044        isAnimated: !0,
3045        rootElement: this._element.parentNode,
3046        clickCallback: () => this.hide(),
3047      });
3048    }
3049    _enforceFocusOnElement(t) {
3050      P.off(document, "focusin.bs.offcanvas"),
3051        P.on(document, "focusin.bs.offcanvas", (e) => {
3052          document === e.target ||
3053            t === e.target ||
3054            t.contains(e.target) ||
3055            t.focus();
3056        }),
3057        t.focus();
3058    }
3059    _addEventListeners() {
3060      P.on(
3061        this._element,
3062        "click.dismiss.bs.offcanvas",
3063        '[data-bs-dismiss="offcanvas"]',
3064        () => this.hide()
3065      ),
3066        P.on(this._element, "keydown.dismiss.bs.offcanvas", (t) => {
3067          this._config.keyboard && "Escape" === t.key && this.hide();
3068        });
3069    }
3070    static jQueryInterface(t) {
3071      return this.each(function () {
3072        const e = Ne.getOrCreateInstance(this, t);
3073        if ("string" == typeof t) {
3074          if (void 0 === e[t] || t.startsWith("_") || "constructor" === t)
3075            throw new TypeError(`No method named "${t}"`);
3076          e[t](this);
3077        }
3078      });
3079    }
3080  }
3081  P.on(
3082    document,
3083    "click.bs.offcanvas.data-api",
3084    '[data-bs-toggle="offcanvas"]',
3085    function (e) {
3086      const i = s(this);
3087      if ((["A", "AREA"].includes(this.tagName) && e.preventDefault(), h(this)))
3088        return;
3089      P.one(i, "hidden.bs.offcanvas", () => {
3090        c(this) && this.focus();
3091      });
3092      const n = t.findOne(".offcanvas.show");
3093      n && n !== i && Ne.getInstance(n).hide(),
3094        Ne.getOrCreateInstance(i).toggle(this);
3095    }
3096  ),
3097    P.on(window, "load.bs.offcanvas.data-api", () =>
3098      t.find(".offcanvas.show").forEach((t) => Ne.getOrCreateInstance(t).show())
3099    ),
3100    _(Ne);
3101  const je = new Set([
3102      "background",
3103      "cite",
3104      "href",
3105      "itemtype",
3106      "longdesc",
3107      "poster",
3108      "src",
3109      "xlink:href",
3110    ]),
3111    Me = /^(?:(?:https?|mailto|ftp|tel|file):|[^#&/:?]*(?:[#/?]|$))/i,
3112    Pe =
3113      /^data:(?:image\/(?:bmp|gif|jpeg|jpg|png|tiff|webp)|video\/(?:mpeg|mp4|ogg|webm)|audio\/(?:mp3|oga|ogg|opus));base64,[\d+/a-z]+=*$/i,
3114    He = (t, e) => {
3115      const i = t.nodeName.toLowerCase();
3116      if (e.includes(i))
3117        return (
3118          !je.has(i) || Boolean(Me.test(t.nodeValue) || Pe.test(t.nodeValue))
3119        );
3120      const n = e.filter((t) => t instanceof RegExp);
3121      for (let t = 0, e = n.length; t < e; t++) if (n[t].test(i)) return !0;
3122      return !1;
3123    };
3124  function Re(t, e, i) {
3125    if (!t.length) return t;
3126    if (i && "function" == typeof i) return i(t);
3127    const n = new window.DOMParser().parseFromString(t, "text/html"),
3128      s = Object.keys(e),
3129      o = [].concat(...n.body.querySelectorAll("*"));
3130    for (let t = 0, i = o.length; t < i; t++) {
3131      const i = o[t],
3132        n = i.nodeName.toLowerCase();
3133      if (!s.includes(n)) {
3134        i.remove();
3135        continue;
3136      }
3137      const r = [].concat(...i.attributes),
3138        a = [].concat(e["*"] || [], e[n] || []);
3139      r.forEach((t) => {
3140        He(t, a) || i.removeAttribute(t.nodeName);
3141      });
3142    }
3143    return n.body.innerHTML;
3144  }
3145  const Be = new RegExp("(^|\\s)bs-tooltip\\S+", "g"),
3146    We = new Set(["sanitize", "allowList", "sanitizeFn"]),
3147    qe = {
3148      animation: "boolean",
3149      template: "string",
3150      title: "(string|element|function)",
3151      trigger: "string",
3152      delay: "(number|object)",
3153      html: "boolean",
3154      selector: "(string|boolean)",
3155      placement: "(string|function)",
3156      offset: "(array|string|function)",
3157      container: "(string|element|boolean)",
3158      fallbackPlacements: "array",
3159      boundary: "(string|element)",
3160      customClass: "(string|function)",
3161      sanitize: "boolean",
3162      sanitizeFn: "(null|function)",
3163      allowList: "object",
3164      popperConfig: "(null|object|function)",
3165    },
3166    ze = {
3167      AUTO: "auto",
3168      TOP: "top",
3169      RIGHT: g() ? "left" : "right",
3170      BOTTOM: "bottom",
3171      LEFT: g() ? "right" : "left",
3172    },
3173    $e = {
3174      animation: !0,
3175      template:
3176        '<div class="tooltip" role="tooltip"><div class="tooltip-arrow"></div><div class="tooltip-inner"></div></div>',
3177      trigger: "hover focus",
3178      title: "",
3179      delay: 0,
3180      html: !1,
3181      selector: !1,
3182      placement: "top",
3183      offset: [0, 0],
3184      container: !1,
3185      fallbackPlacements: ["top", "right", "bottom", "left"],
3186      boundary: "clippingParents",
3187      customClass: "",
3188      sanitize: !0,
3189      sanitizeFn: null,
3190      allowList: {
3191        "*": ["class", "dir", "id", "lang", "role", /^aria-[\w-]*$/i],
3192        a: ["target", "href", "title", "rel"],
3193        area: [],
3194        b: [],
3195        br: [],
3196        col: [],
3197        code: [],
3198        div: [],
3199        em: [],
3200        hr: [],
3201        h1: [],
3202        h2: [],
3203        h3: [],
3204        h4: [],
3205        h5: [],
3206        h6: [],
3207        i: [],
3208        img: ["src", "srcset", "alt", "title", "width", "height"],
3209        li: [],
3210        ol: [],
3211        p: [],
3212        pre: [],
3213        s: [],
3214        small: [],
3215        span: [],
3216        sub: [],
3217        sup: [],
3218        strong: [],
3219        u: [],
3220        ul: [],
3221      },
3222      popperConfig: null,
3223    },
3224    Ue = {
3225      HIDE: "hide.bs.tooltip",
3226      HIDDEN: "hidden.bs.tooltip",
3227      SHOW: "show.bs.tooltip",
3228      SHOWN: "shown.bs.tooltip",
3229      INSERTED: "inserted.bs.tooltip",
3230      CLICK: "click.bs.tooltip",
3231      FOCUSIN: "focusin.bs.tooltip",
3232      FOCUSOUT: "focusout.bs.tooltip",
3233      MOUSEENTER: "mouseenter.bs.tooltip",
3234      MOUSELEAVE: "mouseleave.bs.tooltip",
3235    };
3236  class Fe extends B {
3237    constructor(t, e) {
3238      if (void 0 === fe)
3239        throw new TypeError(
3240          "Bootstrap's tooltips require Popper (https://popper.js.org)"
3241        );
3242      super(t),
3243        (this._isEnabled = !0),
3244        (this._timeout = 0),
3245        (this._hoverState = ""),
3246        (this._activeTrigger = {}),
3247        (this._popper = null),
3248        (this._config = this._getConfig(e)),
3249        (this.tip = null),
3250        this._setListeners();
3251    }
3252    static get Default() {
3253      return $e;
3254    }
3255    static get NAME() {
3256      return "tooltip";
3257    }
3258    static get Event() {
3259      return Ue;
3260    }
3261    static get DefaultType() {
3262      return qe;
3263    }
3264    enable() {
3265      this._isEnabled = !0;
3266    }
3267    disable() {
3268      this._isEnabled = !1;
3269    }
3270    toggleEnabled() {
3271      this._isEnabled = !this._isEnabled;
3272    }
3273    toggle(t) {
3274      if (this._isEnabled)
3275        if (t) {
3276          const e = this._initializeOnDelegatedTarget(t);
3277          (e._activeTrigger.click = !e._activeTrigger.click),
3278            e._isWithActiveTrigger() ? e._enter(null, e) : e._leave(null, e);
3279        } else {
3280          if (this.getTipElement().classList.contains("show"))
3281            return void this._leave(null, this);
3282          this._enter(null, this);
3283        }
3284    }
3285    dispose() {
3286      clearTimeout(this._timeout),
3287        P.off(
3288          this._element.closest(".modal"),
3289          "hide.bs.modal",
3290          this._hideModalHandler
3291        ),
3292        this.tip && this.tip.remove(),
3293        this._popper && this._popper.destroy(),
3294        super.dispose();
3295    }
3296    show() {
3297      if ("none" === this._element.style.display)
3298        throw new Error("Please use show on visible elements");
3299      if (!this.isWithContent() || !this._isEnabled) return;
3300      const t = P.trigger(this._element, this.constructor.Event.SHOW),
3301        i = d(this._element),
3302        n =
3303          null === i
3304            ? this._element.ownerDocument.documentElement.contains(
3305                this._element
3306              )
3307            : i.contains(this._element);
3308      if (t.defaultPrevented || !n) return;
3309      const s = this.getTipElement(),
3310        o = e(this.constructor.NAME);
3311      s.setAttribute("id", o),
3312        this._element.setAttribute("aria-describedby", o),
3313        this.setContent(),
3314        this._config.animation && s.classList.add("fade");
3315      const r =
3316          "function" == typeof this._config.placement
3317            ? this._config.placement.call(this, s, this._element)
3318            : this._config.placement,
3319        a = this._getAttachment(r);
3320      this._addAttachmentClass(a);
3321      const { container: l } = this._config;
3322      R.set(s, this.constructor.DATA_KEY, this),
3323        this._element.ownerDocument.documentElement.contains(this.tip) ||
3324          (l.appendChild(s),
3325          P.trigger(this._element, this.constructor.Event.INSERTED)),
3326        this._popper
3327          ? this._popper.update()
3328          : (this._popper = ue(this._element, s, this._getPopperConfig(a))),
3329        s.classList.add("show");
3330      const c =
3331        "function" == typeof this._config.customClass
3332          ? this._config.customClass()
3333          : this._config.customClass;
3334      c && s.classList.add(...c.split(" ")),
3335        "ontouchstart" in document.documentElement &&
3336          [].concat(...document.body.children).forEach((t) => {
3337            P.on(t, "mouseover", u);
3338          });
3339      const h = this.tip.classList.contains("fade");
3340      this._queueCallback(
3341        () => {
3342          const t = this._hoverState;
3343          (this._hoverState = null),
3344            P.trigger(this._element, this.constructor.Event.SHOWN),
3345            "out" === t && this._leave(null, this);
3346        },
3347        this.tip,
3348        h
3349      );
3350    }
3351    hide() {
3352      if (!this._popper) return;
3353      const t = this.getTipElement();
3354      if (
3355        P.trigger(this._element, this.constructor.Event.HIDE).defaultPrevented
3356      )
3357        return;
3358      t.classList.remove("show"),
3359        "ontouchstart" in document.documentElement &&
3360          []
3361            .concat(...document.body.children)
3362            .forEach((t) => P.off(t, "mouseover", u)),
3363        (this._activeTrigger.click = !1),
3364        (this._activeTrigger.focus = !1),
3365        (this._activeTrigger.hover = !1);
3366      const e = this.tip.classList.contains("fade");
3367      this._queueCallback(
3368        () => {
3369          this._isWithActiveTrigger() ||
3370            ("show" !== this._hoverState && t.remove(),
3371            this._cleanTipClass(),
3372            this._element.removeAttribute("aria-describedby"),
3373            P.trigger(this._element, this.constructor.Event.HIDDEN),
3374            this._popper && (this._popper.destroy(), (this._popper = null)));
3375        },
3376        this.tip,
3377        e
3378      ),
3379        (this._hoverState = "");
3380    }
3381    update() {
3382      null !== this._popper && this._popper.update();
3383    }
3384    isWithContent() {
3385      return Boolean(this.getTitle());
3386    }
3387    getTipElement() {
3388      if (this.tip) return this.tip;
3389      const t = document.createElement("div");
3390      return (
3391        (t.innerHTML = this._config.template),
3392        (this.tip = t.children[0]),
3393        this.tip
3394      );
3395    }
3396    setContent() {
3397      const e = this.getTipElement();
3398      this.setElementContent(t.findOne(".tooltip-inner", e), this.getTitle()),
3399        e.classList.remove("fade", "show");
3400    }
3401    setElementContent(t, e) {
3402      if (null !== t)
3403        return r(e)
3404          ? ((e = a(e)),
3405            void (this._config.html
3406              ? e.parentNode !== t && ((t.innerHTML = ""), t.appendChild(e))
3407              : (t.textContent = e.textContent)))
3408          : void (this._config.html
3409              ? (this._config.sanitize &&
3410                  (e = Re(e, this._config.allowList, this._config.sanitizeFn)),
3411                (t.innerHTML = e))
3412              : (t.textContent = e));
3413    }
3414    getTitle() {
3415      let t = this._element.getAttribute("data-bs-original-title");
3416      return (
3417        t ||
3418          (t =
3419            "function" == typeof this._config.title
3420              ? this._config.title.call(this._element)
3421              : this._config.title),
3422        t
3423      );
3424    }
3425    updateAttachment(t) {
3426      return "right" === t ? "end" : "left" === t ? "start" : t;
3427    }
3428    _initializeOnDelegatedTarget(t, e) {
3429      const i = this.constructor.DATA_KEY;
3430      return (
3431        (e = e || R.get(t.delegateTarget, i)) ||
3432          ((e = new this.constructor(
3433            t.delegateTarget,
3434            this._getDelegateConfig()
3435          )),
3436          R.set(t.delegateTarget, i, e)),
3437        e
3438      );
3439    }
3440    _getOffset() {
3441      const { offset: t } = this._config;
3442      return "string" == typeof t
3443        ? t.split(",").map((t) => Number.parseInt(t, 10))
3444        : "function" == typeof t
3445        ? (e) => t(e, this._element)
3446        : t;
3447    }
3448    _getPopperConfig(t) {
3449      const e = {
3450        placement: t,
3451        modifiers: [
3452          {
3453            name: "flip",
3454            options: { fallbackPlacements: this._config.fallbackPlacements },
3455          },
3456          { name: "offset", options: { offset: this._getOffset() } },
3457          {
3458            name: "preventOverflow",
3459            options: { boundary: this._config.boundary },
3460          },
3461          {
3462            name: "arrow",
3463            options: { element: `.${this.constructor.NAME}-arrow` },
3464          },
3465          {
3466            name: "onChange",
3467            enabled: !0,
3468            phase: "afterWrite",
3469            fn: (t) => this._handlePopperPlacementChange(t),
3470          },
3471        ],
3472        onFirstUpdate: (t) => {
3473          t.options.placement !== t.placement &&
3474            this._handlePopperPlacementChange(t);
3475        },
3476      };
3477      return {
3478        ...e,
3479        ...("function" == typeof this._config.popperConfig
3480          ? this._config.popperConfig(e)
3481          : this._config.popperConfig),
3482      };
3483    }
3484    _addAttachmentClass(t) {
3485      this.getTipElement().classList.add(
3486        "bs-tooltip-" + this.updateAttachment(t)
3487      );
3488    }
3489    _getAttachment(t) {
3490      return ze[t.toUpperCase()];
3491    }
3492    _setListeners() {
3493      this._config.trigger.split(" ").forEach((t) => {
3494        if ("click" === t)
3495          P.on(
3496            this._element,
3497            this.constructor.Event.CLICK,
3498            this._config.selector,
3499            (t) => this.toggle(t)
3500          );
3501        else if ("manual" !== t) {
3502          const e =
3503              "hover" === t
3504                ? this.constructor.Event.MOUSEENTER
3505                : this.constructor.Event.FOCUSIN,
3506            i =
3507              "hover" === t
3508                ? this.constructor.Event.MOUSELEAVE
3509                : this.constructor.Event.FOCUSOUT;
3510          P.on(this._element, e, this._config.selector, (t) => this._enter(t)),
3511            P.on(this._element, i, this._config.selector, (t) =>
3512              this._leave(t)
3513            );
3514        }
3515      }),
3516        (this._hideModalHandler = () => {
3517          this._element && this.hide();
3518        }),
3519        P.on(
3520          this._element.closest(".modal"),
3521          "hide.bs.modal",
3522          this._hideModalHandler
3523        ),
3524        this._config.selector
3525          ? (this._config = {
3526              ...this._config,
3527              trigger: "manual",
3528              selector: "",
3529            })
3530          : this._fixTitle();
3531    }
3532    _fixTitle() {
3533      const t = this._element.getAttribute("title"),
3534        e = typeof this._element.getAttribute("data-bs-original-title");
3535      (t || "string" !== e) &&
3536        (this._element.setAttribute("data-bs-original-title", t || ""),
3537        !t ||
3538          this._element.getAttribute("aria-label") ||
3539          this._element.textContent ||
3540          this._element.setAttribute("aria-label", t),
3541        this._element.setAttribute("title", ""));
3542    }
3543    _enter(t, e) {
3544      (e = this._initializeOnDelegatedTarget(t, e)),
3545        t && (e._activeTrigger["focusin" === t.type ? "focus" : "hover"] = !0),
3546        e.getTipElement().classList.contains("show") || "show" === e._hoverState
3547          ? (e._hoverState = "show")
3548          : (clearTimeout(e._timeout),
3549            (e._hoverState = "show"),
3550            e._config.delay && e._config.delay.show
3551              ? (e._timeout = setTimeout(() => {
3552                  "show" === e._hoverState && e.show();
3553                }, e._config.delay.show))
3554              : e.show());
3555    }
3556    _leave(t, e) {
3557      (e = this._initializeOnDelegatedTarget(t, e)),
3558        t &&
3559          (e._activeTrigger["focusout" === t.type ? "focus" : "hover"] =
3560            e._element.contains(t.relatedTarget)),
3561        e._isWithActiveTrigger() ||
3562          (clearTimeout(e._timeout),
3563          (e._hoverState = "out"),
3564          e._config.delay && e._config.delay.hide
3565            ? (e._timeout = setTimeout(() => {
3566                "out" === e._hoverState && e.hide();
3567              }, e._config.delay.hide))
3568            : e.hide());
3569    }
3570    _isWithActiveTrigger() {
3571      for (const t in this._activeTrigger)
3572        if (this._activeTrigger[t]) return !0;
3573      return !1;
3574    }
3575    _getConfig(t) {
3576      const e = U.getDataAttributes(this._element);
3577      return (
3578        Object.keys(e).forEach((t) => {
3579          We.has(t) && delete e[t];
3580        }),
3581        ((t = {
3582          ...this.constructor.Default,
3583          ...e,
3584          ...("object" == typeof t && t ? t : {}),
3585        }).container = !1 === t.container ? document.body : a(t.container)),
3586        "number" == typeof t.delay &&
3587          (t.delay = { show: t.delay, hide: t.delay }),
3588        "number" == typeof t.title && (t.title = t.title.toString()),
3589        "number" == typeof t.content && (t.content = t.content.toString()),
3590        l("tooltip", t, this.constructor.DefaultType),
3591        t.sanitize && (t.template = Re(t.template, t.allowList, t.sanitizeFn)),
3592        t
3593      );
3594    }
3595    _getDelegateConfig() {
3596      const t = {};
3597      if (this._config)
3598        for (const e in this._config)
3599          this.constructor.Default[e] !== this._config[e] &&
3600            (t[e] = this._config[e]);
3601      return t;
3602    }
3603    _cleanTipClass() {
3604      const t = this.getTipElement(),
3605        e = t.getAttribute("class").match(Be);
3606      null !== e &&
3607        e.length > 0 &&
3608        e.map((t) => t.trim()).forEach((e) => t.classList.remove(e));
3609    }
3610    _handlePopperPlacementChange(t) {
3611      const { state: e } = t;
3612      e &&
3613        ((this.tip = e.elements.popper),
3614        this._cleanTipClass(),
3615        this._addAttachmentClass(this._getAttachment(e.placement)));
3616    }
3617    static jQueryInterface(t) {
3618      return this.each(function () {
3619        const e = Fe.getOrCreateInstance(this, t);
3620        if ("string" == typeof t) {
3621          if (void 0 === e[t]) throw new TypeError(`No method named "${t}"`);
3622          e[t]();
3623        }
3624      });
3625    }
3626  }
3627  _(Fe);
3628  const Ve = new RegExp("(^|\\s)bs-popover\\S+", "g"),
3629    Ke = {
3630      ...Fe.Default,
3631      placement: "right",
3632      offset: [0, 8],
3633      trigger: "click",
3634      content: "",
3635      template:
3636        '<div class="popover" role="tooltip"><div class="popover-arrow"></div><h3 class="popover-header"></h3><div class="popover-body"></div></div>',
3637    },
3638    Xe = { ...Fe.DefaultType, content: "(string|element|function)" },
3639    Ye = {
3640      HIDE: "hide.bs.popover",
3641      HIDDEN: "hidden.bs.popover",
3642      SHOW: "show.bs.popover",
3643      SHOWN: "shown.bs.popover",
3644      INSERTED: "inserted.bs.popover",
3645      CLICK: "click.bs.popover",
3646      FOCUSIN: "focusin.bs.popover",
3647      FOCUSOUT: "focusout.bs.popover",
3648      MOUSEENTER: "mouseenter.bs.popover",
3649      MOUSELEAVE: "mouseleave.bs.popover",
3650    };
3651  class Qe extends Fe {
3652    static get Default() {
3653      return Ke;
3654    }
3655    static get NAME() {
3656      return "popover";
3657    }
3658    static get Event() {
3659      return Ye;
3660    }
3661    static get DefaultType() {
3662      return Xe;
3663    }
3664    isWithContent() {
3665      return this.getTitle() || this._getContent();
3666    }
3667    getTipElement() {
3668      return (
3669        this.tip ||
3670          ((this.tip = super.getTipElement()),
3671          this.getTitle() || t.findOne(".popover-header", this.tip).remove(),
3672          this._getContent() || t.findOne(".popover-body", this.tip).remove()),
3673        this.tip
3674      );
3675    }
3676    setContent() {
3677      const e = this.getTipElement();
3678      this.setElementContent(t.findOne(".popover-header", e), this.getTitle());
3679      let i = this._getContent();
3680      "function" == typeof i && (i = i.call(this._element)),
3681        this.setElementContent(t.findOne(".popover-body", e), i),
3682        e.classList.remove("fade", "show");
3683    }
3684    _addAttachmentClass(t) {
3685      this.getTipElement().classList.add(
3686        "bs-popover-" + this.updateAttachment(t)
3687      );
3688    }
3689    _getContent() {
3690      return (
3691        this._element.getAttribute("data-bs-content") || this._config.content
3692      );
3693    }
3694    _cleanTipClass() {
3695      const t = this.getTipElement(),
3696        e = t.getAttribute("class").match(Ve);
3697      null !== e &&
3698        e.length > 0 &&
3699        e.map((t) => t.trim()).forEach((e) => t.classList.remove(e));
3700    }
3701    static jQueryInterface(t) {
3702      return this.each(function () {
3703        const e = Qe.getOrCreateInstance(this, t);
3704        if ("string" == typeof t) {
3705          if (void 0 === e[t]) throw new TypeError(`No method named "${t}"`);
3706          e[t]();
3707        }
3708      });
3709    }
3710  }
3711  _(Qe);
3712  const Ge = { offset: 10, method: "auto", target: "" },
3713    Ze = { offset: "number", method: "string", target: "(string|element)" };
3714  class Je extends B {
3715    constructor(t, e) {
3716      super(t),
3717        (this._scrollElement =
3718          "BODY" === this._element.tagName ? window : this._element),
3719        (this._config = this._getConfig(e)),
3720        (this._selector = `${this._config.target} .nav-link, ${this._config.target} .list-group-item, ${this._config.target} .dropdown-item`),
3721        (this._offsets = []),
3722        (this._targets = []),
3723        (this._activeTarget = null),
3724        (this._scrollHeight = 0),
3725        P.on(this._scrollElement, "scroll.bs.scrollspy", () => this._process()),
3726        this.refresh(),
3727        this._process();
3728    }
3729    static get Default() {
3730      return Ge;
3731    }
3732    static get NAME() {
3733      return "scrollspy";
3734    }
3735    refresh() {
3736      const e =
3737          this._scrollElement === this._scrollElement.window
3738            ? "offset"
3739            : "position",
3740        i = "auto" === this._config.method ? e : this._config.method,
3741        s = "position" === i ? this._getScrollTop() : 0;
3742      (this._offsets = []),
3743        (this._targets = []),
3744        (this._scrollHeight = this._getScrollHeight()),
3745        t
3746          .find(this._selector)
3747          .map((e) => {
3748            const o = n(e),
3749              r = o ? t.findOne(o) : null;
3750            if (r) {
3751              const t = r.getBoundingClientRect();
3752              if (t.width || t.height) return [U[i](r).top + s, o];
3753            }
3754            return null;
3755          })
3756          .filter((t) => t)
3757          .sort((t, e) => t[0] - e[0])
3758          .forEach((t) => {
3759            this._offsets.push(t[0]), this._targets.push(t[1]);
3760          });
3761    }
3762    dispose() {
3763      P.off(this._scrollElement, ".bs.scrollspy"), super.dispose();
3764    }
3765    _getConfig(t) {
3766      if (
3767        "string" !=
3768          typeof (t = {
3769            ...Ge,
3770            ...U.getDataAttributes(this._element),
3771            ...("object" == typeof t && t ? t : {}),
3772          }).target &&
3773        r(t.target)
3774      ) {
3775        let { id: i } = t.target;
3776        i || ((i = e("scrollspy")), (t.target.id = i)), (t.target = "#" + i);
3777      }
3778      return l("scrollspy", t, Ze), t;
3779    }
3780    _getScrollTop() {
3781      return this._scrollElement === window
3782        ? this._scrollElement.pageYOffset
3783        : this._scrollElement.scrollTop;
3784    }
3785    _getScrollHeight() {
3786      return (
3787        this._scrollElement.scrollHeight ||
3788        Math.max(
3789          document.body.scrollHeight,
3790          document.documentElement.scrollHeight
3791        )
3792      );
3793    }
3794    _getOffsetHeight() {
3795      return this._scrollElement === window
3796        ? window.innerHeight
3797        : this._scrollElement.getBoundingClientRect().height;
3798    }
3799    _process() {
3800      const t = this._getScrollTop() + this._config.offset,
3801        e = this._getScrollHeight(),
3802        i = this._config.offset + e - this._getOffsetHeight();
3803      if ((this._scrollHeight !== e && this.refresh(), t >= i)) {
3804        const t = this._targets[this._targets.length - 1];
3805        this._activeTarget !== t && this._activate(t);
3806      } else {
3807        if (this._activeTarget && t < this._offsets[0] && this._offsets[0] > 0)
3808          return (this._activeTarget = null), void this._clear();
3809        for (let e = this._offsets.length; e--; )
3810          this._activeTarget !== this._targets[e] &&
3811            t >= this._offsets[e] &&
3812            (void 0 === this._offsets[e + 1] || t < this._offsets[e + 1]) &&
3813            this._activate(this._targets[e]);
3814      }
3815    }
3816    _activate(e) {
3817      (this._activeTarget = e), this._clear();
3818      const i = this._selector
3819          .split(",")
3820          .map((t) => `${t}[data-bs-target="${e}"],${t}[href="${e}"]`),
3821        n = t.findOne(i.join(","));
3822      n.classList.contains("dropdown-item")
3823        ? (t
3824            .findOne(".dropdown-toggle", n.closest(".dropdown"))
3825            .classList.add("active"),
3826          n.classList.add("active"))
3827        : (n.classList.add("active"),
3828          t.parents(n, ".nav, .list-group").forEach((e) => {
3829            t
3830              .prev(e, ".nav-link, .list-group-item")
3831              .forEach((t) => t.classList.add("active")),
3832              t.prev(e, ".nav-item").forEach((e) => {
3833                t.children(e, ".nav-link").forEach((t) =>
3834                  t.classList.add("active")
3835                );
3836              });
3837          })),
3838        P.trigger(this._scrollElement, "activate.bs.scrollspy", {
3839          relatedTarget: e,
3840        });
3841    }
3842    _clear() {
3843      t.find(this._selector)
3844        .filter((t) => t.classList.contains("active"))
3845        .forEach((t) => t.classList.remove("active"));
3846    }
3847    static jQueryInterface(t) {
3848      return this.each(function () {
3849        const e = Je.getOrCreateInstance(this, t);
3850        if ("string" == typeof t) {
3851          if (void 0 === e[t]) throw new TypeError(`No method named "${t}"`);
3852          e[t]();
3853        }
3854      });
3855    }
3856  }
3857  P.on(window, "load.bs.scrollspy.data-api", () => {
3858    t.find('[data-bs-spy="scroll"]').forEach((t) => new Je(t));
3859  }),
3860    _(Je);
3861  class ti extends B {
3862    static get NAME() {
3863      return "tab";
3864    }
3865    show() {
3866      if (
3867        this._element.parentNode &&
3868        this._element.parentNode.nodeType === Node.ELEMENT_NODE &&
3869        this._element.classList.contains("active")
3870      )
3871        return;
3872      let e;
3873      const i = s(this._element),
3874        n = this._element.closest(".nav, .list-group");
3875      if (n) {
3876        const i =
3877          "UL" === n.nodeName || "OL" === n.nodeName
3878            ? ":scope > li > .active"
3879            : ".active";
3880        (e = t.find(i, n)), (e = e[e.length - 1]);
3881      }
3882      const o = e
3883        ? P.trigger(e, "hide.bs.tab", { relatedTarget: this._element })
3884        : null;
3885      if (
3886        P.trigger(this._element, "show.bs.tab", { relatedTarget: e })
3887          .defaultPrevented ||
3888        (null !== o && o.defaultPrevented)
3889      )
3890        return;
3891      this._activate(this._element, n);
3892      const r = () => {
3893        P.trigger(e, "hidden.bs.tab", { relatedTarget: this._element }),
3894          P.trigger(this._element, "shown.bs.tab", { relatedTarget: e });
3895      };
3896      i ? this._activate(i, i.parentNode, r) : r();
3897    }
3898    _activate(e, i, n) {
3899      const s = (
3900          !i || ("UL" !== i.nodeName && "OL" !== i.nodeName)
3901            ? t.children(i, ".active")
3902            : t.find(":scope > li > .active", i)
3903        )[0],
3904        o = n && s && s.classList.contains("fade"),
3905        r = () => this._transitionComplete(e, s, n);
3906      s && o
3907        ? (s.classList.remove("show"), this._queueCallback(r, e, !0))
3908        : r();
3909    }
3910    _transitionComplete(e, i, n) {
3911      if (i) {
3912        i.classList.remove("active");
3913        const e = t.findOne(":scope > .dropdown-menu .active", i.parentNode);
3914        e && e.classList.remove("active"),
3915          "tab" === i.getAttribute("role") &&
3916            i.setAttribute("aria-selected", !1);
3917      }
3918      e.classList.add("active"),
3919        "tab" === e.getAttribute("role") && e.setAttribute("aria-selected", !0),
3920        f(e),
3921        e.classList.contains("fade") && e.classList.add("show");
3922      let s = e.parentNode;
3923      if (
3924        (s && "LI" === s.nodeName && (s = s.parentNode),
3925        s && s.classList.contains("dropdown-menu"))
3926      ) {
3927        const i = e.closest(".dropdown");
3928        i &&
3929          t
3930            .find(".dropdown-toggle", i)
3931            .forEach((t) => t.classList.add("active")),
3932          e.setAttribute("aria-expanded", !0);
3933      }
3934      n && n();
3935    }
3936    static jQueryInterface(t) {
3937      return this.each(function () {
3938        const e = ti.getOrCreateInstance(this);
3939        if ("string" == typeof t) {
3940          if (void 0 === e[t]) throw new TypeError(`No method named "${t}"`);
3941          e[t]();
3942        }
3943      });
3944    }
3945  }
3946  P.on(
3947    document,
3948    "click.bs.tab.data-api",
3949    '[data-bs-toggle="tab"], [data-bs-toggle="pill"], [data-bs-toggle="list"]',
3950    function (t) {
3951      ["A", "AREA"].includes(this.tagName) && t.preventDefault(),
3952        h(this) || ti.getOrCreateInstance(this).show();
3953    }
3954  ),
3955    _(ti);
3956  const ei = { animation: "boolean", autohide: "boolean", delay: "number" },
3957    ii = { animation: !0, autohide: !0, delay: 5e3 };
3958  class ni extends B {
3959    constructor(t, e) {
3960      super(t),
3961        (this._config = this._getConfig(e)),
3962        (this._timeout = null),
3963        (this._hasMouseInteraction = !1),
3964        (this._hasKeyboardInteraction = !1),
3965        this._setListeners();
3966    }
3967    static get DefaultType() {
3968      return ei;
3969    }
3970    static get Default() {
3971      return ii;
3972    }
3973    static get NAME() {
3974      return "toast";
3975    }
3976    show() {
3977      P.trigger(this._element, "show.bs.toast").defaultPrevented ||
3978        (this._clearTimeout(),
3979        this._config.animation && this._element.classList.add("fade"),
3980        this._element.classList.remove("hide"),
3981        f(this._element),
3982        this._element.classList.add("showing"),
3983        this._queueCallback(
3984          () => {
3985            this._element.classList.remove("showing"),
3986              this._element.classList.add("show"),
3987              P.trigger(this._element, "shown.bs.toast"),
3988              this._maybeScheduleHide();
3989          },
3990          this._element,
3991          this._config.animation
3992        ));
3993    }
3994    hide() {
3995      this._element.classList.contains("show") &&
3996        (P.trigger(this._element, "hide.bs.toast").defaultPrevented ||
3997          (this._element.classList.remove("show"),
3998          this._queueCallback(
3999            () => {
4000              this._element.classList.add("hide"),
4001                P.trigger(this._element, "hidden.bs.toast");
4002            },
4003            this._element,
4004            this._config.animation
4005          )));
4006    }
4007    dispose() {
4008      this._clearTimeout(),
4009        this._element.classList.contains("show") &&
4010          this._element.classList.remove("show"),
4011        super.dispose();
4012    }
4013    _getConfig(t) {
4014      return (
4015        (t = {
4016          ...ii,
4017          ...U.getDataAttributes(this._element),
4018          ...("object" == typeof t && t ? t : {}),
4019        }),
4020        l("toast", t, this.constructor.DefaultType),
4021        t
4022      );
4023    }
4024    _maybeScheduleHide() {
4025      this._config.autohide &&
4026        (this._hasMouseInteraction ||
4027          this._hasKeyboardInteraction ||
4028          (this._timeout = setTimeout(() => {
4029            this.hide();
4030          }, this._config.delay)));
4031    }
4032    _onInteraction(t, e) {
4033      switch (t.type) {
4034        case "mouseover":
4035        case "mouseout":
4036          this._hasMouseInteraction = e;
4037          break;
4038        case "focusin":
4039        case "focusout":
4040          this._hasKeyboardInteraction = e;
4041      }
4042      if (e) return void this._clearTimeout();
4043      const i = t.relatedTarget;
4044      this._element === i ||
4045        this._element.contains(i) ||
4046        this._maybeScheduleHide();
4047    }
4048    _setListeners() {
4049      P.on(
4050        this._element,
4051        "click.dismiss.bs.toast",
4052        '[data-bs-dismiss="toast"]',
4053        () => this.hide()
4054      ),
4055        P.on(this._element, "mouseover.bs.toast", (t) =>
4056          this._onInteraction(t, !0)
4057        ),
4058        P.on(this._element, "mouseout.bs.toast", (t) =>
4059          this._onInteraction(t, !1)
4060        ),
4061        P.on(this._element, "focusin.bs.toast", (t) =>
4062          this._onInteraction(t, !0)
4063        ),
4064        P.on(this._element, "focusout.bs.toast", (t) =>
4065          this._onInteraction(t, !1)
4066        );
4067    }
4068    _clearTimeout() {
4069      clearTimeout(this._timeout), (this._timeout = null);
4070    }
4071    static jQueryInterface(t) {
4072      return this.each(function () {
4073        const e = ni.getOrCreateInstance(this, t);
4074        if ("string" == typeof t) {