bootstrap.js - MVC-databaskonstruktion

bootstrap.js (148168B)
      1 /*!
      2   * Bootstrap v5.1.0 (https://getbootstrap.com/)
      3   * Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)
      4   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
      5   */
      6 (function (global, factory) {
      7   typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('@popperjs/core')) :
      8   typeof define === 'function' && define.amd ? define(['@popperjs/core'], factory) :
      9   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.bootstrap = factory(global.Popper));
     10 }(this, (function (Popper) { 'use strict';
     11 
     12   function _interopNamespace(e) {
     13     if (e && e.__esModule) return e;
     14     var n = Object.create(null);
     15     if (e) {
     16       Object.keys(e).forEach(function (k) {
     17         if (k !== 'default') {
     18           var d = Object.getOwnPropertyDescriptor(e, k);
     19           Object.defineProperty(n, k, d.get ? d : {
     20             enumerable: true,
     21             get: function () {
     22               return e[k];
     23             }
     24           });
     25         }
     26       });
     27     }
     28     n['default'] = e;
     29     return Object.freeze(n);
     30   }
     31 
     32   var Popper__namespace = /*#__PURE__*/_interopNamespace(Popper);
     33 
     34   /**
     35    * --------------------------------------------------------------------------
     36    * Bootstrap (v5.1.0): util/index.js
     37    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
     38    * --------------------------------------------------------------------------
     39    */
     40   const MAX_UID = 1000000;
     41   const MILLISECONDS_MULTIPLIER = 1000;
     42   const TRANSITION_END = 'transitionend'; // Shoutout AngusCroll (https://goo.gl/pxwQGp)
     43 
     44   const toType = obj => {
     45     if (obj === null || obj === undefined) {
     46       return `${obj}`;
     47     }
     48 
     49     return {}.toString.call(obj).match(/\s([a-z]+)/i)[1].toLowerCase();
     50   };
     51   /**
     52    * --------------------------------------------------------------------------
     53    * Public Util Api
     54    * --------------------------------------------------------------------------
     55    */
     56 
     57 
     58   const getUID = prefix => {
     59     do {
     60       prefix += Math.floor(Math.random() * MAX_UID);
     61     } while (document.getElementById(prefix));
     62 
     63     return prefix;
     64   };
     65 
     66   const getSelector = element => {
     67     let selector = element.getAttribute('data-bs-target');
     68 
     69     if (!selector || selector === '#') {
     70       let hrefAttr = element.getAttribute('href'); // The only valid content that could double as a selector are IDs or classes,
     71       // so everything starting with `#` or `.`. If a "real" URL is used as the selector,
     72       // `document.querySelector` will rightfully complain it is invalid.
     73       // See https://github.com/twbs/bootstrap/issues/32273
     74 
     75       if (!hrefAttr || !hrefAttr.includes('#') && !hrefAttr.startsWith('.')) {
     76         return null;
     77       } // Just in case some CMS puts out a full URL with the anchor appended
     78 
     79 
     80       if (hrefAttr.includes('#') && !hrefAttr.startsWith('#')) {
     81         hrefAttr = `#${hrefAttr.split('#')[1]}`;
     82       }
     83 
     84       selector = hrefAttr && hrefAttr !== '#' ? hrefAttr.trim() : null;
     85     }
     86 
     87     return selector;
     88   };
     89 
     90   const getSelectorFromElement = element => {
     91     const selector = getSelector(element);
     92 
     93     if (selector) {
     94       return document.querySelector(selector) ? selector : null;
     95     }
     96 
     97     return null;
     98   };
     99 
    100   const getElementFromSelector = element => {
    101     const selector = getSelector(element);
    102     return selector ? document.querySelector(selector) : null;
    103   };
    104 
    105   const getTransitionDurationFromElement = element => {
    106     if (!element) {
    107       return 0;
    108     } // Get transition-duration of the element
    109 
    110 
    111     let {
    112       transitionDuration,
    113       transitionDelay
    114     } = window.getComputedStyle(element);
    115     const floatTransitionDuration = Number.parseFloat(transitionDuration);
    116     const floatTransitionDelay = Number.parseFloat(transitionDelay); // Return 0 if element or transition duration is not found
    117 
    118     if (!floatTransitionDuration && !floatTransitionDelay) {
    119       return 0;
    120     } // If multiple durations are defined, take the first
    121 
    122 
    123     transitionDuration = transitionDuration.split(',')[0];
    124     transitionDelay = transitionDelay.split(',')[0];
    125     return (Number.parseFloat(transitionDuration) + Number.parseFloat(transitionDelay)) * MILLISECONDS_MULTIPLIER;
    126   };
    127 
    128   const triggerTransitionEnd = element => {
    129     element.dispatchEvent(new Event(TRANSITION_END));
    130   };
    131 
    132   const isElement = obj => {
    133     if (!obj || typeof obj !== 'object') {
    134       return false;
    135     }
    136 
    137     if (typeof obj.jquery !== 'undefined') {
    138       obj = obj[0];
    139     }
    140 
    141     return typeof obj.nodeType !== 'undefined';
    142   };
    143 
    144   const getElement = obj => {
    145     if (isElement(obj)) {
    146       // it's a jQuery object or a node element
    147       return obj.jquery ? obj[0] : obj;
    148     }
    149 
    150     if (typeof obj === 'string' && obj.length > 0) {
    151       return document.querySelector(obj);
    152     }
    153 
    154     return null;
    155   };
    156 
    157   const typeCheckConfig = (componentName, config, configTypes) => {
    158     Object.keys(configTypes).forEach(property => {
    159       const expectedTypes = configTypes[property];
    160       const value = config[property];
    161       const valueType = value && isElement(value) ? 'element' : toType(value);
    162 
    163       if (!new RegExp(expectedTypes).test(valueType)) {
    164         throw new TypeError(`${componentName.toUpperCase()}: Option "${property}" provided type "${valueType}" but expected type "${expectedTypes}".`);
    165       }
    166     });
    167   };
    168 
    169   const isVisible = element => {
    170     if (!isElement(element) || element.getClientRects().length === 0) {
    171       return false;
    172     }
    173 
    174     return getComputedStyle(element).getPropertyValue('visibility') === 'visible';
    175   };
    176 
    177   const isDisabled = element => {
    178     if (!element || element.nodeType !== Node.ELEMENT_NODE) {
    179       return true;
    180     }
    181 
    182     if (element.classList.contains('disabled')) {
    183       return true;
    184     }
    185 
    186     if (typeof element.disabled !== 'undefined') {
    187       return element.disabled;
    188     }
    189 
    190     return element.hasAttribute('disabled') && element.getAttribute('disabled') !== 'false';
    191   };
    192 
    193   const findShadowRoot = element => {
    194     if (!document.documentElement.attachShadow) {
    195       return null;
    196     } // Can find the shadow root otherwise it'll return the document
    197 
    198 
    199     if (typeof element.getRootNode === 'function') {
    200       const root = element.getRootNode();
    201       return root instanceof ShadowRoot ? root : null;
    202     }
    203 
    204     if (element instanceof ShadowRoot) {
    205       return element;
    206     } // when we don't find a shadow root
    207 
    208 
    209     if (!element.parentNode) {
    210       return null;
    211     }
    212 
    213     return findShadowRoot(element.parentNode);
    214   };
    215 
    216   const noop = () => {};
    217   /**
    218    * Trick to restart an element's animation
    219    *
    220    * @param {HTMLElement} element
    221    * @return void
    222    *
    223    * @see https://www.charistheo.io/blog/2021/02/restart-a-css-animation-with-javascript/#restarting-a-css-animation
    224    */
    225 
    226 
    227   const reflow = element => {
    228     // eslint-disable-next-line no-unused-expressions
    229     element.offsetHeight;
    230   };
    231 
    232   const getjQuery = () => {
    233     const {
    234       jQuery
    235     } = window;
    236 
    237     if (jQuery && !document.body.hasAttribute('data-bs-no-jquery')) {
    238       return jQuery;
    239     }
    240 
    241     return null;
    242   };
    243 
    244   const DOMContentLoadedCallbacks = [];
    245 
    246   const onDOMContentLoaded = callback => {
    247     if (document.readyState === 'loading') {
    248       // add listener on the first call when the document is in loading state
    249       if (!DOMContentLoadedCallbacks.length) {
    250         document.addEventListener('DOMContentLoaded', () => {
    251           DOMContentLoadedCallbacks.forEach(callback => callback());
    252         });
    253       }
    254 
    255       DOMContentLoadedCallbacks.push(callback);
    256     } else {
    257       callback();
    258     }
    259   };
    260 
    261   const isRTL = () => document.documentElement.dir === 'rtl';
    262 
    263   const defineJQueryPlugin = plugin => {
    264     onDOMContentLoaded(() => {
    265       const $ = getjQuery();
    266       /* istanbul ignore if */
    267 
    268       if ($) {
    269         const name = plugin.NAME;
    270         const JQUERY_NO_CONFLICT = $.fn[name];
    271         $.fn[name] = plugin.jQueryInterface;
    272         $.fn[name].Constructor = plugin;
    273 
    274         $.fn[name].noConflict = () => {
    275           $.fn[name] = JQUERY_NO_CONFLICT;
    276           return plugin.jQueryInterface;
    277         };
    278       }
    279     });
    280   };
    281 
    282   const execute = callback => {
    283     if (typeof callback === 'function') {
    284       callback();
    285     }
    286   };
    287 
    288   const executeAfterTransition = (callback, transitionElement, waitForTransition = true) => {
    289     if (!waitForTransition) {
    290       execute(callback);
    291       return;
    292     }
    293 
    294     const durationPadding = 5;
    295     const emulatedDuration = getTransitionDurationFromElement(transitionElement) + durationPadding;
    296     let called = false;
    297 
    298     const handler = ({
    299       target
    300     }) => {
    301       if (target !== transitionElement) {
    302         return;
    303       }
    304 
    305       called = true;
    306       transitionElement.removeEventListener(TRANSITION_END, handler);
    307       execute(callback);
    308     };
    309 
    310     transitionElement.addEventListener(TRANSITION_END, handler);
    311     setTimeout(() => {
    312       if (!called) {
    313         triggerTransitionEnd(transitionElement);
    314       }
    315     }, emulatedDuration);
    316   };
    317   /**
    318    * Return the previous/next element of a list.
    319    *
    320    * @param {array} list    The list of elements
    321    * @param activeElement   The active element
    322    * @param shouldGetNext   Choose to get next or previous element
    323    * @param isCycleAllowed
    324    * @return {Element|elem} The proper element
    325    */
    326 
    327 
    328   const getNextActiveElement = (list, activeElement, shouldGetNext, isCycleAllowed) => {
    329     let index = list.indexOf(activeElement); // if the element does not exist in the list return an element depending on the direction and if cycle is allowed
    330 
    331     if (index === -1) {
    332       return list[!shouldGetNext && isCycleAllowed ? list.length - 1 : 0];
    333     }
    334 
    335     const listLength = list.length;
    336     index += shouldGetNext ? 1 : -1;
    337 
    338     if (isCycleAllowed) {
    339       index = (index + listLength) % listLength;
    340     }
    341 
    342     return list[Math.max(0, Math.min(index, listLength - 1))];
    343   };
    344 
    345   /**
    346    * --------------------------------------------------------------------------
    347    * Bootstrap (v5.1.0): dom/event-handler.js
    348    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
    349    * --------------------------------------------------------------------------
    350    */
    351   /**
    352    * ------------------------------------------------------------------------
    353    * Constants
    354    * ------------------------------------------------------------------------
    355    */
    356 
    357   const namespaceRegex = /[^.]*(?=\..*)\.|.*/;
    358   const stripNameRegex = /\..*/;
    359   const stripUidRegex = /::\d+$/;
    360   const eventRegistry = {}; // Events storage
    361 
    362   let uidEvent = 1;
    363   const customEvents = {
    364     mouseenter: 'mouseover',
    365     mouseleave: 'mouseout'
    366   };
    367   const customEventsRegex = /^(mouseenter|mouseleave)/i;
    368   const nativeEvents = 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']);
    369   /**
    370    * ------------------------------------------------------------------------
    371    * Private methods
    372    * ------------------------------------------------------------------------
    373    */
    374 
    375   function getUidEvent(element, uid) {
    376     return uid && `${uid}::${uidEvent++}` || element.uidEvent || uidEvent++;
    377   }
    378 
    379   function getEvent(element) {
    380     const uid = getUidEvent(element);
    381     element.uidEvent = uid;
    382     eventRegistry[uid] = eventRegistry[uid] || {};
    383     return eventRegistry[uid];
    384   }
    385 
    386   function bootstrapHandler(element, fn) {
    387     return function handler(event) {
    388       event.delegateTarget = element;
    389 
    390       if (handler.oneOff) {
    391         EventHandler.off(element, event.type, fn);
    392       }
    393 
    394       return fn.apply(element, [event]);
    395     };
    396   }
    397 
    398   function bootstrapDelegationHandler(element, selector, fn) {
    399     return function handler(event) {
    400       const domElements = element.querySelectorAll(selector);
    401 
    402       for (let {
    403         target
    404       } = event; target && target !== this; target = target.parentNode) {
    405         for (let i = domElements.length; i--;) {
    406           if (domElements[i] === target) {
    407             event.delegateTarget = target;
    408 
    409             if (handler.oneOff) {
    410               // eslint-disable-next-line unicorn/consistent-destructuring
    411               EventHandler.off(element, event.type, selector, fn);
    412             }
    413 
    414             return fn.apply(target, [event]);
    415           }
    416         }
    417       } // To please ESLint
    418 
    419 
    420       return null;
    421     };
    422   }
    423 
    424   function findHandler(events, handler, delegationSelector = null) {
    425     const uidEventList = Object.keys(events);
    426 
    427     for (let i = 0, len = uidEventList.length; i < len; i++) {
    428       const event = events[uidEventList[i]];
    429 
    430       if (event.originalHandler === handler && event.delegationSelector === delegationSelector) {
    431         return event;
    432       }
    433     }
    434 
    435     return null;
    436   }
    437 
    438   function normalizeParams(originalTypeEvent, handler, delegationFn) {
    439     const delegation = typeof handler === 'string';
    440     const originalHandler = delegation ? delegationFn : handler;
    441     let typeEvent = getTypeEvent(originalTypeEvent);
    442     const isNative = nativeEvents.has(typeEvent);
    443 
    444     if (!isNative) {
    445       typeEvent = originalTypeEvent;
    446     }
    447 
    448     return [delegation, originalHandler, typeEvent];
    449   }
    450 
    451   function addHandler(element, originalTypeEvent, handler, delegationFn, oneOff) {
    452     if (typeof originalTypeEvent !== 'string' || !element) {
    453       return;
    454     }
    455 
    456     if (!handler) {
    457       handler = delegationFn;
    458       delegationFn = null;
    459     } // in case of mouseenter or mouseleave wrap the handler within a function that checks for its DOM position
    460     // this prevents the handler from being dispatched the same way as mouseover or mouseout does
    461 
    462 
    463     if (customEventsRegex.test(originalTypeEvent)) {
    464       const wrapFn = fn => {
    465         return function (event) {
    466           if (!event.relatedTarget || event.relatedTarget !== event.delegateTarget && !event.delegateTarget.contains(event.relatedTarget)) {
    467             return fn.call(this, event);
    468           }
    469         };
    470       };
    471 
    472       if (delegationFn) {
    473         delegationFn = wrapFn(delegationFn);
    474       } else {
    475         handler = wrapFn(handler);
    476       }
    477     }
    478 
    479     const [delegation, originalHandler, typeEvent] = normalizeParams(originalTypeEvent, handler, delegationFn);
    480     const events = getEvent(element);
    481     const handlers = events[typeEvent] || (events[typeEvent] = {});
    482     const previousFn = findHandler(handlers, originalHandler, delegation ? handler : null);
    483 
    484     if (previousFn) {
    485       previousFn.oneOff = previousFn.oneOff && oneOff;
    486       return;
    487     }
    488 
    489     const uid = getUidEvent(originalHandler, originalTypeEvent.replace(namespaceRegex, ''));
    490     const fn = delegation ? bootstrapDelegationHandler(element, handler, delegationFn) : bootstrapHandler(element, handler);
    491     fn.delegationSelector = delegation ? handler : null;
    492     fn.originalHandler = originalHandler;
    493     fn.oneOff = oneOff;
    494     fn.uidEvent = uid;
    495     handlers[uid] = fn;
    496     element.addEventListener(typeEvent, fn, delegation);
    497   }
    498 
    499   function removeHandler(element, events, typeEvent, handler, delegationSelector) {
    500     const fn = findHandler(events[typeEvent], handler, delegationSelector);
    501 
    502     if (!fn) {
    503       return;
    504     }
    505 
    506     element.removeEventListener(typeEvent, fn, Boolean(delegationSelector));
    507     delete events[typeEvent][fn.uidEvent];
    508   }
    509 
    510   function removeNamespacedHandlers(element, events, typeEvent, namespace) {
    511     const storeElementEvent = events[typeEvent] || {};
    512     Object.keys(storeElementEvent).forEach(handlerKey => {
    513       if (handlerKey.includes(namespace)) {
    514         const event = storeElementEvent[handlerKey];
    515         removeHandler(element, events, typeEvent, event.originalHandler, event.delegationSelector);
    516       }
    517     });
    518   }
    519 
    520   function getTypeEvent(event) {
    521     // allow to get the native events from namespaced events ('click.bs.button' --> 'click')
    522     event = event.replace(stripNameRegex, '');
    523     return customEvents[event] || event;
    524   }
    525 
    526   const EventHandler = {
    527     on(element, event, handler, delegationFn) {
    528       addHandler(element, event, handler, delegationFn, false);
    529     },
    530 
    531     one(element, event, handler, delegationFn) {
    532       addHandler(element, event, handler, delegationFn, true);
    533     },
    534 
    535     off(element, originalTypeEvent, handler, delegationFn) {
    536       if (typeof originalTypeEvent !== 'string' || !element) {
    537         return;
    538       }
    539 
    540       const [delegation, originalHandler, typeEvent] = normalizeParams(originalTypeEvent, handler, delegationFn);
    541       const inNamespace = typeEvent !== originalTypeEvent;
    542       const events = getEvent(element);
    543       const isNamespace = originalTypeEvent.startsWith('.');
    544 
    545       if (typeof originalHandler !== 'undefined') {
    546         // Simplest case: handler is passed, remove that listener ONLY.
    547         if (!events || !events[typeEvent]) {
    548           return;
    549         }
    550 
    551         removeHandler(element, events, typeEvent, originalHandler, delegation ? handler : null);
    552         return;
    553       }
    554 
    555       if (isNamespace) {
    556         Object.keys(events).forEach(elementEvent => {
    557           removeNamespacedHandlers(element, events, elementEvent, originalTypeEvent.slice(1));
    558         });
    559       }
    560 
    561       const storeElementEvent = events[typeEvent] || {};
    562       Object.keys(storeElementEvent).forEach(keyHandlers => {
    563         const handlerKey = keyHandlers.replace(stripUidRegex, '');
    564 
    565         if (!inNamespace || originalTypeEvent.includes(handlerKey)) {
    566           const event = storeElementEvent[keyHandlers];
    567           removeHandler(element, events, typeEvent, event.originalHandler, event.delegationSelector);
    568         }
    569       });
    570     },
    571 
    572     trigger(element, event, args) {
    573       if (typeof event !== 'string' || !element) {
    574         return null;
    575       }
    576 
    577       const $ = getjQuery();
    578       const typeEvent = getTypeEvent(event);
    579       const inNamespace = event !== typeEvent;
    580       const isNative = nativeEvents.has(typeEvent);
    581       let jQueryEvent;
    582       let bubbles = true;
    583       let nativeDispatch = true;
    584       let defaultPrevented = false;
    585       let evt = null;
    586 
    587       if (inNamespace && $) {
    588         jQueryEvent = $.Event(event, args);
    589         $(element).trigger(jQueryEvent);
    590         bubbles = !jQueryEvent.isPropagationStopped();
    591         nativeDispatch = !jQueryEvent.isImmediatePropagationStopped();
    592         defaultPrevented = jQueryEvent.isDefaultPrevented();
    593       }
    594 
    595       if (isNative) {
    596         evt = document.createEvent('HTMLEvents');
    597         evt.initEvent(typeEvent, bubbles, true);
    598       } else {
    599         evt = new CustomEvent(event, {
    600           bubbles,
    601           cancelable: true
    602         });
    603       } // merge custom information in our event
    604 
    605 
    606       if (typeof args !== 'undefined') {
    607         Object.keys(args).forEach(key => {
    608           Object.defineProperty(evt, key, {
    609             get() {
    610               return args[key];
    611             }
    612 
    613           });
    614         });
    615       }
    616 
    617       if (defaultPrevented) {
    618         evt.preventDefault();
    619       }
    620 
    621       if (nativeDispatch) {
    622         element.dispatchEvent(evt);
    623       }
    624 
    625       if (evt.defaultPrevented && typeof jQueryEvent !== 'undefined') {
    626         jQueryEvent.preventDefault();
    627       }
    628 
    629       return evt;
    630     }
    631 
    632   };
    633 
    634   /**
    635    * --------------------------------------------------------------------------
    636    * Bootstrap (v5.1.0): dom/data.js
    637    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
    638    * --------------------------------------------------------------------------
    639    */
    640 
    641   /**
    642    * ------------------------------------------------------------------------
    643    * Constants
    644    * ------------------------------------------------------------------------
    645    */
    646   const elementMap = new Map();
    647   var Data = {
    648     set(element, key, instance) {
    649       if (!elementMap.has(element)) {
    650         elementMap.set(element, new Map());
    651       }
    652 
    653       const instanceMap = elementMap.get(element); // make it clear we only want one instance per element
    654       // can be removed later when multiple key/instances are fine to be used
    655 
    656       if (!instanceMap.has(key) && instanceMap.size !== 0) {
    657         // eslint-disable-next-line no-console
    658         console.error(`Bootstrap doesn't allow more than one instance per element. Bound instance: ${Array.from(instanceMap.keys())[0]}.`);
    659         return;
    660       }
    661 
    662       instanceMap.set(key, instance);
    663     },
    664 
    665     get(element, key) {
    666       if (elementMap.has(element)) {
    667         return elementMap.get(element).get(key) || null;
    668       }
    669 
    670       return null;
    671     },
    672 
    673     remove(element, key) {
    674       if (!elementMap.has(element)) {
    675         return;
    676       }
    677 
    678       const instanceMap = elementMap.get(element);
    679       instanceMap.delete(key); // free up element references if there are no instances left for an element
    680 
    681       if (instanceMap.size === 0) {
    682         elementMap.delete(element);
    683       }
    684     }
    685 
    686   };
    687 
    688   /**
    689    * --------------------------------------------------------------------------
    690    * Bootstrap (v5.1.0): base-component.js
    691    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
    692    * --------------------------------------------------------------------------
    693    */
    694   /**
    695    * ------------------------------------------------------------------------
    696    * Constants
    697    * ------------------------------------------------------------------------
    698    */
    699 
    700   const VERSION = '5.1.0';
    701 
    702   class BaseComponent {
    703     constructor(element) {
    704       element = getElement(element);
    705 
    706       if (!element) {
    707         return;
    708       }
    709 
    710       this._element = element;
    711       Data.set(this._element, this.constructor.DATA_KEY, this);
    712     }
    713 
    714     dispose() {
    715       Data.remove(this._element, this.constructor.DATA_KEY);
    716       EventHandler.off(this._element, this.constructor.EVENT_KEY);
    717       Object.getOwnPropertyNames(this).forEach(propertyName => {
    718         this[propertyName] = null;
    719       });
    720     }
    721 
    722     _queueCallback(callback, element, isAnimated = true) {
    723       executeAfterTransition(callback, element, isAnimated);
    724     }
    725     /** Static */
    726 
    727 
    728     static getInstance(element) {
    729       return Data.get(getElement(element), this.DATA_KEY);
    730     }
    731 
    732     static getOrCreateInstance(element, config = {}) {
    733       return this.getInstance(element) || new this(element, typeof config === 'object' ? config : null);
    734     }
    735 
    736     static get VERSION() {
    737       return VERSION;
    738     }
    739 
    740     static get NAME() {
    741       throw new Error('You have to implement the static method "NAME", for each component!');
    742     }
    743 
    744     static get DATA_KEY() {
    745       return `bs.${this.NAME}`;
    746     }
    747 
    748     static get EVENT_KEY() {
    749       return `.${this.DATA_KEY}`;
    750     }
    751 
    752   }
    753 
    754   /**
    755    * --------------------------------------------------------------------------
    756    * Bootstrap (v5.1.0): util/component-functions.js
    757    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
    758    * --------------------------------------------------------------------------
    759    */
    760 
    761   const enableDismissTrigger = (component, method = 'hide') => {
    762     const clickEvent = `click.dismiss${component.EVENT_KEY}`;
    763     const name = component.NAME;
    764     EventHandler.on(document, clickEvent, `[data-bs-dismiss="${name}"]`, function (event) {
    765       if (['A', 'AREA'].includes(this.tagName)) {
    766         event.preventDefault();
    767       }
    768 
    769       if (isDisabled(this)) {
    770         return;
    771       }
    772 
    773       const target = getElementFromSelector(this) || this.closest(`.${name}`);
    774       const instance = component.getOrCreateInstance(target); // Method argument is left, for Alert and only, as it doesn't implement the 'hide' method
    775 
    776       instance[method]();
    777     });
    778   };
    779 
    780   /**
    781    * --------------------------------------------------------------------------
    782    * Bootstrap (v5.1.0): alert.js
    783    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
    784    * --------------------------------------------------------------------------
    785    */
    786   /**
    787    * ------------------------------------------------------------------------
    788    * Constants
    789    * ------------------------------------------------------------------------
    790    */
    791 
    792   const NAME$d = 'alert';
    793   const DATA_KEY$c = 'bs.alert';
    794   const EVENT_KEY$c = `.${DATA_KEY$c}`;
    795   const EVENT_CLOSE = `close${EVENT_KEY$c}`;
    796   const EVENT_CLOSED = `closed${EVENT_KEY$c}`;
    797   const CLASS_NAME_FADE$5 = 'fade';
    798   const CLASS_NAME_SHOW$8 = 'show';
    799   /**
    800    * ------------------------------------------------------------------------
    801    * Class Definition
    802    * ------------------------------------------------------------------------
    803    */
    804 
    805   class Alert extends BaseComponent {
    806     // Getters
    807     static get NAME() {
    808       return NAME$d;
    809     } // Public
    810 
    811 
    812     close() {
    813       const closeEvent = EventHandler.trigger(this._element, EVENT_CLOSE);
    814 
    815       if (closeEvent.defaultPrevented) {
    816         return;
    817       }
    818 
    819       this._element.classList.remove(CLASS_NAME_SHOW$8);
    820 
    821       const isAnimated = this._element.classList.contains(CLASS_NAME_FADE$5);
    822 
    823       this._queueCallback(() => this._destroyElement(), this._element, isAnimated);
    824     } // Private
    825 
    826 
    827     _destroyElement() {
    828       this._element.remove();
    829 
    830       EventHandler.trigger(this._element, EVENT_CLOSED);
    831       this.dispose();
    832     } // Static
    833 
    834 
    835     static jQueryInterface(config) {
    836       return this.each(function () {
    837         const data = Alert.getOrCreateInstance(this);
    838 
    839         if (typeof config !== 'string') {
    840           return;
    841         }
    842 
    843         if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {
    844           throw new TypeError(`No method named "${config}"`);
    845         }
    846 
    847         data[config](this);
    848       });
    849     }
    850 
    851   }
    852   /**
    853    * ------------------------------------------------------------------------
    854    * Data Api implementation
    855    * ------------------------------------------------------------------------
    856    */
    857 
    858 
    859   enableDismissTrigger(Alert, 'close');
    860   /**
    861    * ------------------------------------------------------------------------
    862    * jQuery
    863    * ------------------------------------------------------------------------
    864    * add .Alert to jQuery only if jQuery is present
    865    */
    866 
    867   defineJQueryPlugin(Alert);
    868 
    869   /**
    870    * --------------------------------------------------------------------------
    871    * Bootstrap (v5.1.0): button.js
    872    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
    873    * --------------------------------------------------------------------------
    874    */
    875   /**
    876    * ------------------------------------------------------------------------
    877    * Constants
    878    * ------------------------------------------------------------------------
    879    */
    880 
    881   const NAME$c = 'button';
    882   const DATA_KEY$b = 'bs.button';
    883   const EVENT_KEY$b = `.${DATA_KEY$b}`;
    884   const DATA_API_KEY$7 = '.data-api';
    885   const CLASS_NAME_ACTIVE$3 = 'active';
    886   const SELECTOR_DATA_TOGGLE$5 = '[data-bs-toggle="button"]';
    887   const EVENT_CLICK_DATA_API$6 = `click${EVENT_KEY$b}${DATA_API_KEY$7}`;
    888   /**
    889    * ------------------------------------------------------------------------
    890    * Class Definition
    891    * ------------------------------------------------------------------------
    892    */
    893 
    894   class Button extends BaseComponent {
    895     // Getters
    896     static get NAME() {
    897       return NAME$c;
    898     } // Public
    899 
    900 
    901     toggle() {
    902       // Toggle class and sync the `aria-pressed` attribute with the return value of the `.toggle()` method
    903       this._element.setAttribute('aria-pressed', this._element.classList.toggle(CLASS_NAME_ACTIVE$3));
    904     } // Static
    905 
    906 
    907     static jQueryInterface(config) {
    908       return this.each(function () {
    909         const data = Button.getOrCreateInstance(this);
    910 
    911         if (config === 'toggle') {
    912           data[config]();
    913         }
    914       });
    915     }
    916 
    917   }
    918   /**
    919    * ------------------------------------------------------------------------
    920    * Data Api implementation
    921    * ------------------------------------------------------------------------
    922    */
    923 
    924 
    925   EventHandler.on(document, EVENT_CLICK_DATA_API$6, SELECTOR_DATA_TOGGLE$5, event => {
    926     event.preventDefault();
    927     const button = event.target.closest(SELECTOR_DATA_TOGGLE$5);
    928     const data = Button.getOrCreateInstance(button);
    929     data.toggle();
    930   });
    931   /**
    932    * ------------------------------------------------------------------------
    933    * jQuery
    934    * ------------------------------------------------------------------------
    935    * add .Button to jQuery only if jQuery is present
    936    */
    937 
    938   defineJQueryPlugin(Button);
    939 
    940   /**
    941    * --------------------------------------------------------------------------
    942    * Bootstrap (v5.1.0): dom/manipulator.js
    943    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
    944    * --------------------------------------------------------------------------
    945    */
    946   function normalizeData(val) {
    947     if (val === 'true') {
    948       return true;
    949     }
    950 
    951     if (val === 'false') {
    952       return false;
    953     }
    954 
    955     if (val === Number(val).toString()) {
    956       return Number(val);
    957     }
    958 
    959     if (val === '' || val === 'null') {
    960       return null;
    961     }
    962 
    963     return val;
    964   }
    965 
    966   function normalizeDataKey(key) {
    967     return key.replace(/[A-Z]/g, chr => `-${chr.toLowerCase()}`);
    968   }
    969 
    970   const Manipulator = {
    971     setDataAttribute(element, key, value) {
    972       element.setAttribute(`data-bs-${normalizeDataKey(key)}`, value);
    973     },
    974 
    975     removeDataAttribute(element, key) {
    976       element.removeAttribute(`data-bs-${normalizeDataKey(key)}`);
    977     },
    978 
    979     getDataAttributes(element) {
    980       if (!element) {
    981         return {};
    982       }
    983 
    984       const attributes = {};
    985       Object.keys(element.dataset).filter(key => key.startsWith('bs')).forEach(key => {
    986         let pureKey = key.replace(/^bs/, '');
    987         pureKey = pureKey.charAt(0).toLowerCase() + pureKey.slice(1, pureKey.length);
    988         attributes[pureKey] = normalizeData(element.dataset[key]);
    989       });
    990       return attributes;
    991     },
    992 
    993     getDataAttribute(element, key) {
    994       return normalizeData(element.getAttribute(`data-bs-${normalizeDataKey(key)}`));
    995     },
    996 
    997     offset(element) {
    998       const rect = element.getBoundingClientRect();
    999       return {
   1000         top: rect.top + window.pageYOffset,
   1001         left: rect.left + window.pageXOffset
   1002       };
   1003     },
   1004 
   1005     position(element) {
   1006       return {
   1007         top: element.offsetTop,
   1008         left: element.offsetLeft
   1009       };
   1010     }
   1011 
   1012   };
   1013 
   1014   /**
   1015    * --------------------------------------------------------------------------
   1016    * Bootstrap (v5.1.0): dom/selector-engine.js
   1017    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
   1018    * --------------------------------------------------------------------------
   1019    */
   1020   const NODE_TEXT = 3;
   1021   const SelectorEngine = {
   1022     find(selector, element = document.documentElement) {
   1023       return [].concat(...Element.prototype.querySelectorAll.call(element, selector));
   1024     },
   1025 
   1026     findOne(selector, element = document.documentElement) {
   1027       return Element.prototype.querySelector.call(element, selector);
   1028     },
   1029 
   1030     children(element, selector) {
   1031       return [].concat(...element.children).filter(child => child.matches(selector));
   1032     },
   1033 
   1034     parents(element, selector) {
   1035       const parents = [];
   1036       let ancestor = element.parentNode;
   1037 
   1038       while (ancestor && ancestor.nodeType === Node.ELEMENT_NODE && ancestor.nodeType !== NODE_TEXT) {
   1039         if (ancestor.matches(selector)) {
   1040           parents.push(ancestor);
   1041         }
   1042 
   1043         ancestor = ancestor.parentNode;
   1044       }
   1045 
   1046       return parents;
   1047     },
   1048 
   1049     prev(element, selector) {
   1050       let previous = element.previousElementSibling;
   1051 
   1052       while (previous) {
   1053         if (previous.matches(selector)) {
   1054           return [previous];
   1055         }
   1056 
   1057         previous = previous.previousElementSibling;
   1058       }
   1059 
   1060       return [];
   1061     },
   1062 
   1063     next(element, selector) {
   1064       let next = element.nextElementSibling;
   1065 
   1066       while (next) {
   1067         if (next.matches(selector)) {
   1068           return [next];
   1069         }
   1070 
   1071         next = next.nextElementSibling;
   1072       }
   1073 
   1074       return [];
   1075     },
   1076 
   1077     focusableChildren(element) {
   1078       const focusables = ['a', 'button', 'input', 'textarea', 'select', 'details', '[tabindex]', '[contenteditable="true"]'].map(selector => `${selector}:not([tabindex^="-"])`).join(', ');
   1079       return this.find(focusables, element).filter(el => !isDisabled(el) && isVisible(el));
   1080     }
   1081 
   1082   };
   1083 
   1084   /**
   1085    * --------------------------------------------------------------------------
   1086    * Bootstrap (v5.1.0): carousel.js
   1087    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
   1088    * --------------------------------------------------------------------------
   1089    */
   1090   /**
   1091    * ------------------------------------------------------------------------
   1092    * Constants
   1093    * ------------------------------------------------------------------------
   1094    */
   1095 
   1096   const NAME$b = 'carousel';
   1097   const DATA_KEY$a = 'bs.carousel';
   1098   const EVENT_KEY$a = `.${DATA_KEY$a}`;
   1099   const DATA_API_KEY$6 = '.data-api';
   1100   const ARROW_LEFT_KEY = 'ArrowLeft';
   1101   const ARROW_RIGHT_KEY = 'ArrowRight';
   1102   const TOUCHEVENT_COMPAT_WAIT = 500; // Time for mouse compat events to fire after touch
   1103 
   1104   const SWIPE_THRESHOLD = 40;
   1105   const Default$a = {
   1106     interval: 5000,
   1107     keyboard: true,
   1108     slide: false,
   1109     pause: 'hover',
   1110     wrap: true,
   1111     touch: true
   1112   };
   1113   const DefaultType$a = {
   1114     interval: '(number|boolean)',
   1115     keyboard: 'boolean',
   1116     slide: '(boolean|string)',
   1117     pause: '(string|boolean)',
   1118     wrap: 'boolean',
   1119     touch: 'boolean'
   1120   };
   1121   const ORDER_NEXT = 'next';
   1122   const ORDER_PREV = 'prev';
   1123   const DIRECTION_LEFT = 'left';
   1124   const DIRECTION_RIGHT = 'right';
   1125   const KEY_TO_DIRECTION = {
   1126     [ARROW_LEFT_KEY]: DIRECTION_RIGHT,
   1127     [ARROW_RIGHT_KEY]: DIRECTION_LEFT
   1128   };
   1129   const EVENT_SLIDE = `slide${EVENT_KEY$a}`;
   1130   const EVENT_SLID = `slid${EVENT_KEY$a}`;
   1131   const EVENT_KEYDOWN = `keydown${EVENT_KEY$a}`;
   1132   const EVENT_MOUSEENTER = `mouseenter${EVENT_KEY$a}`;
   1133   const EVENT_MOUSELEAVE = `mouseleave${EVENT_KEY$a}`;
   1134   const EVENT_TOUCHSTART = `touchstart${EVENT_KEY$a}`;
   1135   const EVENT_TOUCHMOVE = `touchmove${EVENT_KEY$a}`;
   1136   const EVENT_TOUCHEND = `touchend${EVENT_KEY$a}`;
   1137   const EVENT_POINTERDOWN = `pointerdown${EVENT_KEY$a}`;
   1138   const EVENT_POINTERUP = `pointerup${EVENT_KEY$a}`;
   1139   const EVENT_DRAG_START = `dragstart${EVENT_KEY$a}`;
   1140   const EVENT_LOAD_DATA_API$2 = `load${EVENT_KEY$a}${DATA_API_KEY$6}`;
   1141   const EVENT_CLICK_DATA_API$5 = `click${EVENT_KEY$a}${DATA_API_KEY$6}`;
   1142   const CLASS_NAME_CAROUSEL = 'carousel';
   1143   const CLASS_NAME_ACTIVE$2 = 'active';
   1144   const CLASS_NAME_SLIDE = 'slide';
   1145   const CLASS_NAME_END = 'carousel-item-end';
   1146   const CLASS_NAME_START = 'carousel-item-start';
   1147   const CLASS_NAME_NEXT = 'carousel-item-next';
   1148   const CLASS_NAME_PREV = 'carousel-item-prev';
   1149   const CLASS_NAME_POINTER_EVENT = 'pointer-event';
   1150   const SELECTOR_ACTIVE$1 = '.active';
   1151   const SELECTOR_ACTIVE_ITEM = '.active.carousel-item';
   1152   const SELECTOR_ITEM = '.carousel-item';
   1153   const SELECTOR_ITEM_IMG = '.carousel-item img';
   1154   const SELECTOR_NEXT_PREV = '.carousel-item-next, .carousel-item-prev';
   1155   const SELECTOR_INDICATORS = '.carousel-indicators';
   1156   const SELECTOR_INDICATOR = '[data-bs-target]';
   1157   const SELECTOR_DATA_SLIDE = '[data-bs-slide], [data-bs-slide-to]';
   1158   const SELECTOR_DATA_RIDE = '[data-bs-ride="carousel"]';
   1159   const POINTER_TYPE_TOUCH = 'touch';
   1160   const POINTER_TYPE_PEN = 'pen';
   1161   /**
   1162    * ------------------------------------------------------------------------
   1163    * Class Definition
   1164    * ------------------------------------------------------------------------
   1165    */
   1166 
   1167   class Carousel extends BaseComponent {
   1168     constructor(element, config) {
   1169       super(element);
   1170       this._items = null;
   1171       this._interval = null;
   1172       this._activeElement = null;
   1173       this._isPaused = false;
   1174       this._isSliding = false;
   1175       this.touchTimeout = null;
   1176       this.touchStartX = 0;
   1177       this.touchDeltaX = 0;
   1178       this._config = this._getConfig(config);
   1179       this._indicatorsElement = SelectorEngine.findOne(SELECTOR_INDICATORS, this._element);
   1180       this._touchSupported = 'ontouchstart' in document.documentElement || navigator.maxTouchPoints > 0;
   1181       this._pointerEvent = Boolean(window.PointerEvent);
   1182 
   1183       this._addEventListeners();
   1184     } // Getters
   1185 
   1186 
   1187     static get Default() {
   1188       return Default$a;
   1189     }
   1190 
   1191     static get NAME() {
   1192       return NAME$b;
   1193     } // Public
   1194 
   1195 
   1196     next() {
   1197       this._slide(ORDER_NEXT);
   1198     }
   1199 
   1200     nextWhenVisible() {
   1201       // Don't call next when the page isn't visible
   1202       // or the carousel or its parent isn't visible
   1203       if (!document.hidden && isVisible(this._element)) {
   1204         this.next();
   1205       }
   1206     }
   1207 
   1208     prev() {
   1209       this._slide(ORDER_PREV);
   1210     }
   1211 
   1212     pause(event) {
   1213       if (!event) {
   1214         this._isPaused = true;
   1215       }
   1216 
   1217       if (SelectorEngine.findOne(SELECTOR_NEXT_PREV, this._element)) {
   1218         triggerTransitionEnd(this._element);
   1219         this.cycle(true);
   1220       }
   1221 
   1222       clearInterval(this._interval);
   1223       this._interval = null;
   1224     }
   1225 
   1226     cycle(event) {
   1227       if (!event) {
   1228         this._isPaused = false;
   1229       }
   1230 
   1231       if (this._interval) {
   1232         clearInterval(this._interval);
   1233         this._interval = null;
   1234       }
   1235 
   1236       if (this._config && this._config.interval && !this._isPaused) {
   1237         this._updateInterval();
   1238 
   1239         this._interval = setInterval((document.visibilityState ? this.nextWhenVisible : this.next).bind(this), this._config.interval);
   1240       }
   1241     }
   1242 
   1243     to(index) {
   1244       this._activeElement = SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element);
   1245 
   1246       const activeIndex = this._getItemIndex(this._activeElement);
   1247 
   1248       if (index > this._items.length - 1 || index < 0) {
   1249         return;
   1250       }
   1251 
   1252       if (this._isSliding) {
   1253         EventHandler.one(this._element, EVENT_SLID, () => this.to(index));
   1254         return;
   1255       }
   1256 
   1257       if (activeIndex === index) {
   1258         this.pause();
   1259         this.cycle();
   1260         return;
   1261       }
   1262 
   1263       const order = index > activeIndex ? ORDER_NEXT : ORDER_PREV;
   1264 
   1265       this._slide(order, this._items[index]);
   1266     } // Private
   1267 
   1268 
   1269     _getConfig(config) {
   1270       config = { ...Default$a,
   1271         ...Manipulator.getDataAttributes(this._element),
   1272         ...(typeof config === 'object' ? config : {})
   1273       };
   1274       typeCheckConfig(NAME$b, config, DefaultType$a);
   1275       return config;
   1276     }
   1277 
   1278     _handleSwipe() {
   1279       const absDeltax = Math.abs(this.touchDeltaX);
   1280 
   1281       if (absDeltax <= SWIPE_THRESHOLD) {
   1282         return;
   1283       }
   1284 
   1285       const direction = absDeltax / this.touchDeltaX;
   1286       this.touchDeltaX = 0;
   1287 
   1288       if (!direction) {
   1289         return;
   1290       }
   1291 
   1292       this._slide(direction > 0 ? DIRECTION_RIGHT : DIRECTION_LEFT);
   1293     }
   1294 
   1295     _addEventListeners() {
   1296       if (this._config.keyboard) {
   1297         EventHandler.on(this._element, EVENT_KEYDOWN, event => this._keydown(event));
   1298       }
   1299 
   1300       if (this._config.pause === 'hover') {
   1301         EventHandler.on(this._element, EVENT_MOUSEENTER, event => this.pause(event));
   1302         EventHandler.on(this._element, EVENT_MOUSELEAVE, event => this.cycle(event));
   1303       }
   1304 
   1305       if (this._config.touch && this._touchSupported) {
   1306         this._addTouchEventListeners();
   1307       }
   1308     }
   1309 
   1310     _addTouchEventListeners() {
   1311       const start = event => {
   1312         if (this._pointerEvent && (event.pointerType === POINTER_TYPE_PEN || event.pointerType === POINTER_TYPE_TOUCH)) {
   1313           this.touchStartX = event.clientX;
   1314         } else if (!this._pointerEvent) {
   1315           this.touchStartX = event.touches[0].clientX;
   1316         }
   1317       };
   1318 
   1319       const move = event => {
   1320         // ensure swiping with one touch and not pinching
   1321         this.touchDeltaX = event.touches && event.touches.length > 1 ? 0 : event.touches[0].clientX - this.touchStartX;
   1322       };
   1323 
   1324       const end = event => {
   1325         if (this._pointerEvent && (event.pointerType === POINTER_TYPE_PEN || event.pointerType === POINTER_TYPE_TOUCH)) {
   1326           this.touchDeltaX = event.clientX - this.touchStartX;
   1327         }
   1328 
   1329         this._handleSwipe();
   1330 
   1331         if (this._config.pause === 'hover') {
   1332           // If it's a touch-enabled device, mouseenter/leave are fired as
   1333           // part of the mouse compatibility events on first tap - the carousel
   1334           // would stop cycling until user tapped out of it;
   1335           // here, we listen for touchend, explicitly pause the carousel
   1336           // (as if it's the second time we tap on it, mouseenter compat event
   1337           // is NOT fired) and after a timeout (to allow for mouse compatibility
   1338           // events to fire) we explicitly restart cycling
   1339           this.pause();
   1340 
   1341           if (this.touchTimeout) {
   1342             clearTimeout(this.touchTimeout);
   1343           }
   1344 
   1345           this.touchTimeout = setTimeout(event => this.cycle(event), TOUCHEVENT_COMPAT_WAIT + this._config.interval);
   1346         }
   1347       };
   1348 
   1349       SelectorEngine.find(SELECTOR_ITEM_IMG, this._element).forEach(itemImg => {
   1350         EventHandler.on(itemImg, EVENT_DRAG_START, e => e.preventDefault());
   1351       });
   1352 
   1353       if (this._pointerEvent) {
   1354         EventHandler.on(this._element, EVENT_POINTERDOWN, event => start(event));
   1355         EventHandler.on(this._element, EVENT_POINTERUP, event => end(event));
   1356 
   1357         this._element.classList.add(CLASS_NAME_POINTER_EVENT);
   1358       } else {
   1359         EventHandler.on(this._element, EVENT_TOUCHSTART, event => start(event));
   1360         EventHandler.on(this._element, EVENT_TOUCHMOVE, event => move(event));
   1361         EventHandler.on(this._element, EVENT_TOUCHEND, event => end(event));
   1362       }
   1363     }
   1364 
   1365     _keydown(event) {
   1366       if (/input|textarea/i.test(event.target.tagName)) {
   1367         return;
   1368       }
   1369 
   1370       const direction = KEY_TO_DIRECTION[event.key];
   1371 
   1372       if (direction) {
   1373         event.preventDefault();
   1374 
   1375         this._slide(direction);
   1376       }
   1377     }
   1378 
   1379     _getItemIndex(element) {
   1380       this._items = element && element.parentNode ? SelectorEngine.find(SELECTOR_ITEM, element.parentNode) : [];
   1381       return this._items.indexOf(element);
   1382     }
   1383 
   1384     _getItemByOrder(order, activeElement) {
   1385       const isNext = order === ORDER_NEXT;
   1386       return getNextActiveElement(this._items, activeElement, isNext, this._config.wrap);
   1387     }
   1388 
   1389     _triggerSlideEvent(relatedTarget, eventDirectionName) {
   1390       const targetIndex = this._getItemIndex(relatedTarget);
   1391 
   1392       const fromIndex = this._getItemIndex(SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element));
   1393 
   1394       return EventHandler.trigger(this._element, EVENT_SLIDE, {
   1395         relatedTarget,
   1396         direction: eventDirectionName,
   1397         from: fromIndex,
   1398         to: targetIndex
   1399       });
   1400     }
   1401 
   1402     _setActiveIndicatorElement(element) {
   1403       if (this._indicatorsElement) {
   1404         const activeIndicator = SelectorEngine.findOne(SELECTOR_ACTIVE$1, this._indicatorsElement);
   1405         activeIndicator.classList.remove(CLASS_NAME_ACTIVE$2);
   1406         activeIndicator.removeAttribute('aria-current');
   1407         const indicators = SelectorEngine.find(SELECTOR_INDICATOR, this._indicatorsElement);
   1408 
   1409         for (let i = 0; i < indicators.length; i++) {
   1410           if (Number.parseInt(indicators[i].getAttribute('data-bs-slide-to'), 10) === this._getItemIndex(element)) {
   1411             indicators[i].classList.add(CLASS_NAME_ACTIVE$2);
   1412             indicators[i].setAttribute('aria-current', 'true');
   1413             break;
   1414           }
   1415         }
   1416       }
   1417     }
   1418 
   1419     _updateInterval() {
   1420       const element = this._activeElement || SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element);
   1421 
   1422       if (!element) {
   1423         return;
   1424       }
   1425 
   1426       const elementInterval = Number.parseInt(element.getAttribute('data-bs-interval'), 10);
   1427 
   1428       if (elementInterval) {
   1429         this._config.defaultInterval = this._config.defaultInterval || this._config.interval;
   1430         this._config.interval = elementInterval;
   1431       } else {
   1432         this._config.interval = this._config.defaultInterval || this._config.interval;
   1433       }
   1434     }
   1435 
   1436     _slide(directionOrOrder, element) {
   1437       const order = this._directionToOrder(directionOrOrder);
   1438 
   1439       const activeElement = SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element);
   1440 
   1441       const activeElementIndex = this._getItemIndex(activeElement);
   1442 
   1443       const nextElement = element || this._getItemByOrder(order, activeElement);
   1444 
   1445       const nextElementIndex = this._getItemIndex(nextElement);
   1446 
   1447       const isCycling = Boolean(this._interval);
   1448       const isNext = order === ORDER_NEXT;
   1449       const directionalClassName = isNext ? CLASS_NAME_START : CLASS_NAME_END;
   1450       const orderClassName = isNext ? CLASS_NAME_NEXT : CLASS_NAME_PREV;
   1451 
   1452       const eventDirectionName = this._orderToDirection(order);
   1453 
   1454       if (nextElement && nextElement.classList.contains(CLASS_NAME_ACTIVE$2)) {
   1455         this._isSliding = false;
   1456         return;
   1457       }
   1458 
   1459       if (this._isSliding) {
   1460         return;
   1461       }
   1462 
   1463       const slideEvent = this._triggerSlideEvent(nextElement, eventDirectionName);
   1464 
   1465       if (slideEvent.defaultPrevented) {
   1466         return;
   1467       }
   1468 
   1469       if (!activeElement || !nextElement) {
   1470         // Some weirdness is happening, so we bail
   1471         return;
   1472       }
   1473 
   1474       this._isSliding = true;
   1475 
   1476       if (isCycling) {
   1477         this.pause();
   1478       }
   1479 
   1480       this._setActiveIndicatorElement(nextElement);
   1481 
   1482       this._activeElement = nextElement;
   1483 
   1484       const triggerSlidEvent = () => {
   1485         EventHandler.trigger(this._element, EVENT_SLID, {
   1486           relatedTarget: nextElement,
   1487           direction: eventDirectionName,
   1488           from: activeElementIndex,
   1489           to: nextElementIndex
   1490         });
   1491       };
   1492 
   1493       if (this._element.classList.contains(CLASS_NAME_SLIDE)) {
   1494         nextElement.classList.add(orderClassName);
   1495         reflow(nextElement);
   1496         activeElement.classList.add(directionalClassName);
   1497         nextElement.classList.add(directionalClassName);
   1498 
   1499         const completeCallBack = () => {
   1500           nextElement.classList.remove(directionalClassName, orderClassName);
   1501           nextElement.classList.add(CLASS_NAME_ACTIVE$2);
   1502           activeElement.classList.remove(CLASS_NAME_ACTIVE$2, orderClassName, directionalClassName);
   1503           this._isSliding = false;
   1504           setTimeout(triggerSlidEvent, 0);
   1505         };
   1506 
   1507         this._queueCallback(completeCallBack, activeElement, true);
   1508       } else {
   1509         activeElement.classList.remove(CLASS_NAME_ACTIVE$2);
   1510         nextElement.classList.add(CLASS_NAME_ACTIVE$2);
   1511         this._isSliding = false;
   1512         triggerSlidEvent();
   1513       }
   1514 
   1515       if (isCycling) {
   1516         this.cycle();
   1517       }
   1518     }
   1519 
   1520     _directionToOrder(direction) {
   1521       if (![DIRECTION_RIGHT, DIRECTION_LEFT].includes(direction)) {
   1522         return direction;
   1523       }
   1524 
   1525       if (isRTL()) {
   1526         return direction === DIRECTION_LEFT ? ORDER_PREV : ORDER_NEXT;
   1527       }
   1528 
   1529       return direction === DIRECTION_LEFT ? ORDER_NEXT : ORDER_PREV;
   1530     }
   1531 
   1532     _orderToDirection(order) {
   1533       if (![ORDER_NEXT, ORDER_PREV].includes(order)) {
   1534         return order;
   1535       }
   1536 
   1537       if (isRTL()) {
   1538         return order === ORDER_PREV ? DIRECTION_LEFT : DIRECTION_RIGHT;
   1539       }
   1540 
   1541       return order === ORDER_PREV ? DIRECTION_RIGHT : DIRECTION_LEFT;
   1542     } // Static
   1543 
   1544 
   1545     static carouselInterface(element, config) {
   1546       const data = Carousel.getOrCreateInstance(element, config);
   1547       let {
   1548         _config
   1549       } = data;
   1550 
   1551       if (typeof config === 'object') {
   1552         _config = { ..._config,
   1553           ...config
   1554         };
   1555       }
   1556 
   1557       const action = typeof config === 'string' ? config : _config.slide;
   1558 
   1559       if (typeof config === 'number') {
   1560         data.to(config);
   1561       } else if (typeof action === 'string') {
   1562         if (typeof data[action] === 'undefined') {
   1563           throw new TypeError(`No method named "${action}"`);
   1564         }
   1565 
   1566         data[action]();
   1567       } else if (_config.interval && _config.ride) {
   1568         data.pause();
   1569         data.cycle();
   1570       }
   1571     }
   1572 
   1573     static jQueryInterface(config) {
   1574       return this.each(function () {
   1575         Carousel.carouselInterface(this, config);
   1576       });
   1577     }
   1578 
   1579     static dataApiClickHandler(event) {
   1580       const target = getElementFromSelector(this);
   1581 
   1582       if (!target || !target.classList.contains(CLASS_NAME_CAROUSEL)) {
   1583         return;
   1584       }
   1585 
   1586       const config = { ...Manipulator.getDataAttributes(target),
   1587         ...Manipulator.getDataAttributes(this)
   1588       };
   1589       const slideIndex = this.getAttribute('data-bs-slide-to');
   1590 
   1591       if (slideIndex) {
   1592         config.interval = false;
   1593       }
   1594 
   1595       Carousel.carouselInterface(target, config);
   1596 
   1597       if (slideIndex) {
   1598         Carousel.getInstance(target).to(slideIndex);
   1599       }
   1600 
   1601       event.preventDefault();
   1602     }
   1603 
   1604   }
   1605   /**
   1606    * ------------------------------------------------------------------------
   1607    * Data Api implementation
   1608    * ------------------------------------------------------------------------
   1609    */
   1610 
   1611 
   1612   EventHandler.on(document, EVENT_CLICK_DATA_API$5, SELECTOR_DATA_SLIDE, Carousel.dataApiClickHandler);
   1613   EventHandler.on(window, EVENT_LOAD_DATA_API$2, () => {
   1614     const carousels = SelectorEngine.find(SELECTOR_DATA_RIDE);
   1615 
   1616     for (let i = 0, len = carousels.length; i < len; i++) {
   1617       Carousel.carouselInterface(carousels[i], Carousel.getInstance(carousels[i]));
   1618     }
   1619   });
   1620   /**
   1621    * ------------------------------------------------------------------------
   1622    * jQuery
   1623    * ------------------------------------------------------------------------
   1624    * add .Carousel to jQuery only if jQuery is present
   1625    */
   1626 
   1627   defineJQueryPlugin(Carousel);
   1628 
   1629   /**
   1630    * --------------------------------------------------------------------------
   1631    * Bootstrap (v5.1.0): collapse.js
   1632    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
   1633    * --------------------------------------------------------------------------
   1634    */
   1635   /**
   1636    * ------------------------------------------------------------------------
   1637    * Constants
   1638    * ------------------------------------------------------------------------
   1639    */
   1640 
   1641   const NAME$a = 'collapse';
   1642   const DATA_KEY$9 = 'bs.collapse';
   1643   const EVENT_KEY$9 = `.${DATA_KEY$9}`;
   1644   const DATA_API_KEY$5 = '.data-api';
   1645   const Default$9 = {
   1646     toggle: true,
   1647     parent: null
   1648   };
   1649   const DefaultType$9 = {
   1650     toggle: 'boolean',
   1651     parent: '(null|element)'
   1652   };
   1653   const EVENT_SHOW$5 = `show${EVENT_KEY$9}`;
   1654   const EVENT_SHOWN$5 = `shown${EVENT_KEY$9}`;
   1655   const EVENT_HIDE$5 = `hide${EVENT_KEY$9}`;
   1656   const EVENT_HIDDEN$5 = `hidden${EVENT_KEY$9}`;
   1657   const EVENT_CLICK_DATA_API$4 = `click${EVENT_KEY$9}${DATA_API_KEY$5}`;
   1658   const CLASS_NAME_SHOW$7 = 'show';
   1659   const CLASS_NAME_COLLAPSE = 'collapse';
   1660   const CLASS_NAME_COLLAPSING = 'collapsing';
   1661   const CLASS_NAME_COLLAPSED = 'collapsed';
   1662   const CLASS_NAME_HORIZONTAL = 'collapse-horizontal';
   1663   const WIDTH = 'width';
   1664   const HEIGHT = 'height';
   1665   const SELECTOR_ACTIVES = '.show, .collapsing';
   1666   const SELECTOR_DATA_TOGGLE$4 = '[data-bs-toggle="collapse"]';
   1667   /**
   1668    * ------------------------------------------------------------------------
   1669    * Class Definition
   1670    * ------------------------------------------------------------------------
   1671    */
   1672 
   1673   class Collapse extends BaseComponent {
   1674     constructor(element, config) {
   1675       super(element);
   1676       this._isTransitioning = false;
   1677       this._config = this._getConfig(config);
   1678       this._triggerArray = [];
   1679       const toggleList = SelectorEngine.find(SELECTOR_DATA_TOGGLE$4);
   1680 
   1681       for (let i = 0, len = toggleList.length; i < len; i++) {
   1682         const elem = toggleList[i];
   1683         const selector = getSelectorFromElement(elem);
   1684         const filterElement = SelectorEngine.find(selector).filter(foundElem => foundElem === this._element);
   1685 
   1686         if (selector !== null && filterElement.length) {
   1687           this._selector = selector;
   1688 
   1689           this._triggerArray.push(elem);
   1690         }
   1691       }
   1692 
   1693       this._initializeChildren();
   1694 
   1695       if (!this._config.parent) {
   1696         this._addAriaAndCollapsedClass(this._triggerArray, this._isShown());
   1697       }
   1698 
   1699       if (this._config.toggle) {
   1700         this.toggle();
   1701       }
   1702     } // Getters
   1703 
   1704 
   1705     static get Default() {
   1706       return Default$9;
   1707     }
   1708 
   1709     static get NAME() {
   1710       return NAME$a;
   1711     } // Public
   1712 
   1713 
   1714     toggle() {
   1715       if (this._isShown()) {
   1716         this.hide();
   1717       } else {
   1718         this.show();
   1719       }
   1720     }
   1721 
   1722     show() {
   1723       if (this._isTransitioning || this._isShown()) {
   1724         return;
   1725       }
   1726 
   1727       let actives = [];
   1728       let activesData;
   1729 
   1730       if (this._config.parent) {
   1731         const children = SelectorEngine.find(`.${CLASS_NAME_COLLAPSE} .${CLASS_NAME_COLLAPSE}`, this._config.parent);
   1732         actives = SelectorEngine.find(SELECTOR_ACTIVES, this._config.parent).filter(elem => !children.includes(elem)); // remove children if greater depth
   1733       }
   1734 
   1735       const container = SelectorEngine.findOne(this._selector);
   1736 
   1737       if (actives.length) {
   1738         const tempActiveData = actives.find(elem => container !== elem);
   1739         activesData = tempActiveData ? Collapse.getInstance(tempActiveData) : null;
   1740 
   1741         if (activesData && activesData._isTransitioning) {
   1742           return;
   1743         }
   1744       }
   1745 
   1746       const startEvent = EventHandler.trigger(this._element, EVENT_SHOW$5);
   1747 
   1748       if (startEvent.defaultPrevented) {
   1749         return;
   1750       }
   1751 
   1752       actives.forEach(elemActive => {
   1753         if (container !== elemActive) {
   1754           Collapse.getOrCreateInstance(elemActive, {
   1755             toggle: false
   1756           }).hide();
   1757         }
   1758 
   1759         if (!activesData) {
   1760           Data.set(elemActive, DATA_KEY$9, null);
   1761         }
   1762       });
   1763 
   1764       const dimension = this._getDimension();
   1765 
   1766       this._element.classList.remove(CLASS_NAME_COLLAPSE);
   1767 
   1768       this._element.classList.add(CLASS_NAME_COLLAPSING);
   1769 
   1770       this._element.style[dimension] = 0;
   1771 
   1772       this._addAriaAndCollapsedClass(this._triggerArray, true);
   1773 
   1774       this._isTransitioning = true;
   1775 
   1776       const complete = () => {
   1777         this._isTransitioning = false;
   1778 
   1779         this._element.classList.remove(CLASS_NAME_COLLAPSING);
   1780 
   1781         this._element.classList.add(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW$7);
   1782 
   1783         this._element.style[dimension] = '';
   1784         EventHandler.trigger(this._element, EVENT_SHOWN$5);
   1785       };
   1786 
   1787       const capitalizedDimension = dimension[0].toUpperCase() + dimension.slice(1);
   1788       const scrollSize = `scroll${capitalizedDimension}`;
   1789 
   1790       this._queueCallback(complete, this._element, true);
   1791 
   1792       this._element.style[dimension] = `${this._element[scrollSize]}px`;
   1793     }
   1794 
   1795     hide() {
   1796       if (this._isTransitioning || !this._isShown()) {
   1797         return;
   1798       }
   1799 
   1800       const startEvent = EventHandler.trigger(this._element, EVENT_HIDE$5);
   1801 
   1802       if (startEvent.defaultPrevented) {
   1803         return;
   1804       }
   1805 
   1806       const dimension = this._getDimension();
   1807 
   1808       this._element.style[dimension] = `${this._element.getBoundingClientRect()[dimension]}px`;
   1809       reflow(this._element);
   1810 
   1811       this._element.classList.add(CLASS_NAME_COLLAPSING);
   1812 
   1813       this._element.classList.remove(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW$7);
   1814 
   1815       const triggerArrayLength = this._triggerArray.length;
   1816 
   1817       for (let i = 0; i < triggerArrayLength; i++) {
   1818         const trigger = this._triggerArray[i];
   1819         const elem = getElementFromSelector(trigger);
   1820 
   1821         if (elem && !this._isShown(elem)) {
   1822           this._addAriaAndCollapsedClass([trigger], false);
   1823         }
   1824       }
   1825 
   1826       this._isTransitioning = true;
   1827 
   1828       const complete = () => {
   1829         this._isTransitioning = false;
   1830 
   1831         this._element.classList.remove(CLASS_NAME_COLLAPSING);
   1832 
   1833         this._element.classList.add(CLASS_NAME_COLLAPSE);
   1834 
   1835         EventHandler.trigger(this._element, EVENT_HIDDEN$5);
   1836       };
   1837 
   1838       this._element.style[dimension] = '';
   1839 
   1840       this._queueCallback(complete, this._element, true);
   1841     }
   1842 
   1843     _isShown(element = this._element) {
   1844       return element.classList.contains(CLASS_NAME_SHOW$7);
   1845     } // Private
   1846 
   1847 
   1848     _getConfig(config) {
   1849       config = { ...Default$9,
   1850         ...Manipulator.getDataAttributes(this._element),
   1851         ...config
   1852       };
   1853       config.toggle = Boolean(config.toggle); // Coerce string values
   1854 
   1855       config.parent = getElement(config.parent);
   1856       typeCheckConfig(NAME$a, config, DefaultType$9);
   1857       return config;
   1858     }
   1859 
   1860     _getDimension() {
   1861       return this._element.classList.contains(CLASS_NAME_HORIZONTAL) ? WIDTH : HEIGHT;
   1862     }
   1863 
   1864     _initializeChildren() {
   1865       if (!this._config.parent) {
   1866         return;
   1867       }
   1868 
   1869       const children = SelectorEngine.find(`.${CLASS_NAME_COLLAPSE} .${CLASS_NAME_COLLAPSE}`, this._config.parent);
   1870       SelectorEngine.find(SELECTOR_DATA_TOGGLE$4, this._config.parent).filter(elem => !children.includes(elem)).forEach(element => {
   1871         const selected = getElementFromSelector(element);
   1872 
   1873         if (selected) {
   1874           this._addAriaAndCollapsedClass([element], this._isShown(selected));
   1875         }
   1876       });
   1877     }
   1878 
   1879     _addAriaAndCollapsedClass(triggerArray, isOpen) {
   1880       if (!triggerArray.length) {
   1881         return;
   1882       }
   1883 
   1884       triggerArray.forEach(elem => {
   1885         if (isOpen) {
   1886           elem.classList.remove(CLASS_NAME_COLLAPSED);
   1887         } else {
   1888           elem.classList.add(CLASS_NAME_COLLAPSED);
   1889         }
   1890 
   1891         elem.setAttribute('aria-expanded', isOpen);
   1892       });
   1893     } // Static
   1894 
   1895 
   1896     static jQueryInterface(config) {
   1897       return this.each(function () {
   1898         const _config = {};
   1899 
   1900         if (typeof config === 'string' && /show|hide/.test(config)) {
   1901           _config.toggle = false;
   1902         }
   1903 
   1904         const data = Collapse.getOrCreateInstance(this, _config);
   1905 
   1906         if (typeof config === 'string') {
   1907           if (typeof data[config] === 'undefined') {
   1908             throw new TypeError(`No method named "${config}"`);
   1909           }
   1910 
   1911           data[config]();
   1912         }
   1913       });
   1914     }
   1915 
   1916   }
   1917   /**
   1918    * ------------------------------------------------------------------------
   1919    * Data Api implementation
   1920    * ------------------------------------------------------------------------
   1921    */
   1922 
   1923 
   1924   EventHandler.on(document, EVENT_CLICK_DATA_API$4, SELECTOR_DATA_TOGGLE$4, function (event) {
   1925     // preventDefault only for <a> elements (which change the URL) not inside the collapsible element
   1926     if (event.target.tagName === 'A' || event.delegateTarget && event.delegateTarget.tagName === 'A') {
   1927       event.preventDefault();
   1928     }
   1929 
   1930     const selector = getSelectorFromElement(this);
   1931     const selectorElements = SelectorEngine.find(selector);
   1932     selectorElements.forEach(element => {
   1933       Collapse.getOrCreateInstance(element, {
   1934         toggle: false
   1935       }).toggle();
   1936     });
   1937   });
   1938   /**
   1939    * ------------------------------------------------------------------------
   1940    * jQuery
   1941    * ------------------------------------------------------------------------
   1942    * add .Collapse to jQuery only if jQuery is present
   1943    */
   1944 
   1945   defineJQueryPlugin(Collapse);
   1946 
   1947   /**
   1948    * --------------------------------------------------------------------------
   1949    * Bootstrap (v5.1.0): dropdown.js
   1950    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
   1951    * --------------------------------------------------------------------------
   1952    */
   1953   /**
   1954    * ------------------------------------------------------------------------
   1955    * Constants
   1956    * ------------------------------------------------------------------------
   1957    */
   1958 
   1959   const NAME$9 = 'dropdown';
   1960   const DATA_KEY$8 = 'bs.dropdown';
   1961   const EVENT_KEY$8 = `.${DATA_KEY$8}`;
   1962   const DATA_API_KEY$4 = '.data-api';
   1963   const ESCAPE_KEY$2 = 'Escape';
   1964   const SPACE_KEY = 'Space';
   1965   const TAB_KEY$1 = 'Tab';
   1966   const ARROW_UP_KEY = 'ArrowUp';
   1967   const ARROW_DOWN_KEY = 'ArrowDown';
   1968   const RIGHT_MOUSE_BUTTON = 2; // MouseEvent.button value for the secondary button, usually the right button
   1969 
   1970   const REGEXP_KEYDOWN = new RegExp(`${ARROW_UP_KEY}|${ARROW_DOWN_KEY}|${ESCAPE_KEY$2}`);
   1971   const EVENT_HIDE$4 = `hide${EVENT_KEY$8}`;
   1972   const EVENT_HIDDEN$4 = `hidden${EVENT_KEY$8}`;
   1973   const EVENT_SHOW$4 = `show${EVENT_KEY$8}`;
   1974   const EVENT_SHOWN$4 = `shown${EVENT_KEY$8}`;
   1975   const EVENT_CLICK_DATA_API$3 = `click${EVENT_KEY$8}${DATA_API_KEY$4}`;
   1976   const EVENT_KEYDOWN_DATA_API = `keydown${EVENT_KEY$8}${DATA_API_KEY$4}`;
   1977   const EVENT_KEYUP_DATA_API = `keyup${EVENT_KEY$8}${DATA_API_KEY$4}`;
   1978   const CLASS_NAME_SHOW$6 = 'show';
   1979   const CLASS_NAME_DROPUP = 'dropup';
   1980   const CLASS_NAME_DROPEND = 'dropend';
   1981   const CLASS_NAME_DROPSTART = 'dropstart';
   1982   const CLASS_NAME_NAVBAR = 'navbar';
   1983   const SELECTOR_DATA_TOGGLE$3 = '[data-bs-toggle="dropdown"]';
   1984   const SELECTOR_MENU = '.dropdown-menu';
   1985   const SELECTOR_NAVBAR_NAV = '.navbar-nav';
   1986   const SELECTOR_VISIBLE_ITEMS = '.dropdown-menu .dropdown-item:not(.disabled):not(:disabled)';
   1987   const PLACEMENT_TOP = isRTL() ? 'top-end' : 'top-start';
   1988   const PLACEMENT_TOPEND = isRTL() ? 'top-start' : 'top-end';
   1989   const PLACEMENT_BOTTOM = isRTL() ? 'bottom-end' : 'bottom-start';
   1990   const PLACEMENT_BOTTOMEND = isRTL() ? 'bottom-start' : 'bottom-end';
   1991   const PLACEMENT_RIGHT = isRTL() ? 'left-start' : 'right-start';
   1992   const PLACEMENT_LEFT = isRTL() ? 'right-start' : 'left-start';
   1993   const Default$8 = {
   1994     offset: [0, 2],
   1995     boundary: 'clippingParents',
   1996     reference: 'toggle',
   1997     display: 'dynamic',
   1998     popperConfig: null,
   1999     autoClose: true
   2000   };
   2001   const DefaultType$8 = {
   2002     offset: '(array|string|function)',
   2003     boundary: '(string|element)',
   2004     reference: '(string|element|object)',
   2005     display: 'string',
   2006     popperConfig: '(null|object|function)',
   2007     autoClose: '(boolean|string)'
   2008   };
   2009   /**
   2010    * ------------------------------------------------------------------------
   2011    * Class Definition
   2012    * ------------------------------------------------------------------------
   2013    */
   2014 
   2015   class Dropdown extends BaseComponent {
   2016     constructor(element, config) {
   2017       super(element);
   2018       this._popper = null;
   2019       this._config = this._getConfig(config);
   2020       this._menu = this._getMenuElement();
   2021       this._inNavbar = this._detectNavbar();
   2022     } // Getters
   2023 
   2024 
   2025     static get Default() {
   2026       return Default$8;
   2027     }
   2028 
   2029     static get DefaultType() {
   2030       return DefaultType$8;
   2031     }
   2032 
   2033     static get NAME() {
   2034       return NAME$9;
   2035     } // Public
   2036 
   2037 
   2038     toggle() {
   2039       return this._isShown() ? this.hide() : this.show();
   2040     }
   2041 
   2042     show() {
   2043       if (isDisabled(this._element) || this._isShown(this._menu)) {
   2044         return;
   2045       }
   2046 
   2047       const relatedTarget = {
   2048         relatedTarget: this._element
   2049       };
   2050       const showEvent = EventHandler.trigger(this._element, EVENT_SHOW$4, relatedTarget);
   2051 
   2052       if (showEvent.defaultPrevented) {
   2053         return;
   2054       }
   2055 
   2056       const parent = Dropdown.getParentFromElement(this._element); // Totally disable Popper for Dropdowns in Navbar
   2057 
   2058       if (this._inNavbar) {
   2059         Manipulator.setDataAttribute(this._menu, 'popper', 'none');
   2060       } else {
   2061         this._createPopper(parent);
   2062       } // If this is a touch-enabled device we add extra
   2063       // empty mouseover listeners to the body's immediate children;
   2064       // only needed because of broken event delegation on iOS
   2065       // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html
   2066 
   2067 
   2068       if ('ontouchstart' in document.documentElement && !parent.closest(SELECTOR_NAVBAR_NAV)) {
   2069         [].concat(...document.body.children).forEach(elem => EventHandler.on(elem, 'mouseover', noop));
   2070       }
   2071 
   2072       this._element.focus();
   2073 
   2074       this._element.setAttribute('aria-expanded', true);
   2075 
   2076       this._menu.classList.add(CLASS_NAME_SHOW$6);
   2077 
   2078       this._element.classList.add(CLASS_NAME_SHOW$6);
   2079 
   2080       EventHandler.trigger(this._element, EVENT_SHOWN$4, relatedTarget);
   2081     }
   2082 
   2083     hide() {
   2084       if (isDisabled(this._element) || !this._isShown(this._menu)) {
   2085         return;
   2086       }
   2087 
   2088       const relatedTarget = {
   2089         relatedTarget: this._element
   2090       };
   2091 
   2092       this._completeHide(relatedTarget);
   2093     }
   2094 
   2095     dispose() {
   2096       if (this._popper) {
   2097         this._popper.destroy();
   2098       }
   2099 
   2100       super.dispose();
   2101     }
   2102 
   2103     update() {
   2104       this._inNavbar = this._detectNavbar();
   2105 
   2106       if (this._popper) {
   2107         this._popper.update();
   2108       }
   2109     } // Private
   2110 
   2111 
   2112     _completeHide(relatedTarget) {
   2113       const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$4, relatedTarget);
   2114 
   2115       if (hideEvent.defaultPrevented) {
   2116         return;
   2117       } // If this is a touch-enabled device we remove the extra
   2118       // empty mouseover listeners we added for iOS support
   2119 
   2120 
   2121       if ('ontouchstart' in document.documentElement) {
   2122         [].concat(...document.body.children).forEach(elem => EventHandler.off(elem, 'mouseover', noop));
   2123       }
   2124 
   2125       if (this._popper) {
   2126         this._popper.destroy();
   2127       }
   2128 
   2129       this._menu.classList.remove(CLASS_NAME_SHOW$6);
   2130 
   2131       this._element.classList.remove(CLASS_NAME_SHOW$6);
   2132 
   2133       this._element.setAttribute('aria-expanded', 'false');
   2134 
   2135       Manipulator.removeDataAttribute(this._menu, 'popper');
   2136       EventHandler.trigger(this._element, EVENT_HIDDEN$4, relatedTarget);
   2137     }
   2138 
   2139     _getConfig(config) {
   2140       config = { ...this.constructor.Default,
   2141         ...Manipulator.getDataAttributes(this._element),
   2142         ...config
   2143       };
   2144       typeCheckConfig(NAME$9, config, this.constructor.DefaultType);
   2145 
   2146       if (typeof config.reference === 'object' && !isElement(config.reference) && typeof config.reference.getBoundingClientRect !== 'function') {
   2147         // Popper virtual elements require a getBoundingClientRect method
   2148         throw new TypeError(`${NAME$9.toUpperCase()}: Option "reference" provided type "object" without a required "getBoundingClientRect" method.`);
   2149       }
   2150 
   2151       return config;
   2152     }
   2153 
   2154     _createPopper(parent) {
   2155       if (typeof Popper__namespace === 'undefined') {
   2156         throw new TypeError('Bootstrap\'s dropdowns require Popper (https://popper.js.org)');
   2157       }
   2158 
   2159       let referenceElement = this._element;
   2160 
   2161       if (this._config.reference === 'parent') {
   2162         referenceElement = parent;
   2163       } else if (isElement(this._config.reference)) {
   2164         referenceElement = getElement(this._config.reference);
   2165       } else if (typeof this._config.reference === 'object') {
   2166         referenceElement = this._config.reference;
   2167       }
   2168 
   2169       const popperConfig = this._getPopperConfig();
   2170 
   2171       const isDisplayStatic = popperConfig.modifiers.find(modifier => modifier.name === 'applyStyles' && modifier.enabled === false);
   2172       this._popper = Popper__namespace.createPopper(referenceElement, this._menu, popperConfig);
   2173 
   2174       if (isDisplayStatic) {
   2175         Manipulator.setDataAttribute(this._menu, 'popper', 'static');
   2176       }
   2177     }
   2178 
   2179     _isShown(element = this._element) {
   2180       return element.classList.contains(CLASS_NAME_SHOW$6);
   2181     }
   2182 
   2183     _getMenuElement() {
   2184       return SelectorEngine.next(this._element, SELECTOR_MENU)[0];
   2185     }
   2186 
   2187     _getPlacement() {
   2188       const parentDropdown = this._element.parentNode;
   2189 
   2190       if (parentDropdown.classList.contains(CLASS_NAME_DROPEND)) {
   2191         return PLACEMENT_RIGHT;
   2192       }
   2193 
   2194       if (parentDropdown.classList.contains(CLASS_NAME_DROPSTART)) {
   2195         return PLACEMENT_LEFT;
   2196       } // We need to trim the value because custom properties can also include spaces
   2197 
   2198 
   2199       const isEnd = getComputedStyle(this._menu).getPropertyValue('--bs-position').trim() === 'end';
   2200 
   2201       if (parentDropdown.classList.contains(CLASS_NAME_DROPUP)) {
   2202         return isEnd ? PLACEMENT_TOPEND : PLACEMENT_TOP;
   2203       }
   2204 
   2205       return isEnd ? PLACEMENT_BOTTOMEND : PLACEMENT_BOTTOM;
   2206     }
   2207 
   2208     _detectNavbar() {
   2209       return this._element.closest(`.${CLASS_NAME_NAVBAR}`) !== null;
   2210     }
   2211 
   2212     _getOffset() {
   2213       const {
   2214         offset
   2215       } = this._config;
   2216 
   2217       if (typeof offset === 'string') {
   2218         return offset.split(',').map(val => Number.parseInt(val, 10));
   2219       }
   2220 
   2221       if (typeof offset === 'function') {
   2222         return popperData => offset(popperData, this._element);
   2223       }
   2224 
   2225       return offset;
   2226     }
   2227 
   2228     _getPopperConfig() {
   2229       const defaultBsPopperConfig = {
   2230         placement: this._getPlacement(),
   2231         modifiers: [{
   2232           name: 'preventOverflow',
   2233           options: {
   2234             boundary: this._config.boundary
   2235           }
   2236         }, {
   2237           name: 'offset',
   2238           options: {
   2239             offset: this._getOffset()
   2240           }
   2241         }]
   2242       }; // Disable Popper if we have a static display
   2243 
   2244       if (this._config.display === 'static') {
   2245         defaultBsPopperConfig.modifiers = [{
   2246           name: 'applyStyles',
   2247           enabled: false
   2248         }];
   2249       }
   2250 
   2251       return { ...defaultBsPopperConfig,
   2252         ...(typeof this._config.popperConfig === 'function' ? this._config.popperConfig(defaultBsPopperConfig) : this._config.popperConfig)
   2253       };
   2254     }
   2255 
   2256     _selectMenuItem({
   2257       key,
   2258       target
   2259     }) {
   2260       const items = SelectorEngine.find(SELECTOR_VISIBLE_ITEMS, this._menu).filter(isVisible);
   2261 
   2262       if (!items.length) {
   2263         return;
   2264       } // if target isn't included in items (e.g. when expanding the dropdown)
   2265       // allow cycling to get the last item in case key equals ARROW_UP_KEY
   2266 
   2267 
   2268       getNextActiveElement(items, target, key === ARROW_DOWN_KEY, !items.includes(target)).focus();
   2269     } // Static
   2270 
   2271 
   2272     static jQueryInterface(config) {
   2273       return this.each(function () {
   2274         const data = Dropdown.getOrCreateInstance(this, config);
   2275 
   2276         if (typeof config !== 'string') {
   2277           return;
   2278         }
   2279 
   2280         if (typeof data[config] === 'undefined') {
   2281           throw new TypeError(`No method named "${config}"`);
   2282         }
   2283 
   2284         data[config]();
   2285       });
   2286     }
   2287 
   2288     static clearMenus(event) {
   2289       if (event && (event.button === RIGHT_MOUSE_BUTTON || event.type === 'keyup' && event.key !== TAB_KEY$1)) {
   2290         return;
   2291       }
   2292 
   2293       const toggles = SelectorEngine.find(SELECTOR_DATA_TOGGLE$3);
   2294 
   2295       for (let i = 0, len = toggles.length; i < len; i++) {
   2296         const context = Dropdown.getInstance(toggles[i]);
   2297 
   2298         if (!context || context._config.autoClose === false) {
   2299           continue;
   2300         }
   2301 
   2302         if (!context._isShown()) {
   2303           continue;
   2304         }
   2305 
   2306         const relatedTarget = {
   2307           relatedTarget: context._element
   2308         };
   2309 
   2310         if (event) {
   2311           const composedPath = event.composedPath();
   2312           const isMenuTarget = composedPath.includes(context._menu);
   2313 
   2314           if (composedPath.includes(context._element) || context._config.autoClose === 'inside' && !isMenuTarget || context._config.autoClose === 'outside' && isMenuTarget) {
   2315             continue;
   2316           } // Tab navigation through the dropdown menu or events from contained inputs shouldn't close the menu
   2317 
   2318 
   2319           if (context._menu.contains(event.target) && (event.type === 'keyup' && event.key === TAB_KEY$1 || /input|select|option|textarea|form/i.test(event.target.tagName))) {
   2320             continue;
   2321           }
   2322 
   2323           if (event.type === 'click') {
   2324             relatedTarget.clickEvent = event;
   2325           }
   2326         }
   2327 
   2328         context._completeHide(relatedTarget);
   2329       }
   2330     }
   2331 
   2332     static getParentFromElement(element) {
   2333       return getElementFromSelector(element) || element.parentNode;
   2334     }
   2335 
   2336     static dataApiKeydownHandler(event) {
   2337       // If not input/textarea:
   2338       //  - And not a key in REGEXP_KEYDOWN => not a dropdown command
   2339       // If input/textarea:
   2340       //  - If space key => not a dropdown command
   2341       //  - If key is other than escape
   2342       //    - If key is not up or down => not a dropdown command
   2343       //    - If trigger inside the menu => not a dropdown command
   2344       if (/input|textarea/i.test(event.target.tagName) ? event.key === SPACE_KEY || event.key !== ESCAPE_KEY$2 && (event.key !== ARROW_DOWN_KEY && event.key !== ARROW_UP_KEY || event.target.closest(SELECTOR_MENU)) : !REGEXP_KEYDOWN.test(event.key)) {
   2345         return;
   2346       }
   2347 
   2348       const isActive = this.classList.contains(CLASS_NAME_SHOW$6);
   2349 
   2350       if (!isActive && event.key === ESCAPE_KEY$2) {
   2351         return;
   2352       }
   2353 
   2354       event.preventDefault();
   2355       event.stopPropagation();
   2356 
   2357       if (isDisabled(this)) {
   2358         return;
   2359       }
   2360 
   2361       const getToggleButton = this.matches(SELECTOR_DATA_TOGGLE$3) ? this : SelectorEngine.prev(this, SELECTOR_DATA_TOGGLE$3)[0];
   2362       const instance = Dropdown.getOrCreateInstance(getToggleButton);
   2363 
   2364       if (event.key === ESCAPE_KEY$2) {
   2365         instance.hide();
   2366         return;
   2367       }
   2368 
   2369       if (event.key === ARROW_UP_KEY || event.key === ARROW_DOWN_KEY) {
   2370         if (!isActive) {
   2371           instance.show();
   2372         }
   2373 
   2374         instance._selectMenuItem(event);
   2375 
   2376         return;
   2377       }
   2378 
   2379       if (!isActive || event.key === SPACE_KEY) {
   2380         Dropdown.clearMenus();
   2381       }
   2382     }
   2383 
   2384   }
   2385   /**
   2386    * ------------------------------------------------------------------------
   2387    * Data Api implementation
   2388    * ------------------------------------------------------------------------
   2389    */
   2390 
   2391 
   2392   EventHandler.on(document, EVENT_KEYDOWN_DATA_API, SELECTOR_DATA_TOGGLE$3, Dropdown.dataApiKeydownHandler);
   2393   EventHandler.on(document, EVENT_KEYDOWN_DATA_API, SELECTOR_MENU, Dropdown.dataApiKeydownHandler);
   2394   EventHandler.on(document, EVENT_CLICK_DATA_API$3, Dropdown.clearMenus);
   2395   EventHandler.on(document, EVENT_KEYUP_DATA_API, Dropdown.clearMenus);
   2396   EventHandler.on(document, EVENT_CLICK_DATA_API$3, SELECTOR_DATA_TOGGLE$3, function (event) {
   2397     event.preventDefault();
   2398     Dropdown.getOrCreateInstance(this).toggle();
   2399   });
   2400   /**
   2401    * ------------------------------------------------------------------------
   2402    * jQuery
   2403    * ------------------------------------------------------------------------
   2404    * add .Dropdown to jQuery only if jQuery is present
   2405    */
   2406 
   2407   defineJQueryPlugin(Dropdown);
   2408 
   2409   /**
   2410    * --------------------------------------------------------------------------
   2411    * Bootstrap (v5.1.0): util/scrollBar.js
   2412    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
   2413    * --------------------------------------------------------------------------
   2414    */
   2415   const SELECTOR_FIXED_CONTENT = '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top';
   2416   const SELECTOR_STICKY_CONTENT = '.sticky-top';
   2417 
   2418   class ScrollBarHelper {
   2419     constructor() {
   2420       this._element = document.body;
   2421     }
   2422 
   2423     getWidth() {
   2424       // https://developer.mozilla.org/en-US/docs/Web/API/Window/innerWidth#usage_notes
   2425       const documentWidth = document.documentElement.clientWidth;
   2426       return Math.abs(window.innerWidth - documentWidth);
   2427     }
   2428 
   2429     hide() {
   2430       const width = this.getWidth();
   2431 
   2432       this._disableOverFlow(); // give padding to element to balance the hidden scrollbar width
   2433 
   2434 
   2435       this._setElementAttributes(this._element, 'paddingRight', calculatedValue => calculatedValue + width); // trick: We adjust positive paddingRight and negative marginRight to sticky-top elements to keep showing fullwidth
   2436 
   2437 
   2438       this._setElementAttributes(SELECTOR_FIXED_CONTENT, 'paddingRight', calculatedValue => calculatedValue + width);
   2439 
   2440       this._setElementAttributes(SELECTOR_STICKY_CONTENT, 'marginRight', calculatedValue => calculatedValue - width);
   2441     }
   2442 
   2443     _disableOverFlow() {
   2444       this._saveInitialAttribute(this._element, 'overflow');
   2445 
   2446       this._element.style.overflow = 'hidden';
   2447     }
   2448 
   2449     _setElementAttributes(selector, styleProp, callback) {
   2450       const scrollbarWidth = this.getWidth();
   2451 
   2452       const manipulationCallBack = element => {
   2453         if (element !== this._element && window.innerWidth > element.clientWidth + scrollbarWidth) {
   2454           return;
   2455         }
   2456 
   2457         this._saveInitialAttribute(element, styleProp);
   2458 
   2459         const calculatedValue = window.getComputedStyle(element)[styleProp];
   2460         element.style[styleProp] = `${callback(Number.parseFloat(calculatedValue))}px`;
   2461       };
   2462 
   2463       this._applyManipulationCallback(selector, manipulationCallBack);
   2464     }
   2465 
   2466     reset() {
   2467       this._resetElementAttributes(this._element, 'overflow');
   2468 
   2469       this._resetElementAttributes(this._element, 'paddingRight');
   2470 
   2471       this._resetElementAttributes(SELECTOR_FIXED_CONTENT, 'paddingRight');
   2472 
   2473       this._resetElementAttributes(SELECTOR_STICKY_CONTENT, 'marginRight');
   2474     }
   2475 
   2476     _saveInitialAttribute(element, styleProp) {
   2477       const actualValue = element.style[styleProp];
   2478 
   2479       if (actualValue) {
   2480         Manipulator.setDataAttribute(element, styleProp, actualValue);
   2481       }
   2482     }
   2483 
   2484     _resetElementAttributes(selector, styleProp) {
   2485       const manipulationCallBack = element => {
   2486         const value = Manipulator.getDataAttribute(element, styleProp);
   2487 
   2488         if (typeof value === 'undefined') {
   2489           element.style.removeProperty(styleProp);
   2490         } else {
   2491           Manipulator.removeDataAttribute(element, styleProp);
   2492           element.style[styleProp] = value;
   2493         }
   2494       };
   2495 
   2496       this._applyManipulationCallback(selector, manipulationCallBack);
   2497     }
   2498 
   2499     _applyManipulationCallback(selector, callBack) {
   2500       if (isElement(selector)) {
   2501         callBack(selector);
   2502       } else {
   2503         SelectorEngine.find(selector, this._element).forEach(callBack);
   2504       }
   2505     }
   2506 
   2507     isOverflowing() {
   2508       return this.getWidth() > 0;
   2509     }
   2510 
   2511   }
   2512 
   2513   /**
   2514    * --------------------------------------------------------------------------
   2515    * Bootstrap (v5.1.0): util/backdrop.js
   2516    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
   2517    * --------------------------------------------------------------------------
   2518    */
   2519   const Default$7 = {
   2520     className: 'modal-backdrop',
   2521     isVisible: true,
   2522     // if false, we use the backdrop helper without adding any element to the dom
   2523     isAnimated: false,
   2524     rootElement: 'body',
   2525     // give the choice to place backdrop under different elements
   2526     clickCallback: null
   2527   };
   2528   const DefaultType$7 = {
   2529     className: 'string',
   2530     isVisible: 'boolean',
   2531     isAnimated: 'boolean',
   2532     rootElement: '(element|string)',
   2533     clickCallback: '(function|null)'
   2534   };
   2535   const NAME$8 = 'backdrop';
   2536   const CLASS_NAME_FADE$4 = 'fade';
   2537   const CLASS_NAME_SHOW$5 = 'show';
   2538   const EVENT_MOUSEDOWN = `mousedown.bs.${NAME$8}`;
   2539 
   2540   class Backdrop {
   2541     constructor(config) {
   2542       this._config = this._getConfig(config);
   2543       this._isAppended = false;
   2544       this._element = null;
   2545     }
   2546 
   2547     show(callback) {
   2548       if (!this._config.isVisible) {
   2549         execute(callback);
   2550         return;
   2551       }
   2552 
   2553       this._append();
   2554 
   2555       if (this._config.isAnimated) {
   2556         reflow(this._getElement());
   2557       }
   2558 
   2559       this._getElement().classList.add(CLASS_NAME_SHOW$5);
   2560 
   2561       this._emulateAnimation(() => {
   2562         execute(callback);
   2563       });
   2564     }
   2565 
   2566     hide(callback) {
   2567       if (!this._config.isVisible) {
   2568         execute(callback);
   2569         return;
   2570       }
   2571 
   2572       this._getElement().classList.remove(CLASS_NAME_SHOW$5);
   2573 
   2574       this._emulateAnimation(() => {
   2575         this.dispose();
   2576         execute(callback);
   2577       });
   2578     } // Private
   2579 
   2580 
   2581     _getElement() {
   2582       if (!this._element) {
   2583         const backdrop = document.createElement('div');
   2584         backdrop.className = this._config.className;
   2585 
   2586         if (this._config.isAnimated) {
   2587           backdrop.classList.add(CLASS_NAME_FADE$4);
   2588         }
   2589 
   2590         this._element = backdrop;
   2591       }
   2592 
   2593       return this._element;
   2594     }
   2595 
   2596     _getConfig(config) {
   2597       config = { ...Default$7,
   2598         ...(typeof config === 'object' ? config : {})
   2599       }; // use getElement() with the default "body" to get a fresh Element on each instantiation
   2600 
   2601       config.rootElement = getElement(config.rootElement);
   2602       typeCheckConfig(NAME$8, config, DefaultType$7);
   2603       return config;
   2604     }
   2605 
   2606     _append() {
   2607       if (this._isAppended) {
   2608         return;
   2609       }
   2610 
   2611       this._config.rootElement.append(this._getElement());
   2612 
   2613       EventHandler.on(this._getElement(), EVENT_MOUSEDOWN, () => {
   2614         execute(this._config.clickCallback);
   2615       });
   2616       this._isAppended = true;
   2617     }
   2618 
   2619     dispose() {
   2620       if (!this._isAppended) {
   2621         return;
   2622       }
   2623 
   2624       EventHandler.off(this._element, EVENT_MOUSEDOWN);
   2625 
   2626       this._element.remove();
   2627 
   2628       this._isAppended = false;
   2629     }
   2630 
   2631     _emulateAnimation(callback) {
   2632       executeAfterTransition(callback, this._getElement(), this._config.isAnimated);
   2633     }
   2634 
   2635   }
   2636 
   2637   /**
   2638    * --------------------------------------------------------------------------
   2639    * Bootstrap (v5.1.0): util/focustrap.js
   2640    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
   2641    * --------------------------------------------------------------------------
   2642    */
   2643   const Default$6 = {
   2644     trapElement: null,
   2645     // The element to trap focus inside of
   2646     autofocus: true
   2647   };
   2648   const DefaultType$6 = {
   2649     trapElement: 'element',
   2650     autofocus: 'boolean'
   2651   };
   2652   const NAME$7 = 'focustrap';
   2653   const DATA_KEY$7 = 'bs.focustrap';
   2654   const EVENT_KEY$7 = `.${DATA_KEY$7}`;
   2655   const EVENT_FOCUSIN$1 = `focusin${EVENT_KEY$7}`;
   2656   const EVENT_KEYDOWN_TAB = `keydown.tab${EVENT_KEY$7}`;
   2657   const TAB_KEY = 'Tab';
   2658   const TAB_NAV_FORWARD = 'forward';
   2659   const TAB_NAV_BACKWARD = 'backward';
   2660 
   2661   class FocusTrap {
   2662     constructor(config) {
   2663       this._config = this._getConfig(config);
   2664       this._isActive = false;
   2665       this._lastTabNavDirection = null;
   2666     }
   2667 
   2668     activate() {
   2669       const {
   2670         trapElement,
   2671         autofocus
   2672       } = this._config;
   2673 
   2674       if (this._isActive) {
   2675         return;
   2676       }
   2677 
   2678       if (autofocus) {
   2679         trapElement.focus();
   2680       }
   2681 
   2682       EventHandler.off(document, EVENT_KEY$7); // guard against infinite focus loop
   2683 
   2684       EventHandler.on(document, EVENT_FOCUSIN$1, event => this._handleFocusin(event));
   2685       EventHandler.on(document, EVENT_KEYDOWN_TAB, event => this._handleKeydown(event));
   2686       this._isActive = true;
   2687     }
   2688 
   2689     deactivate() {
   2690       if (!this._isActive) {
   2691         return;
   2692       }
   2693 
   2694       this._isActive = false;
   2695       EventHandler.off(document, EVENT_KEY$7);
   2696     } // Private
   2697 
   2698 
   2699     _handleFocusin(event) {
   2700       const {
   2701         target
   2702       } = event;
   2703       const {
   2704         trapElement
   2705       } = this._config;
   2706 
   2707       if (target === document || target === trapElement || trapElement.contains(target)) {
   2708         return;
   2709       }
   2710 
   2711       const elements = SelectorEngine.focusableChildren(trapElement);
   2712 
   2713       if (elements.length === 0) {
   2714         trapElement.focus();
   2715       } else if (this._lastTabNavDirection === TAB_NAV_BACKWARD) {
   2716         elements[elements.length - 1].focus();
   2717       } else {
   2718         elements[0].focus();
   2719       }
   2720     }
   2721 
   2722     _handleKeydown(event) {
   2723       if (event.key !== TAB_KEY) {
   2724         return;
   2725       }
   2726 
   2727       this._lastTabNavDirection = event.shiftKey ? TAB_NAV_BACKWARD : TAB_NAV_FORWARD;
   2728     }
   2729 
   2730     _getConfig(config) {
   2731       config = { ...Default$6,
   2732         ...(typeof config === 'object' ? config : {})
   2733       };
   2734       typeCheckConfig(NAME$7, config, DefaultType$6);
   2735       return config;
   2736     }
   2737 
   2738   }
   2739 
   2740   /**
   2741    * --------------------------------------------------------------------------
   2742    * Bootstrap (v5.1.0): modal.js
   2743    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
   2744    * --------------------------------------------------------------------------
   2745    */
   2746   /**
   2747    * ------------------------------------------------------------------------
   2748    * Constants
   2749    * ------------------------------------------------------------------------
   2750    */
   2751 
   2752   const NAME$6 = 'modal';
   2753   const DATA_KEY$6 = 'bs.modal';
   2754   const EVENT_KEY$6 = `.${DATA_KEY$6}`;
   2755   const DATA_API_KEY$3 = '.data-api';
   2756   const ESCAPE_KEY$1 = 'Escape';
   2757   const Default$5 = {
   2758     backdrop: true,
   2759     keyboard: true,
   2760     focus: true
   2761   };
   2762   const DefaultType$5 = {
   2763     backdrop: '(boolean|string)',
   2764     keyboard: 'boolean',
   2765     focus: 'boolean'
   2766   };
   2767   const EVENT_HIDE$3 = `hide${EVENT_KEY$6}`;
   2768   const EVENT_HIDE_PREVENTED = `hidePrevented${EVENT_KEY$6}`;
   2769   const EVENT_HIDDEN$3 = `hidden${EVENT_KEY$6}`;
   2770   const EVENT_SHOW$3 = `show${EVENT_KEY$6}`;
   2771   const EVENT_SHOWN$3 = `shown${EVENT_KEY$6}`;
   2772   const EVENT_RESIZE = `resize${EVENT_KEY$6}`;
   2773   const EVENT_CLICK_DISMISS = `click.dismiss${EVENT_KEY$6}`;
   2774   const EVENT_KEYDOWN_DISMISS$1 = `keydown.dismiss${EVENT_KEY$6}`;
   2775   const EVENT_MOUSEUP_DISMISS = `mouseup.dismiss${EVENT_KEY$6}`;
   2776   const EVENT_MOUSEDOWN_DISMISS = `mousedown.dismiss${EVENT_KEY$6}`;
   2777   const EVENT_CLICK_DATA_API$2 = `click${EVENT_KEY$6}${DATA_API_KEY$3}`;
   2778   const CLASS_NAME_OPEN = 'modal-open';
   2779   const CLASS_NAME_FADE$3 = 'fade';
   2780   const CLASS_NAME_SHOW$4 = 'show';
   2781   const CLASS_NAME_STATIC = 'modal-static';
   2782   const SELECTOR_DIALOG = '.modal-dialog';
   2783   const SELECTOR_MODAL_BODY = '.modal-body';
   2784   const SELECTOR_DATA_TOGGLE$2 = '[data-bs-toggle="modal"]';
   2785   /**
   2786    * ------------------------------------------------------------------------
   2787    * Class Definition
   2788    * ------------------------------------------------------------------------
   2789    */
   2790 
   2791   class Modal extends BaseComponent {
   2792     constructor(element, config) {
   2793       super(element);
   2794       this._config = this._getConfig(config);
   2795       this._dialog = SelectorEngine.findOne(SELECTOR_DIALOG, this._element);
   2796       this._backdrop = this._initializeBackDrop();
   2797       this._focustrap = this._initializeFocusTrap();
   2798       this._isShown = false;
   2799       this._ignoreBackdropClick = false;
   2800       this._isTransitioning = false;
   2801       this._scrollBar = new ScrollBarHelper();
   2802     } // Getters
   2803 
   2804 
   2805     static get Default() {
   2806       return Default$5;
   2807     }
   2808 
   2809     static get NAME() {
   2810       return NAME$6;
   2811     } // Public
   2812 
   2813 
   2814     toggle(relatedTarget) {
   2815       return this._isShown ? this.hide() : this.show(relatedTarget);
   2816     }
   2817 
   2818     show(relatedTarget) {
   2819       if (this._isShown || this._isTransitioning) {
   2820         return;
   2821       }
   2822 
   2823       const showEvent = EventHandler.trigger(this._element, EVENT_SHOW$3, {
   2824         relatedTarget
   2825       });
   2826 
   2827       if (showEvent.defaultPrevented) {
   2828         return;
   2829       }
   2830 
   2831       this._isShown = true;
   2832 
   2833       if (this._isAnimated()) {
   2834         this._isTransitioning = true;
   2835       }
   2836 
   2837       this._scrollBar.hide();
   2838 
   2839       document.body.classList.add(CLASS_NAME_OPEN);
   2840 
   2841       this._adjustDialog();
   2842 
   2843       this._setEscapeEvent();
   2844 
   2845       this._setResizeEvent();
   2846 
   2847       EventHandler.on(this._dialog, EVENT_MOUSEDOWN_DISMISS, () => {
   2848         EventHandler.one(this._element, EVENT_MOUSEUP_DISMISS, event => {
   2849           if (event.target === this._element) {
   2850             this._ignoreBackdropClick = true;
   2851           }
   2852         });
   2853       });
   2854 
   2855       this._showBackdrop(() => this._showElement(relatedTarget));
   2856     }
   2857 
   2858     hide() {
   2859       if (!this._isShown || this._isTransitioning) {
   2860         return;
   2861       }
   2862 
   2863       const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$3);
   2864 
   2865       if (hideEvent.defaultPrevented) {
   2866         return;
   2867       }
   2868 
   2869       this._isShown = false;
   2870 
   2871       const isAnimated = this._isAnimated();
   2872 
   2873       if (isAnimated) {
   2874         this._isTransitioning = true;
   2875       }
   2876 
   2877       this._setEscapeEvent();
   2878 
   2879       this._setResizeEvent();
   2880 
   2881       this._focustrap.deactivate();
   2882 
   2883       this._element.classList.remove(CLASS_NAME_SHOW$4);
   2884 
   2885       EventHandler.off(this._element, EVENT_CLICK_DISMISS);
   2886       EventHandler.off(this._dialog, EVENT_MOUSEDOWN_DISMISS);
   2887 
   2888       this._queueCallback(() => this._hideModal(), this._element, isAnimated);
   2889     }
   2890 
   2891     dispose() {
   2892       [window, this._dialog].forEach(htmlElement => EventHandler.off(htmlElement, EVENT_KEY$6));
   2893 
   2894       this._backdrop.dispose();
   2895 
   2896       this._focustrap.deactivate();
   2897 
   2898       super.dispose();
   2899     }
   2900 
   2901     handleUpdate() {
   2902       this._adjustDialog();
   2903     } // Private
   2904 
   2905 
   2906     _initializeBackDrop() {
   2907       return new Backdrop({
   2908         isVisible: Boolean(this._config.backdrop),
   2909         // 'static' option will be translated to true, and booleans will keep their value
   2910         isAnimated: this._isAnimated()
   2911       });
   2912     }
   2913 
   2914     _initializeFocusTrap() {
   2915       return new FocusTrap({
   2916         trapElement: this._element
   2917       });
   2918     }
   2919 
   2920     _getConfig(config) {
   2921       config = { ...Default$5,
   2922         ...Manipulator.getDataAttributes(this._element),
   2923         ...(typeof config === 'object' ? config : {})
   2924       };
   2925       typeCheckConfig(NAME$6, config, DefaultType$5);
   2926       return config;
   2927     }
   2928 
   2929     _showElement(relatedTarget) {
   2930       const isAnimated = this._isAnimated();
   2931 
   2932       const modalBody = SelectorEngine.findOne(SELECTOR_MODAL_BODY, this._dialog);
   2933 
   2934       if (!this._element.parentNode || this._element.parentNode.nodeType !== Node.ELEMENT_NODE) {
   2935         // Don't move modal's DOM position
   2936         document.body.append(this._element);
   2937       }
   2938 
   2939       this._element.style.display = 'block';
   2940 
   2941       this._element.removeAttribute('aria-hidden');
   2942 
   2943       this._element.setAttribute('aria-modal', true);
   2944 
   2945       this._element.setAttribute('role', 'dialog');
   2946 
   2947       this._element.scrollTop = 0;
   2948 
   2949       if (modalBody) {
   2950         modalBody.scrollTop = 0;
   2951       }
   2952 
   2953       if (isAnimated) {
   2954         reflow(this._element);
   2955       }
   2956 
   2957       this._element.classList.add(CLASS_NAME_SHOW$4);
   2958 
   2959       const transitionComplete = () => {
   2960         if (this._config.focus) {
   2961           this._focustrap.activate();
   2962         }
   2963 
   2964         this._isTransitioning = false;
   2965         EventHandler.trigger(this._element, EVENT_SHOWN$3, {
   2966           relatedTarget
   2967         });
   2968       };
   2969 
   2970       this._queueCallback(transitionComplete, this._dialog, isAnimated);
   2971     }
   2972 
   2973     _setEscapeEvent() {
   2974       if (this._isShown) {
   2975         EventHandler.on(this._element, EVENT_KEYDOWN_DISMISS$1, event => {
   2976           if (this._config.keyboard && event.key === ESCAPE_KEY$1) {
   2977             event.preventDefault();
   2978             this.hide();
   2979           } else if (!this._config.keyboard && event.key === ESCAPE_KEY$1) {
   2980             this._triggerBackdropTransition();
   2981           }
   2982         });
   2983       } else {
   2984         EventHandler.off(this._element, EVENT_KEYDOWN_DISMISS$1);
   2985       }
   2986     }
   2987 
   2988     _setResizeEvent() {
   2989       if (this._isShown) {
   2990         EventHandler.on(window, EVENT_RESIZE, () => this._adjustDialog());
   2991       } else {
   2992         EventHandler.off(window, EVENT_RESIZE);
   2993       }
   2994     }
   2995 
   2996     _hideModal() {
   2997       this._element.style.display = 'none';
   2998 
   2999       this._element.setAttribute('aria-hidden', true);
   3000 
   3001       this._element.removeAttribute('aria-modal');
   3002 
   3003       this._element.removeAttribute('role');
   3004 
   3005       this._isTransitioning = false;
   3006 
   3007       this._backdrop.hide(() => {
   3008         document.body.classList.remove(CLASS_NAME_OPEN);
   3009 
   3010         this._resetAdjustments();
   3011 
   3012         this._scrollBar.reset();
   3013 
   3014         EventHandler.trigger(this._element, EVENT_HIDDEN$3);
   3015       });
   3016     }
   3017 
   3018     _showBackdrop(callback) {
   3019       EventHandler.on(this._element, EVENT_CLICK_DISMISS, event => {
   3020         if (this._ignoreBackdropClick) {
   3021           this._ignoreBackdropClick = false;
   3022           return;
   3023         }
   3024 
   3025         if (event.target !== event.currentTarget) {
   3026           return;
   3027         }
   3028 
   3029         if (this._config.backdrop === true) {
   3030           this.hide();
   3031         } else if (this._config.backdrop === 'static') {
   3032           this._triggerBackdropTransition();
   3033         }
   3034       });
   3035 
   3036       this._backdrop.show(callback);
   3037     }
   3038 
   3039     _isAnimated() {
   3040       return this._element.classList.contains(CLASS_NAME_FADE$3);
   3041     }
   3042 
   3043     _triggerBackdropTransition() {
   3044       const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE_PREVENTED);
   3045 
   3046       if (hideEvent.defaultPrevented) {
   3047         return;
   3048       }
   3049 
   3050       const {
   3051         classList,
   3052         scrollHeight,
   3053         style
   3054       } = this._element;
   3055       const isModalOverflowing = scrollHeight > document.documentElement.clientHeight; // return if the following background transition hasn't yet completed
   3056 
   3057       if (!isModalOverflowing && style.overflowY === 'hidden' || classList.contains(CLASS_NAME_STATIC)) {
   3058         return;
   3059       }
   3060 
   3061       if (!isModalOverflowing) {
   3062         style.overflowY = 'hidden';
   3063       }
   3064 
   3065       classList.add(CLASS_NAME_STATIC);
   3066 
   3067       this._queueCallback(() => {
   3068         classList.remove(CLASS_NAME_STATIC);
   3069 
   3070         if (!isModalOverflowing) {
   3071           this._queueCallback(() => {
   3072             style.overflowY = '';
   3073           }, this._dialog);
   3074         }
   3075       }, this._dialog);
   3076 
   3077       this._element.focus();
   3078     } // ----------------------------------------------------------------------
   3079     // the following methods are used to handle overflowing modals
   3080     // ----------------------------------------------------------------------
   3081 
   3082 
   3083     _adjustDialog() {
   3084       const isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight;
   3085 
   3086       const scrollbarWidth = this._scrollBar.getWidth();
   3087 
   3088       const isBodyOverflowing = scrollbarWidth > 0;
   3089 
   3090       if (!isBodyOverflowing && isModalOverflowing && !isRTL() || isBodyOverflowing && !isModalOverflowing && isRTL()) {
   3091         this._element.style.paddingLeft = `${scrollbarWidth}px`;
   3092       }
   3093 
   3094       if (isBodyOverflowing && !isModalOverflowing && !isRTL() || !isBodyOverflowing && isModalOverflowing && isRTL()) {
   3095         this._element.style.paddingRight = `${scrollbarWidth}px`;
   3096       }
   3097     }
   3098 
   3099     _resetAdjustments() {
   3100       this._element.style.paddingLeft = '';
   3101       this._element.style.paddingRight = '';
   3102     } // Static
   3103 
   3104 
   3105     static jQueryInterface(config, relatedTarget) {
   3106       return this.each(function () {
   3107         const data = Modal.getOrCreateInstance(this, config);
   3108 
   3109         if (typeof config !== 'string') {
   3110           return;
   3111         }
   3112 
   3113         if (typeof data[config] === 'undefined') {
   3114           throw new TypeError(`No method named "${config}"`);
   3115         }
   3116 
   3117         data[config](relatedTarget);
   3118       });
   3119     }
   3120 
   3121   }
   3122   /**
   3123    * ------------------------------------------------------------------------
   3124    * Data Api implementation
   3125    * ------------------------------------------------------------------------
   3126    */
   3127 
   3128 
   3129   EventHandler.on(document, EVENT_CLICK_DATA_API$2, SELECTOR_DATA_TOGGLE$2, function (event) {
   3130     const target = getElementFromSelector(this);
   3131 
   3132     if (['A', 'AREA'].includes(this.tagName)) {
   3133       event.preventDefault();
   3134     }
   3135 
   3136     EventHandler.one(target, EVENT_SHOW$3, showEvent => {
   3137       if (showEvent.defaultPrevented) {
   3138         // only register focus restorer if modal will actually get shown
   3139         return;
   3140       }
   3141 
   3142       EventHandler.one(target, EVENT_HIDDEN$3, () => {
   3143         if (isVisible(this)) {
   3144           this.focus();
   3145         }
   3146       });
   3147     });
   3148     const data = Modal.getOrCreateInstance(target);
   3149     data.toggle(this);
   3150   });
   3151   enableDismissTrigger(Modal);
   3152   /**
   3153    * ------------------------------------------------------------------------
   3154    * jQuery
   3155    * ------------------------------------------------------------------------
   3156    * add .Modal to jQuery only if jQuery is present
   3157    */
   3158 
   3159   defineJQueryPlugin(Modal);
   3160 
   3161   /**
   3162    * --------------------------------------------------------------------------
   3163    * Bootstrap (v5.1.0): offcanvas.js
   3164    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
   3165    * --------------------------------------------------------------------------
   3166    */
   3167   /**
   3168    * ------------------------------------------------------------------------
   3169    * Constants
   3170    * ------------------------------------------------------------------------
   3171    */
   3172 
   3173   const NAME$5 = 'offcanvas';
   3174   const DATA_KEY$5 = 'bs.offcanvas';
   3175   const EVENT_KEY$5 = `.${DATA_KEY$5}`;
   3176   const DATA_API_KEY$2 = '.data-api';
   3177   const EVENT_LOAD_DATA_API$1 = `load${EVENT_KEY$5}${DATA_API_KEY$2}`;
   3178   const ESCAPE_KEY = 'Escape';
   3179   const Default$4 = {
   3180     backdrop: true,
   3181     keyboard: true,
   3182     scroll: false
   3183   };
   3184   const DefaultType$4 = {
   3185     backdrop: 'boolean',
   3186     keyboard: 'boolean',
   3187     scroll: 'boolean'
   3188   };
   3189   const CLASS_NAME_SHOW$3 = 'show';
   3190   const CLASS_NAME_BACKDROP = 'offcanvas-backdrop';
   3191   const OPEN_SELECTOR = '.offcanvas.show';
   3192   const EVENT_SHOW$2 = `show${EVENT_KEY$5}`;
   3193   const EVENT_SHOWN$2 = `shown${EVENT_KEY$5}`;
   3194   const EVENT_HIDE$2 = `hide${EVENT_KEY$5}`;
   3195   const EVENT_HIDDEN$2 = `hidden${EVENT_KEY$5}`;
   3196   const EVENT_CLICK_DATA_API$1 = `click${EVENT_KEY$5}${DATA_API_KEY$2}`;
   3197   const EVENT_KEYDOWN_DISMISS = `keydown.dismiss${EVENT_KEY$5}`;
   3198   const SELECTOR_DATA_TOGGLE$1 = '[data-bs-toggle="offcanvas"]';
   3199   /**
   3200    * ------------------------------------------------------------------------
   3201    * Class Definition
   3202    * ------------------------------------------------------------------------
   3203    */
   3204 
   3205   class Offcanvas extends BaseComponent {
   3206     constructor(element, config) {
   3207       super(element);
   3208       this._config = this._getConfig(config);
   3209       this._isShown = false;
   3210       this._backdrop = this._initializeBackDrop();
   3211       this._focustrap = this._initializeFocusTrap();
   3212 
   3213       this._addEventListeners();
   3214     } // Getters
   3215 
   3216 
   3217     static get NAME() {
   3218       return NAME$5;
   3219     }
   3220 
   3221     static get Default() {
   3222       return Default$4;
   3223     } // Public
   3224 
   3225 
   3226     toggle(relatedTarget) {
   3227       return this._isShown ? this.hide() : this.show(relatedTarget);
   3228     }
   3229 
   3230     show(relatedTarget) {
   3231       if (this._isShown) {
   3232         return;
   3233       }
   3234 
   3235       const showEvent = EventHandler.trigger(this._element, EVENT_SHOW$2, {
   3236         relatedTarget
   3237       });
   3238 
   3239       if (showEvent.defaultPrevented) {
   3240         return;
   3241       }
   3242 
   3243       this._isShown = true;
   3244       this._element.style.visibility = 'visible';
   3245 
   3246       this._backdrop.show();
   3247 
   3248       if (!this._config.scroll) {
   3249         new ScrollBarHelper().hide();
   3250       }
   3251 
   3252       this._element.removeAttribute('aria-hidden');
   3253 
   3254       this._element.setAttribute('aria-modal', true);
   3255 
   3256       this._element.setAttribute('role', 'dialog');
   3257 
   3258       this._element.classList.add(CLASS_NAME_SHOW$3);
   3259 
   3260       const completeCallBack = () => {
   3261         if (!this._config.scroll) {
   3262           this._focustrap.activate();
   3263         }
   3264 
   3265         EventHandler.trigger(this._element, EVENT_SHOWN$2, {
   3266           relatedTarget
   3267         });
   3268       };
   3269 
   3270       this._queueCallback(completeCallBack, this._element, true);
   3271     }
   3272 
   3273     hide() {
   3274       if (!this._isShown) {
   3275         return;
   3276       }
   3277 
   3278       const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$2);
   3279 
   3280       if (hideEvent.defaultPrevented) {
   3281         return;
   3282       }
   3283 
   3284       this._focustrap.deactivate();
   3285 
   3286       this._element.blur();
   3287 
   3288       this._isShown = false;
   3289 
   3290       this._element.classList.remove(CLASS_NAME_SHOW$3);
   3291 
   3292       this._backdrop.hide();
   3293 
   3294       const completeCallback = () => {
   3295         this._element.setAttribute('aria-hidden', true);
   3296 
   3297         this._element.removeAttribute('aria-modal');
   3298 
   3299         this._element.removeAttribute('role');
   3300 
   3301         this._element.style.visibility = 'hidden';
   3302 
   3303         if (!this._config.scroll) {
   3304           new ScrollBarHelper().reset();
   3305         }
   3306 
   3307         EventHandler.trigger(this._element, EVENT_HIDDEN$2);
   3308       };
   3309 
   3310       this._queueCallback(completeCallback, this._element, true);
   3311     }
   3312 
   3313     dispose() {
   3314       this._backdrop.dispose();
   3315 
   3316       this._focustrap.deactivate();
   3317 
   3318       super.dispose();
   3319     } // Private
   3320 
   3321 
   3322     _getConfig(config) {
   3323       config = { ...Default$4,
   3324         ...Manipulator.getDataAttributes(this._element),
   3325         ...(typeof config === 'object' ? config : {})
   3326       };
   3327       typeCheckConfig(NAME$5, config, DefaultType$4);
   3328       return config;
   3329     }
   3330 
   3331     _initializeBackDrop() {
   3332       return new Backdrop({
   3333         className: CLASS_NAME_BACKDROP,
   3334         isVisible: this._config.backdrop,
   3335         isAnimated: true,
   3336         rootElement: this._element.parentNode,
   3337         clickCallback: () => this.hide()
   3338       });
   3339     }
   3340 
   3341     _initializeFocusTrap() {
   3342       return new FocusTrap({
   3343         trapElement: this._element
   3344       });
   3345     }
   3346 
   3347     _addEventListeners() {
   3348       EventHandler.on(this._element, EVENT_KEYDOWN_DISMISS, event => {
   3349         if (this._config.keyboard && event.key === ESCAPE_KEY) {
   3350           this.hide();
   3351         }
   3352       });
   3353     } // Static
   3354 
   3355 
   3356     static jQueryInterface(config) {
   3357       return this.each(function () {
   3358         const data = Offcanvas.getOrCreateInstance(this, config);
   3359 
   3360         if (typeof config !== 'string') {
   3361           return;
   3362         }
   3363 
   3364         if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {
   3365           throw new TypeError(`No method named "${config}"`);
   3366         }
   3367 
   3368         data[config](this);
   3369       });
   3370     }
   3371 
   3372   }
   3373   /**
   3374    * ------------------------------------------------------------------------
   3375    * Data Api implementation
   3376    * ------------------------------------------------------------------------
   3377    */
   3378 
   3379 
   3380   EventHandler.on(document, EVENT_CLICK_DATA_API$1, SELECTOR_DATA_TOGGLE$1, function (event) {
   3381     const target = getElementFromSelector(this);
   3382 
   3383     if (['A', 'AREA'].includes(this.tagName)) {
   3384       event.preventDefault();
   3385     }
   3386 
   3387     if (isDisabled(this)) {
   3388       return;
   3389     }
   3390 
   3391     EventHandler.one(target, EVENT_HIDDEN$2, () => {
   3392       // focus on trigger when it is closed
   3393       if (isVisible(this)) {
   3394         this.focus();
   3395       }
   3396     }); // avoid conflict when clicking a toggler of an offcanvas, while another is open
   3397 
   3398     const allReadyOpen = SelectorEngine.findOne(OPEN_SELECTOR);
   3399 
   3400     if (allReadyOpen && allReadyOpen !== target) {
   3401       Offcanvas.getInstance(allReadyOpen).hide();
   3402     }
   3403 
   3404     const data = Offcanvas.getOrCreateInstance(target);
   3405     data.toggle(this);
   3406   });
   3407   EventHandler.on(window, EVENT_LOAD_DATA_API$1, () => SelectorEngine.find(OPEN_SELECTOR).forEach(el => Offcanvas.getOrCreateInstance(el).show()));
   3408   enableDismissTrigger(Offcanvas);
   3409   /**
   3410    * ------------------------------------------------------------------------
   3411    * jQuery
   3412    * ------------------------------------------------------------------------
   3413    */
   3414 
   3415   defineJQueryPlugin(Offcanvas);
   3416 
   3417   /**
   3418    * --------------------------------------------------------------------------
   3419    * Bootstrap (v5.1.0): util/sanitizer.js
   3420    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
   3421    * --------------------------------------------------------------------------
   3422    */
   3423   const uriAttrs = new Set(['background', 'cite', 'href', 'itemtype', 'longdesc', 'poster', 'src', 'xlink:href']);
   3424   const ARIA_ATTRIBUTE_PATTERN = /^aria-[\w-]*$/i;
   3425   /**
   3426    * A pattern that recognizes a commonly useful subset of URLs that are safe.
   3427    *
   3428    * Shoutout to Angular 7 https://github.com/angular/angular/blob/7.2.4/packages/core/src/sanitization/url_sanitizer.ts
   3429    */
   3430 
   3431   const SAFE_URL_PATTERN = /^(?:(?:https?|mailto|ftp|tel|file):|[^#&/:?]*(?:[#/?]|$))/i;
   3432   /**
   3433    * A pattern that matches safe data URLs. Only matches image, video and audio types.
   3434    *
   3435    * Shoutout to Angular 7 https://github.com/angular/angular/blob/7.2.4/packages/core/src/sanitization/url_sanitizer.ts
   3436    */
   3437 
   3438   const DATA_URL_PATTERN = /^data:(?:image\/(?:bmp|gif|jpeg|jpg|png|tiff|webp)|video\/(?:mpeg|mp4|ogg|webm)|audio\/(?:mp3|oga|ogg|opus));base64,[\d+/a-z]+=*$/i;
   3439 
   3440   const allowedAttribute = (attr, allowedAttributeList) => {
   3441     const attrName = attr.nodeName.toLowerCase();
   3442 
   3443     if (allowedAttributeList.includes(attrName)) {
   3444       if (uriAttrs.has(attrName)) {
   3445         return Boolean(SAFE_URL_PATTERN.test(attr.nodeValue) || DATA_URL_PATTERN.test(attr.nodeValue));
   3446       }
   3447 
   3448       return true;
   3449     }
   3450 
   3451     const regExp = allowedAttributeList.filter(attrRegex => attrRegex instanceof RegExp); // Check if a regular expression validates the attribute.
   3452 
   3453     for (let i = 0, len = regExp.length; i < len; i++) {
   3454       if (regExp[i].test(attrName)) {
   3455         return true;
   3456       }
   3457     }
   3458 
   3459     return false;
   3460   };
   3461 
   3462   const DefaultAllowlist = {
   3463     // Global attributes allowed on any supplied element below.
   3464     '*': ['class', 'dir', 'id', 'lang', 'role', ARIA_ATTRIBUTE_PATTERN],
   3465     a: ['target', 'href', 'title', 'rel'],
   3466     area: [],
   3467     b: [],
   3468     br: [],
   3469     col: [],
   3470     code: [],
   3471     div: [],
   3472     em: [],
   3473     hr: [],
   3474     h1: [],
   3475     h2: [],
   3476     h3: [],
   3477     h4: [],
   3478     h5: [],
   3479     h6: [],
   3480     i: [],
   3481     img: ['src', 'srcset', 'alt', 'title', 'width', 'height'],
   3482     li: [],
   3483     ol: [],
   3484     p: [],
   3485     pre: [],
   3486     s: [],
   3487     small: [],
   3488     span: [],
   3489     sub: [],
   3490     sup: [],
   3491     strong: [],
   3492     u: [],
   3493     ul: []
   3494   };
   3495   function sanitizeHtml(unsafeHtml, allowList, sanitizeFn) {
   3496     if (!unsafeHtml.length) {
   3497       return unsafeHtml;
   3498     }
   3499 
   3500     if (sanitizeFn && typeof sanitizeFn === 'function') {
   3501       return sanitizeFn(unsafeHtml);
   3502     }
   3503 
   3504     const domParser = new window.DOMParser();
   3505     const createdDocument = domParser.parseFromString(unsafeHtml, 'text/html');
   3506     const allowlistKeys = Object.keys(allowList);
   3507     const elements = [].concat(...createdDocument.body.querySelectorAll('*'));
   3508 
   3509     for (let i = 0, len = elements.length; i < len; i++) {
   3510       const el = elements[i];
   3511       const elName = el.nodeName.toLowerCase();
   3512 
   3513       if (!allowlistKeys.includes(elName)) {
   3514         el.remove();
   3515         continue;
   3516       }
   3517 
   3518       const attributeList = [].concat(...el.attributes);
   3519       const allowedAttributes = [].concat(allowList['*'] || [], allowList[elName] || []);
   3520       attributeList.forEach(attr => {
   3521         if (!allowedAttribute(attr, allowedAttributes)) {
   3522           el.removeAttribute(attr.nodeName);
   3523         }
   3524       });
   3525     }
   3526 
   3527     return createdDocument.body.innerHTML;
   3528   }
   3529 
   3530   /**
   3531    * --------------------------------------------------------------------------
   3532    * Bootstrap (v5.1.0): tooltip.js
   3533    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
   3534    * --------------------------------------------------------------------------
   3535    */
   3536   /**
   3537    * ------------------------------------------------------------------------
   3538    * Constants
   3539    * ------------------------------------------------------------------------
   3540    */
   3541 
   3542   const NAME$4 = 'tooltip';
   3543   const DATA_KEY$4 = 'bs.tooltip';
   3544   const EVENT_KEY$4 = `.${DATA_KEY$4}`;
   3545   const CLASS_PREFIX$1 = 'bs-tooltip';
   3546   const DISALLOWED_ATTRIBUTES = new Set(['sanitize', 'allowList', 'sanitizeFn']);
   3547   const DefaultType$3 = {
   3548     animation: 'boolean',
   3549     template: 'string',
   3550     title: '(string|element|function)',
   3551     trigger: 'string',
   3552     delay: '(number|object)',
   3553     html: 'boolean',
   3554     selector: '(string|boolean)',
   3555     placement: '(string|function)',
   3556     offset: '(array|string|function)',
   3557     container: '(string|element|boolean)',
   3558     fallbackPlacements: 'array',
   3559     boundary: '(string|element)',
   3560     customClass: '(string|function)',
   3561     sanitize: 'boolean',
   3562     sanitizeFn: '(null|function)',
   3563     allowList: 'object',
   3564     popperConfig: '(null|object|function)'
   3565   };
   3566   const AttachmentMap = {
   3567     AUTO: 'auto',
   3568     TOP: 'top',
   3569     RIGHT: isRTL() ? 'left' : 'right',
   3570     BOTTOM: 'bottom',
   3571     LEFT: isRTL() ? 'right' : 'left'
   3572   };
   3573   const Default$3 = {
   3574     animation: true,
   3575     template: '<div class="tooltip" role="tooltip">' + '<div class="tooltip-arrow"></div>' + '<div class="tooltip-inner"></div>' + '</div>',
   3576     trigger: 'hover focus',
   3577     title: '',
   3578     delay: 0,
   3579     html: false,
   3580     selector: false,
   3581     placement: 'top',
   3582     offset: [0, 0],
   3583     container: false,
   3584     fallbackPlacements: ['top', 'right', 'bottom', 'left'],
   3585     boundary: 'clippingParents',
   3586     customClass: '',
   3587     sanitize: true,
   3588     sanitizeFn: null,
   3589     allowList: DefaultAllowlist,
   3590     popperConfig: null
   3591   };
   3592   const Event$2 = {
   3593     HIDE: `hide${EVENT_KEY$4}`,
   3594     HIDDEN: `hidden${EVENT_KEY$4}`,
   3595     SHOW: `show${EVENT_KEY$4}`,
   3596     SHOWN: `shown${EVENT_KEY$4}`,
   3597     INSERTED: `inserted${EVENT_KEY$4}`,
   3598     CLICK: `click${EVENT_KEY$4}`,
   3599     FOCUSIN: `focusin${EVENT_KEY$4}`,
   3600     FOCUSOUT: `focusout${EVENT_KEY$4}`,
   3601     MOUSEENTER: `mouseenter${EVENT_KEY$4}`,
   3602     MOUSELEAVE: `mouseleave${EVENT_KEY$4}`
   3603   };
   3604   const CLASS_NAME_FADE$2 = 'fade';
   3605   const CLASS_NAME_MODAL = 'modal';
   3606   const CLASS_NAME_SHOW$2 = 'show';
   3607   const HOVER_STATE_SHOW = 'show';
   3608   const HOVER_STATE_OUT = 'out';
   3609   const SELECTOR_TOOLTIP_INNER = '.tooltip-inner';
   3610   const SELECTOR_MODAL = `.${CLASS_NAME_MODAL}`;
   3611   const EVENT_MODAL_HIDE = 'hide.bs.modal';
   3612   const TRIGGER_HOVER = 'hover';
   3613   const TRIGGER_FOCUS = 'focus';
   3614   const TRIGGER_CLICK = 'click';
   3615   const TRIGGER_MANUAL = 'manual';
   3616   /**
   3617    * ------------------------------------------------------------------------
   3618    * Class Definition
   3619    * ------------------------------------------------------------------------
   3620    */
   3621 
   3622   class Tooltip extends BaseComponent {
   3623     constructor(element, config) {
   3624       if (typeof Popper__namespace === 'undefined') {
   3625         throw new TypeError('Bootstrap\'s tooltips require Popper (https://popper.js.org)');
   3626       }
   3627 
   3628       super(element); // private
   3629 
   3630       this._isEnabled = true;
   3631       this._timeout = 0;
   3632       this._hoverState = '';
   3633       this._activeTrigger = {};
   3634       this._popper = null; // Protected
   3635 
   3636       this._config = this._getConfig(config);
   3637       this.tip = null;
   3638 
   3639       this._setListeners();
   3640     } // Getters
   3641 
   3642 
   3643     static get Default() {
   3644       return Default$3;
   3645     }
   3646 
   3647     static get NAME() {
   3648       return NAME$4;
   3649     }
   3650 
   3651     static get Event() {
   3652       return Event$2;
   3653     }
   3654 
   3655     static get DefaultType() {
   3656       return DefaultType$3;
   3657     } // Public
   3658 
   3659 
   3660     enable() {
   3661       this._isEnabled = true;
   3662     }
   3663 
   3664     disable() {
   3665       this._isEnabled = false;
   3666     }
   3667 
   3668     toggleEnabled() {
   3669       this._isEnabled = !this._isEnabled;
   3670     }
   3671 
   3672     toggle(event) {
   3673       if (!this._isEnabled) {
   3674         return;
   3675       }
   3676 
   3677       if (event) {
   3678         const context = this._initializeOnDelegatedTarget(event);
   3679 
   3680         context._activeTrigger.click = !context._activeTrigger.click;
   3681 
   3682         if (context._isWithActiveTrigger()) {
   3683           context._enter(null, context);
   3684         } else {
   3685           context._leave(null, context);
   3686         }
   3687       } else {
   3688         if (this.getTipElement().classList.contains(CLASS_NAME_SHOW$2)) {
   3689           this._leave(null, this);
   3690 
   3691           return;
   3692         }
   3693 
   3694         this._enter(null, this);
   3695       }
   3696     }
   3697 
   3698     dispose() {
   3699       clearTimeout(this._timeout);
   3700       EventHandler.off(this._element.closest(SELECTOR_MODAL), EVENT_MODAL_HIDE, this._hideModalHandler);
   3701 
   3702       if (this.tip) {
   3703         this.tip.remove();
   3704       }
   3705 
   3706       if (this._popper) {
   3707         this._popper.destroy();
   3708       }
   3709 
   3710       super.dispose();
   3711     }
   3712 
   3713     show() {
   3714       if (this._element.style.display === 'none') {
   3715         throw new Error('Please use show on visible elements');
   3716       }
   3717 
   3718       if (!(this.isWithContent() && this._isEnabled)) {
   3719         return;
   3720       }
   3721 
   3722       const showEvent = EventHandler.trigger(this._element, this.constructor.Event.SHOW);
   3723       const shadowRoot = findShadowRoot(this._element);
   3724       const isInTheDom = shadowRoot === null ? this._element.ownerDocument.documentElement.contains(this._element) : shadowRoot.contains(this._element);
   3725 
   3726       if (showEvent.defaultPrevented || !isInTheDom) {
   3727         return;
   3728       }
   3729 
   3730       const tip = this.getTipElement();
   3731       const tipId = getUID(this.constructor.NAME);
   3732       tip.setAttribute('id', tipId);
   3733 
   3734       this._element.setAttribute('aria-describedby', tipId);
   3735 
   3736       if (this._config.animation) {
   3737         tip.classList.add(CLASS_NAME_FADE$2);
   3738       }
   3739 
   3740       const placement = typeof this._config.placement === 'function' ? this._config.placement.call(this, tip, this._element) : this._config.placement;
   3741 
   3742       const attachment = this._getAttachment(placement);
   3743 
   3744       this._addAttachmentClass(attachment);
   3745 
   3746       const {
   3747         container
   3748       } = this._config;
   3749       Data.set(tip, this.constructor.DATA_KEY, this);
   3750 
   3751       if (!this._element.ownerDocument.documentElement.contains(this.tip)) {
   3752         container.append(tip);
   3753         EventHandler.trigger(this._element, this.constructor.Event.INSERTED);
   3754       }
   3755 
   3756       if (this._popper) {
   3757         this._popper.update();
   3758       } else {
   3759         this._popper = Popper__namespace.createPopper(this._element, tip, this._getPopperConfig(attachment));
   3760       }
   3761 
   3762       tip.classList.add(CLASS_NAME_SHOW$2);
   3763 
   3764       const customClass = this._resolvePossibleFunction(this._config.customClass);
   3765 
   3766       if (customClass) {
   3767         tip.classList.add(...customClass.split(' '));
   3768       } // If this is a touch-enabled device we add extra
   3769       // empty mouseover listeners to the body's immediate children;
   3770       // only needed because of broken event delegation on iOS
   3771       // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html
   3772 
   3773 
   3774       if ('ontouchstart' in document.documentElement) {
   3775         [].concat(...document.body.children).forEach(element => {
   3776           EventHandler.on(element, 'mouseover', noop);
   3777         });
   3778       }
   3779 
   3780       const complete = () => {
   3781         const prevHoverState = this._hoverState;
   3782         this._hoverState = null;
   3783         EventHandler.trigger(this._element, this.constructor.Event.SHOWN);
   3784 
   3785         if (prevHoverState === HOVER_STATE_OUT) {
   3786           this._leave(null, this);
   3787         }
   3788       };
   3789 
   3790       const isAnimated = this.tip.classList.contains(CLASS_NAME_FADE$2);
   3791 
   3792       this._queueCallback(complete, this.tip, isAnimated);
   3793     }
   3794 
   3795     hide() {
   3796       if (!this._popper) {
   3797         return;
   3798       }
   3799 
   3800       const tip = this.getTipElement();
   3801 
   3802       const complete = () => {
   3803         if (this._isWithActiveTrigger()) {
   3804           return;
   3805         }
   3806 
   3807         if (this._hoverState !== HOVER_STATE_SHOW) {
   3808           tip.remove();
   3809         }
   3810 
   3811         this._cleanTipClass();
   3812 
   3813         this._element.removeAttribute('aria-describedby');
   3814 
   3815         EventHandler.trigger(this._element, this.constructor.Event.HIDDEN);
   3816 
   3817         if (this._popper) {
   3818           this._popper.destroy();
   3819 
   3820           this._popper = null;
   3821         }
   3822       };
   3823 
   3824       const hideEvent = EventHandler.trigger(this._element, this.constructor.Event.HIDE);
   3825 
   3826       if (hideEvent.defaultPrevented) {
   3827         return;
   3828       }
   3829 
   3830       tip.classList.remove(CLASS_NAME_SHOW$2); // If this is a touch-enabled device we remove the extra
   3831       // empty mouseover listeners we added for iOS support
   3832 
   3833       if ('ontouchstart' in document.documentElement) {
   3834         [].concat(...document.body.children).forEach(element => EventHandler.off(element, 'mouseover', noop));
   3835       }
   3836 
   3837       this._activeTrigger[TRIGGER_CLICK] = false;
   3838       this._activeTrigger[TRIGGER_FOCUS] = false;
   3839       this._activeTrigger[TRIGGER_HOVER] = false;
   3840       const isAnimated = this.tip.classList.contains(CLASS_NAME_FADE$2);
   3841 
   3842       this._queueCallback(complete, this.tip, isAnimated);
   3843 
   3844       this._hoverState = '';
   3845     }
   3846 
   3847     update() {
   3848       if (this._popper !== null) {
   3849         this._popper.update();
   3850       }
   3851     } // Protected
   3852 
   3853 
   3854     isWithContent() {
   3855       return Boolean(this.getTitle());
   3856     }
   3857 
   3858     getTipElement() {
   3859       if (this.tip) {
   3860         return this.tip;
   3861       }
   3862 
   3863       const element = document.createElement('div');
   3864       element.innerHTML = this._config.template;
   3865       const tip = element.children[0];
   3866       this.setContent(tip);
   3867       tip.classList.remove(CLASS_NAME_FADE$2, CLASS_NAME_SHOW$2);
   3868       this.tip = tip;
   3869       return this.tip;
   3870     }
   3871 
   3872     setContent(tip) {
   3873       this._sanitizeAndSetContent(tip, this.getTitle(), SELECTOR_TOOLTIP_INNER);
   3874     }
   3875 
   3876     _sanitizeAndSetContent(template, content, selector) {
   3877       const templateElement = SelectorEngine.findOne(selector, template);
   3878 
   3879       if (!content && templateElement) {
   3880         templateElement.remove();
   3881         return;
   3882       } // we use append for html objects to maintain js events
   3883 
   3884 
   3885       this.setElementContent(templateElement, content);
   3886     }
   3887 
   3888     setElementContent(element, content) {
   3889       if (element === null) {
   3890         return;
   3891       }
   3892 
   3893       if (isElement(content)) {
   3894         content = getElement(content); // content is a DOM node or a jQuery
   3895 
   3896         if (this._config.html) {
   3897           if (content.parentNode !== element) {
   3898             element.innerHTML = '';
   3899             element.append(content);
   3900           }
   3901         } else {
   3902           element.textContent = content.textContent;
   3903         }
   3904 
   3905         return;
   3906       }
   3907 
   3908       if (this._config.html) {
   3909         if (this._config.sanitize) {
   3910           content = sanitizeHtml(content, this._config.allowList, this._config.sanitizeFn);
   3911         }
   3912 
   3913         element.innerHTML = content;
   3914       } else {
   3915         element.textContent = content;
   3916       }
   3917     }
   3918 
   3919     getTitle() {
   3920       const title = this._element.getAttribute('data-bs-original-title') || this._config.title;
   3921 
   3922       return this._resolvePossibleFunction(title);
   3923     }
   3924 
   3925     updateAttachment(attachment) {
   3926       if (attachment === 'right') {
   3927         return 'end';
   3928       }
   3929 
   3930       if (attachment === 'left') {
   3931         return 'start';
   3932       }
   3933 
   3934       return attachment;
   3935     } // Private
   3936 
   3937 
   3938     _initializeOnDelegatedTarget(event, context) {
   3939       return context || this.constructor.getOrCreateInstance(event.delegateTarget, this._getDelegateConfig());
   3940     }
   3941 
   3942     _getOffset() {
   3943       const {
   3944         offset
   3945       } = this._config;
   3946 
   3947       if (typeof offset === 'string') {
   3948         return offset.split(',').map(val => Number.parseInt(val, 10));
   3949       }
   3950 
   3951       if (typeof offset === 'function') {
   3952         return popperData => offset(popperData, this._element);
   3953       }
   3954 
   3955       return offset;
   3956     }
   3957 
   3958     _resolvePossibleFunction(content) {
   3959       return typeof content === 'function' ? content.call(this._element) : content;
   3960     }
   3961 
   3962     _getPopperConfig(attachment) {
   3963       const defaultBsPopperConfig = {
   3964         placement: attachment,
   3965         modifiers: [{
   3966           name: 'flip',
   3967           options: {
   3968             fallbackPlacements: this._config.fallbackPlacements
   3969           }
   3970         }, {
   3971           name: 'offset',
   3972           options: {
   3973             offset: this._getOffset()
   3974           }
   3975         }, {
   3976           name: 'preventOverflow',
   3977           options: {
   3978             boundary: this._config.boundary
   3979           }
   3980         }, {
   3981           name: 'arrow',
   3982           options: {
   3983             element: `.${this.constructor.NAME}-arrow`
   3984           }
   3985         }, {
   3986           name: 'onChange',
   3987           enabled: true,
   3988           phase: 'afterWrite',
   3989           fn: data => this._handlePopperPlacementChange(data)
   3990         }],
   3991         onFirstUpdate: data => {
   3992           if (data.options.placement !== data.placement) {
   3993             this._handlePopperPlacementChange(data);
   3994           }
   3995         }
   3996       };
   3997       return { ...defaultBsPopperConfig,
   3998         ...(typeof this._config.popperConfig === 'function' ? this._config.popperConfig(defaultBsPopperConfig) : this._config.popperConfig)
   3999       };
   4000     }
   4001 
   4002     _addAttachmentClass(attachment) {
   4003       this.getTipElement().classList.add(`${this._getBasicClassPrefix()}-${this.updateAttachment(attachment)}`);
   4004     }
   4005 
   4006     _getAttachment(placement) {
   4007       return AttachmentMap[placement.toUpperCase()];
   4008     }
   4009 
   4010     _setListeners() {
   4011       const triggers = this._config.trigger.split(' ');
   4012 
   4013       triggers.forEach(trigger => {
   4014         if (trigger === 'click') {
   4015           EventHandler.on(this._element, this.constructor.Event.CLICK, this._config.selector, event => this.toggle(event));
   4016         } else if (trigger !== TRIGGER_MANUAL) {
   4017           const eventIn = trigger === TRIGGER_HOVER ? this.constructor.Event.MOUSEENTER : this.constructor.Event.FOCUSIN;
   4018           const eventOut = trigger === TRIGGER_HOVER ? this.constructor.Event.MOUSELEAVE : this.constructor.Event.FOCUSOUT;
   4019           EventHandler.on(this._element, eventIn, this._config.selector, event => this._enter(event));
   4020           EventHandler.on(this._element, eventOut, this._config.selector, event => this._leave(event));
   4021         }
   4022       });
   4023 
   4024       this._hideModalHandler = () => {
   4025         if (this._element) {
   4026           this.hide();
   4027         }
   4028       };
   4029 
   4030       EventHandler.on(this._element.closest(SELECTOR_MODAL), EVENT_MODAL_HIDE, this._hideModalHandler);
   4031 
   4032       if (this._config.selector) {
   4033         this._config = { ...this._config,
   4034           trigger: 'manual',
   4035           selector: ''
   4036         };
   4037       } else {
   4038         this._fixTitle();
   4039       }
   4040     }
   4041 
   4042     _fixTitle() {
   4043       const title = this._element.getAttribute('title');
   4044 
   4045       const originalTitleType = typeof this._element.getAttribute('data-bs-original-title');
   4046 
   4047       if (title || originalTitleType !== 'string') {
   4048         this._element.setAttribute('data-bs-original-title', title || '');
   4049 
   4050         if (title && !this._element.getAttribute('aria-label') && !this._element.textContent) {
   4051           this._element.setAttribute('aria-label', title);
   4052         }
   4053 
   4054         this._element.setAttribute('title', '');
   4055       }
   4056     }
   4057 
   4058     _enter(event, context) {
   4059       context = this._initializeOnDelegatedTarget(event, context);
   4060 
   4061       if (event) {
   4062         context._activeTrigger[event.type === 'focusin' ? TRIGGER_FOCUS : TRIGGER_HOVER] = true;
   4063       }
   4064 
   4065       if (context.getTipElement().classList.contains(CLASS_NAME_SHOW$2) || context._hoverState === HOVER_STATE_SHOW) {
   4066         context._hoverState = HOVER_STATE_SHOW;
   4067         return;
   4068       }
   4069 
   4070       clearTimeout(context._timeout);
   4071       context._hoverState = HOVER_STATE_SHOW;
   4072 
   4073       if (!context._config.delay || !context._config.delay.show) {
   4074         context.show();
   4075         return;
   4076       }
   4077 
   4078       context._timeout = setTimeout(() => {
   4079         if (context._hoverState === HOVER_STATE_SHOW) {
   4080           context.show();
   4081         }
   4082       }, context._config.delay.show);
   4083     }
   4084 
   4085     _leave(event, context) {
   4086       context = this._initializeOnDelegatedTarget(event, context);
   4087 
   4088       if (event) {
   4089         context._activeTrigger[event.type === 'focusout' ? TRIGGER_FOCUS : TRIGGER_HOVER] = context._element.contains(event.relatedTarget);
   4090       }
   4091 
   4092       if (context._isWithActiveTrigger()) {
   4093         return;
   4094       }
   4095 
   4096       clearTimeout(context._timeout);
   4097       context._hoverState = HOVER_STATE_OUT;
   4098 
   4099       if (!context._config.delay || !context._config.delay.hide) {
   4100         context.hide();
   4101         return;
   4102       }
   4103 
   4104       context._timeout = setTimeout(() => {
   4105         if (context._hoverState === HOVER_STATE_OUT) {
   4106           context.hide();
   4107         }
   4108       }, context._config.delay.hide);
   4109     }
   4110 
   4111     _isWithActiveTrigger() {
   4112       for (const trigger in this._activeTrigger) {
   4113         if (this._activeTrigger[trigger]) {
   4114           return true;
   4115         }
   4116       }
   4117 
   4118       return false;
   4119     }
   4120 
   4121     _getConfig(config) {
   4122       const dataAttributes = Manipulator.getDataAttributes(this._element);
   4123       Object.keys(dataAttributes).forEach(dataAttr => {
   4124         if (DISALLOWED_ATTRIBUTES.has(dataAttr)) {
   4125           delete dataAttributes[dataAttr];
   4126         }
   4127       });
   4128       config = { ...this.constructor.Default,
   4129         ...dataAttributes,
   4130         ...(typeof config === 'object' && config ? config : {})
   4131       };
   4132       config.container = config.container === false ? document.body : getElement(config.container);
   4133 
   4134       if (typeof config.delay === 'number') {
   4135         config.delay = {
   4136           show: config.delay,
   4137           hide: config.delay
   4138         };
   4139       }
   4140 
   4141       if (typeof config.title === 'number') {
   4142         config.title = config.title.toString();
   4143       }
   4144 
   4145       if (typeof config.content === 'number') {
   4146         config.content = config.content.toString();
   4147       }
   4148 
   4149       typeCheckConfig(NAME$4, config, this.constructor.DefaultType);
   4150 
   4151       if (config.sanitize) {
   4152         config.template = sanitizeHtml(config.template, config.allowList, config.sanitizeFn);
   4153       }
   4154 
   4155       return config;
   4156     }
   4157 
   4158     _getDelegateConfig() {
   4159       const config = {};
   4160 
   4161       for (const key in this._config) {
   4162         if (this.constructor.Default[key] !== this._config[key]) {
   4163           config[key] = this._config[key];
   4164         }
   4165       } // In the future can be replaced with:
   4166       // const keysWithDifferentValues = Object.entries(this._config).filter(entry => this.constructor.Default[entry[0]] !== this._config[entry[0]])
   4167       // `Object.fromEntries(keysWithDifferentValues)`
   4168 
   4169 
   4170       return config;
   4171     }
   4172 
   4173     _cleanTipClass() {
   4174       const tip = this.getTipElement();
   4175       const basicClassPrefixRegex = new RegExp(`(^|\\s)${this._getBasicClassPrefix()}\\S+`, 'g');
   4176       const tabClass = tip.getAttribute('class').match(basicClassPrefixRegex);
   4177 
   4178       if (tabClass !== null && tabClass.length > 0) {
   4179         tabClass.map(token => token.trim()).forEach(tClass => tip.classList.remove(tClass));
   4180       }
   4181     }
   4182 
   4183     _getBasicClassPrefix() {
   4184       return CLASS_PREFIX$1;
   4185     }
   4186 
   4187     _handlePopperPlacementChange(popperData) {
   4188       const {
   4189         state
   4190       } = popperData;
   4191 
   4192       if (!state) {
   4193         return;
   4194       }
   4195 
   4196       this.tip = state.elements.popper;
   4197 
   4198       this._cleanTipClass();
   4199 
   4200       this._addAttachmentClass(this._getAttachment(state.placement));
   4201     } // Static
   4202 
   4203 
   4204     static jQueryInterface(config) {
   4205       return this.each(function () {
   4206         const data = Tooltip.getOrCreateInstance(this, config);
   4207 
   4208         if (typeof config === 'string') {
   4209           if (typeof data[config] === 'undefined') {
   4210             throw new TypeError(`No method named "${config}"`);
   4211           }
   4212 
   4213           data[config]();
   4214         }
   4215       });
   4216     }
   4217 
   4218   }
   4219   /**
   4220    * ------------------------------------------------------------------------
   4221    * jQuery
   4222    * ------------------------------------------------------------------------
   4223    * add .Tooltip to jQuery only if jQuery is present
   4224    */
   4225 
   4226 
   4227   defineJQueryPlugin(Tooltip);
   4228 
   4229   /**
   4230    * --------------------------------------------------------------------------
   4231    * Bootstrap (v5.1.0): popover.js
   4232    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
   4233    * --------------------------------------------------------------------------
   4234    */
   4235   /**
   4236    * ------------------------------------------------------------------------
   4237    * Constants
   4238    * ------------------------------------------------------------------------
   4239    */
   4240 
   4241   const NAME$3 = 'popover';
   4242   const DATA_KEY$3 = 'bs.popover';
   4243   const EVENT_KEY$3 = `.${DATA_KEY$3}`;
   4244   const CLASS_PREFIX = 'bs-popover';
   4245   const Default$2 = { ...Tooltip.Default,
   4246     placement: 'right',
   4247     offset: [0, 8],
   4248     trigger: 'click',
   4249     content: '',
   4250     template: '<div class="popover" role="tooltip">' + '<div class="popover-arrow"></div>' + '<h3 class="popover-header"></h3>' + '<div class="popover-body"></div>' + '</div>'
   4251   };
   4252   const DefaultType$2 = { ...Tooltip.DefaultType,
   4253     content: '(string|element|function)'
   4254   };
   4255   const Event$1 = {
   4256     HIDE: `hide${EVENT_KEY$3}`,
   4257     HIDDEN: `hidden${EVENT_KEY$3}`,
   4258     SHOW: `show${EVENT_KEY$3}`,
   4259     SHOWN: `shown${EVENT_KEY$3}`,
   4260     INSERTED: `inserted${EVENT_KEY$3}`,
   4261     CLICK: `click${EVENT_KEY$3}`,
   4262     FOCUSIN: `focusin${EVENT_KEY$3}`,
   4263     FOCUSOUT: `focusout${EVENT_KEY$3}`,
   4264     MOUSEENTER: `mouseenter${EVENT_KEY$3}`,
   4265     MOUSELEAVE: `mouseleave${EVENT_KEY$3}`
   4266   };
   4267   const SELECTOR_TITLE = '.popover-header';
   4268   const SELECTOR_CONTENT = '.popover-body';
   4269   /**
   4270    * ------------------------------------------------------------------------
   4271    * Class Definition
   4272    * ------------------------------------------------------------------------
   4273    */
   4274 
   4275   class Popover extends Tooltip {
   4276     // Getters
   4277     static get Default() {
   4278       return Default$2;
   4279     }
   4280 
   4281     static get NAME() {
   4282       return NAME$3;
   4283     }
   4284 
   4285     static get Event() {
   4286       return Event$1;
   4287     }
   4288 
   4289     static get DefaultType() {
   4290       return DefaultType$2;
   4291     } // Overrides
   4292 
   4293 
   4294     isWithContent() {
   4295       return this.getTitle() || this._getContent();
   4296     }
   4297 
   4298     setContent(tip) {
   4299       this._sanitizeAndSetContent(tip, this.getTitle(), SELECTOR_TITLE);
   4300 
   4301       this._sanitizeAndSetContent(tip, this._getContent(), SELECTOR_CONTENT);
   4302     } // Private
   4303 
   4304 
   4305     _getContent() {
   4306       return this._resolvePossibleFunction(this._config.content);
   4307     }
   4308 
   4309     _getBasicClassPrefix() {
   4310       return CLASS_PREFIX;
   4311     } // Static
   4312 
   4313 
   4314     static jQueryInterface(config) {
   4315       return this.each(function () {
   4316         const data = Popover.getOrCreateInstance(this, config);
   4317 
   4318         if (typeof config === 'string') {
   4319           if (typeof data[config] === 'undefined') {
   4320             throw new TypeError(`No method named "${config}"`);
   4321           }
   4322 
   4323           data[config]();
   4324         }
   4325       });
   4326     }
   4327 
   4328   }
   4329   /**
   4330    * ------------------------------------------------------------------------
   4331    * jQuery
   4332    * ------------------------------------------------------------------------
   4333    * add .Popover to jQuery only if jQuery is present
   4334    */
   4335 
   4336 
   4337   defineJQueryPlugin(Popover);
   4338 
   4339   /**
   4340    * --------------------------------------------------------------------------
   4341    * Bootstrap (v5.1.0): scrollspy.js
   4342    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
   4343    * --------------------------------------------------------------------------
   4344    */
   4345   /**
   4346    * ------------------------------------------------------------------------
   4347    * Constants
   4348    * ------------------------------------------------------------------------
   4349    */
   4350 
   4351   const NAME$2 = 'scrollspy';
   4352   const DATA_KEY$2 = 'bs.scrollspy';
   4353   const EVENT_KEY$2 = `.${DATA_KEY$2}`;
   4354   const DATA_API_KEY$1 = '.data-api';
   4355   const Default$1 = {
   4356     offset: 10,
   4357     method: 'auto',
   4358     target: ''
   4359   };
   4360   const DefaultType$1 = {
   4361     offset: 'number',
   4362     method: 'string',
   4363     target: '(string|element)'
   4364   };
   4365   const EVENT_ACTIVATE = `activate${EVENT_KEY$2}`;
   4366   const EVENT_SCROLL = `scroll${EVENT_KEY$2}`;
   4367   const EVENT_LOAD_DATA_API = `load${EVENT_KEY$2}${DATA_API_KEY$1}`;
   4368   const CLASS_NAME_DROPDOWN_ITEM = 'dropdown-item';
   4369   const CLASS_NAME_ACTIVE$1 = 'active';
   4370   const SELECTOR_DATA_SPY = '[data-bs-spy="scroll"]';
   4371   const SELECTOR_NAV_LIST_GROUP$1 = '.nav, .list-group';
   4372   const SELECTOR_NAV_LINKS = '.nav-link';
   4373   const SELECTOR_NAV_ITEMS = '.nav-item';
   4374   const SELECTOR_LIST_ITEMS = '.list-group-item';
   4375   const SELECTOR_LINK_ITEMS = `${SELECTOR_NAV_LINKS}, ${SELECTOR_LIST_ITEMS}, .${CLASS_NAME_DROPDOWN_ITEM}`;
   4376   const SELECTOR_DROPDOWN$1 = '.dropdown';
   4377   const SELECTOR_DROPDOWN_TOGGLE$1 = '.dropdown-toggle';
   4378   const METHOD_OFFSET = 'offset';
   4379   const METHOD_POSITION = 'position';
   4380   /**
   4381    * ------------------------------------------------------------------------
   4382    * Class Definition
   4383    * ------------------------------------------------------------------------
   4384    */
   4385 
   4386   class ScrollSpy extends BaseComponent {
   4387     constructor(element, config) {
   4388       super(element);
   4389       this._scrollElement = this._element.tagName === 'BODY' ? window : this._element;
   4390       this._config = this._getConfig(config);
   4391       this._offsets = [];
   4392       this._targets = [];
   4393       this._activeTarget = null;
   4394       this._scrollHeight = 0;
   4395       EventHandler.on(this._scrollElement, EVENT_SCROLL, () => this._process());
   4396       this.refresh();
   4397 
   4398       this._process();
   4399     } // Getters
   4400 
   4401 
   4402     static get Default() {
   4403       return Default$1;
   4404     }
   4405 
   4406     static get NAME() {
   4407       return NAME$2;
   4408     } // Public
   4409 
   4410 
   4411     refresh() {
   4412       const autoMethod = this._scrollElement === this._scrollElement.window ? METHOD_OFFSET : METHOD_POSITION;
   4413       const offsetMethod = this._config.method === 'auto' ? autoMethod : this._config.method;
   4414       const offsetBase = offsetMethod === METHOD_POSITION ? this._getScrollTop() : 0;
   4415       this._offsets = [];
   4416       this._targets = [];
   4417       this._scrollHeight = this._getScrollHeight();
   4418       const targets = SelectorEngine.find(SELECTOR_LINK_ITEMS, this._config.target);
   4419       targets.map(element => {
   4420         const targetSelector = getSelectorFromElement(element);
   4421         const target = targetSelector ? SelectorEngine.findOne(targetSelector) : null;
   4422 
   4423         if (target) {
   4424           const targetBCR = target.getBoundingClientRect();
   4425 
   4426           if (targetBCR.width || targetBCR.height) {
   4427             return [Manipulator[offsetMethod](target).top + offsetBase, targetSelector];
   4428           }
   4429         }
   4430 
   4431         return null;
   4432       }).filter(item => item).sort((a, b) => a[0] - b[0]).forEach(item => {
   4433         this._offsets.push(item[0]);
   4434 
   4435         this._targets.push(item[1]);
   4436       });
   4437     }
   4438 
   4439     dispose() {
   4440       EventHandler.off(this._scrollElement, EVENT_KEY$2);
   4441       super.dispose();
   4442     } // Private
   4443 
   4444 
   4445     _getConfig(config) {
   4446       config = { ...Default$1,
   4447         ...Manipulator.getDataAttributes(this._element),
   4448         ...(typeof config === 'object' && config ? config : {})
   4449       };
   4450       config.target = getElement(config.target) || document.documentElement;
   4451       typeCheckConfig(NAME$2, config, DefaultType$1);
   4452       return config;
   4453     }
   4454 
   4455     _getScrollTop() {
   4456       return this._scrollElement === window ? this._scrollElement.pageYOffset : this._scrollElement.scrollTop;
   4457     }
   4458 
   4459     _getScrollHeight() {
   4460       return this._scrollElement.scrollHeight || Math.max(document.body.scrollHeight, document.documentElement.scrollHeight);
   4461     }
   4462 
   4463     _getOffsetHeight() {
   4464       return this._scrollElement === window ? window.innerHeight : this._scrollElement.getBoundingClientRect().height;
   4465     }
   4466 
   4467     _process() {
   4468       const scrollTop = this._getScrollTop() + this._config.offset;
   4469 
   4470       const scrollHeight = this._getScrollHeight();
   4471 
   4472       const maxScroll = this._config.offset + scrollHeight - this._getOffsetHeight();
   4473 
   4474       if (this._scrollHeight !== scrollHeight) {
   4475         this.refresh();
   4476       }
   4477 
   4478       if (scrollTop >= maxScroll) {
   4479         const target = this._targets[this._targets.length - 1];
   4480 
   4481         if (this._activeTarget !== target) {
   4482           this._activate(target);
   4483         }
   4484 
   4485         return;
   4486       }
   4487 
   4488       if (this._activeTarget && scrollTop < this._offsets[0] && this._offsets[0] > 0) {
   4489         this._activeTarget = null;
   4490 
   4491         this._clear();
   4492 
   4493         return;
   4494       }
   4495 
   4496       for (let i = this._offsets.length; i--;) {
   4497         const isActiveTarget = this._activeTarget !== this._targets[i] && scrollTop >= this._offsets[i] && (typeof this._offsets[i + 1] === 'undefined' || scrollTop < this._offsets[i + 1]);
   4498 
   4499         if (isActiveTarget) {
   4500           this._activate(this._targets[i]);
   4501         }
   4502       }
   4503     }
   4504 
   4505     _activate(target) {
   4506       this._activeTarget = target;
   4507 
   4508       this._clear();
   4509 
   4510       const queries = SELECTOR_LINK_ITEMS.split(',').map(selector => `${selector}[data-bs-target="${target}"],${selector}[href="${target}"]`);
   4511       const link = SelectorEngine.findOne(queries.join(','), this._config.target);
   4512       link.classList.add(CLASS_NAME_ACTIVE$1);
   4513 
   4514       if (link.classList.contains(CLASS_NAME_DROPDOWN_ITEM)) {
   4515         SelectorEngine.findOne(SELECTOR_DROPDOWN_TOGGLE$1, link.closest(SELECTOR_DROPDOWN$1)).classList.add(CLASS_NAME_ACTIVE$1);
   4516       } else {
   4517         SelectorEngine.parents(link, SELECTOR_NAV_LIST_GROUP$1).forEach(listGroup => {
   4518           // Set triggered links parents as active
   4519           // With both <ul> and <nav> markup a parent is the previous sibling of any nav ancestor
   4520           SelectorEngine.prev(listGroup, `${SELECTOR_NAV_LINKS}, ${SELECTOR_LIST_ITEMS}`).forEach(item => item.classList.add(CLASS_NAME_ACTIVE$1)); // Handle special case when .nav-link is inside .nav-item
   4521 
   4522           SelectorEngine.prev(listGroup, SELECTOR_NAV_ITEMS).forEach(navItem => {
   4523             SelectorEngine.children(navItem, SELECTOR_NAV_LINKS).forEach(item => item.classList.add(CLASS_NAME_ACTIVE$1));
   4524           });
   4525         });
   4526       }
   4527 
   4528       EventHandler.trigger(this._scrollElement, EVENT_ACTIVATE, {
   4529         relatedTarget: target
   4530       });
   4531     }
   4532 
   4533     _clear() {
   4534       SelectorEngine.find(SELECTOR_LINK_ITEMS, this._config.target).filter(node => node.classList.contains(CLASS_NAME_ACTIVE$1)).forEach(node => node.classList.remove(CLASS_NAME_ACTIVE$1));
   4535     } // Static
   4536 
   4537 
   4538     static jQueryInterface(config) {
   4539       return this.each(function () {
   4540         const data = ScrollSpy.getOrCreateInstance(this, config);
   4541 
   4542         if (typeof config !== 'string') {
   4543           return;
   4544         }
   4545 
   4546         if (typeof data[config] === 'undefined') {
   4547           throw new TypeError(`No method named "${config}"`);
   4548         }
   4549 
   4550         data[config]();
   4551       });
   4552     }
   4553 
   4554   }
   4555   /**
   4556    * ------------------------------------------------------------------------
   4557    * Data Api implementation
   4558    * ------------------------------------------------------------------------
   4559    */
   4560 
   4561 
   4562   EventHandler.on(window, EVENT_LOAD_DATA_API, () => {
   4563     SelectorEngine.find(SELECTOR_DATA_SPY).forEach(spy => new ScrollSpy(spy));
   4564   });
   4565   /**
   4566    * ------------------------------------------------------------------------
   4567    * jQuery
   4568    * ------------------------------------------------------------------------
   4569    * add .ScrollSpy to jQuery only if jQuery is present
   4570    */
   4571 
   4572   defineJQueryPlugin(ScrollSpy);
   4573 
   4574   /**
   4575    * --------------------------------------------------------------------------
   4576    * Bootstrap (v5.1.0): tab.js
   4577    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
   4578    * --------------------------------------------------------------------------
   4579    */
   4580   /**
   4581    * ------------------------------------------------------------------------
   4582    * Constants
   4583    * ------------------------------------------------------------------------
   4584    */
   4585 
   4586   const NAME$1 = 'tab';
   4587   const DATA_KEY$1 = 'bs.tab';
   4588   const EVENT_KEY$1 = `.${DATA_KEY$1}`;
   4589   const DATA_API_KEY = '.data-api';
   4590   const EVENT_HIDE$1 = `hide${EVENT_KEY$1}`;
   4591   const EVENT_HIDDEN$1 = `hidden${EVENT_KEY$1}`;
   4592   const EVENT_SHOW$1 = `show${EVENT_KEY$1}`;
   4593   const EVENT_SHOWN$1 = `shown${EVENT_KEY$1}`;
   4594   const EVENT_CLICK_DATA_API = `click${EVENT_KEY$1}${DATA_API_KEY}`;
   4595   const CLASS_NAME_DROPDOWN_MENU = 'dropdown-menu';
   4596   const CLASS_NAME_ACTIVE = 'active';
   4597   const CLASS_NAME_FADE$1 = 'fade';
   4598   const CLASS_NAME_SHOW$1 = 'show';
   4599   const SELECTOR_DROPDOWN = '.dropdown';
   4600   const SELECTOR_NAV_LIST_GROUP = '.nav, .list-group';
   4601   const SELECTOR_ACTIVE = '.active';
   4602   const SELECTOR_ACTIVE_UL = ':scope > li > .active';
   4603   const SELECTOR_DATA_TOGGLE = '[data-bs-toggle="tab"], [data-bs-toggle="pill"], [data-bs-toggle="list"]';
   4604   const SELECTOR_DROPDOWN_TOGGLE = '.dropdown-toggle';
   4605   const SELECTOR_DROPDOWN_ACTIVE_CHILD = ':scope > .dropdown-menu .active';
   4606   /**
   4607    * ------------------------------------------------------------------------
   4608    * Class Definition
   4609    * ------------------------------------------------------------------------
   4610    */
   4611 
   4612   class Tab extends BaseComponent {
   4613     // Getters
   4614     static get NAME() {
   4615       return NAME$1;
   4616     } // Public
   4617 
   4618 
   4619     show() {
   4620       if (this._element.parentNode && this._element.parentNode.nodeType === Node.ELEMENT_NODE && this._element.classList.contains(CLASS_NAME_ACTIVE)) {
   4621         return;
   4622       }
   4623 
   4624       let previous;
   4625       const target = getElementFromSelector(this._element);
   4626 
   4627       const listElement = this._element.closest(SELECTOR_NAV_LIST_GROUP);
   4628 
   4629       if (listElement) {
   4630         const itemSelector = listElement.nodeName === 'UL' || listElement.nodeName === 'OL' ? SELECTOR_ACTIVE_UL : SELECTOR_ACTIVE;
   4631         previous = SelectorEngine.find(itemSelector, listElement);
   4632         previous = previous[previous.length - 1];
   4633       }
   4634 
   4635       const hideEvent = previous ? EventHandler.trigger(previous, EVENT_HIDE$1, {
   4636         relatedTarget: this._element
   4637       }) : null;
   4638       const showEvent = EventHandler.trigger(this._element, EVENT_SHOW$1, {
   4639         relatedTarget: previous
   4640       });
   4641 
   4642       if (showEvent.defaultPrevented || hideEvent !== null && hideEvent.defaultPrevented) {
   4643         return;
   4644       }
   4645 
   4646       this._activate(this._element, listElement);
   4647 
   4648       const complete = () => {
   4649         EventHandler.trigger(previous, EVENT_HIDDEN$1, {
   4650           relatedTarget: this._element
   4651         });
   4652         EventHandler.trigger(this._element, EVENT_SHOWN$1, {
   4653           relatedTarget: previous
   4654         });
   4655       };
   4656 
   4657       if (target) {
   4658         this._activate(target, target.parentNode, complete);
   4659       } else {
   4660         complete();
   4661       }
   4662     } // Private
   4663 
   4664 
   4665     _activate(element, container, callback) {
   4666       const activeElements = container && (container.nodeName === 'UL' || container.nodeName === 'OL') ? SelectorEngine.find(SELECTOR_ACTIVE_UL, container) : SelectorEngine.children(container, SELECTOR_ACTIVE);
   4667       const active = activeElements[0];
   4668       const isTransitioning = callback && active && active.classList.contains(CLASS_NAME_FADE$1);
   4669 
   4670       const complete = () => this._transitionComplete(element, active, callback);
   4671 
   4672       if (active && isTransitioning) {
   4673         active.classList.remove(CLASS_NAME_SHOW$1);
   4674 
   4675         this._queueCallback(complete, element, true);
   4676       } else {
   4677         complete();
   4678       }
   4679     }
   4680 
   4681     _transitionComplete(element, active, callback) {
   4682       if (active) {
   4683         active.classList.remove(CLASS_NAME_ACTIVE);
   4684         const dropdownChild = SelectorEngine.findOne(SELECTOR_DROPDOWN_ACTIVE_CHILD, active.parentNode);
   4685 
   4686         if (dropdownChild) {
   4687           dropdownChild.classList.remove(CLASS_NAME_ACTIVE);
   4688         }
   4689 
   4690         if (active.getAttribute('role') === 'tab') {
   4691           active.setAttribute('aria-selected', false);
   4692         }
   4693       }
   4694 
   4695       element.classList.add(CLASS_NAME_ACTIVE);
   4696 
   4697       if (element.getAttribute('role') === 'tab') {
   4698         element.setAttribute('aria-selected', true);
   4699       }
   4700 
   4701       reflow(element);
   4702 
   4703       if (element.classList.contains(CLASS_NAME_FADE$1)) {
   4704         element.classList.add(CLASS_NAME_SHOW$1);
   4705       }
   4706 
   4707       let parent = element.parentNode;
   4708 
   4709       if (parent && parent.nodeName === 'LI') {
   4710         parent = parent.parentNode;
   4711       }
   4712 
   4713       if (parent && parent.classList.contains(CLASS_NAME_DROPDOWN_MENU)) {
   4714         const dropdownElement = element.closest(SELECTOR_DROPDOWN);
   4715 
   4716         if (dropdownElement) {
   4717           SelectorEngine.find(SELECTOR_DROPDOWN_TOGGLE, dropdownElement).forEach(dropdown => dropdown.classList.add(CLASS_NAME_ACTIVE));
   4718         }
   4719 
   4720         element.setAttribute('aria-expanded', true);
   4721       }
   4722 
   4723       if (callback) {
   4724         callback();
   4725       }
   4726     } // Static
   4727 
   4728 
   4729     static jQueryInterface(config) {
   4730       return this.each(function () {
   4731         const data = Tab.getOrCreateInstance(this);
   4732 
   4733         if (typeof config === 'string') {
   4734           if (typeof data[config] === 'undefined') {
   4735             throw new TypeError(`No method named "${config}"`);
   4736           }
   4737 
   4738           data[config]();
   4739         }
   4740       });
   4741     }
   4742 
   4743   }
   4744   /**
   4745    * ------------------------------------------------------------------------
   4746    * Data Api implementation
   4747    * ------------------------------------------------------------------------
   4748    */
   4749 
   4750 
   4751   EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (event) {
   4752     if (['A', 'AREA'].includes(this.tagName)) {
   4753       event.preventDefault();
   4754     }
   4755 
   4756     if (isDisabled(this)) {
   4757       return;
   4758     }
   4759 
   4760     const data = Tab.getOrCreateInstance(this);
   4761     data.show();
   4762   });
   4763   /**
   4764    * ------------------------------------------------------------------------
   4765    * jQuery
   4766    * ------------------------------------------------------------------------
   4767    * add .Tab to jQuery only if jQuery is present
   4768    */
   4769 
   4770   defineJQueryPlugin(Tab);
   4771 
   4772   /**
   4773    * --------------------------------------------------------------------------
   4774    * Bootstrap (v5.1.0): toast.js
   4775    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
   4776    * --------------------------------------------------------------------------
   4777    */
   4778   /**
   4779    * ------------------------------------------------------------------------
   4780    * Constants
   4781    * ------------------------------------------------------------------------
   4782    */
   4783 
   4784   const NAME = 'toast';
   4785   const DATA_KEY = 'bs.toast';
   4786   const EVENT_KEY = `.${DATA_KEY}`;
   4787   const EVENT_MOUSEOVER = `mouseover${EVENT_KEY}`;
   4788   const EVENT_MOUSEOUT = `mouseout${EVENT_KEY}`;
   4789   const EVENT_FOCUSIN = `focusin${EVENT_KEY}`;
   4790   const EVENT_FOCUSOUT = `focusout${EVENT_KEY}`;
   4791   const EVENT_HIDE = `hide${EVENT_KEY}`;
   4792   const EVENT_HIDDEN = `hidden${EVENT_KEY}`;
   4793   const EVENT_SHOW = `show${EVENT_KEY}`;
   4794   const EVENT_SHOWN = `shown${EVENT_KEY}`;
   4795   const CLASS_NAME_FADE = 'fade';
   4796   const CLASS_NAME_HIDE = 'hide'; // @deprecated - kept here only for backwards compatibility
   4797 
   4798   const CLASS_NAME_SHOW = 'show';
   4799   const CLASS_NAME_SHOWING = 'showing';
   4800   const DefaultType = {
   4801     animation: 'boolean',
   4802     autohide: 'boolean',
   4803     delay: 'number'
   4804   };
   4805   const Default = {
   4806     animation: true,
   4807     autohide: true,
   4808     delay: 5000
   4809   };
   4810   /**
   4811    * ------------------------------------------------------------------------
   4812    * Class Definition
   4813    * ------------------------------------------------------------------------
   4814    */
   4815 
   4816   class Toast extends BaseComponent {
   4817     constructor(element, config) {
   4818       super(element);
   4819       this._config = this._getConfig(config);
   4820       this._timeout = null;
   4821       this._hasMouseInteraction = false;
   4822       this._hasKeyboardInteraction = false;
   4823 
   4824       this._setListeners();
   4825     } // Getters
   4826 
   4827 
   4828     static get DefaultType() {
   4829       return DefaultType;
   4830     }
   4831 
   4832     static get Default() {
   4833       return Default;
   4834     }
   4835 
   4836     static get NAME() {
   4837       return NAME;
   4838     } // Public
   4839 
   4840 
   4841     show() {
   4842       const showEvent = EventHandler.trigger(this._element, EVENT_SHOW);
   4843 
   4844       if (showEvent.defaultPrevented) {
   4845         return;
   4846       }
   4847 
   4848       this._clearTimeout();
   4849 
   4850       if (this._config.animation) {
   4851         this._element.classList.add(CLASS_NAME_FADE);
   4852       }
   4853 
   4854       const complete = () => {
   4855         this._element.classList.remove(CLASS_NAME_SHOWING);
   4856 
   4857         EventHandler.trigger(this._element, EVENT_SHOWN);
   4858 
   4859         this._maybeScheduleHide();
   4860       };
   4861 
   4862       this._element.classList.remove(CLASS_NAME_HIDE); // @deprecated
   4863 
   4864 
   4865       reflow(this._element);
   4866 
   4867       this._element.classList.add(CLASS_NAME_SHOW);
   4868 
   4869       this._element.classList.add(CLASS_NAME_SHOWING);
   4870 
   4871       this._queueCallback(complete, this._element, this._config.animation);
   4872     }
   4873 
   4874     hide() {
   4875       if (!this._element.classList.contains(CLASS_NAME_SHOW)) {
   4876         return;
   4877       }
   4878 
   4879       const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE);
   4880 
   4881       if (hideEvent.defaultPrevented) {
   4882         return;
   4883       }
   4884 
   4885       const complete = () => {
   4886         this._element.classList.add(CLASS_NAME_HIDE); // @deprecated
   4887 
   4888 
   4889         this._element.classList.remove(CLASS_NAME_SHOWING);
   4890 
   4891         this._element.classList.remove(CLASS_NAME_SHOW);
   4892 
   4893         EventHandler.trigger(this._element, EVENT_HIDDEN);
   4894       };
   4895 
   4896       this._element.classList.add(CLASS_NAME_SHOWING);
   4897 
   4898       this._queueCallback(complete, this._element, this._config.animation);
   4899     }
   4900 
   4901     dispose() {
   4902       this._clearTimeout();
   4903 
   4904       if (this._element.classList.contains(CLASS_NAME_SHOW)) {
   4905         this._element.classList.remove(CLASS_NAME_SHOW);
   4906       }
   4907 
   4908       super.dispose();
   4909     } // Private
   4910 
   4911 
   4912     _getConfig(config) {
   4913       config = { ...Default,
   4914         ...Manipulator.getDataAttributes(this._element),
   4915         ...(typeof config === 'object' && config ? config : {})
   4916       };
   4917       typeCheckConfig(NAME, config, this.constructor.DefaultType);
   4918       return config;
   4919     }
   4920 
   4921     _maybeScheduleHide() {
   4922       if (!this._config.autohide) {
   4923         return;
   4924       }
   4925 
   4926       if (this._hasMouseInteraction || this._hasKeyboardInteraction) {
   4927         return;
   4928       }
   4929 
   4930       this._timeout = setTimeout(() => {
   4931         this.hide();
   4932       }, this._config.delay);
   4933     }
   4934 
   4935     _onInteraction(event, isInteracting) {
   4936       switch (event.type) {
   4937         case 'mouseover':
   4938         case 'mouseout':
   4939           this._hasMouseInteraction = isInteracting;
   4940           break;
   4941 
   4942         case 'focusin':
   4943         case 'focusout':
   4944           this._hasKeyboardInteraction = isInteracting;
   4945           break;
   4946       }
   4947 
   4948       if (isInteracting) {
   4949         this._clearTimeout();
   4950 
   4951         return;
   4952       }
   4953 
   4954       const nextElement = event.relatedTarget;
   4955 
   4956       if (this._element === nextElement || this._element.contains(nextElement)) {
   4957         return;
   4958       }
   4959 
   4960       this._maybeScheduleHide();
   4961     }
   4962 
   4963     _setListeners() {
   4964       EventHandler.on(this._element, EVENT_MOUSEOVER, event => this._onInteraction(event, true));
   4965       EventHandler.on(this._element, EVENT_MOUSEOUT, event => this._onInteraction(event, false));
   4966       EventHandler.on(this._element, EVENT_FOCUSIN, event => this._onInteraction(event, true));
   4967       EventHandler.on(this._element, EVENT_FOCUSOUT, event => this._onInteraction(event, false));
   4968     }
   4969 
   4970     _clearTimeout() {
   4971       clearTimeout(this._timeout);
   4972       this._timeout = null;
   4973     } // Static
   4974 
   4975 
   4976     static jQueryInterface(config) {
   4977       return this.each(function () {
   4978         const data = Toast.getOrCreateInstance(this, config);
   4979 
   4980         if (typeof config === 'string') {
   4981           if (typeof data[config] === 'undefined') {
   4982             throw new TypeError(`No method named "${config}"`);
   4983           }
   4984 
   4985           data[config](this);
   4986         }
   4987       });
   4988     }
   4989 
   4990   }
   4991 
   4992   enableDismissTrigger(Toast);
   4993   /**
   4994    * ------------------------------------------------------------------------
   4995    * jQuery
   4996    * ------------------------------------------------------------------------
   4997    * add .Toast to jQuery only if jQuery is present
   4998    */
   4999 
   5000   defineJQueryPlugin(Toast);
   5001 
   5002   /**
   5003    * --------------------------------------------------------------------------
   5004    * Bootstrap (v5.1.0): index.umd.js
   5005    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
   5006    * --------------------------------------------------------------------------
   5007    */
   5008   var index_umd = {
   5009     Alert,
   5010     Button,
   5011     Carousel,
   5012     Collapse,
   5013     Dropdown,
   5014     Modal,
   5015     Offcanvas,
   5016     Popover,
   5017     ScrollSpy,
   5018     Tab,
   5019     Toast,
   5020     Tooltip
   5021   };
   5022 
   5023   return index_umd;
   5024 
   5025 })));
   5026 //# sourceMappingURL=bootstrap.js.map
	MVC-databaskonstruktion
	Log \| Files \| Refs \| README