bootstrap.js - cscg24-photoeditor - CSCG 2024 Challenge 'PhotoEditor'

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