https://drivocar.netlify.app/js/bootstrap.min.js

1/*!
2 * Bootstrap v5.3.3 (https://getbootstrap.com/)
3 * Copyright 2011-2024 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 ? module.exports = e(require("@popperjs/core")) : "function" == typeof define && define.amd ? define(["@popperjs/core"], e) : (t = "undefined" != typeof globalThis ? globalThis : t || self).bootstrap = e(t.Popper)
8}(this, (function(t) {
9    "use strict";
10
11    function e(t) {
12        const e = Object.create(null, {
13            [Symbol.toStringTag]: {
14                value: "Module"
15            }
16        });
17        if (t)
18            for (const i in t)
19                if ("default" !== i) {
20                    const s = Object.getOwnPropertyDescriptor(t, i);
21                    Object.defineProperty(e, i, s.get ? s : {
22                        enumerable: !0,
23                        get: () => t[i]
24                    })
25                }
26        return e.default = t, Object.freeze(e)
27    }
28    const i = e(t),
29        s = new Map,
30        n = {
31            set(t, e, i) {
32                s.has(t) || s.set(t, new Map);
33                const n = s.get(t);
34                n.has(e) || 0 === n.size ? n.set(e, i) : console.error(`Bootstrap doesn't allow more than one instance per element. Bound instance: ${Array.from(n.keys())[0]}.`)
35            },
36            get: (t, e) => s.has(t) && s.get(t).get(e) || null,
37            remove(t, e) {
38                if (!s.has(t)) return;
39                const i = s.get(t);
40                i.delete(e), 0 === i.size && s.delete(t)
41            }
42        },
43        o = "transitionend",
44        r = t => (t && window.CSS && window.CSS.escape && (t = t.replace(/#([^\s"#']+)/g, ((t, e) => `#${CSS.escape(e)}`))), t),
45        a = t => {
46            t.dispatchEvent(new Event(o))
47        },
48        l = t => !(!t || "object" != typeof t) && (void 0 !== t.jquery && (t = t[0]), void 0 !== t.nodeType),
49        c = t => l(t) ? t.jquery ? t[0] : t : "string" == typeof t && t.length > 0 ? document.querySelector(r(t)) : null,
50        h = t => {
51            if (!l(t) || 0 === t.getClientRects().length) return !1;
52            const e = "visible" === getComputedStyle(t).getPropertyValue("visibility"),
53                i = t.closest("details:not([open])");
54            if (!i) return e;
55            if (i !== t) {
56                const e = t.closest("summary");
57                if (e && e.parentNode !== i) return !1;
58                if (null === e) return !1
59            }
60            return e
61        },
62        d = t => !t || t.nodeType !== Node.ELEMENT_NODE || !!t.classList.contains("disabled") || (void 0 !== t.disabled ? t.disabled : t.hasAttribute("disabled") && "false" !== t.getAttribute("disabled")),
63        u = t => {
64            if (!document.documentElement.attachShadow) return null;
65            if ("function" == typeof t.getRootNode) {
66                const e = t.getRootNode();
67                return e instanceof ShadowRoot ? e : null
68            }
69            return t instanceof ShadowRoot ? t : t.parentNode ? u(t.parentNode) : null
70        },
71        _ = () => {},
72        g = t => {
73            t.offsetHeight
74        },
75        f = () => window.jQuery && !document.body.hasAttribute("data-bs-no-jquery") ? window.jQuery : null,
76        m = [],
77        p = () => "rtl" === document.documentElement.dir,
78        b = t => {
79            var e;
80            e = () => {
81                const e = f();
82                if (e) {
83                    const i = t.NAME,
84                        s = e.fn[i];
85                    e.fn[i] = t.jQueryInterface, e.fn[i].Constructor = t, e.fn[i].noConflict = () => (e.fn[i] = s, t.jQueryInterface)
86                }
87            }, "loading" === document.readyState ? (m.length || document.addEventListener("DOMContentLoaded", (() => {
88                for (const t of m) t()
89            })), m.push(e)) : e()
90        },
91        v = (t, e = [], i = t) => "function" == typeof t ? t(...e) : i,
92        y = (t, e, i = !0) => {
93            if (!i) return void v(t);
94            const s = (t => {
95                if (!t) return 0;
96                let {
97                    transitionDuration: e,
98                    transitionDelay: i
99                } = window.getComputedStyle(t);

100                const s = Number.parseFloat(e),
101                    n = Number.parseFloat(i);
102                return s || n ? (e = e.split(",")[0], i = i.split(",")[0], 1e3 * (Number.parseFloat(e) + Number.parseFloat(i))) : 0
103            })(e) + 5;
104            let n = !1;
105            const r = ({
106                target: i
107            }) => {
108                i === e && (n = !0, e.removeEventListener(o, r), v(t))
109            };
110            e.addEventListener(o, r), setTimeout((() => {
111                n || a(e)
112            }), s)
113        },
114        w = (t, e, i, s) => {
115            const n = t.length;
116            let o = t.indexOf(e);
117            return -1 === o ? !i && s ? t[n - 1] : t[0] : (o += i ? 1 : -1, s && (o = (o + n) % n), t[Math.max(0, Math.min(o, n - 1))])
118        },
119        A = /[^.]*(?=\..*)\.|.*/,
120        E = /\..*/,
121        C = /::\d+$/,
122        T = {};
123    let k = 1;
124    const $ = {
125            mouseenter: "mouseover",
126            mouseleave: "mouseout"
127        },
128        S = new Set(["click", "dblclick", "mouseup", "mousedown", "contextmenu", "mousewheel", "DOMMouseScroll", "mouseover", "mouseout", "mousemove", "selectstart", "selectend", "keydown", "keypress", "keyup", "orientationchange", "touchstart", "touchmove", "touchend", "touchcancel", "pointerdown", "pointermove", "pointerup", "pointerleave", "pointercancel", "gesturestart", "gesturechange", "gestureend", "focus", "blur", "change", "reset", "select", "submit", "focusin", "focusout", "load", "unload", "beforeunload", "resize", "move", "DOMContentLoaded", "readystatechange", "error", "abort", "scroll"]);
129
130    function L(t, e) {
131        return e && `${e}::${k++}` || t.uidEvent || k++
132    }
133
134    function O(t) {
135        const e = L(t);
136        return t.uidEvent = e, T[e] = T[e] || {}, T[e]
137    }
138
139    function I(t, e, i = null) {
140        return Object.values(t).find((t => t.callable === e && t.delegationSelector === i))
141    }
142
143    function D(t, e, i) {
144        const s = "string" == typeof e,
145            n = s ? i : e || i;
146        let o = M(t);
147        return S.has(o) || (o = t), [s, n, o]
148    }
149
150    function N(t, e, i, s, n) {
151        if ("string" != typeof e || !t) return;
152        let [o, r, a] = D(e, i, s);
153        if (e in $) {
154            const t = t => function(e) {
155                if (!e.relatedTarget || e.relatedTarget !== e.delegateTarget && !e.delegateTarget.contains(e.relatedTarget)) return t.call(this, e)
156            };
157            r = t(r)
158        }
159        const l = O(t),
160            c = l[a] || (l[a] = {}),
161            h = I(c, r, o ? i : null);
162        if (h) return void(h.oneOff = h.oneOff && n);
163        const d = L(r, e.replace(A, "")),
164            u = o ? function(t, e, i) {
165                return function s(n) {
166                    const o = t.querySelectorAll(e);
167                    for (let {
168                            target: r
169                        } = n; r && r !== this; r = r.parentNode)
170                        for (const a of o)
171                            if (a === r) return F(n, {
172                                delegateTarget: r
173                            }), s.oneOff && j.off(t, n.type, e, i), i.apply(r, [n])
174                }
175            }(t, i, r) : function(t, e) {
176                return function i(s) {
177                    return F(s, {
178                        delegateTarget: t
179                    }), i.oneOff && j.off(t, s.type, e), e.apply(t, [s])
180                }
181            }(t, r);
182        u.delegationSelector = o ? i : null, u.callable = r, u.oneOff = n, u.uidEvent = d, c[d] = u, t.addEventListener(a, u, o)
183    }
184
185    function P(t, e, i, s, n) {
186        const o = I(e[i], s, n);
187        o && (t.removeEventListener(i, o, Boolean(n)), delete e[i][o.uidEvent])
188    }
189
190    function x(t, e, i, s) {
191        const n = e[i] || {};
192        for (const [o, r] of Object.entries(n)) o.includes(s) && P(t, e, i, r.callable, r.delegationSelector)
193    }
194
195    function M(t) {
196        return t = t.replace(E, ""), $[t] || t
197    }
198    const j = {
199        on(t, e, i, s) {
200            N(t, e, i, s, !1)
201        },
202        one(t, e, i, s) {
203            N(t, e, i, s, !0)
204        },
205        off(t, e, i, s) {
206            if ("string" != typeof e || !t) return;
207            const [n, o, r] = D(e, i, s), a = r !== e, l = O(t), c = l[r] || {}, h = e.startsWith(".");
208            if (void 0 === o) {
209                if (h)
210                    for (const i of Object.keys(l)) x(t, l, i, e.slice(1));
211                for (const [i, s] of Object.entries(c)) {
212                    const n = i.replace(C, "");
213                    a && !e.includes(n) || P(t, l, r, s.callable, s.delegationSelector)
214                }
215            } else {
216                if (!Object.keys(c).length) return;
217                P(t, l, r, o, n ? i : null)
218            }
219        },
220        trigger(t, e, i) {
221            if ("string" != typeof e || !t) return null;
222            const s = f();
223            let n = null,
224                o = !0,
225                r = !0,
226                a = !1;
227            e !== M(e) && s && (n = s.Event(e, i), s(t).trigger(n), o = !n.isPropagationStopped(), r = !n.isImmediatePropagationStopped(), a = n.isDefaultPrevented());
228            const l = F(new Event(e, {
229                bubbles: o,
230                cancelable: !0
231            }), i);
232            return a && l.preventDefault(), r && t.dispatchEvent(l), l.defaultPrevented && n && n.preventDefault(), l
233        }
234    };
235
236    function F(t, e = {}) {
237        for (const [i, s] of Object.entries(e)) try {
238            t[i] = s
239        } catch (e) {
240            Object.defineProperty(t, i, {
241                configurable: !0,
242                get: () => s
243            })
244        }
245        return t
246    }
247
248    function z(t) {
249        if ("true" === t) return !0;
250        if ("false" === t) return !1;
251        if (t === Number(t).toString()) return Number(t);
252        if ("" === t || "null" === t) return null;
253        if ("string" != typeof t) return t;
254        try {
255            return JSON.parse(decodeURIComponent(t))
256        } catch (e) {
257            return t
258        }
259    }
260
261    function H(t) {
262        return t.replace(/[A-Z]/g, (t => `-${t.toLowerCase()}`))
263    }
264    const B = {
265        setDataAttribute(t, e, i) {
266            t.setAttribute(`data-bs-${H(e)}`, i)
267        },
268        removeDataAttribute(t, e) {
269            t.removeAttribute(`data-bs-${H(e)}`)
270        },
271        getDataAttributes(t) {
272            if (!t) return {};
273            const e = {},
274                i = Object.keys(t.dataset).filter((t => t.startsWith("bs") && !t.startsWith("bsConfig")));
275            for (const s of i) {
276                let i = s.replace(/^bs/, "");
277                i = i.charAt(0).toLowerCase() + i.slice(1, i.length), e[i] = z(t.dataset[s])
278            }
279            return e
280        },
281        getDataAttribute: (t, e) => z(t.getAttribute(`data-bs-${H(e)}`))
282    };
283    class q {
284        static get Default() {
285            return {}
286        }
287        static get DefaultType() {
288            return {}
289        }
290        static get NAME() {
291            throw new Error('You have to implement the static method "NAME", for each component!')
292        }
293        _getConfig(t) {
294            return t = this._mergeConfigObj(t), t = this._configAfterMerge(t), this._typeCheckConfig(t), t
295        }
296        _configAfterMerge(t) {
297            return t
298        }
299        _mergeConfigObj(t, e) {
300            const i = l(e) ? B.getDataAttribute(e, "config") : {};
301            return { ...this.constructor.Default,
302                ..."object" == typeof i ? i : {},
303                ...l(e) ? B.getDataAttributes(e) : {},
304                ..."object" == typeof t ? t : {}
305            }
306        }
307        _typeCheckConfig(t, e = this.constructor.DefaultType) {
308            for (const [s, n] of Object.entries(e)) {
309                const e = t[s],
310                    o = l(e) ? "element" : null == (i = e) ? `${i}` : Object.prototype.toString.call(i).match(/\s([a-z]+)/i)[1].toLowerCase();
311                if (!new RegExp(n).test(o)) throw new TypeError(`${this.constructor.NAME.toUpperCase()}: Option "${s}" provided type "${o}" but expected type "${n}".`)
312            }
313            var i
314        }
315    }
316    class W extends q {
317        constructor(t, e) {
318            super(), (t = c(t)) && (this._element = t, this._config = this._getConfig(e), n.set(this._element, this.constructor.DATA_KEY, this))
319        }
320        dispose() {
321            n.remove(this._element, this.constructor.DATA_KEY), j.off(this._element, this.constructor.EVENT_KEY);
322            for (const t of Object.getOwnPropertyNames(this)) this[t] = null
323        }
324        _queueCallback(t, e, i = !0) {
325            y(t, e, i)
326        }
327        _getConfig(t) {
328            return t = this._mergeConfigObj(t, this._element), t = this._configAfterMerge(t), this._typeCheckConfig(t), t
329        }
330        static getInstance(t) {
331            return n.get(c(t), this.DATA_KEY)
332        }
333        static getOrCreateInstance(t, e = {}) {
334            return this.getInstance(t) || new this(t, "object" == typeof e ? e : null)
335        }
336        static get VERSION() {
337            return "5.3.3"
338        }
339        static get DATA_KEY() {
340            return `bs.${this.NAME}`
341        }
342        static get EVENT_KEY() {
343            return `.${this.DATA_KEY}`
344        }
345        static eventName(t) {
346            return `${t}${this.EVENT_KEY}`
347        }
348    }
349    const R = t => {
350            let e = t.getAttribute("data-bs-target");
351            if (!e || "#" === e) {
352                let i = t.getAttribute("href");
353                if (!i || !i.includes("#") && !i.startsWith(".")) return null;
354                i.includes("#") && !i.startsWith("#") && (i = `#${i.split("#")[1]}`), e = i && "#" !== i ? i.trim() : null
355            }
356            return e ? e.split(",").map((t => r(t))).join(",") : null
357        },
358        K = {
359            find: (t, e = document.documentElement) => [].concat(...Element.prototype.querySelectorAll.call(e, t)),
360            findOne: (t, e = document.documentElement) => Element.prototype.querySelector.call(e, t),
361            children: (t, e) => [].concat(...t.children).filter((t => t.matches(e))),
362            parents(t, e) {
363                const i = [];
364                let s = t.parentNode.closest(e);
365                for (; s;) i.push(s), s = s.parentNode.closest(e);
366                return i
367            },
368            prev(t, e) {
369                let i = t.previousElementSibling;
370                for (; i;) {
371                    if (i.matches(e)) return [i];
372                    i = i.previousElementSibling
373                }
374                return []
375            },
376            next(t, e) {
377                let i = t.nextElementSibling;
378                for (; i;) {
379                    if (i.matches(e)) return [i];
380                    i = i.nextElementSibling
381                }
382                return []
383            },
384            focusableChildren(t) {
385                const e = ["a", "button", "input", "textarea", "select", "details", "[tabindex]", '[contenteditable="true"]'].map((t => `${t}:not([tabindex^="-"])`)).join(",");
386                return this.find(e, t).filter((t => !d(t) && h(t)))
387            },
388            getSelectorFromElement(t) {
389                const e = R(t);
390                return e && K.findOne(e) ? e : null
391            },
392            getElementFromSelector(t) {
393                const e = R(t);
394                return e ? K.findOne(e) : null
395            },
396            getMultipleElementsFromSelector(t) {
397                const e = R(t);
398                return e ? K.find(e) : []
399            }
400        },
401        V = (t, e = "hide") => {
402            const i = `click.dismiss${t.EVENT_KEY}`,
403                s = t.NAME;
404            j.on(document, i, `[data-bs-dismiss="${s}"]`, (function(i) {
405                if (["A", "AREA"].includes(this.tagName) && i.preventDefault(), d(this)) return;
406                const n = K.getElementFromSelector(this) || this.closest(`.${s}`);
407                t.getOrCreateInstance(n)[e]()
408            }))
409        },
410        Q = ".bs.alert",
411        X = `close${Q}`,
412        Y = `closed${Q}`;
413    class U extends W {
414        static get NAME() {
415            return "alert"
416        }
417        close() {
418            if (j.trigger(this._element, X).defaultPrevented) return;
419            this._element.classList.remove("show");
420            const t = this._element.classList.contains("fade");
421            this._queueCallback((() => this._destroyElement()), this._element, t)
422        }
423        _destroyElement() {
424            this._element.remove(), j.trigger(this._element, Y), this.dispose()
425        }
426        static jQueryInterface(t) {
427            return this.each((function() {
428                const e = U.getOrCreateInstance(this);
429                if ("string" == typeof t) {
430                    if (void 0 === e[t] || t.startsWith("_") || "constructor" === t) throw new TypeError(`No method n

586            if (t > e.length - 1 || t < 0) return;
587            if (this._isSliding) return void j.one(this._element, ft, (() => this.to(t)));
588            const i = this._getItemIndex(this._getActive());
589            if (i === t) return;
590            const s = t > i ? ht : dt;
591            this._slide(s, e[t])
592        }
593        dispose() {
594            this._swipeHelper && this._swipeHelper.dispose(), super.dispose()
595        }
596        _configAfterMerge(t) {
597            return t.defaultInterval = t.interval, t
598        }
599        _addEventListeners() {
600            this._config.keyboard && j.on(this._element, mt, (t => this._keydown(t))), "hover" === this._config.pause && (j.on(this._element, pt, (() => this.pause())), j.on(this._element, bt, (() => this._maybeEnableCycle()))), this._config.touch && at.isSupported() && this._addTouchEventListeners()
601        }
602        _addTouchEventListeners() {
603            for (const t of K.find(".carousel-item img", this._element)) j.on(t, vt, (t => t.preventDefault()));
604            const t = {
605                leftCallback: () => this._slide(this._directionToOrder(ut)),
606                rightCallback: () => this._slide(this._directionToOrder(_t)),
607                endCallback: () => {
608                    "hover" === this._config.pause && (this.pause(), this.touchTimeout && clearTimeout(this.touchTimeout), this.touchTimeout = setTimeout((() => this._maybeEnableCycle()), 500 + this._config.interval))
609                }
610            };
611            this._swipeHelper = new at(this._element, t)
612        }
613        _keydown(t) {
614            if (/input|textarea/i.test(t.target.tagName)) return;
615            const e = $t[t.key];
616            e && (t.preventDefault(), this._slide(this._directionToOrder(e)))
617        }
618        _getItemIndex(t) {
619            return this._getItems().indexOf(t)
620        }
621        _setActiveIndicatorElement(t) {
622            if (!this._indicatorsElement) return;
623            const e = K.findOne(Ct, this._indicatorsElement);
624            e.classList.remove(Et), e.removeAttribute("aria-current");
625            const i = K.findOne(`[data-bs-slide-to="${t}"]`, this._indicatorsElement);
626            i && (i.classList.add(Et), i.setAttribute("aria-current", "true"))
627        }
628        _updateInterval() {
629            const t = this._activeElement || this._getActive();
630            if (!t) return;
631            const e = Number.parseInt(t.getAttribute("data-bs-interval"), 10);
632            this._config.interval = e || this._config.defaultInterval
633        }
634        _slide(t, e = null) {
635            if (this._isSliding) return;
636            const i = this._getActive(),
637                s = t === ht,
638                n = e || w(this._getItems(), i, s, this._config.wrap);
639            if (n === i) return;
640            const o = this._getItemIndex(n),
641                r = e => j.trigger(this._element, e, {
642                    relatedTarget: n,
643                    direction: this._orderToDirection(t),
644                    from: this._getItemIndex(i),
645                    to: o
646                });
647            if (r(gt).defaultPrevented) return;
648            if (!i || !n) return;
649            const a = Boolean(this._interval);
650            this.pause(), this._isSliding = !0, this._setActiveIndicatorElement(o), this._activeElement = n;
651            const l = s ? "carousel-item-start" : "carousel-item-end",
652                c = s ? "carousel-item-next" : "carousel-item-prev";
653            n.classList.add(c), g(n), i.classList.add(l), n.classList.add(l), this._queueCallback((() => {
654                n.classList.remove(l, c), n.classList.add(Et), i.classList.remove(Et, c, l), this._isSliding = !1, r(ft)
655            }), i, this._isAnimated()), a && this.cycle()
656        }
657        _isAnimated() {
658            return this._element.classList.contains("slide")
659        }
660        _getActive() {
661            return K.findOne(kt, this._element)
662        }
663        _getItems() {
664            return K.find(Tt, this._element)
665        }
666        _clearInterval() {
667            this._interval && (clearInterval(this._interval), this._interval = null)
668        }
669        _directionToOrder(t) {
670            return p() ? t === ut ? dt : ht : t === ut ? ht : dt
671        }
672        _orderToDirection(t) {
673            return p() ? t === dt ? ut : _t : t === dt ? _t : ut
674        }
675        static jQueryInterface(t) {
676            return this.each((function() {
677                const e = Ot.getOrCreateInstance(this, t);
678                if ("number" != typeof t) {
679                    if ("string" == typeof t) {
680                        if (void 0 === e[t] || t.startsWith("_") || "constructor" === t) throw new TypeError(`No method n

870navbar-nav"))
871                    for (const t of [].concat(...document.body.children)) j.on(t, "mouseover", _);
872                this._element.focus(), this._element.setAttribute("aria-expanded", !0), this._menu.classList.add(se), this._element.classList.add(se), j.trigger(this._element, Zt, t)
873            }
874        }
875        hide() {
876            if (d(this._element) || !this._isShown()) return;
877            const t = {
878                relatedTarget: this._element
879            };
880            this._completeHide(t)
881        }
882        dispose() {
883            this._popper && this._popper.destroy(), super.dispose()
884        }
885        update() {
886            this._inNavbar = this._detectNavbar(), this._popper && this._popper.update()
887        }
888        _completeHide(t) {
889            if (!j.trigger(this._element, Ut, t).defaultPrevented) {
890                if ("ontouchstart" in document.documentElement)
891                    for (const t of [].concat(...document.body.children)) j.off(t, "mouseover", _);
892                this._popper && this._popper.destroy(), this._menu.classList.remove(se), this._element.classList.remove(se), this._element.setAttribute("aria-expanded", "false"), B.removeDataAttribute(this._menu, "popper"), j.trigger(this._element, Gt, t)
893            }
894        }
895        _getConfig(t) {
896            if ("object" == typeof(t = super._getConfig(t)).reference && !l(t.reference) && "function" != typeof t.reference.getBoundingClientRect) throw new TypeError(`${Kt.toUpperCase()}: Option "reference" provided type "object" without a required "getBoundingClientRect" method.`);
897            return t
898        }
899        _createPopper() {
900            if (void 0 === i) throw new TypeError("Bootstrap's dropdowns require Popper (https://popper.js.org)");
901            let t = this._element;
902            "parent" === this._config.reference ? t = this._parent : l(this._config.reference) ? t = c(this._config.reference) : "object" == typeof this._config.reference && (t = this._config.reference);
903            const e = this._getPopperConfig();
904            this._popper = i.createPopper(t, this._menu, e)
905        }
906        _isShown() {
907            return this._menu.classList.contains(se)
908        }
909        _getPlacement() {
910            const t = this._parent;
911            if (t.classList.contains("dropend")) return de;
912            if (t.classList.contains("dropstart")) return ue;
913            if (t.classList.contains("dropup-center")) return "top";
914            if (t.classList.contains("dropdown-center")) return "bottom";
915            const e = "end" === getComputedStyle(this._menu).getPropertyValue("--bs-position").trim();
916            return t.classList.contains("dropup") ? e ? le : ae : e ? he : ce
917        }
918        _detectNavbar() {

919            return null !== this._element.closest(".navbar")
920        }
921        _getOffset() {
922            const {
923                offset: t
924            } = this._config;
925            return "string" == typeof t ? t.split(",").map((t => Number.parseInt(t, 10))) : "function" == typeof t ? e => t(e, this._element) : t
926        }
927        _getPopperConfig() {
928            const t = {
929                placement: this._getPlacement(),
930                modifiers: [{
931                    name: "preventOverflow",
932                    options: {
933                        boundary: this._config.boundary
934                    }
935                }, {
936                    name: "offset",
937                    options: {
938                        offset: this._getOffset()
939                    }
940                }]
941            };
942            return (this._inNavbar || "static" === this._config.display) && (B.setDataAttribute(this._menu, "popper", "static"), t.modifiers = [{
943                name: "applyStyles",
944                enabled: !1
945            }]), { ...t,
946                ...v(this._config.popperConfig, [t])
947            }
948        }
949        _selectMenuItem({
950            key: t,
951            target: e
952        }) {
953            const i = K.find(".dropdown-menu .dropdown-item:not(.disabled):not(:disabled)", this._menu).filter((t => h(t)));
954            i.length && w(i, e, t === Yt, !i.includes(e)).focus()
955        }
956        static jQueryInterface(t) {
957            return this.each((function() {
958                const e = fe.getOrCreateInstance(this, t);
959                if ("string" == typeof t) {
960                    if (void 0 === e[t]) throw new TypeError(`No method named "${t}"`);
961                    e[t]()
962                }
963            }))
964        }
965        static clearMenus(t) {
966            if (2 === t.button || "keyup" === t.type && "Tab" !== t.key) return;
967            const e = K.find(oe);
968            for (const i of e) {
969                const e = fe.getInstance(i);
970                if (!e || !1 === e._config.autoClose) continue;
971                const s = t.composedPath(),
972                    n = s.includes(e._menu);
973                if (s.includes(e._element) || "inside" === e._config.autoClose && !n || "outside" === e._config.autoClose && n) continue;
974                if (e._menu.contains(t.target) && ("keyup" === t.type && "Tab" === t.key || /input|select|option|textarea|form/i.test(t.target.tagName))) continue;
975                const o = {
976                    relatedTarget: e._element
977                };
978                "click" === t.type && (o.clickEvent = t), e._completeHide(o)
979            }
980        }
981        static dataApiKeydownHandler(t) {
982            const e = /input|textarea/i.test(t.target.tagName),
983                i = "Escape" === t.key,
984                s = [Xt, Yt].includes(t.key);
985            if (!s && !i) return;
986            if (e && !i) return;
987            t.preventDefault();
988            const n = this.matches(ne) ? this : K.prev(this, ne)[0] || K.next(this, ne)[0] || K.findOne(ne, t.delegateTarget.parentNode),
989                o = fe.getOrCreateInstance(n);
990            if (s) return t.stopPropagation(), o.show(), void o._selectMenuItem(t);
991            o._isShown() && (t.stopPropagation(), o.hide(), n.focus())
992        }
993    }
994    j.on(document, ee, ne, fe.dataApiKeydownHandler), j.on(document, ee, re, fe.dataApiKeydownHandler), j.on(document, te, fe.clearMenus), j.on(document, ie, fe.clearMenus), j.on(document, te, ne, (function(t) {
995        t.preventDefault(), fe.getOrCreateInstance(this).toggle()
996    })), b(fe);
997    const me = "backdrop",
998        pe = "show",
999        be = `mousedown.bs.${me}`,
1000        ve = {
1001            className: "modal-backdrop",
1002            clickCallback: null,
1003            isAnimated: !1,
1004            isVisible: !0,
1005            rootElement: "body"
1006        },
1007        ye = {
1008            className: "string",
1009            clickCallback: "(function|null)",
1010            isAnimated: "boolean",
1011            isVisible: "boolean",
1012            rootElement: "(element|string)"
1013        };
1014    class we extends q {
1015        constructor(t) {
1016            super(), this._config = this._getConfig(t), this._isAppended = !1, this._element = null
1017        }
1018        static get Default() {
1019            return ve
1020        }
1021        static get DefaultType() {
1022            return ye
1023        }
1024        static get NAME() {
1025            return me
1026        }
1027        show(t) {
1028            if (!this._config.isVisible) return void v(t);
1029            this._append();
1030            const e = this._getElement();
1031            this._config.isAnimated && g(e), e.classList.add(pe), this._emulateAnimation((() => {
1032                v(t)
1033            }))
1034        }
1035        hide(t) {
1036            this._config.isVisible ? (this._getElement().classList.remove(pe), this._emulateAnimation((() => {
1037                this.dispose(), v(t)
1038            }))) : v(t)
1039        }
1040        dispose() {
1041            this._isAppended && (j.off(this._element, be), this._element.remove(), this._isAppended = !1)
1042        }
1043        _getElement() {
1044            if (!this._element) {
1045                const t = document.createElement("div");
1046                t.className = this._config.className, this._config.isAnimated && t.classList.add("fade"), this._element = t
1047            }
1048            return this._element
1049        }
1050        _configAfterMerge(t) {
1051            return t.rootElement = c(t.rootElement), t
1052        }
1053        _append() {
1054            if (this._isAppended) return;
1055            const t = this._getElement();
1056            this._config.rootElement.append(t), j.on(t, be, (() => {
1057                v(this._config.clickCallback)
1058            })), this._isAppended = !0
1059        }
1060        _emulateAnimation(t) {
1061            y(t, this._getElement(), this._config.isAnimated)
1062        }
1063    }
1064    const Ae = ".bs.focustrap",
1065        Ee = `focusin${Ae}`,
1066        Ce = `keydown.tab${Ae}`,
1067        Te = "backward",
1068        ke = {
1069            autofocus: !0,
1070            trapElement: null
1071        },
1072        $e = {
1073            autofocus: "boolean",
1074            trapElement: "element"
1075        };
1076    class Se extends q {
1077        constructor(t) {
1078            super(), this._config = this._getConfig(t), this._isActive = !1, this._lastTabNavDirection = null
1079        }
1080        static get Default() {
1081            return ke

1082        }
1083        static get DefaultType() {
1084            return $e
1085        }
1086        static get NAME() {
1087            return "focustrap"
1088        }
1089        activate() {
1090            this._isActive || (this._config.autofocus && this._config.trapElement.focus(), j.off(document, Ae), j.on(document, Ee, (t => this._handleFocusin(t))), j.on(document, Ce, (t => this._handleKeydown(t))), this._isActive = !0)
1091        }
1092        deactivate() {
1093            this._isActive && (this._isActive = !1, j.off(document, Ae))
1094        }
1095        _handleFocusin(t) {
1096            const {
1097                trapElement: e
1098            } = this._config;
1099            if (t.target === document || t.target === e || e.contains(t.target)) return;
1100            const i = K.focusableChildren(e);
1101            0 === i.length ? e.focus() : this._lastTabNavDirection === Te ? i[i.length - 1].focus() : i[0].focus()
1102        }
1103        _handleKeydown(t) {
1104            "Tab" === t.key && (this._lastTabNavDirection = t.shiftKey ? Te : "forward")
1105        }
1106    }
1107    const Le = ".fixed-top, .fixed-bottom, .is-fixed, .sticky-top",
1108        Oe = ".sticky-top",
1109        Ie = "padding-right",
1110        De = "margin-right";
1111    class Ne {
1112        constructor() {
1113            this._element = document.body
1114        }
1115        getWidth() {
1116            const t = document.documentElement.clientWidth;
1117            return Math.abs(window.innerWidth - t)
1118        }
1119        hide() {
1120            const t = this.getWidth();
1121            this._disableOverFlow(), this._setElementAttributes(this._element, Ie, (e => e + t)), this._setElementAttributes(Le, Ie, (e => e + t)), this._setElementAttributes(Oe, De, (e => e - t))
1122        }
1123        reset() {
1124            this._resetElementAttributes(this._element, "overflow"), this._resetElementAttributes(this._element, Ie), this._resetElementAttributes(Le, Ie), this._resetElementAttributes(Oe, De)
1125        }
1126        isOverflowing() {
1127            return this.getWidth() > 0
1128        }
1129        _disableOverFlow() {
1130            this._saveInitialAttribute(this._element, "overflow"), this._element.style.overflow = "hidden"
1131        }
1132        _setElementAttributes(t, e, i) {
1133            const s = this.getWidth();
1134            this._applyManipulationCallback(t, (t => {
1135                if (t !== this._element && window.innerWidth > t.clientWidth + s) return;
1136                this._saveInitialAttribute(t, e);
1137                const n = window.getComputedStyle(t).getPropertyValue(e);
1138                t.style.setProperty(e, `${i(Number.parseFloat(n))}px`)
1139            }))
1140        }
1141        _saveInitialAttribute(t, e) {
1142            const i = t.style.getPropertyValue(e);
1143            i && B.setDataAttribute(t, e, i)
1144        }
1145        _resetElementAttributes(t, e) {
1146            this._applyManipulationCallback(t, (t => {
1147                const i = B.getDataAttribute(t, e);
1148                null !== i ? (B.removeDataAttribute(t, e), t.style.setProperty(e, i)) : t.style.removeProperty(e)
1149            }))
1150        }
1151        _applyManipulationCallback(t, e) {
1152            if (l(t)) e(t);
1153            else
1154                for (const i of K.find(t, this._element)) e(i)
1155        }
1156    }
1157    const Pe = ".bs.modal",
1158        xe = `hide${Pe}`,
1159        Me = `hidePrevented${Pe}`,
1160        je = `hidden${Pe}`,
1161        Fe = `show${Pe}`,
1162        ze = `shown${Pe}`,
1163        He = `resize${Pe}`,
1164        Be = `click.dismiss${Pe}`,
1165        qe = `mousedown.dismiss${Pe}`,
1166        We = `keydown.dismiss${Pe}`,
1167        Re = `click${Pe}.data-api`,
1168        Ke = "modal-open",
1169        Ve = "show",

1170        Qe = "modal-static",
1171        Xe = {
1172            backdrop: !0,
1173            focus: !0,
1174            keyboard: !0
1175        },
1176        Ye = {
1177            backdrop: "(boolean|string)",
1178            focus: "boolean",
1179            keyboard: "boolean"
1180        };
1181    class Ue extends W {
1182        constructor(t, e) {
1183            super(t, e), this._dialog = K.findOne(".modal-dialog", this._element), this._backdrop = this._initializeBackDrop(), this._focustrap = this._initializeFocusTrap(), this._isShown = !1, this._isTransitioning = !1, this._scrollBar = new Ne, this._addEventListeners()
1184        }
1185        static get Default() {
1186            return Xe
1187        }
1188        static get DefaultType() {
1189            return Ye
1190        }
1191        static get NAME() {
1192            return "modal"
1193        }
1194        toggle(t) {
1195            return this._isShown ? this.hide() : this.show(t)
1196        }
1197        show(t) {
1198            this._isShown || this._isTransitioning || j.trigger(this._element, Fe, {
1199                relatedTarget: t
1200            }).defaultPrevented || (this._isShown = !0, this._isTransitioning = !0, this._scrollBar.hide(), document.body.classList.add(Ke), this._adjustDialog(), this._backdrop.show((() => this._showElement(t))))
1201        }
1202        hide() {
1203            this._isShown && !this._isTransitioning && (j.trigger(this._element, xe).defaultPrevented || (this._isShown = !1, this._isTransitioning = !0, this._focustrap.deactivate(), this._element.classList.remove(Ve), this._queueCallback((() => this._hideModal()), this._element, this._isAnimated())))
1204        }
1205        dispose() {
1206            j.off(window, Pe), j.off(this._dialog, Pe), this._backdrop.dispose(), this._focustrap.deactivate(), super.dispose()
1207        }
1208        handleUpdate() {
1209            this._adjustDialog()
1210        }
1211        _initializeBackDrop() {
1212            return new we({
1213                isVisible: Boolean(this._config.backdrop),
1214                isAnimated: this._isAnimated()
1215            })
1216        }
1217        _initializeFocusTrap() {
1218            return new Se({
1219                trapElement: this._element
1220            })
1221        }
1222        _showElement(t) {
1223            document.body.contains(this._element) || document.body.append(this._element), this._element.style.display = "block", this._element.removeAttribute("aria-hidden"), this._element.setAttribute("aria-modal", !0), this._element.setAttribute("role", "dialog"), this._element.scrollTop = 0;
1224            const e = K.findOne(".modal-body", this._dialog);
1225            e && (e.scrollTop = 0), g(this._element), this._element.classList.add(Ve), this._queueCallback((() => {
1226                this._config.focus && this._focustrap.activate(), this._isTransitioning = !1, j.trigger(this._element, ze, {
1227                    relatedTarget: t
1228                })
1229            }), this._dialog, this._isAnimated())
1230        }
1231        _addEventListeners() {
1232            j.on(this._element, We, (t => {
1233                "Escape" === t.key && (this._config.keyboard ? this.hide() : this._triggerBackdropTransition())
1234            })), j.on(window, He, (() => {
1235                this._isShown && !this._isTransitioning && this._adjustDialog()
1236            })), j.on(this._element, qe, (t => {
1237                j.one(this._element, Be, (e => {
1238                    this._element === t.target && this._element === e.target && ("static" !== this._config.backdrop ? this._config.backdrop && this.hide() : this._triggerBackdropTransition())
1239                }))
1240            }))
1241        }
1242        _hideModal() {
1243            this._element.style.display = "none", this._element.setAttribute("aria-hidden", !0), this._element.removeAttribute("aria-modal"), this._element.removeAttribute("role"), this._isTransitioning = !1, this._backdrop.hide((() => {
1244                document.body.classList.remove(Ke), this._resetAdjustments(), this._scrollBar.reset(), j.trigger(this._element, je)
1245            }))
1246        }
1247        _isAnimated() {
1248            return this._element.classList.contains("fade")
1249        }
1250        _triggerBackdropTransition() {
1251            if (j.trigger(this._element, Me).defaultPrevented) return;
1252            const t = this._element.scrollHeight > document.documentElement.clientHeight,
1253                e = this._element.style.overflowY;
1254            "hidden" === e || this._element.classList.contains(Qe) || (t || (this._element.style.overflowY = "hidden"), this._element.classList.add(Qe), this._queueCallback((() => {
1255                this._element.classList.remove(Qe), this._queueCallback((() => {
1256                    this._element.style.overflowY = e
1257                }), this._dialog)
1258            }), this._dialog), this._element.focus())
1259        }
1260        _adjustDialog() {
1261            const t = this._element.scrollHeight > document.documentElement.clientHeight,
1262                e = this._scrollBar.getWidth(),
1263                i = e > 0;
1264            if (i && !t) {
1265                const t = p() ? "paddingLeft" : "paddingRight";
1266                this._element.style[t] = `${e}px`
1267            }
1268            if (!i && t) {
1269                const t = p() ? "paddingRight" : "paddingLeft";
1270                this._element.style[t] = `${e}px`
1271            }
1272        }
1273        _resetAdjustments() {
1274            this._element.style.paddingLeft = "", this._element.style.paddingRight = ""
1275        }
1276        static jQueryInterface(t, e) {
1277            return this.each((function() {
1278                const i = Ue.getOrCreateInstance(this, t);
1279                if ("string" == typeof t) {
1280                    if (void 0 === i[t]) throw new TypeError(`No method n

1643            this._popper && this._popper.update()
1644        }
1645        _isWithContent() {
1646            return Boolean(this._getTitle())
1647        }
1648        _getTipElement() {
1649            return this.tip || (this.tip = this._createTipElement(this._newContent || this._getContentForTemplate())), this.tip
1650        }
1651        _createTipElement(t) {
1652            const e = this._getTemplateFactory(t).toHtml();
1653            if (!e) return null;
1654            e.classList.remove(Ci, Ti), e.classList.add(`bs-${this.constructor.NAME}-auto`);
1655            const i = (t => {
1656                do {
1657                    t += Math.floor(1e6 * Math.random())
1658                } while (document.getElementById(t));
1659                return t
1660            })(this.constructor.NAME).toString();
1661            return e.setAttribute("id", i), this._isAnimated() && e.classList.add(Ci), e
1662        }
1663        setContent(t) {
1664            this._newContent = t, this._isShown() && (this._disposePopper(), this.show())
1665        }
1666        _getTemplateFactory(t) {
1667            return this._templateFactory ? this._templateFactory.changeContent(t) : this._templateFactory = new Ai({ ...this._config,
1668                content: t,
1669                extraClass: this._resolvePossibleFunction(this._config.customClass)
1670            }), this._templateFactory
1671        }
1672        _getContentForTemplate() {
1673            return {
1674                ".tooltip-inner": this._getTitle()
1675            }
1676        }
1677        _getTitle() {
1678            return this._resolvePossibleFunction(this._config.title) || this._element.getAttribute("data-bs-original-title")
1679        }
1680        _initializeOnDelegatedTarget(t) {
1681            return this.constructor.getOrCreateInstance(t.delegateTarget, this._getDelegateConfig())
1682        }
1683        _isAnimated() {
1684            return this._config.animation || this.tip && this.tip.classList.contains(Ci)
1685        }
1686        _isShown() {
1687            return this.tip && this.tip.classList.contains(Ti)
1688        }
1689        _createPopper(t) {
1690            const e = v(this._config.placement, [this, t, this._element]),
1691                s = Oi[e.toUpperCase()];
1692            return i.createPopper(this._element, t, this._getPopperConfig(s))
1693        }
1694        _getOffset() {
1695            const {
1696                offset: t
1697            } = this._config;
1698            return "string" == typeof t ? t.split(",").map((t => Number.parseInt(t, 10))) : "function" == typeof t ? e => t(e, this._element) : t
1699        }
1700        _resolvePossibleFunction(t) {
1701            return v(t, [this._element])
1702        }
1703        _getPopperConfig(t) {
1704            const e = {
1705                placement: t,
1706                modifiers: [{
1707                    name: "flip",
1708                    options: {
1709                        fallbackPlacements: this._config.fallbackPlacements
1710                    }
1711                }, {
1712                    name: "offset",
1713                    options: {
1714                        offset: this._getOffset()
1715                    }
1716                }, {
1717                    name: "preventOverflow",
1718                    options: {
1719                        boundary: this._config.boundary
1720                    }
1721                }, {
1722                    name: "arrow",
1723                    options: {
1724                        element: `.${this.constructor.NAME}-arrow`
1725                    }
1726                }, {
1727                    name: "preSetPlacement",
1728                    enabled: !0,
1729                    phase: "beforeMain",
1730                    fn: t => {
1731                        this._getTipElement().setAttribute("data-popper-placement", t.state.placement)
1732                    }
1733                }]
1734            };
1735            return { ...e,
1736                ...v(this._config.popperConfig, [e])
1737            }
1738        }
1739        _setListeners() {
1740            const t = this._config.trigger.split(" ");
1741            for (const e of t)
1742                if ("click" === e) j.on(this._element, this.constructor.eventName("click"), this._config.selector, (t => {
1743                    this._initializeOnDelegatedTarget(t).toggle()
1744                }));
1745                else if ("manual" !== e) {
1746                const t = e === Si ? this.constructor.eventName("mouseenter") : this.constructor.eventName("focusin"),
1747                    i = e === Si ? this.constructor.eventName("mouseleave") : this.constructor.eventName("focusout");
1748                j.on(this._element, t, this._config.selector, (t => {
1749                    const e = this._initializeOnDelegatedTarget(t);
1750                    e._activeTrigger["focusin" === t.type ? Li : Si] = !0, e._enter()
1751                })), j.on(this._element, i, this._config.selector, (t => {
1752                    const e = this._initializeOnDelegatedTarget(t);
1753                    e._activeTrigger["focusout" === t.type ? Li : Si] = e._element.contains(t.relatedTarget), e._leave()
1754                }))
1755            }
1756            this._hideModalHandler = () => {
1757                this._element && this.hide()
1758            }, j.on(this._element.closest(ki), $i, this._hideModalHandler)
1759        }
1760        _fixTitle() {
1761            const t = this._element.getAttribute("title");
1762            t && (this._element.getAttribute("aria-label") || this._element.textContent.trim() || this._element.setAttribute("aria-label", t), this._element.setAttribute("data-bs-original-title", t), this._element.removeAttribute("title"))
1763        }
1764        _enter() {
1765            this._isShown() || this._isHovered ? this._isHovered = !0 : (this._isHovered = !0, this._setTimeout((() => {
1766                this._isHovered && this.show()
1767            }), this._config.delay.show))
1768        }
1769        _leave() {
1770            this._isWithActiveTrigger() || (this._isHovered = !1, this._setTimeout((() => {
1771                this._isHovered || this.hide()
1772            }), this._config.delay.hide))
1773        }
1774        _setTimeout(t, e) {
1775            clearTimeout(this._timeout), this._timeout = setTimeout(t, e)
1776        }
1777        _isWithActiveTrigger() {
1778            return Object.values(this._activeTrigger).includes(!0)
1779        }
1780        _getConfig(t) {
1781            const e = B.getDataAttributes(this._element);
1782            for (const t of Object.keys(e)) Ei.has(t) && delete e[t];
1783            return t = { ...e,
1784                ..."object" == typeof t && t ? t : {}
1785            }, t = this._mergeConfigObj(t), t = this._configAfterMerge(t), this._typeCheckConfig(t), t
1786        }
1787        _configAfterMerge(t) {
1788            return t.container = !1 === t.container ? document.body : c(t.container), "number" == typeof t.delay && (t.delay = {
1789                show: t.delay,
1790                hide: t.delay
1791            }), "number" == typeof t.title && (t.title = t.title.toString()), "number" == typeof t.content && (t.content = t.content.toString()), t
1792        }
1793        _getDelegateConfig() {
1794            const t = {};
1795            for (const [e, i] of Object.entries(this._config)) this.constructor.Default[e] !== i && (t[e] = i);
1796            return t.selector = !1, t.trigger = "manual", t
1797        }
1798        _disposePopper() {
1799            this._popper && (this._popper.destroy(), this._popper = null), this.tip && (this.tip.remove(), this.tip = null)
1800        }
1801        static jQueryInterface(t) {
1802            return this.each((function() {
1803                const e = Ni.getOrCreateInstance(this, t);
1804                if ("string" == typeof t) {
1805                    if (void 0 === e[t]) throw new TypeError(`No method n

2090            return t.closest(".nav-item, .list-group-item") || t
2091        }
2092        static jQueryInterface(t) {
2093            return this.each((function() {
2094                const e = ms.getOrCreateInstance(this);
2095                if ("string" == typeof t) {
2096                    if (void 0 === e[t] || t.startsWith("_") || "constructor" === t) throw new TypeError(`No method named "${t}"`);
2097                    e[t]()
2098                }
2099            }))
2100        }
2101    }
2102    j.on(document, Zi, _s, (function(t) {
2103        ["A", "AREA"].includes(this.tagName) && t.preventDefault(), d(this) || ms.getOrCreateInstance(this).show()
2104    })), j.on(window, es, (() => {
2105        for (const t of K.find(fs)) ms.getOrCreateInstance(t)
2106    })), b(ms);
2107    const ps = ".bs.toast",
2108        bs = `mouseover${ps}`,
2109        vs = `mouseout${ps}`,
2110        ys = `focusin${ps}`,
2111        ws = `focusout${ps}`,
2112        As = `hide${ps}`,
2113        Es = `hidden${ps}`,
2114        Cs = `show${ps}`,
2115        Ts = `shown${ps}`,
2116        ks = "hide",
2117        $s = "show",
2118        Ss = "showing",
2119        Ls = {
2120            animation: "boolean",
2121            autohide: "boolean",
2122            delay: "number"
2123        },
2124        Os = {
2125            animation: !0,
2126            autohide: !0,
2127            delay: 5e3
2128        };
2129    class Is extends W {
2130        constructor(t, e) {
2131            super(t, e), this._timeout = null, this._hasMouseInteraction = !1, this._hasKeyboardInteraction = !1, this._setListeners()
2132        }
2133        static get Default() {
2134            return Os
2135        }
2136        static get DefaultType() {
2137            return Ls
2138        }
2139        static get NAME() {
2140            return "toast"
2141        }
2142        show() {
2143            j.trigger(this._element, Cs).defaultPrevented || (this._clearTimeout(), this._config.animation && this._element.classList.add("fade"), this._element.classList.remove(ks), g(this._element), this._element.classList.add($s, Ss), this._queueCallback((() => {
2144                this._element.classList.remove(Ss), j.trigger(this._element, Ts), this._maybeScheduleHide()
2145            }), this._element, this._config.animation))
2146        }
2147        hide() {
2148            this.isShown() && (j.trigger(this._element, As).defaultPrevented || (this._element.classList.add(Ss), this._queueCallback((() => {
2149                this._element.classList.add(ks), this._element.classList.remove(Ss, $s), j.trigger(this._element, Es)
2150            }), this._element, this._config.animation)))
2151        }
2152        dispose() {
2153            this._clearTimeout(), this.isShown() && this._element.classList.remove($s), super.dispose()
2154        }
2155        isShown() {
2156            return this._element.classList.contains($s)
2157        }
2158        _maybeScheduleHide() {
2159            this._config.autohide && (this._hasMouseInteraction || this._hasKeyboardInteraction || (this._timeout = setTimeout((() => {
2160                this.hide()
2161            }), this._config.delay)))
2162        }
2163        _onInteraction(t, e) {
2164            switch (t.type) {
2165                case "mouseover":
2166                case "mouseout":
2167                    this._hasMouseInteraction = e;
2168                    break;
2169                case "focusin":
2170                case "focusout":
2171                    this._hasKeyboardInteraction = e
2172            }
2173            if (e) return void this._clearTimeout();
2174            const i = t.relatedTarget;
2175            this._element === i || this._element.contains(i) || this._maybeScheduleHide()
2176        }
2177        _setListeners() {
2178            j.on(this._element, bs, (t => this._onInteraction(t, !0))), j.on(this._element, vs, (t => this._onInteraction(t, !1))), j.on(this._element, ys, (t => this._onInteraction(t, !0))), j.on(this._element, ws, (t => this._onInteraction(t, !1)))
2179        }
2180        _clearTimeout() {
2181            clearTimeout(this._timeout), this._timeout = null
2182        }
2183        static jQueryInterface(t) {
2184            return this.each((function() {
2185                const e = Is.getOrCreateInstance(this, t);
2186                if ("string" == typeof t) {
2187                    if (void 0 === e[t]) throw new TypeError(`No method n