Subversion Repositories oidplus

Rev

Rev 1151 | Rev 1339 | Go to most recent revision | View as "text/javascript" | Blame | Compare with Previous | Last modification | View Log | RSS feed

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