https://www.pinesol.ca/js/bootstrap.min.js

52            Object.keys(i).forEach((s) => {
53                const n = i[s],
54                    o = e[s],
55                    r =
56                        o && l(o)
57                            ? 'element'
58                            : null == (a = o)
59                              ? `${a}`
60                              : {}.toString
61                                    .call(a)
62                                    .match(/\s([a-z]+)/i)[1]
63                                    .toLowerCase();
64                var a;
65                if (!new RegExp(n).test(r))
66                    throw new TypeError(
67                        `${t.toUpperCase()}: Option "${s}" provided type "${r}" but expected type "${n}".`
68                    );
69            });
70        },
71        d = (t) =>
72            !(!l(t) || 0 === t.getClientRects().length) &&
73            'visible' === getComputedStyle(t).getPropertyValue('visibility'),
74        u = (t) =>
75            !t ||
76            t.nodeType !== Node.ELEMENT_NODE ||
77            !!t.classList.contains('disabled') ||
78            (void 0 !== t.disabled ? t.disabled : t.hasAttribute('disabled') && 'false' !== t.getAttribute('disabled')),
79        g = (t) => {
80            if (!document.documentElement.attachShadow) return null;
81            if ('function' == typeof t.getRootNode) {
82                const e = t.getRootNode();
83                return e instanceof ShadowRoot ? e : null;
84            }
85            return t instanceof ShadowRoot ? t : t.parentNode ? g(t.parentNode) : null;
86        },
87        _ = () => {},
88        f = (t) => {
89            t.offsetHeight;
90        },
91        p = () => {
92            const { jQuery: t } = window;
93            return t && !document.body.hasAttribute('data-bs-no-jquery') ? t : null;
94        },
95        m = [],
96        b = () => 'rtl' === document.documentElement.dir,
97        v = (t) => {
98            var e;
99            (e = () => {
100                const e = p();
101                if (e) {
102                    const i = t.NAME,
103                        s = e.fn[i];
104                    (e.fn[i] = t.jQueryInterface),
105                        (e.fn[i].Constructor = t),
106                        (e.fn[i].noConflict = () => ((e.fn[i] = s), t.jQueryInterface));
107                }
108            }),
109                'loading' === document.readyState
110                    ? (m.length ||
111                          document.addEventListener('DOMContentLoaded', () => {
112                              m.forEach((t) => t());
113                          }),
114                      m.push(e))
115                    : e();
116        },
117        y = (t) => {
118            'function' == typeof t && t();
119        },
120        E = (t, e, i = !0) => {
121            if (!i) return void y(t);
122            const n =
123                ((t) => {
124                    if (!t) return 0;
125                    let { transitionDuration: e, transitionDelay: i } = window.getComputedStyle(t);
126                    const s = Number.parseFloat(e),
127                        n = Number.parseFloat(i);
128                    return s || n
129                        ? ((e = e.split(',')[0]),
130                          (i = i.split(',')[0]),
131                          1e3 * (Number.parseFloat(e) + Number.parseFloat(i)))
132                        : 0;
133                })(e) + 5;
134            let o = !1;
135            const r = ({ target: i }) => {
136                i === e && ((o = !0), e.removeEventListener(s, r), y(t));
137            };
138            e.addEventListener(s, r),
139                setTimeout(() => {
140                    o || a(e);
141                }, n);
142        },
143        w = (t, e, i, s) => {
144            let n = t.indexOf(e);
145            if (-1 === n) return t[!i && s ? t.length - 1 : 0];
146            const o = t.length;
147            return (n += i ? 1 : -1), s && (n = (n + o) % o), t[Math.max(0, Math.min(n, o - 1))];
148        },
149        A = /[^.]*(?=\..*)\.|.*/,
150        T = /\..*/,
151        C = /::\d+$/,
152        k = {};
153    let L = 1;
154    const S = { mouseenter: 'mouseover', mouseleave: 'mouseout' },
155        O = /^(mouseenter|mouseleave)/i,
156        N = new Set([
157            'click',
158            'dblclick',
159            'mouseup',
160            'mousedown',
161            'contextmenu',
162            'mousewheel',
163            'DOMMouseScroll',
164            'mouseover',
165            'mouseout',
166            'mousemove',
167            'selectstart',
168            'selectend',
169            'keydown',
170            'keypress',
171            'keyup',
172            'orientationchange',
173            'touchstart',
174            'touchmove',
175            'touchend',
176            'touchcancel',
177            'pointerdown',
178            'pointermove',
179            'pointerup',
180            'pointerleave',
181            'pointercancel',
182            'gesturestart',
183            'gesturechange',
184            'gestureend',
185            'focus',
186            'blur',
187            'change',
188            'reset',
189            'select',
190            'submit',
191            'focusin',
192            'focusout',
193            'load',
194            'unload',
195            'beforeunload',
196            'resize',
197            'move',
198            'DOMContentLoaded',
199            'readystatechange',
200            'error',
201            'abort',
202            'scroll',
203        ]);
204    function D(t, e) {
205        return (e && `${e}::${L++}`) || t.uidEvent || L++;
206    }
207    function I(t) {
208        const e = D(t);
209        return (t.uidEvent = e), (k[e] = k[e] || {}), k[e];
210    }
211    function P(t, e, i = null) {
212        const s = Object.keys(t);
213        for (let n = 0, o = s.length; n < o; n++) {
214            const o = t[s[n]];
215            if (o.originalHandler === e && o.delegationSelector === i) return o;
216        }
217        return null;
218    }
219    function x(t, e, i) {
220        const s = 'string' == typeof e,
221            n = s ? i : e;
222        let o = H(t);
223        return N.has(o) || (o = t), [s, n, o];
224    }
225    function M(t, e, i, s, n) {
226        if ('string' != typeof e || !t) return;
227        if ((i || ((i = s), (s = null)), O.test(e))) {
228            const t = (t) =>
229                function (e) {
230                    if (
231                        !e.relatedTarget ||
232                        (e.relatedTarget !== e.delegateTarget && !e.delegateTarget.contains(e.relatedTarget))
233                    )
234                        return t.call(this, e);
235                };
236            s ? (s = t(s)) : (i = t(i));
237        }
238        const [o, r, a] = x(e, i, s),
239            l = I(t),
240            c = l[a] || (l[a] = {}),
241            h = P(c, r, o ? i : null);
242        if (h) return void (h.oneOff = h.oneOff && n);
243        const d = D(r, e.replace(A, '')),
244            u = o
245                ? (function (t, e, i) {
246                      return function s(n) {
247                          const o = t.querySelectorAll(e);
248                          for (let { target: r } = n; r && r !== this; r = r.parentNode)
249                              for (let a = o.length; a--; )
250                                  if (o[a] === r)
251                                      return (
252                                          (n.delegateTarget = r), s.oneOff && $.off(t, n.type, e, i), i.apply(r, [n])
253                                      );
254                          return null;
255                      };
256                  })(t, i, s)
257                : (function (t, e) {
258                      return function i(s) {
259                          return (s.delegateTarget = t), i.oneOff && $.off(t, s.type, e), e.apply(t, [s]);
260                      };
261                  })(t, i);
262        (u.delegationSelector = o ? i : null),
263            (u.originalHandler = r),
264            (u.oneOff = n),
265            (u.uidEvent = d),
266            (c[d] = u),
267            t.addEventListener(a, u, o);
268    }
269    function j(t, e, i, s, n) {
270        const o = P(e[i], s, n);
271        o && (t.removeEventListener(i, o, Boolean(n)), delete e[i][o.uidEvent]);
272    }
273    function H(t) {
274        return (t = t.replace(T, '')), S[t] || t;
275    }
276    const $ = {
277            on(t, e, i, s) {
278                M(t, e, i, s, !1);
279            },
280            one(t, e, i, s) {
281                M(t, e, i, s, !0);
282            },
283            off(t, e, i, s) {
284                if ('string' != typeof e || !t) return;
285                const [n, o, r] = x(e, i, s),
286                    a = r !== e,
287                    l = I(t),
288                    c = e.startsWith('.');
289                if (void 0 !== o) {
290                    if (!l || !l[r]) return;
291                    return void j(t, l, r, o, n ? i : null);
292                }
293                c &&
294                    Object.keys(l).forEach((i) => {
295                        !(function (t, e, i, s) {
296                            const n = e[i] || {};
297                            Object.keys(n).forEach((o) => {
298                                if (o.includes(s)) {
299                                    const s = n[o];
300                                    j(t, e, i, s.originalHandler, s.delegationSelector);
301                                }
302                            });
303                        })(t, l, i, e.slice(1));
304                    });
305                const h = l[r] || {};
306                Object.keys(h).forEach((i) => {
307                    const s = i.replace(C, '');
308                    if (!a || e.includes(s)) {
309                        const e = h[i];
310                        j(t, l, r, e.originalHandler, e.delegationSelector);
311                    }
312                });
313            },
314            trigger(t, e, i) {
315                if ('string' != typeof e || !t) return null;
316                const s = p(),
317                    n = H(e),
318                    o = e !== n,
319                    r = N.has(n);
320                let a,
321                    l = !0,
322                    c = !0,
323                    h = !1,
324                    d = null;
325                return (
326                    o &&
327                        s &&
328                        ((a = s.Event(e, i)),
329                        s(t).trigger(a),
330                        (l = !a.isPropagationStopped()),
331                        (c = !a.isImmediatePropagationStopped()),
332                        (h = a.isDefaultPrevented())),
333                    r
334                        ? ((d = document.createEvent('HTMLEvents')), d.initEvent(n, l, !0))
335                        : (d = new CustomEvent(e, { bubbles: l, cancelable: !0 })),
336                    void 0 !== i &&
337                        Object.keys(i).forEach((t) => {
338                            Object.defineProperty(d, t, { get: () => i[t] });
339                        }),
340                    h && d.preventDefault(),
341                    c && t.dispatchEvent(d),
342                    d.defaultPrevented && void 0 !== a && a.preventDefault(),
343                    d
344                );
345            },
346        },
347        B = new Map(),
348        z = {
349            set(t, e, i) {
350                B.has(t) || B.set(t, new Map());
351                const s = B.get(t);
352                s.has(e) || 0 === s.size
353                    ? s.set(e, i)
354                    : console.error(
355                          `Bootstrap doesn't allow more than one instance per element. Bound instance: ${Array.from(s.keys())[0]}.`
356                      );
357            },
358            get: (t, e) => (B.has(t) && B.get(t).get(e)) || null,
359            remove(t, e) {
360                if (!B.has(t)) return;
361                const i = B.get(t);
362                i.delete(e), 0 === i.size && B.delete(t);
363            },
364        };
365    class R {
366        constructor(t) {
367            (t = c(t)) && ((this._element = t), z.set(this._element, this.constructor.DATA_KEY, this));
368        }
369        dispose() {
370            z.remove(this._element, this.constructor.DATA_KEY),
371                $.off(this._element, this.constructor.EVENT_KEY),
372                Object.getOwnPropertyNames(this).forEach((t) => {
373                    this[t] = null;
374                });
375        }
376        _queueCallback(t, e, i = !0) {
377            E(t, e, i);
378        }
379        static getInstance(t) {
380            return z.get(c(t), this.DATA_KEY);
381        }
382        static getOrCreateInstance(t, e = {}) {
383            return this.getInstance(t) || new this(t, 'object' == typeof e ? e : null);
384        }
385        static get VERSION() {
386            return '5.1.3';
387        }
388        static get NAME() {
389            throw new Error('You have to implement the static method "NAME", for each component!');
390        }
391        static get DATA_KEY() {
392            return `bs.${this.NAME}`;
393        }
394        static get EVENT_KEY() {
395            return `.${this.DATA_KEY}`;
396        }
397    }
398    const F = (t, e = 'hide') => {
399        const i = `click.dismiss${t.EVENT_KEY}`,
400            s = t.NAME;
401        $.on(document, i, `[data-bs-dismiss="${s}"]`, function (i) {
402            if ((['A', 'AREA'].includes(this.tagName) && i.preventDefault(), u(this))) return;
403            const n = r(this) || this.closest(`.${s}`);
404            t.getOrCreateInstance(n)[e]();
405        });
406    };
407    class q extends R {
408        static get NAME() {
409            return 'alert';
410        }
411        close() {
412            if ($.trigger(this._element, 'close.bs.alert').defaultPrevented) return;
413            this._element.classList.remove('show');
414            const t = this._element.classList.contains('fade');
415            this._queueCallback(() => this._destroyElement(), this._element, t);
416        }
417        _destroyElement() {
418            this._element.remove(), $.trigger(this._element, 'closed.bs.alert'), this.dispose();
419        }
420        static jQueryInterface(t) {
421            return this.each(function () {
422                const e = q.getOrCreateInstance(this);
423                if ('string' == typeof t) {
424                    if (void 0 === e[t] || t.startsWith('_') || 'constructor' === t)
425                        throw new TypeError(`No method named "${t}"`);
426                    e[t](this);
427                }
428            });
429        }
430    }
431    F(q, 'close'), v(q);
432    const W = '[data-bs-toggle="button"]';
433    class U extends R {
434        static get NAME() {
435            return 'button';
436        }
437        toggle() {
438            this._element.setAttribute('aria-pressed', this._element.classList.toggle('active'));
439        }
440        static jQueryInterface(t) {
441            return this.each(function () {
442                const e = U.getOrCreateInstance(this);
443                'toggle' === t && e[t]();
444            });
445        }
446    }
447    function K(t) {
448        return (
449            'true' === t ||
450            ('false' !== t && (t === Number(t).toString() ? Number(t) : '' === t || 'null' === t ? null : t))
451        );
452    }
453    function V(t) {
454        return t.replace(/[A-Z]/g, (t) => `-${t.toLowerCase()}`);
455    }
456    $.on(document, 'click.bs.button.data-api', W, (t) => {
457        t.preventDefault();
458        const e = t.target.closest(W);
459        U.getOrCreateInstance(e).toggle();
460    }),
461        v(U);
462    const X = {
463            setDataAttribute(t, e, i) {
464                t.setAttribute(`data-bs-${V(e)}`, i);
465            },
466            removeDataAttribute(t, e) {
467                t.removeAttribute(`data-bs-${V(e)}`);
468            },
469            getDataAttributes(t) {
470                if (!t) return {};
471                const e = {};
472                return (
473                    Object.keys(t.dataset)
474                        .filter((t) => t.startsWith('bs'))
475                        .forEach((i) => {
476                            let s = i.replace(/^bs/, '');
477                            (s = s.charAt(0).toLowerCase() + s.slice(1, s.length)), (e[s] = K(t.dataset[i]));
478                        }),
479                    e
480                );
481            },
482            getDataAttribute: (t, e) => K(t.getAttribute(`data-bs-${V(e)}`)),
483            offset(t) {
484                const e = t.getBoundingClientRect();
485                return { top: e.top + window.pageYOffset, left: e.left + window.pageXOffset };
486            },
487            position: (t) => ({ top: t.offsetTop, left: t.offsetLeft }),
488        },
489        Y = {
490            find: (t, e = document.documentElement) => [].concat(...Element.prototype.querySelectorAll.call(e, t)),
491            findOne: (t, e = document.documentElement) => Element.prototype.querySelector.call(e, t),
492            children: (t, e) => [].concat(...t.children).filter((t) => t.matches(e)),
493            parents(t, e) {
494                const i = [];
495                let s = t.parentNode;
496                for (; s && s.nodeType === Node.ELEMENT_NODE && 3 !== s.nodeType; )
497                    s.matches(e) && i.push(s), (s = s.parentNode);
498                return i;
499            },
500            prev(t, e) {
501                let i = t.previousElementSibling;
502                for (; i; ) {
503                    if (i.matches(e)) return [i];
504                    i = i.previousElementSibling;
505                }
506                return [];
507            },
508            next(t, e) {
509                let i = t.nextElementSibling;
510                for (; i; ) {
511                    if (i.matches(e)) return [i];
512                    i = i.nextElementSibling;
513                }
514                return [];
515            },
516            focusableChildren(t) {
517                const e = [
518                    'a',
519                    'button',
520                    'input',
521                    'textarea',
522                    'select',
523                    'details',
524                    '[tabindex]',
525                    '[contenteditable="true"]',
526                ]
527                    .map((t) => `${t}:not([tabindex^="-"])`)
528                    .join(', ');
529                return this.find(e, t).filter((t) => !u(t) && d(t));
530            },
531        },
532        Q = 'carousel',
533        G = { interval: 5e3, keyboard: !0, slide: !1, pause: 'hover', wrap: !0, touch: !0 },
534        Z = {
535            interval: '(number|boolean)',
536            keyboard: 'boolean',
537            slide: '(boolean|string)',
538            pause: '(string|boolean)',
539            wrap: 'boolean',
540            touch: 'boolean',
541        },
542        J = 'next',
543        tt = 'prev',
544        et = 'left',
545        it = 'right',
546        st = { ArrowLeft: it, ArrowRight: et },
547        nt = 'slid.bs.carousel',
548        ot = 'active',
549        rt = '.active.carousel-item';
550    class at extends R {
551        constructor(t, e) {
552            super(t),
553                (this._items = null),
554                (this._interval = null),
555                (this._activeElement = null),
556                (this._isPaused = !1),
557                (this._isSliding = !1),
558                (this.touchTimeout = null),
559                (this.touchStartX = 0),
560                (this.touchDeltaX = 0),
561                (this._config = this._getConfig(e)),
562                (this._indicatorsElement = Y.findOne('.carousel-indicators', this._element)),
563                (this._touchSupported = 'ontouchstart' in document.documentElement || navigator.maxTouchPoints > 0),
564                (this._pointerEvent = Boolean(window.PointerEvent)),
565                this._addEventListeners();
566        }
567        static get Default() {
568            return G;
569        }
570        static get NAME() {
571            return Q;
572        }
573        next() {
574            this._slide(J);
575        }
576        nextWhenVisible() {
577            !document.hidden && d(this._element) && this.next();
578        }
579        prev() {
580            this._slide(tt);
581        }
582        pause(t) {
583            t || (this._isPaused = !0),
584                Y.findOne('.carousel-item-next, .carousel-item-prev', this._element) &&
585                    (a(this._element), this.cycle(!0)),
586                clearInterval(this._interval),
587                (this._interval = null);
588        }
589        cycle(t) {
590            t || (this._isPaused = !1),
591                this._interval && (clearInterval(this._interval), (this._interval = null)),
592                this._config &&
593                    this._config.interval &&
594                    !this._isPaused &&
595                    (this._updateInterval(),
596                    (this._interval = setInterval(
597                        (document.visibilityState ? this.nextWhenVisible : this.next).bind(this),
598                        this._config.interval
599                    )));
600        }
601        to(t) {
602            this._activeElement = Y.findOne(rt, this._element);
603            const e = this._getItemIndex(this._activeElement);
604            if (t > this._items.length - 1 || t < 0) return;
605            if (this._isSliding) return void $.one(this._element, nt, () => this.to(t));
606            if (e === t) return this.pause(), void this.cycle();
607            const i = t > e ? J : tt;
608            this._slide(i, this._items[t]);
609        }
610        _getConfig(t) {
611            return (
612                (t = { ...G, ...X.getDataAttributes(this._element), ...('object' == typeof t ? t : {}) }), h(Q, t, Z), t
613            );
614        }
615        _handleSwipe() {
616            const t = Math.abs(this.touchDeltaX);
617            if (t <= 40) return;
618            const e = t / this.touchDeltaX;
619            (this.touchDeltaX = 0), e && this._slide(e > 0 ? it : et);
620        }
621        _addEventListeners() {
622            this._config.keyboard && $.on(this._element, 'keydown.bs.carousel', (t) => this._keydown(t)),
623                'hover' === this._config.pause &&
624                    ($.on(this._element, 'mouseenter.bs.carousel', (t) => this.pause(t)),
625                    $.on(this._element, 'mouseleave.bs.carousel', (t) => this.cycle(t))),
626                this._config.touch && this._touchSupported && this._addTouchEventListeners();
627        }
628        _addTouchEventListeners() {
629            const t = (t) => this._pointerEvent && ('pen' === t.pointerType || 'touch' === t.pointerType),
630                e = (e) => {
631                    t(e)
632                        ? (this.touchStartX = e.clientX)
633                        : this._pointerEvent || (this.touchStartX = e.touches[0].clientX);
634                },
635                i = (t) => {
636                    this.touchDeltaX = t.touches && t.touches.length > 1 ? 0 : t.touches[0].clientX - this.touchStartX;
637                },
638                s = (e) => {
639                    t(e) && (this.touchDeltaX = e.clientX - this.touchStartX),
640                        this._handleSwipe(),
641                        'hover' === this._config.pause &&
642                            (this.pause(),
643                            this.touchTimeout && clearTimeout(this.touchTimeout),
644                            (this.touchTimeout = setTimeout((t) => this.cycle(t), 500 + this._config.interval)));
645                };
646            Y.find('.carousel-item img', this._element).forEach((t) => {
647                $.on(t, 'dragstart.bs.carousel', (t) => t.preventDefault());
648            }),
649                this._pointerEvent
650                    ? ($.on(this._element, 'pointerdown.bs.carousel', (t) => e(t)),
651                      $.on(this._element, 'pointerup.bs.carousel', (t) => s(t)),
652                      this._element.classList.add('pointer-event'))
653                    : ($.on(this._element, 'touchstart.bs.carousel', (t) => e(t)),
654                      $.on(this._element, 'touchmove.bs.carousel', (t) => i(t)),
655                      $.on(this._element, 'touchend.bs.carousel', (t) => s(t)));
656        }
657        _keydown(t) {
658            if (/input|textarea/i.test(t.target.tagName)) return;
659            const e = st[t.key];
660            e && (t.preventDefault(), this._slide(e));
661        }
662        _getItemIndex(t) {
663            return (
664                (this._items = t && t.parentNode ? Y.find('.carousel-item', t.parentNode) : []), this._items.indexOf(t)
665            );
666        }
667        _getItemByOrder(t, e) {
668            const i = t === J;
669            return w(this._items, e, i, this._config.wrap);
670        }
671        _triggerSlideEvent(t, e) {
672            const i = this._getItemIndex(t),
673                s = this._getItemIndex(Y.findOne(rt, this._element));
674            return $.trigger(this._element, 'slide.bs.carousel', { relatedTarget: t, direction: e, from: s, to: i });
675        }
676        _setActiveIndicatorElement(t) {
677            if (this._indicatorsElement) {
678                const e = Y.findOne('.active', this._indicatorsElement);
679                e.classList.remove(ot), e.removeAttribute('aria-current');
680                const i = Y.find('[data-bs-target]', this._indicatorsElement);
681                for (let e = 0; e < i.length; e++)
682                    if (Number.parseInt(i[e].getAttribute('data-bs-slide-to'), 10) === this._getItemIndex(t)) {
683                        i[e].classList.add(ot), i[e].setAttribute('aria-current', 'true');
684                        break;
685                    }
686            }
687        }
688        _updateInterval() {
689            const t = this._activeElement || Y.findOne(rt, this._element);
690            if (!t) return;
691            const e = Number.parseInt(t.getAttribute('data-bs-interval'), 10);
692            e
693                ? ((this._config.defaultInterval = this._config.defaultInterval || this._config.interval),
694                  (this._config.interval = e))
695                : (this._config.interval = this._config.defaultInterval || this._config.interval);
696        }
697        _slide(t, e) {
698            const i = this._directionToOrder(t),
699                s = Y.findOne(rt, this._element),
700                n = this._getItemIndex(s),
701                o = e || this._getItemByOrder(i, s),
702                r = this._getItemIndex(o),
703                a = Boolean(this._interval),
704                l = i === J,
705                c = l ? 'carousel-item-start' : 'carousel-item-end',
706                h = l ? 'carousel-item-next' : 'carousel-item-prev',
707                d = this._orderToDirection(i);
708            if (o && o.classList.contains(ot)) return void (this._isSliding = !1);
709            if (this._isSliding) return;
710            if (this._triggerSlideEvent(o, d).defaultPrevented) return;
711            if (!s || !o) return;
712            (this._isSliding = !0), a && this.pause(), this._setActiveIndicatorElement(o), (this._activeElement = o);
713            const u = () => {
714                $.trigger(this._element, nt, { relatedTarget: o, direction: d, from: n, to: r });
715            };
716            if (this._element.classList.contains('slide')) {
717                o.classList.add(h), f(o), s.classList.add(c), o.classList.add(c);
718                const t = () => {
719                    o.classList.remove(c, h),
720                        o.classList.add(ot),
721                        s.classList.remove(ot, h, c),
722                        (this._isSliding = !1),
723                        setTimeout(u, 0);
724                };
725                this._queueCallback(t, s, !0);
726            } else s.classList.remove(ot), o.classList.add(ot), (this._isSliding = !1), u();
727            a && this.cycle();
728        }
729        _directionToOrder(t) {
730            return [it, et].includes(t) ? (b() ? (t === et ? tt : J) : t === et ? J : tt) : t;
731        }
732        _orderToDirection(t) {
733            return [J, tt].includes(t) ? (b() ? (t === tt ? et : it) : t === tt ? it : et) : t;
734        }
735        static carouselInterface(t, e) {
736            const i = at.getOrCreateInstance(t, e);
737            let { _config: s } = i;
738            'object' == typeof e && (s = { ...s, ...e });
739            const n = 'string' == typeof e ? e : s.slide;
740            if ('number' == typeof e) i.to(e);
741            else if ('string' == typeof n) {
742                if (void 0 === i[n]) throw new TypeError(`No method n

988);
989        }
990        _completeHide(t) {
991            $.trigger(this._element, 'hide.bs.dropdown', t).defaultPrevented ||
992                ('ontouchstart' in document.documentElement &&
993                    [].concat(...document.body.children).forEach((t) => $.off(t, 'mouseover', _)),
994                this._popper && this._popper.destroy(),
995                this._menu.classList.remove(kt),
996                this._element.classList.remove(kt),
997                this._element.setAttribute('aria-expanded', 'false'),
998                X.removeDataAttribute(this._menu, 'popper'),
999                $.trigger(this._element, 'hidden.bs.dropdown', t));
1000        }
1001        _getConfig(t) {
1002            if (
1003                ((t = { ...this.constructor.Default, ...X.getDataAttributes(this._element), ...t }),
1004                h(bt, t, this.constructor.DefaultType),
1005                'object' == typeof t.reference &&
1006                    !l(t.reference) &&
1007                    'function' != typeof t.reference.getBoundingClientRect)
1008            )
1009                throw new TypeError(
1010                    `${bt.toUpperCase()}: Option "reference" provided type "object" without a required "getBoundingClientRect" method.`
1011                );
1012            return t;
1013        }
1014        _createPopper(t) {
1015            if (void 0 === i) throw new TypeError("Bootstrap's dropdowns require Popper (https://popper.js.org)");
1016            let e = this._element;
1017            'parent' === this._config.reference
1018                ? (e = t)
1019                : l(this._config.reference)
1020                  ? (e = c(this._config.reference))
1021                  : 'object' == typeof this._config.reference && (e = this._config.reference);
1022            const s = this._getPopperConfig(),
1023                n = s.modifiers.find((t) => 'applyStyles' === t.name && !1 === t.enabled);
1024            (this._popper = i.createPopper(e, this._menu, s)), n && X.setDataAttribute(this._menu, 'popper', 'static');
1025        }
1026        _isShown(t = this._element) {
1027            return t.classList.contains(kt);
1028        }
1029        _getMenuElement() {
1030            return Y.next(this._element, St)[0];
1031        }
1032        _getPlacement() {
1033            const t = this._element.parentNode;
1034            if (t.classList.contains('dropend')) return Pt;
1035            if (t.classList.contains('dropstart')) return xt;
1036            const e = 'end' === getComputedStyle(this._menu).getPropertyValue('--bs-position').trim();
1037            return t.classList.contains('dropup') ? (e ? Nt : Ot) : e ? It : Dt;
1038        }
1039        _detectNavbar() {
1040            return null !== this._element.closest('.navbar');
1041        }
1042        _getOffset() {
1043            const { offset: t } = this._config;
1044            return 'string' == typeof t
1045                ? t.split(',').map((t) => Number.parseInt(t, 10))
1046                : 'function' == typeof t
1047                  ? (e) => t(e, this._element)
1048                  : t;
1049        }
1050        _getPopperConfig() {
1051            const t = {
1052                placement: this._getPlacement(),
1053                modifiers: [
1054                    { name: 'preventOverflow', options: { boundary: this._config.boundary } },
1055                    { name: 'offset', options: { offset: this._getOffset() } },
1056                ],
1057            };
1058            return (
1059                'static' === this._config.display && (t.modifiers = [{ name: 'applyStyles', enabled: !1 }]),
1060                {
1061                    ...t,
1062                    ...('function' == typeof this._config.popperConfig
1063                        ? this._config.popperConfig(t)
1064                        : this._config.popperConfig),
1065                }
1066            );
1067        }
1068        _selectMenuItem({ key: t, target: e }) {
1069            const i = Y.find('.dropdown-menu .dropdown-item:not(.disabled):not(:disabled)', this._menu).filter(d);
1070            i.length && w(i, e, t === wt, !i.includes(e)).focus();
1071        }
1072        static jQueryInterface(t) {
1073            return this.each(function () {
1074                const e = Ht.getOrCreateInstance(this, t);
1075                if ('string' == typeof t) {
1076                    if (void 0 === e[t]) throw new TypeError(`No method n

1179            this._applyManipulationCallback(t, (t) => {
1180                const i = X.getDataAttribute(t, e);
1181                void 0 === i ? t.style.removeProperty(e) : (X.removeDataAttribute(t, e), (t.style[e] = i));
1182            });
1183        }
1184        _applyManipulationCallback(t, e) {
1185            l(t) ? e(t) : Y.find(t, this._element).forEach(e);
1186        }
1187        isOverflowing() {
1188            return this.getWidth() > 0;
1189        }
1190    }
1191    const Rt = { className: 'modal-backdrop', isVisible: !0, isAnimated: !1, rootElement: 'body', clickCallback: null },
1192        Ft = {
1193            className: 'string',
1194            isVisible: 'boolean',
1195            isAnimated: 'boolean',
1196            rootElement: '(element|string)',
1197            clickCallback: '(function|null)',
1198        },
1199        qt = 'show',
1200        Wt = 'mousedown.bs.backdrop';
1201    class Ut {
1202        constructor(t) {
1203            (this._config = this._getConfig(t)), (this._isAppended = !1), (this._element = null);
1204        }
1205        show(t) {
1206            this._config.isVisible
1207                ? (this._append(),
1208                  this._config.isAnimated && f(this._getElement()),
1209                  this._getElement().classList.add(qt),
1210                  this._emulateAnimation(() => {
1211                      y(t);
1212                  }))
1213                : y(t);
1214        }
1215        hide(t) {
1216            this._config.isVisible
1217                ? (this._getElement().classList.remove(qt),
1218                  this._emulateAnimation(() => {
1219                      this.dispose(), y(t);
1220                  }))
1221                : y(t);
1222        }
1223        _getElement() {
1224            if (!this._element) {
1225                const t = document.createElement('div');
1226                (t.className = this._config.className),
1227                    this._config.isAnimated && t.classList.add('fade'),
1228                    (this._element = t);
1229            }
1230            return this._element;
1231        }
1232        _getConfig(t) {
1233            return (
1234                ((t = { ...Rt, ...('object' == typeof t ? t : {}) }).rootElement = c(t.rootElement)),
1235                h('backdrop', t, Ft),
1236                t
1237            );
1238        }
1239        _append() {
1240            this._isAppended ||
1241                (this._config.rootElement.append(this._getElement()),
1242                $.on(this._getElement(), Wt, () => {
1243                    y(this._config.clickCallback);
1244                }),
1245                (this._isAppended = !0));
1246        }
1247        dispose() {
1248            this._isAppended && ($.off(this._element, Wt), this._element.remove(), (this._isAppended = !1));
1249        }
1250        _emulateAnimation(t) {
1251            E(t, this._getElement(), this._config.isAnimated);
1252        }
1253    }
1254    const Kt = { trapElement: null, autofocus: !0 },
1255        Vt = { trapElement: 'element', autofocus: 'boolean' },
1256        Xt = '.bs.focustrap',
1257        Yt = 'backward';
1258    class Qt {
1259        constructor(t) {
1260            (this._config = this._getConfig(t)), (this._isActive = !1), (this._lastTabNavDirection = null);
1261        }
1262        activate() {
1263            const { trapElement: t, autofocus: e } = this._config;
1264            this._isActive ||
1265                (e && t.focus(),
1266                $.off(document, Xt),
1267                $.on(document, 'focusin.bs.focustrap', (t) => this._handleFocusin(t)),
1268                $.on(document, 'keydown.tab.bs.focustrap', (t) => this._handleKeydown(t)),
1269                (this._isActive = !0));
1270        }
1271        deactivate() {
1272            this._isActive && ((this._isActive = !1), $.off(document, Xt));
1273        }
1274        _handleFocusin(t) {
1275            const { target: e } = t,
1276                { trapElement: i } = this._config;
1277            if (e === document || e === i || i.contains(e)) return;
1278            const s = Y.focusableChildren(i);
1279            0 === s.length ? i.focus() : this._lastTabNavDirection === Yt ? s[s.length - 1].focus() : s[0].focus();
1280        }
1281        _handleKeydown(t) {
1282            'Tab' === t.key && (this._lastTabNavDirection = t.shiftKey ? Yt : 'forward');
1283        }
1284        _getConfig(t) {
1285            return (t = { ...Kt, ...('object' == typeof t ? t : {}) }), h('focustrap', t, Vt), t;
1286        }
1287    }
1288    const Gt = 'modal',
1289        Zt = 'Escape',
1290        Jt = { backdrop: !0, keyboard: !0, focus: !0 },
1291        te = { backdrop: '(boolean|string)', keyboard: 'boolean', focus: 'boolean' },
1292        ee = 'hidden.bs.modal',
1293        ie = 'show.bs.modal',
1294        se = 'resize.bs.modal',
1295        ne = 'click.dismiss.bs.modal',
1296        oe = 'keydown.dismiss.bs.modal',
1297        re = 'mousedown.dismiss.bs.modal',
1298        ae = 'modal-open',
1299        le = 'show',
1300        ce = 'modal-static';
1301    class he extends R {
1302        constructor(t, e) {
1303            super(t),
1304                (this._config = this._getConfig(e)),
1305                (this._dialog = Y.findOne('.modal-dialog', this._element)),
1306                (this._backdrop = this._initializeBackDrop()),
1307                (this._focustrap = this._initializeFocusTrap()),
1308                (this._isShown = !1),
1309                (this._ignoreBackdropClick = !1),
1310                (this._isTransitioning = !1),
1311                (this._scrollBar = new zt());
1312        }
1313        static get Default() {
1314            return Jt;
1315        }
1316        static get NAME() {
1317            return Gt;
1318        }
1319        toggle(t) {
1320            return this._isShown ? this.hide() : this.show(t);
1321        }
1322        show(t) {
1323            this._isShown ||
1324                this._isTransitioning ||
1325                $.trigger(this._element, ie, { relatedTarget: t }).defaultPrevented ||
1326                ((this._isShown = !0),
1327                this._isAnimated() && (this._isTransitioning = !0),
1328                this._scrollBar.hide(),
1329                document.body.classList.add(ae),
1330                this._adjustDialog(),
1331                this._setEscapeEvent(),
1332                this._setResizeEvent(),
1333                $.on(this._dialog, re, () => {
1334                    $.one(this._element, 'mouseup.dismiss.bs.modal', (t) => {
1335                        t.target === this._element && (this._ignoreBackdropClick = !0);
1336                    });
1337                }),
1338                this._showBackdrop(() => this._showElement(t)));
1339        }
1340        hide() {
1341            if (!this._isShown || this._isTransitioning) return;
1342            if ($.trigger(this._element, 'hide.bs.modal').defaultPrevented) return;
1343            this._isShown = !1;
1344            const t = this._isAnimated();
1345            t && (this._isTransitioning = !0),
1346                this._setEscapeEvent(),
1347                this._setResizeEvent(),
1348                this._focustrap.deactivate(),
1349                this._element.classList.remove(le),
1350                $.off(this._element, ne),
1351                $.off(this._dialog, re),
1352                this._queueCallback(() => this._hideModal(), this._element, t);
1353        }
1354        dispose() {
1355            [window, this._dialog].forEach((t) => $.off(t, '.bs.modal')),
1356                this._backdrop.dispose(),
1357                this._focustrap.deactivate(),
1358                super.dispose();
1359        }
1360        handleUpdate() {
1361            this._adjustDialog();
1362        }
1363        _initializeBackDrop() {
1364            return new Ut({ isVisible: Boolean(this._config.backdrop), isAnimated: this._isAnimated() });
1365        }
1366        _initializeFocusTrap() {
1367            return new Qt({ trapElement: this._element });
1368        }
1369        _getConfig(t) {
1370            return (
1371                (t = { ...Jt, ...X.getDataAttributes(this._element), ...('object' == typeof t ? t : {}) }),
1372                h(Gt, t, te),
1373                t
1374            );
1375        }
1376        _showElement(t) {
1377            const e = this._isAnimated(),
1378                i = Y.findOne('.modal-body', this._dialog);
1379            (this._element.parentNode && this._element.parentNode.nodeType === Node.ELEMENT_NODE) ||
1380                document.body.append(this._element),
1381                (this._element.style.display = 'block'),
1382                this._element.removeAttribute('aria-hidden'),
1383                this._element.setAttribute('aria-modal', !0),
1384                this._element.setAttribute('role', 'dialog'),
1385                (this._element.scrollTop = 0),
1386                i && (i.scrollTop = 0),
1387                e && f(this._element),
1388                this._element.classList.add(le),
1389                this._queueCallback(
1390                    () => {
1391                        this._config.focus && this._focustrap.activate(),
1392                            (this._isTransitioning = !1),
1393                            $.trigger(this._element, 'shown.bs.modal', { relatedTarget: t });
1394                    },
1395                    this._dialog,
1396                    e
1397                );
1398        }
1399        _setEscapeEvent() {
1400            this._isShown
1401                ? $.on(this._element, oe, (t) => {
1402                      this._config.keyboard && t.key === Zt
1403                          ? (t.preventDefault(), this.hide())
1404                          : this._config.keyboard || t.key !== Zt || this._triggerBackdropTransition();
1405                  })
1406                : $.off(this._element, oe);
1407        }
1408        _setResizeEvent() {
1409            this._isShown ? $.on(window, se, () => this._adjustDialog()) : $.off(window, se);
1410        }
1411        _hideModal() {
1412            (this._element.style.display = 'none'),
1413                this._element.setAttribute('aria-hidden', !0),
1414                this._element.removeAttribute('aria-modal'),
1415                this._element.removeAttribute('role'),
1416                (this._isTransitioning = !1),
1417                this._backdrop.hide(() => {
1418                    document.body.classList.remove(ae),
1419                        this._resetAdjustments(),
1420                        this._scrollBar.reset(),
1421                        $.trigger(this._element, ee);
1422                });
1423        }
1424        _showBackdrop(t) {
1425            $.on(this._element, ne, (t) => {
1426                this._ignoreBackdropClick
1427                    ? (this._ignoreBackdropClick = !1)
1428                    : t.target === t.currentTarget &&
1429                      (!0 === this._config.backdrop
1430                          ? this.hide()
1431                          : 'static' === this._config.backdrop && this._triggerBackdropTransition());
1432            }),
1433                this._backdrop.show(t);
1434        }
1435        _isAnimated() {
1436            return this._element.classList.contains('fade');
1437        }
1438        _triggerBackdropTransition() {
1439            if ($.trigger(this._element, 'hidePrevented.bs.modal').defaultPrevented) return;
1440            const { classList: t, scrollHeight: e, style: i } = this._element,
1441                s = e > document.documentElement.clientHeight;
1442            (!s && 'hidden' === i.overflowY) ||
1443                t.contains(ce) ||
1444                (s || (i.overflowY = 'hidden'),
1445                t.add(ce),
1446                this._queueCallback(() => {
1447                    t.remove(ce),
1448                        s ||
1449                            this._queueCallback(() => {
1450                                i.overflowY = '';
1451                            }, this._dialog);
1452                }, this._dialog),
1453                this._element.focus());
1454        }
1455        _adjustDialog() {
1456            const t = this._element.scrollHeight > document.documentElement.clientHeight,
1457                e = this._scrollBar.getWidth(),
1458                i = e > 0;
1459            ((!i && t && !b()) || (i && !t && b())) && (this._element.style.paddingLeft = `${e}px`),
1460                ((i && !t && !b()) || (!i && t && b())) && (this._element.style.paddingRight = `${e}px`);
1461        }
1462        _resetAdjustments() {
1463            (this._element.style.paddingLeft = ''), (this._element.style.paddingRight = '');
1464        }
1465        static jQueryInterface(t, e) {
1466            return this.each(function () {
1467                const i = he.getOrCreateInstance(this, t);
1468                if ('string' == typeof t) {
1469                    if (void 0 === i[t]) throw new TypeError(`No method named "${t}"`);
1470                    i[t](e);
1471                }
1472            });
1473        }
1474    }
1475    $.on(document, 'click.bs.modal.data-api', '[data-bs-toggle="modal"]', function (t) {
1476        const e = r(this);
1477        ['A', 'AREA'].includes(this.tagName) && t.preventDefault(),
1478            $.one(e, ie, (t) => {
1479                t.defaultPrevented ||
1480                    $.one(e, ee, () => {
1481                        d(this) && this.focus();
1482                    });
1483            });
1484        const i = Y.findOne('.modal.show');
1485        i && he.getInstance(i).hide(), he.getOrCreateInstance(e).toggle(this);
1486    }),
1487        F(he),
1488        v(he);
1489    const de = 'offcanvas',
1490        ue = { backdrop: !0, keyboard: !0, scroll: !1 },
1491        ge = { backdrop: 'boolean', keyboard: 'boolean', scroll: 'boolean' },
1492        _e = 'show',
1493        fe = '.offcanvas.show',
1494        pe = 'hidden.bs.offcanvas';
1495    class me extends R {
1496        constructor(t, e) {
1497            super(t),
1498                (this._config = this._getConfig(e)),
1499                (this._isShown = !1),
1500                (this._backdrop = this._initializeBackDrop()),
1501                (this._focustrap = this._initializeFocusTrap()),
1502                this._addEventListeners();
1503        }
1504        static get NAME() {
1505            return de;
1506        }
1507        static get Default() {
1508            return ue;
1509        }
1510        toggle(t) {
1511            return this._isShown ? this.hide() : this.show(t);
1512        }
1513        show(t) {
1514            this._isShown ||
1515                $.trigger(this._element, 'show.bs.offcanvas', { relatedTarget: t }).defaultPrevented ||
1516                ((this._isShown = !0),
1517                (this._element.style.visibility = 'visible'),
1518                this._backdrop.show(),
1519                this._config.scroll || new zt().hide(),
1520                this._element.removeAttribute('aria-hidden'),
1521                this._element.setAttribute('aria-modal', !0),
1522                this._element.setAttribute('role', 'dialog'),
1523                this._element.classList.add(_e),
1524                this._queueCallback(
1525                    () => {
1526                        this._config.scroll || this._focustrap.activate(),
1527                            $.trigger(this._element, 'shown.bs.offcanvas', { relatedTarget: t });
1528                    },
1529                    this._element,
1530                    !0
1531                ));
1532        }
1533        hide() {
1534            this._isShown &&
1535                ($.trigger(this._element, 'hide.bs.offcanvas').defaultPrevented ||
1536                    (this._focustrap.deactivate(),
1537                    this._element.blur(),
1538                    (this._isShown = !1),
1539                    this._element.classList.remove(_e),
1540                    this._backdrop.hide(),
1541                    this._queueCallback(
1542                        () => {
1543                            this._element.setAttribute('aria-hidden', !0),
1544                                this._element.removeAttribute('aria-modal'),
1545                                this._element.removeAttribute('role'),
1546                                (this._element.style.visibility = 'hidden'),
1547                                this._config.scroll || new zt().reset(),
1548                                $.trigger(this._element, pe);
1549                        },
1550                        this._element,
1551                        !0
1552                    )));
1553        }
1554        dispose() {
1555            this._backdrop.dispose(), this._focustrap.deactivate(), super.dispose();
1556        }
1557        _getConfig(t) {
1558            return (
1559                (t = { ...ue, ...X.getDataAttributes(this._element), ...('object' == typeof t ? t : {}) }),
1560                h(de, t, ge),
1561                t
1562            );
1563        }
1564        _initializeBackDrop() {
1565            return new Ut({
1566                className: 'offcanvas-backdrop',
1567                isVisible: this._config.backdrop,
1568                isAnimated: !0,
1569                rootElement: this._element.parentNode,
1570                clickCallback: () => this.hide(),
1571            });
1572        }
1573        _initializeFocusTrap() {
1574            return new Qt({ trapElement: this._element });
1575        }
1576        _addEventListeners() {
1577            $.on(this._element, 'keydown.dismiss.bs.offcanvas', (t) => {
1578                this._config.keyboard && 'Escape' === t.key && this.hide();
1579            });
1580        }
1581        static jQueryInterface(t) {
1582            return this.each(function () {
1583                const e = me.getOrCreateInstance(this, t);
1584                if ('string' == typeof t) {
1585                    if (void 0 === e[t] || t.startsWith('_') || 'constructor' === t)
1586                        throw new TypeError(`No method named "${t}"`);
1587                    e[t](this);
1588                }
1589            });
1590        }
1591    }
1592    $.on(document, 'click.bs.offcanvas.data-api', '[data-bs-toggle="offcanvas"]', function (t) {
1593        const e = r(this);
1594        if ((['A', 'AREA'].includes(this.tagName) && t.preventDefault(), u(this))) return;
1595        $.one(e, pe, () => {
1596            d(this) && this.focus();
1597        });
1598        const i = Y.findOne(fe);
1599        i && i !== e && me.getInstance(i).hide(), me.getOrCreateInstance(e).toggle(this);
1600    }),
1601        $.on(window, 'load.bs.offcanvas.data-api', () => Y.find(fe).forEach((t) => me.getOrCreateInstance(t).show())),
1602        F(me),
1603        v(me);
1604    const be = new Set(['background', 'cite', 'href', 'itemtype', 'longdesc', 'poster', 'src', 'xlink:href']),
1605        ve = /^(?:(?:https?|mailto|ftp|tel|file|sms):|[^#&/:?]*(?:[#/?]|$))/i,
1606        ye =
1607            /^data:(?:image\/(?:bmp|gif|jpeg|jpg|png|tiff|webp)|video\/(?:mpeg|mp4|ogg|webm)|audio\/(?:mp3|oga|ogg|opus));base64,[\d+/a-z]+=*$/i,
1608        Ee = (t, e) => {
1609            const i = t.nodeName.toLowerCase();
1610            if (e.includes(i)) return !be.has(i) || Boolean(ve.test(t.nodeValue) || ye.test(t.nodeValue));
1611            const s = e.filter((t) => t instanceof RegExp);
1612            for (let t = 0, e = s.length; t < e; t++) if (s[t].test(i)) return !0;
1613            return !1;
1614        };
1615    function we(t, e, i) {
1616        if (!t.length) return t;
1617        if (i && 'function' == typeof i) return i(t);
1618        const s = new window.DOMParser().parseFromString(t, 'text/html'),
1619            n = [].concat(...s.body.querySelectorAll('*'));
1620        for (let t = 0, i = n.length; t < i; t++) {
1621            const i = n[t],
1622                s = i.nodeName.toLowerCase();
1623            if (!Object.keys(e).includes(s)) {
1624                i.remove();
1625                continue;
1626            }
1627            const o = [].concat(...i.attributes),
1628                r = [].concat(e['*'] || [], e[s] || []);
1629            o.forEach((t) => {
1630                Ee(t, r) || i.removeAttribute(t.nodeName);
1631            });
1632        }
1633        return s.body.innerHTML;
1634    }
1635    const Ae = 'tooltip',
1636        Te = new Set(['sanitize', 'allowList', 'sanitizeFn']),
1637        Ce = {
1638            animation: 'boolean',
1639            template: 'string',
1640            title: '(string|element|function)',
1641            trigger: 'string',
1642            delay: '(number|object)',
1643            html: 'boolean',
1644            selector: '(string|boolean)',
1645            placement: '(string|function)',
1646            offset: '(array|string|function)',
1647            container: '(string|element|boolean)',
1648            fallbackPlacements: 'array',
1649            boundary: '(string|element)',
1650            customClass: '(string|function)',
1651            sanitize: 'boolean',
1652            sanitizeFn: '(null|function)',
1653            allowList: 'object',
1654            popperConfig: '(null|object|function)',
1655        },
1656        ke = {
1657            AUTO: 'auto',
1658            TOP: 'top',
1659            RIGHT: b() ? 'left' : 'right',
1660            BOTTOM: 'bottom',
1661            LEFT: b() ? 'right' : 'left',
1662        },
1663        Le = {
1664            animation: !0,
1665            template:
1666                '<div class="tooltip" role="tooltip"><div class="tooltip-arrow"></div><div class="tooltip-inner"></div></div>',
1667            trigger: 'hover focus',
1668            title: '',
1669            delay: 0,
1670            html: !1,
1671            selector: !1,
1672            placement: 'top',
1673            offset: [0, 0],
1674            container: !1,
1675            fallbackPlacements: ['top', 'right', 'bottom', 'left'],
1676            boundary: 'clippingParents',
1677            customClass: '',
1678            sanitize: !0,
1679            sanitizeFn: null,
1680            allowList: {
1681                '*': ['class', 'dir', 'id', 'lang', 'role', /^aria-[\w-]*$/i],
1682                a: ['target', 'href', 'title', 'rel'],
1683                area: [],
1684                b: [],
1685                br: [],
1686                col: [],
1687                code: [],
1688                div: [],
1689                em: [],
1690                hr: [],
1691                h1: [],
1692                h2: [],
1693                h3: [],
1694                h4: [],
1695                h5: [],
1696                h6: [],
1697                i: [],
1698                img: ['src', 'srcset', 'alt', 'title', 'width', 'height'],
1699                li: [],
1700                ol: [],
1701                p: [],
1702                pre: [],
1703                s: [],
1704                small: [],
1705                span: [],
1706                sub: [],
1707                sup: [],
1708                strong: [],
1709                u: [],
1710                ul: [],
1711            },
1712            popperConfig: null,
1713        },
1714        Se = {
1715            HIDE: 'hide.bs.tooltip',
1716            HIDDEN: 'hidden.bs.tooltip',
1717            SHOW: 'show.bs.tooltip',
1718            SHOWN: 'shown.bs.tooltip',
1719            INSERTED: 'inserted.bs.tooltip',
1720            CLICK: 'click.bs.tooltip',
1721            FOCUSIN: 'focusin.bs.tooltip',
1722            FOCUSOUT: 'focusout.bs.tooltip',
1723            MOUSEENTER: 'mouseenter.bs.tooltip',
1724            MOUSELEAVE: 'mouseleave.bs.tooltip',
1725        },
1726        Oe = 'fade',
1727        Ne = 'show',
1728        De = 'show',
1729        Ie = 'out',
1730        Pe = '.tooltip-inner',
1731        xe = '.modal',
1732        Me = 'hide.bs.modal',
1733        je = 'hover',
1734        He = 'focus';
1735    class $e extends R {
1736        constructor(t, e) {
1737            if (void 0 === i) throw new TypeError("Bootstrap's tooltips require Popper (https://popper.js.org)");
1738            super(t),
1739                (this._isEnabled = !0),
1740                (this._timeout = 0),
1741                (this._hoverState = ''),
1742                (this._activeTrigger = {}),
1743                (this._popper = null),
1744                (this._config = this._getConfig(e)),
1745                (this.tip = null),
1746                this._setListeners();
1747        }
1748        static get Default() {
1749            return Le;
1750        }
1751        static get NAME() {
1752            return Ae;
1753        }
1754        static get Event() {
1755            return Se;
1756        }
1757        static get DefaultType() {
1758            return Ce;
1759        }
1760        enable() {
1761            this._isEnabled = !0;
1762        }
1763        disable() {
1764            this._isEnabled = !1;
1765        }
1766        toggleEnabled() {
1767            this._isEnabled = !this._isEnabled;
1768        }
1769        toggle(t) {
1770            if (this._isEnabled)
1771                if (t) {
1772                    const e = this._initializeOnDelegatedTarget(t);
1773                    (e._activeTrigger.click = !e._activeTrigger.click),
1774                        e._isWithActiveTrigger() ? e._enter(null, e) : e._leave(null, e);
1775                } else {
1776                    if (this.getTipElement().classList.contains(Ne)) return void this._leave(null, this);
1777                    this._enter(null, this);
1778                }
1779        }
1780        dispose() {
1781            clearTimeout(this._timeout),
1782                $.off(this._element.closest(xe), Me, this._hideModalHandler),
1783                this.tip && this.tip.remove(),
1784                this._disposePopper(),
1785                super.dispose();
1786        }
1787        show() {
1788            if ('none' === this._element.style.display) throw new Error('Please use show on visible elements');
1789            if (!this.isWithContent() || !this._isEnabled) return;
1790            const t = $.trigger(this._element, this.constructor.Event.SHOW),
1791                e = g(this._element),
1792                s =
1793                    null === e
1794                        ? this._element.ownerDocument.documentElement.contains(this._element)
1795                        : e.contains(this._element);
1796            if (t.defaultPrevented || !s) return;
1797            'tooltip' === this.constructor.NAME &&
1798                this.tip &&
1799                this.getTitle() !== this.tip.querySelector(Pe).innerHTML &&
1800                (this._disposePopper(), this.tip.remove(), (this.tip = null));
1801            const n = this.getTipElement(),
1802                o = ((t) => {
1803                    do {
1804                        t += Math.floor(1e6 * Math.random());
1805                    } while (document.getElementById(t));
1806                    return t;
1807                })(this.constructor.NAME);
1808            n.setAttribute('id', o),
1809                this._element.setAttribute('aria-describedby', o),
1810                this._config.animation && n.classList.add(Oe);
1811            const r =
1812                    'function' == typeof this._config.placement
1813                        ? this._config.placement.call(this, n, this._element)
1814                        : this._config.placement,
1815                a = this._getAttachment(r);
1816            this._addAttachmentClass(a);
1817            const { container: l } = this._config;
1818            z.set(n, this.constructor.DATA_KEY, this),
1819                this._element.ownerDocument.documentElement.contains(this.tip) ||
1820                    (l.append(n), $.trigger(this._element, this.constructor.Event.INSERTED)),
1821                this._popper
1822                    ? this._popper.update()
1823                    : (this._popper = i.createPopper(this._element, n, this._getPopperConfig(a))),
1824                n.classList.add(Ne);
1825            const c = this._resolvePossibleFunction(this._config.customClass);
1826            c && n.classList.add(...c.split(' ')),
1827                'ontouchstart' in document.documentElement &&
1828                    [].concat(...document.body.children).forEach((t) => {
1829                        $.on(t, 'mouseover', _);
1830                    });
1831            const h = this.tip.classList.contains(Oe);
1832            this._queueCallback(
1833                () => {
1834                    const t = this._hoverState;
1835                    (this._hoverState = null),
1836                        $.trigger(this._element, this.constructor.Event.SHOWN),
1837                        t === Ie && this._leave(null, this);
1838                },
1839                this.tip,
1840                h
1841            );
1842        }
1843        hide() {
1844            if (!this._popper) return;
1845            const t = this.getTipElement();
1846            if ($.trigger(this._element, this.constructor.Event.HIDE).defaultPrevented) return;
1847            t.classList.remove(Ne),
1848                'ontouchstart' in document.documentElement &&

2109            return 'bs-popover';
2110        }
2111        static jQueryInterface(t) {
2112            return this.each(function () {
2113                const e = Fe.getOrCreateInstance(this, t);
2114                if ('string' == typeof t) {
2115                    if (void 0 === e[t]) throw new TypeError(`No method named "${t}"`);
2116                    e[t]();
2117                }
2118            });
2119        }
2120    }
2121    v(Fe);
2122    const qe = 'scrollspy',
2123        We = { offset: 10, method: 'auto', target: '' },
2124        Ue = { offset: 'number', method: 'string', target: '(string|element)' },
2125        Ke = 'active',
2126        Ve = '.nav-link, .list-group-item, .dropdown-item',
2127        Xe = 'position';
2128    class Ye extends R {
2129        constructor(t, e) {
2130            super(t),
2131                (this._scrollElement = 'BODY' === this._element.tagName ? window : this._element),
2132                (this._config = this._getConfig(e)),
2133                (this._offsets = []),
2134                (this._targets = []),
2135                (this._activeTarget = null),
2136                (this._scrollHeight = 0),
2137                $.on(this._scrollElement, 'scroll.bs.scrollspy', () => this._process()),
2138                this.refresh(),
2139                this._process();
2140        }
2141        static get Default() {
2142            return We;
2143        }
2144        static get NAME() {
2145            return qe;
2146        }
2147        refresh() {
2148            const t = this._scrollElement === this._scrollElement.window ? 'offset' : Xe,
2149                e = 'auto' === this._config.method ? t : this._config.method,
2150                i = e === Xe ? this._getScrollTop() : 0;
2151            (this._offsets = []),
2152                (this._targets = []),
2153                (this._scrollHeight = this._getScrollHeight()),
2154                Y.find(Ve, this._config.target)
2155                    .map((t) => {
2156                        const s = o(t),
2157                            n = s ? Y.findOne(s) : null;
2158                        if (n) {
2159                            const t = n.getBoundingClientRect();
2160                            if (t.width || t.height) return [X[e](n).top + i, s];
2161                        }
2162                        return null;
2163                    })
2164                    .filter((t) => t)
2165                    .sort((t, e) => t[0] - e[0])
2166                    .forEach((t) => {
2167                        this._offsets.push(t[0]), this._targets.push(t[1]);
2168                    });
2169        }
2170        dispose() {
2171            $.off(this._scrollElement, '.bs.scrollspy'), super.dispose();
2172        }
2173        _getConfig(t) {
2174            return (
2175                ((t = {
2176                    ...We,
2177                    ...X.getDataAttributes(this._element),
2178                    ...('object' == typeof t && t ? t : {}),
2179                }).target = c(t.target) || document.documentElement),
2180                h(qe, t, Ue),
2181                t
2182            );
2183        }
2184        _getScrollTop() {
2185            return this._scrollElement === window ? this._scrollElement.pageYOffset : this._scrollElement.scrollTop;
2186        }
2187        _getScrollHeight() {
2188            return (
2189                this._scrollElement.scrollHeight ||
2190                Math.max(document.body.scrollHeight, document.documentElement.scrollHeight)
2191            );
2192        }
2193        _getOffsetHeight() {
2194            return this._scrollElement === window
2195                ? window.innerHeight
2196                : this._scrollElement.getBoundingClientRect().height;
2197        }
2198        _process() {
2199            const t = this._getScrollTop() + this._config.offset,
2200                e = this._getScrollHeight(),
2201                i = this._config.offset + e - this._getOffsetHeight();
2202            if ((this._scrollHeight !== e && this.refresh(), t >= i)) {
2203                const t = this._targets[this._targets.length - 1];
2204                this._activeTarget !== t && this._activate(t);
2205            } else {
2206                if (this._activeTarget && t < this._offsets[0] && this._offsets[0] > 0)
2207                    return (this._activeTarget = null), void this._clear();
2208                for (let e = this._offsets.length; e--; )
2209                    this._activeTarget !== this._targets[e] &&
2210                        t >= this._offsets[e] &&
2211                        (void 0 === this._offsets[e + 1] || t < this._offsets[e + 1]) &&
2212                        this._activate(this._targets[e]);
2213            }
2214        }
2215        _activate(t) {
2216            (this._activeTarget = t), this._clear();
2217            const e = Ve.split(',').map((e) => `${e}[data-bs-target="${t}"],${e}[href="${t}"]`),
2218                i = Y.findOne(e.join(','), this._config.target);
2219            i.classList.add(Ke),
2220                i.classList.contains('dropdown-item')
2221                    ? Y.findOne('.dropdown-toggle', i.closest('.dropdown')).classList.add(Ke)
2222                    : Y.parents(i, '.nav, .list-group').forEach((t) => {
2223                          Y.prev(t, '.nav-link, .list-group-item').forEach((t) => t.classList.add(Ke)),
2224                              Y.prev(t, '.nav-item').forEach((t) => {
2225                                  Y.children(t, '.nav-link').forEach((t) => t.classList.add(Ke));
2226                              });
2227                      }),
2228                $.trigger(this._scrollElement, 'activate.bs.scrollspy', { relatedTarget: t });
2229        }
2230        _clear() {
2231            Y.find(Ve, this._config.target)
2232                .filter((t) => t.classList.contains(Ke))
2233                .forEach((t) => t.classList.remove(Ke));
2234        }
2235        static jQueryInterface(t) {
2236            return this.each(function () {
2237                const e = Ye.getOrCreateInstance(this, t);
2238                if ('string' == typeof t) {
2239                    if (void 0 === e[t]) throw new TypeError(`No method n