https://www.educatenepal.com/assets/js/bootstrap.bundle.js

1/*!
2  * Bootstrap v5.2.0 (https://getbootstrap.com/)
3  * Copyright 2011-2022 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() :
8  typeof define === 'function' && define.amd ? define(factory) :
9  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.bootstrap = factory());
10})(this, (function () { 'use strict';
11
12  /**
13   * --------------------------------------------------------------------------
14   * Bootstrap (v5.2.0): util/index.js
15   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
16   * --------------------------------------------------------------------------
17   */
18  const MAX_UID = 1000000;
19  const MILLISECONDS_MULTIPLIER = 1000;
20  const TRANSITION_END = 'transitionend'; // Shout-out Angus Croll (https://goo.gl/pxwQGp)
21
22  const toType = object => {
23    if (object === null || object === undefined) {
24      return `${object}`;
25    }
26
27    return Object.prototype.toString.call(object).match(/\s([a-z]+)/i)[1].toLowerCase();
28  };
29  /**
30   * Public Util API
31   */
32
33
34  const getUID = prefix => {
35    do {
36      prefix += Math.floor(Math.random() * MAX_UID);
37    } while (document.getElementById(prefix));
38
39    return prefix;
40  };
41
42  const getSelector = element => {
43    let selector = element.getAttribute('data-bs-target');
44
45    if (!selector || selector === '#') {
46      let hrefAttribute = element.getAttribute('href'); // The only valid content that could double as a selector are IDs or classes,
47      // so everything starting with `#` or `.`. If a "real" URL is used as the selector,
48      // `document.querySelector` will rightfully complain it is invalid.
49      // See https://github.com/twbs/bootstrap/issues/32273
50
51      if (!hrefAttribute || !hrefAttribute.includes('#') && !hrefAttribute.startsWith('.')) {
52        return null;
53      } // Just in case some CMS puts out a full URL with the anchor appended
54
55
56      if (hrefAttribute.includes('#') && !hrefAttribute.startsWith('#')) {
57        hrefAttribute = `#${hrefAttribute.split('#')[1]}`;
58      }
59
60      selector = hrefAttribute && hrefAttribute !== '#' ? hrefAttribute.trim() : null;
61    }
62
63    return selector;
64  };
65
66  const getSelectorFromElement = element => {
67    const selector = getSelector(element);
68
69    if (selector) {
70      return document.querySelector(selector) ? selector : null;
71    }
72
73    return null;
74  };
75
76  const getElementFromSelector = element => {
77    const selector = getSelector(element);
78    return selector ? document.querySelector(selector) : null;
79  };
80
81  const getTransitionDurationFromElement = element => {
82    if (!element) {
83      return 0;
84    } // Get transition-duration of the element
85
86
87    let {
88      transitionDuration,
89      transitionDelay
90    } = window.getComputedStyle(element);
91    const floatTransitionDuration = Number.parseFloat(transitionDuration);
92    const floatTransitionDelay = Number.parseFloat(transitionDelay); // Return 0 if element or transition duration is not found
93
94    if (!floatTransitionDuration && !floatTransitionDelay) {
95      return 0;
96    } // If multiple durations are defined, take the first
97
98
99    transitionDuration = transitionDuration.split(',')[0];
100    transitionDelay = transitionDelay.split(',')[0];
101    return (Number.parseFloat(transitionDuration) + Number.parseFloat(transitionDelay)) * MILLISECONDS_MULTIPLIER;
102  };
103
104  const triggerTransitionEnd = element => {
105    element.dispatchEvent(new Event(TRANSITION_END));
106  };
107
108  const isElement$1 = object => {
109    if (!object || typeof object !== 'object') {
110      return false;
111    }
112
113    if (typeof object.jquery !== 'undefined') {
114      object = object[0];
115    }
116
117    return typeof object.nodeType !== 'undefined';
118  };
119
120  const getElement = object => {
121    // it's a jQuery object or a node element
122    if (isElement$1(object)) {
123      return object.jquery ? object[0] : object;
124    }
125
126    if (typeof object === 'string' && object.length > 0) {
127      return document.querySelector(object);
128    }
129
130    return null;
131  };
132
133  const isVisible = element => {
134    if (!isElement$1(element) || element.getClientRects().length === 0) {
135      return false;
136    }
137
138    const elementIsVisible = getComputedStyle(element).getPropertyValue('visibility') === 'visible'; // Handle `details` element as its content may falsie appear visible when it is closed
139
140    const closedDetails = element.closest('details:not([open])');
141
142    if (!closedDetails) {
143      return elementIsVisible;
144    }
145
146    if (closedDetails !== element) {
147      const summary = element.closest('summary');
148
149      if (summary && summary.parentNode !== closedDetails) {
150        return false;
151      }
152
153      if (summary === null) {
154        return false;
155      }
156    }
157
158    return elementIsVisible;
159  };
160
161  const isDisabled = element => {
162    if (!element || element.nodeType !== Node.ELEMENT_NODE) {
163      return true;
164    }
165
166    if (element.classList.contains('disabled')) {
167      return true;
168    }
169
170    if (typeof element.disabled !== 'undefined') {
171      return element.disabled;
172    }
173
174    return element.hasAttribute('disabled') && element.getAttribute('disabled') !== 'false';
175  };
176
177  const findShadowRoot = element => {
178    if (!document.documentElement.attachShadow) {
179      return null;
180    } // Can find the shadow root otherwise it'll return the document
181
182
183    if (typeof element.getRootNode === 'function') {
184      const root = element.getRootNode();
185      return root instanceof ShadowRoot ? root : null;
186    }
187
188    if (element instanceof ShadowRoot) {
189      return element;
190    } // when we don't find a shadow root
191
192
193    if (!element.parentNode) {
194      return null;
195    }
196
197    return findShadowRoot(element.parentNode);
198  };
199
200  const noop = () => {};
201  /**
202   * Trick to restart an element's animation
203   *
204   * @param {HTMLElement} element
205   * @return void
206   *
207   * @see https://www.charistheo.io/blog/2021/02/restart-a-css-animation-with-javascript/#restarting-a-css-animation
208   */
209
210
211  const reflow = element => {
212    element.offsetHeight; // eslint-disable-line no-unused-expressions
213  };
214
215  const getjQuery = () => {
216    if (window.jQuery && !document.body.hasAttribute('data-bs-no-jquery')) {
217      return window.jQuery;
218    }
219
220    return null;
221  };
222
223  const DOMContentLoadedCallbacks = [];
224
225  const onDOMContentLoaded = callback => {
226    if (document.readyState === 'loading') {
227      // add listener on the first call when the document is in loading state
228      if (!DOMContentLoadedCallbacks.length) {
229        document.addEventListener('DOMContentLoaded', () => {
230          for (const callback of DOMContentLoadedCallbacks) {
231            callback();
232          }
233        });
234      }
235
236      DOMContentLoadedCallbacks.push(callback);
237    } else {
238      callback();
239    }
240  };
241
242  const isRTL = () => document.documentElement.dir === 'rtl';
243
244  const defineJQueryPlugin = plugin => {
245    onDOMContentLoaded(() => {
246      const $ = getjQuery();
247      /* istanbul ignore if */
248
249      if ($) {
250        const name = plugin.NAME;
251        const JQUERY_NO_CONFLICT = $.fn[name];
252        $.fn[name] = plugin.jQueryInterface;
253        $.fn[name].Constructor = plugin;
254
255        $.fn[name].noConflict = () => {
256          $.fn[name] = JQUERY_NO_CONFLICT;
257          return plugin.jQueryInterface;
258        };
259      }
260    });
261  };
262
263  const execute = callback => {
264    if (typeof callback === 'function') {
265      callback();
266    }
267  };
268
269  const executeAfterTransition = (callback, transitionElement, waitForTransition = true) => {
270    if (!waitForTransition) {
271      execute(callback);
272      return;
273    }
274
275    const durationPadding = 5;
276    const emulatedDuration = getTransitionDurationFromElement(transitionElement) + durationPadding;
277    let called = false;
278
279    const handler = ({
280      target
281    }) => {
282      if (target !== transitionElement) {
283        return;
284      }
285
286      called = true;
287      transitionElement.removeEventListener(TRANSITION_END, handler);
288      execute(callback);
289    };
290
291    transitionElement.addEventListener(TRANSITION_END, handler);
292    setTimeout(() => {
293      if (!called) {
294        triggerTransitionEnd(transitionElement);
295      }
296    }, emulatedDuration);
297  };
298  /**
299   * Return the previous/next element of a list.
300   *
301   * @param {array} list    The list of elements
302   * @param activeElement   The active element
303   * @param shouldGetNext   Choose to get next or previous element
304   * @param isCycleAllowed
305   * @return {Element|elem} The proper element
306   */
307
308
309  const getNextActiveElement = (list, activeElement, shouldGetNext, isCycleAllowed) => {
310    const listLength = list.length;
311    let index = list.indexOf(activeElement); // if the element does not exist in the list return an element
312    // depending on the direction and if cycle is allowed
313
314    if (index === -1) {
315      return !shouldGetNext && isCycleAllowed ? list[listLength - 1] : list[0];
316    }
317
318    index += shouldGetNext ? 1 : -1;
319
320    if (isCycleAllowed) {
321      index = (index + listLength) % listLength;
322    }
323
324    return list[Math.max(0, Math.min(index, listLength - 1))];
325  };
326
327  /**
328   * --------------------------------------------------------------------------
329   * Bootstrap (v5.2.0): dom/event-handler.js
330   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
331   * --------------------------------------------------------------------------
332   */
333  /**
334   * Constants
335   */
336
337  const namespaceRegex = /[^.]*(?=\..*)\.|.*/;
338  const stripNameRegex = /\..*/;
339  const stripUidRegex = /::\d+$/;
340  const eventRegistry = {}; // Events storage
341
342  let uidEvent = 1;
343  const customEvents = {
344    mouseenter: 'mouseover',
345    mouseleave: 'mouseout'
346  };
347  const nativeEvents = new Set(['click', 'dblclick', 'mouseup', 'mousedown', 'contextmenu', 'mousewheel', 'DOMMouseScroll', 'mouseover', 'mouseout', 'mousemove', 'selectstart', 'selectend', 'keydown', 'ke

374    };
375  }
376
377  function bootstrapDelegationHandler(element, selector, fn) {
378    return function handler(event) {
379      const domElements = element.querySelectorAll(selector);
380
381      for (let {
382        target
383      } = event; target && target !== this; target = target.parentNode) {
384        for (const domElement of domElements) {
385          if (domElement !== target) {
386            continue;
387          }
388
389          hydrateObj(event, {
390            delegateTarget: target
391          });
392
393          if (handler.oneOff) {
394            EventHandler.off(element, event.type, selector, fn);
395          }
396
397          return fn.apply(target, [event]);
398        }
399      }
400    };
401  }
402
403  function findHandler(events, callable, delegationSelector = null) {
404    return Object.values(events).find(event => event.callable === callable && event.delegationSelector === delegationSelector);
405  }
406
407  function normalizeParameters(originalTypeEvent, handler, delegationFunction) {
408    const isDelegated = typeof handler === 'string'; // todo: tooltip passes `false` instead of selector, so we need to check
409
410    const callable = isDelegated ? delegationFunction : handler || delegationFunction;
411    let typeEvent = getTypeEvent(originalTypeEvent);
412
413    if (!nativeEvents.has(typeEvent)) {
414      typeEvent = originalTypeEvent;
415    }
416
417    return [isDelegated, callable, typeEvent];
418  }
419
420  function addHandler(element, originalTypeEvent, handler, delegationFunction, oneOff) {
421    if (typeof originalTypeEvent !== 'string' || !element) {
422      return;
423    }
424
425    let [isDelegated, callable, typeEvent] = normalizeParameters(originalTypeEvent, handler, delegationFunction); // in case of mouseenter or mouseleave wrap the handler within a function that checks for its DOM position
426    // this prevents the handler from being dispatched the same way as mouseover or mouseout does
427
428    if (originalTypeEvent in customEvents) {
429      const wrapFunction = fn => {
430        return function (event) {
431          if (!event.relatedTarget || event.relatedTarget !== event.delegateTarget && !event.delegateTarget.contains(event.relatedTarget)) {
432            return fn.call(this, event);
433          }
434        };
435      };
436
437      callable = wrapFunction(callable);
438    }
439
440    const events = getElementEvents(element);
441    const handlers = events[typeEvent] || (events[typeEvent] = {});
442    const previousFunction = findHandler(handlers, callable, isDelegated ? handler : null);
443
444    if (previousFunction) {
445      previousFunction.oneOff = previousFunction.oneOff && oneOff;
446      return;
447    }
448
449    const uid = makeEventUid(callable, originalTypeEvent.replace(namespaceRegex, ''));
450    const fn = isDelegated ? bootstrapDelegationHandler(element, handler, callable) : bootstrapHandler(element, callable);
451    fn.delegationSelector = isDelegated ? handler : null;
452    fn.callable = callable;
453    fn.oneOff = oneOff;
454    fn.uidEvent = uid;
455    handlers[uid] = fn;
456    element.addEventListener(typeEvent, fn, isDelegated);
457  }
458
459  function removeHandler(element, events, typeEvent, handler, delegationSelector) {
460    const fn = findHandler(events[typeEvent], handler, delegationSelector);
461
462    if (!fn) {
463      return;
464    }
465
466    element.removeEventListener(typeEvent, fn, Boolean(delegationSelector));
467    delete events[typeEvent][fn.uidEvent];
468  }
469
470  function removeNamespacedHandlers(element, events, typeEvent, namespace) {
471    const storeElementEvent = events[typeEvent] || {};
472
473    for (const handlerKey of Object.keys(storeElementEvent)) {
474      if (handlerKey.includes(namespace)) {
475        const event = storeElementEvent[handlerKey];
476        removeHandler(element, events, typeEvent, event.callable, event.delegationSelector);
477      }
478    }
479  }
480
481  function getTypeEvent(event) {
482    // allow to get the native events from namespaced events ('click.bs.button' --> 'click')
483    event = event.replace(stripNameRegex, '');
484    return customEvents[event] || event;
485  }
486
487  const EventHandler = {
488    on(element, event, handler, delegationFunction) {
489      addHandler(element, event, handler, delegationFunction, false);
490    },
491
492    one(element, event, handler, delegationFunction) {
493      addHandler(element, event, handler, delegationFunction, true);
494    },
495
496    off(element, originalTypeEvent, handler, delegationFunction) {
497      if (typeof originalTypeEvent !== 'string' || !element) {
498        return;
499      }
500
501      const [isDelegated, callable, typeEvent] = normalizeParameters(originalTypeEvent, handler, delegationFunction);
502      const inNamespace = typeEvent !== originalTypeEvent;
503      const events = getElementEvents(element);
504      const storeElementEvent = events[typeEvent] || {};
505      const isNamespace = originalTypeEvent.startsWith('.');
506
507      if (typeof callable !== 'undefined') {
508        // Simplest case: handler is passed, remove that listener ONLY.
509        if (!Object.keys(storeElementEvent).length) {
510          return;
511        }
512
513        removeHandler(element, events, typeEvent, callable, isDelegated ? handler : null);
514        return;
515      }
516
517      if (isNamespace) {

518        for (const elementEvent of Object.keys(events)) {
519          removeNamespacedHandlers(element, events, elementEvent, originalTypeEvent.slice(1));
520        }
521      }
522
523      for (const keyHandlers of Object.keys(storeElementEvent)) {
524        const handlerKey = keyHandlers.replace(stripUidRegex, '');
525
526        if (!inNamespace || originalTypeEvent.includes(handlerKey)) {
527          const event = storeElementEvent[keyHandlers];
528          removeHandler(element, events, typeEvent, event.callable, event.delegationSelector);
529        }
530      }
531    },
532
533    trigger(element, event, args) {
534      if (typeof event !== 'string' || !element) {
535        return null;
536      }
537
538      const $ = getjQuery();
539      const typeEvent = getTypeEvent(event);
540      const inNamespace = event !== typeEvent;
541      let jQueryEvent = null;
542      let bubbles = true;
543      let nativeDispatch = true;
544      let defaultPrevented = false;
545
546      if (inNamespace && $) {
547        jQueryEvent = $.Event(event, args);
548        $(element).trigger(jQueryEvent);
549        bubbles = !jQueryEvent.isPropagationStopped();
550        nativeDispatch = !jQueryEvent.isImmediatePropagationStopped();
551        defaultPrevented = jQueryEvent.isDefaultPrevented();
552      }
553
554      let evt = new Event(event, {
555        bubbles,
556        cancelable: true
557      });
558      evt = hydrateObj(evt, args);
559
560      if (defaultPrevented) {
561        evt.preventDefault();
562      }
563
564      if (nativeDispatch) {
565        element.dispatchEvent(evt);
566      }
567
568      if (evt.defaultPrevented && jQueryEvent) {
569        jQueryEvent.preventDefault();
570      }
571
572      return evt;
573    }
574
575  };
576
577  function hydrateObj(obj, meta) {
578    for (const [key, value] of Object.entries(meta || {})) {
579      try {
580        obj[key] = value;
581      } catch (_unused) {
582        Object.defineProperty(obj, key, {
583          configurable: true,
584
585          get() {
586            return value;
587          }
588
589        });
590      }
591    }
592
593    return obj;
594  }
595
596  /**
597   * --------------------------------------------------------------------------
598   * Bootstrap (v5.2.0): dom/data.js
599   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
600   * --------------------------------------------------------------------------
601   */
602
603  /**
604   * Constants
605   */
606  const elementMap = new Map();
607  const Data = {
608    set(element, key, instance) {
609      if (!elementMap.has(element)) {
610        elementMap.set(element, new Map());
611      }
612
613      const instanceMap = elementMap.get(element); // make it clear we only want one instance per element
614      // can be removed later when multiple key/instances are fine to be used
615
616      if (!instanceMap.has(key) && instanceMap.size !== 0) {
617        // eslint-disable-next-line no-console
618        console.error(`Bootstrap doesn't allow more than one instance per element. Bound instance: ${Array.from(instanceMap.keys())[0]}.`);
619        return;
620      }
621
622      instanceMap.set(key, instance);
623    },
624
625    get(element, key) {
626      if (elementMap.has(element)) {
627        return elementMap.get(element).get(key) || null;
628      }
629
630      return null;
631    },
632
633    remove(element, key) {
634      if (!elementMap.has(element)) {
635        return;
636      }
637
638      const instanceMap = elementMap.get(element);
639      instanceMap.delete(key); // free up element references if there are no instances left for an element
640
641      if (instanceMap.size === 0) {
642        elementMap.delete(element);
643      }
644    }
645
646  };
647
648  /**
649   * --------------------------------------------------------------------------
650   * Bootstrap (v5.2.0): dom/manipulator.js
651   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
652   * --------------------------------------------------------------------------
653   */
654  function normalizeData(value) {
655    if (value === 'true') {
656      return true;
657    }
658
659    if (value === 'false') {
660      return false;
661    }
662
663    if (value === Number(value).toString()) {
664      return Number(value);
665    }
666
667    if (value === '' || value === 'null') {
668      return null;
669    }
670
671    if (typeof value !== 'string') {
672      return value;
673    }
674
675    try {
676      return JSON.parse(decodeURIComponent(value));
677    } catch (_unused) {
678      return value;
679    }
680  }
681
682  function normalizeDataKey(key) {
683    return key.replace(/[A-Z]/g, chr => `-${chr.toLowerCase()}`);
684  }
685
686  const Manipulator = {
687    setDataAttribute(element, key, value) {
688      element.setAttribute(`data-bs-${normalizeDataKey(key)}`, value);
689    },
690
691    removeDataAttribute(element, key) {
692      element.removeAttribute(`data-bs-${normalizeDataKey(key)}`);
693    },
694
695    getDataAttributes(element) {
696      if (!element) {
697        return {};
698      }
699
700      const attributes = {};
701      const bsKeys = Object.keys(element.dataset).filter(key => key.startsWith('bs') && !key.startsWith('bsConfig'));
702
703      for (const key of bsKeys) {
704        let pureKey = key.replace(/^bs/, '');
705        pureKey = pureKey.charAt(0).toLowerCase() + pureKey.slice(1, pureKey.length);
706        attributes[pureKey] = normalizeData(element.dataset[key]);
707      }
708
709      return attributes;
710    },
711
712    getDataAttribute(element, key) {
713      return normalizeData(element.getAttribute(`data-bs-${normalizeDataKey(key)}`));
714    }
715
716  };
717
718  /**
719   * --------------------------------------------------------------------------
720   * Bootstrap (v5.2.0): util/config.js
721   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
722   * --------------------------------------------------------------------------
723   */
724  /**
725   * Class definition
726   */
727
728  class Config {
729    // Getters
730    static get Default() {
731      return {};
732    }
733
734    static get DefaultType() {
735      return {};
736    }
737
738    static get NAME() {
739      throw new Error('You have to implement the static method "NAME", for each component!');
740    }
741
742    _getConfig(config) {
743      config = this._mergeConfigObj(config);
744      config = this._configAfterMerge(config);
745
746      this._typeCheckConfig(config);
747
748      return config;
749    }
750
751    _configAfterMerge(config) {
752      return config;
753    }
754
755    _mergeConfigObj(config, element) {
756      const jsonConfig = isElement$1(element) ? Manipulator.getDataAttribute(element, 'config') : {}; // try to parse
757
758      return { ...this.constructor.Default,
759        ...(typeof jsonConfig === 'object' ? jsonConfig : {}),
760        ...(isElement$1(element) ? Manipulator.getDataAttributes(element) : {}),
761        ...(typeof config === 'object' ? config : {})
762      };
763    }
764
765    _typeCheckConfig(config, configTypes = this.constructor.DefaultType) {
766      for (const property of Object.keys(configTypes)) {
767        const expectedTypes = configTypes[property];
768        const value = config[property];
769        const valueType = isElement$1(value) ? 'element' : toType(value);
770
771        if (!new RegExp(expectedTypes).test(valueType)) {
772          throw new TypeError(`${this.constructor.NAME.toUpperCase()}: Option "${property}" provided type "${valueType}" but expected type "${expectedTypes}".`);
773        }
774      }
775    }
776
777  }
778
779  /**
780   * --------------------------------------------------------------------------
781   * Bootstrap (v5.2.0): base-component.js
782   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
783   * --------------------------------------------------------------------------
784   */
785  /**
786   * Constants
787   */
788
789  const VERSION = '5.2.0';
790  /**
791   * Class definition
792   */
793
794  class BaseComponent extends Config {
795    constructor(element, config) {
796      super();
797      element = getElement(element);
798
799      if (!element) {
800        return;
801      }
802
803      this._element = element;
804      this._config = this._getConfig(config);
805      Data.set(this._element, this.constructor.DATA_KEY, this);
806    } // Public
807
808
809    dispose() {
810      Data.remove(this._element, this.constructor.DATA_KEY);
811      EventHandler.off(this._element, this.constructor.EVENT_KEY);
812

813      for (const propertyName of Object.getOwnPropertyNames(this)) {
814        this[propertyName] = null;
815      }
816    }
817
818    _queueCallback(callback, element, isAnimated = true) {
819      executeAfterTransition(callback, element, isAnimated);
820    }
821
822    _getConfig(config) {
823      config = this._mergeConfigObj(config, this._element);
824      config = this._configAfterMerge(config);
825
826      this._typeCheckConfig(config);
827
828      return config;
829    } // Static
830
831
832    static getInstance(element) {
833      return Data.get(getElement(element), this.DATA_KEY);
834    }
835
836    static getOrCreateInstance(element, config = {}) {
837      return this.getInstance(element) || new this(element, typeof config === 'object' ? config : null);
838    }
839
840    static get VERSION() {
841      return VERSION;
842    }
843
844    static get DATA_KEY() {
845      return `bs.${this.NAME}`;
846    }
847
848    static get EVENT_KEY() {
849      return `.${this.DATA_KEY}`;
850    }
851
852    static eventName(name) {
853      return `${name}${this.EVENT_KEY}`;
854    }
855
856  }
857
858  /**
859   * --------------------------------------------------------------------------
860   * Bootstrap (v5.2.0): util/component-functions.js
861   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
862   * --------------------------------------------------------------------------
863   */
864
865  const enableDismissTrigger = (component, method = 'hide') => {
866    const clickEvent = `click.dismiss${component.EVENT_KEY}`;
867    const name = component.NAME;
868    EventHandler.on(document, clickEvent, `[data-bs-dismiss="${name}"]`, function (event) {
869      if (['A', 'AREA'].includes(this.tagName)) {
870        event.preventDefault();
871      }
872
873      if (isDisabled(this)) {
874        return;
875      }
876
877      const target = getElementFromSelector(this) || this.closest(`.${name}`);
878      const instance = component.getOrCreateInstance(target); // Method argument is left, for Alert and only, as it doesn't implement the 'hide' method
879
880      instance[method]();
881    });
882  };
883
884  /**
885   * --------------------------------------------------------------------------
886   * Bootstrap (v5.2.0): alert.js
887   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
888   * --------------------------------------------------------------------------
889   */
890  /**
891   * Constants
892   */
893
894  const NAME$f = 'alert';
895  const DATA_KEY$a = 'bs.alert';
896  const EVENT_KEY$b = `.${DATA_KEY$a}`;
897  const EVENT_CLOSE = `close${EVENT_KEY$b}`;
898  const EVENT_CLOSED = `closed${EVENT_KEY$b}`;
899  const CLASS_NAME_FADE$5 = 'fade';
900  const CLASS_NAME_SHOW$8 = 'show';
901  /**
902   * Class definition
903   */
904
905  class Alert extends BaseComponent {
906    // Getters
907    static get NAME() {
908      return NAME$f;
909    } // Public
910
911
912    close() {
913      const closeEvent = EventHandler.trigger(this._element, EVENT_CLOSE);
914
915      if (closeEvent.defaultPrevented) {
916        return;
917      }
918
919      this._element.classList.remove(CLASS_NAME_SHOW$8);
920
921      const isAnimated = this._element.classList.contains(CLASS_NAME_FADE$5);
922
923      this._queueCallback(() => this._destroyElement(), this._element, isAnimated);
924    } // Private
925
926
927    _destroyElement() {
928      this._element.remove();
929
930      EventHandler.trigger(this._element, EVENT_CLOSED);
931      this.dispose();
932    } // Static
933
934
935    static jQueryInterface(config) {
936      return this.each(function () {
937        const data = Alert.getOrCreateInstance(this);
938
939        if (typeof config !== 'string') {
940          return;
941        }
942
943        if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {
944          throw new TypeError(`No method named "${config}"`);
945        }
946
947        data[config](this);
948      });
949    }
950
951  }
952  /**
953   * Data API implementation
954   */
955
956
957  enableDismissTrigger(Alert, 'close');
958  /**
959   * jQuery
960   */
961
962  defineJQueryPlugin(Alert);
963
964  /**
965   * --------------------------------------------------------------------------
966   * Bootstrap (v5.2.0): button.js
967   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
968   * --------------------------------------------------------------------------
969   */
970  /**
971   * Constants
972   */
973
974  const NAME$e = 'button';
975  const DATA_KEY$9 = 'bs.button';
976  const EVENT_KEY$a = `.${DATA_KEY$9}`;
977  const DATA_API_KEY$6 = '.data-api';
978  const CLASS_NAME_ACTIVE$3 = 'active';
979  const SELECTOR_DATA_TOGGLE$5 = '[data-bs-toggle="button"]';
980  const EVENT_CLICK_DATA_API$6 = `click${EVENT_KEY$a}${DATA_API_KEY$6}`;
981  /**
982   * Class definition
983   */
984
985  class Button extends BaseComponent {
986    // Getters
987    static get NAME() {
988      return NAME$e;
989    } // Public
990
991
992    toggle() {
993      // Toggle class and sync the `aria-pressed` attribute with the return value of the `.toggle(

1291    // TODO:v6 remove boolean support
1292    keyboard: 'boolean',
1293    pause: '(string|boolean)',
1294    ride: '(boolean|string)',
1295    touch: 'boolean',
1296    wrap: 'boolean'
1297  };
1298  /**
1299   * Class definition
1300   */
1301
1302  class Carousel extends BaseComponent {
1303    constructor(element, config) {
1304      super(element, config);
1305      this._interval = null;
1306      this._activeElement = null;
1307      this._isSliding = false;
1308      this.touchTimeout = null;
1309      this._swipeHelper = null;
1310      this._indicatorsElement = SelectorEngine.findOne(SELECTOR_INDICATORS, this._element);
1311
1312      this._addEventListeners();
1313
1314      if (this._config.ride === CLASS_NAME_CAROUSEL) {
1315        this.cycle();
1316      }
1317    } // Getters
1318
1319
1320    static get Default() {
1321      return Default$b;
1322    }
1323
1324    static get DefaultType() {
1325      return DefaultType$b;
1326    }
1327
1328    static get NAME() {
1329      return NAME$c;
1330    } // Public
1331
1332
1333    next() {
1334      this._slide(ORDER_NEXT);
1335    }
1336
1337    nextWhenVisible() {
1338      // FIXME TODO use `document.visibilityState`
1339      // Don't call next when the page isn't visible
1340      // or the carousel or its parent isn't visible
1341      if (!document.hidden && isVisible(this._element)) {
1342        this.next();
1343      }
1344    }
1345
1346    prev() {
1347      this._slide(ORDER_PREV);
1348    }
1349
1350    pause() {
1351      if (this._isSliding) {
1352        triggerTransitionEnd(this._element);
1353      }
1354
1355      this._clearInterval();
1356    }
1357
1358    cycle() {
1359      this._clearInterval();
1360
1361      this._updateInterval();
1362
1363      this._interval = setInterval(() => this.nextWhenVisible(), this._config.interval);
1364    }
1365
1366    _maybeEnableCycle() {
1367      if (!this._config.ride) {
1368        return;
1369      }
1370
1371      if (this._isSliding) {
1372        EventHandler.one(this._element, EVENT_SLID, () => this.cycle());
1373        return;
1374      }
1375
1376      this.cycle();
1377    }
1378
1379    to(index) {
1380      const items = this._getItems();
1381
1382      if (index > items.length - 1 || index < 0) {
1383        return;
1384      }
1385
1386      if (this._isSliding) {
1387        EventHandler.one(this._element, EVENT_SLID, () => this.to(index));
1388        return;
1389      }
1390
1391      const activeIndex = this._getItemIndex(this._getActive());
1392
1393      if (activeIndex === index) {
1394        return;
1395      }
1396
1397      const order = index > activeIndex ? ORDER_NEXT : ORDER_PREV;
1398
1399      this._slide(order, items[index]);
1400    }
1401
1402    dispose() {
1403      if (this._swipeHelper) {
1404        this._swipeHelper.dispose();
1405      }
1406
1407      super.dispose();
1408    } // Private
1409
1410
1411    _configAfterMerge(config) {
1412      config.defaultInterval = config.interval;
1413      return config;
1414    }
1415
1416    _addEventListeners() {
1417      if (this._config.keyboard) {
1418        EventHandler.on(this._element, EVENT_KEYDOWN$1, event => this._keydown(event));
1419      }
1420
1421      if (this._config.pause === 'hover') {
1422        EventHandler.on(this._element, EVENT_MOUSEENTER$1, () => this.pause());
1423        EventHandler.on(this._element, EVENT_MOUSELEAVE$1, () => this._maybeEnableCycle());
1424      }
1425
1426      if (this._config.touch && Swipe.isSupported()) {
1427        this._addTouchEventListeners();
1428      }
1429    }
1430
1431    _addTouchEventListeners() {
1432      for (const img of SelectorEngine.find(SELECTOR_ITEM_IMG, this._element)) {
1433        EventHandler.on(img, EVENT_DRAG_START, event => event.preventDefault());
1434      }
1435
1436      const endCallBack = () => {
1437        if (this._config.pause !== 'hover') {
1438          return;
1439        } // If it's a touch-enabled device, mouseenter/leave are fired as
1440        // part of the mouse compatibility events on first tap - the carousel
1441        // would stop cycling until user tapped out of it;
1442        // here, we listen for touchend, explicitly pause the carousel
1443        // (as if it's the second time we tap on it, mouseenter compat event
1444        // is NOT fired) and after a timeout (to allow for mouse compatibility
1445        // events to fire) we explicitly restart cycling
1446
1447
1448        this.pause();
1449
1450        if (this.touchTimeout) {
1451          clearTimeout(this.touchTimeout);
1452        }
1453
1454        this.touchTimeout = setTimeout(() => this._maybeEnableCycle(), TOUCHEVENT_COMPAT_WAIT + this._config.interval);
1455      };
1456
1457      const swipeConfig = {
1458        leftCallback: () => this._slide(this._directionToOrder(DIRECTION_LEFT)),
1459        rightCallback: () => this._slide(this._directionToOrder(DIRECTION_RIGHT)),
1460        endCallback: endCallBack
1461      };
1462      this._swipeHelper = new Swipe(this._element, swipeConfig);
1463    }
1464
1465    _keydown(event) {
1466      if (/input|textarea/i.test(event.target.tagName)) {
1467        return;
1468      }
1469
1470      const direction = KEY_TO_DIRECTION[event.key];
1471
1472      if (direction) {
1473        event.preventDefault();
1474
1475        this._slide(this._directionToOrder(direction));
1476      }
1477    }
1478
1479    _getItemIndex(element) {
1480      return this._getItems().indexOf(element);
1481    }
1482
1483    _setActiveIndicatorElement(index) {
1484      if (!this._indicatorsElement) {
1485        return;
1486      }
1487
1488      const activeIndicator = SelectorEngine.findOne(SELECTOR_ACTIVE, this._indicatorsElement);
1489      activeIndicator.classList.remove(CLASS_NAME_ACTIVE$2);
1490      activeIndicator.removeAttribute('aria-current');
1491      const newActiveIndicator = SelectorEngine.findOne(`[data-bs-slide-to="${index}"]`, this._indicatorsElement);
1492
1493      if (newActiveIndicator) {
1494        newActiveIndicator.classList.add(CLASS_NAME_ACTIVE$2);
1495        newActiveIndicator.setAttribute('aria-current', 'true');
1496      }
1497    }
1498
1499    _updateInterval() {
1500      const element = this._activeElement || this._getActive();
1501
1502      if (!element) {
1503        return;
1504      }
1505
1506      const elementInterval = Number.parseInt(element.getAttribute('data-bs-interval'), 10);
1507      this._config.interval = elementInterval || this._config.defaultInterval;
1508    }
1509
1510    _slide(order, element = null) {
1511      if (this._isSliding) {
1512        return;
1513      }
1514
1515      const activeElement = this._getActive();
1516
1517      const isNext = order === ORDER_NEXT;
1518      const nextElement = element || getNextActiveElement(this._getItems(), activeElement, isNext, this._config.wrap);
1519
1520      if (nextElement === activeElement) {
1521        return;
1522      }
1523
1524      const nextElementIndex = this._getItemIndex(nextElement);
1525
1526      const triggerEvent = eventName => {
1527        return EventHandler.trigger(this._element, eventName, {
1528          relatedTarget: nextElement,
1529          direction: this._orderToDirection(order),
1530          from: this._getItemIndex(activeElement),
1531          to: nextElementIndex
1532        });
1533      };
1534
1535      const slideEvent = triggerEvent(EVENT_SLIDE);
1536
1537      if (slideEvent.defaultPrevented) {
1538        return;
1539      }
1540
1541      if (!activeElement || !nextElement) {
1542        // Some weirdness is happening, so we bail
1543        // todo: change tests that use empty divs to avoid this check
1544        return;
1545      }
1546
1547      const isCycling = Boolean(this._interval);
1548      this.pause();
1549      this._isSliding = true;
1550
1551      this._setActiveIndicatorElement(nextElementIndex);
1552
1553      this._activeElement = nextElement;
1554      const directionalClassName = isNext ? CLASS_NAME_START : CLASS_NAME_END;
1555      const orderClassName = isNext ? CLASS_NAME_NEXT : CLASS_NAME_PREV;
1556      nextElement.classList.add(orderClassName);
1557      reflow(nextElement);
1558      activeElement.classList.add(directionalClassName);
1559      nextElement.classList.add(directionalClassName);
1560
1561      const completeCallBack = () => {
1562        nextElement.classList.remove(directionalClassName, orderClassName);
1563        nextElement.classList.add(CLASS_NAME_ACTIVE$2);
1564        activeElement.classList.remove(CLASS_NAME_ACTIVE$2, orderClassName, directionalClassName);
1565        this._isSliding = false;
1566        triggerEvent(EVENT_SLID);
1567      };
1568
1569      this._queueCallback(completeCallBack, activeElement, this._isAnimated());
1570
1571      if (isCycling) {
1572        this.cycle();
1573      }
1574    }
1575
1576    _isAnimated() {
1577      return this._element.classList.contains(CLASS_NAME_SLIDE);
1578    }
1579
1580    _getActive() {
1581      return SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element);
1582    }
1583
1584    _getItems() {
1585      return SelectorEngine.find(SELECTOR_ITEM, this._element);
1586    }
1587
1588    _clearInterval() {
1589      if (this._interval) {
1590        clearInterval(this._interval);
1591        this._interval = null;
1592      }
1593    }
1594
1595    _directionToOrder(direction) {
1596      if (isRTL()) {
1597        return direction === DIRECTION_LEFT ? ORDER_PREV : ORDER_NEXT;
1598      }
1599
1600      return direction === DIRECTION_LEFT ? ORDER_NEXT : ORDER_PREV;
1601    }
1602
1603    _orderToDirection(order) {
1604      if (isRTL()) {
1605        return order === ORDER_PREV ? DIRECTION_LEFT : DIRECTION_RIGHT;
1606      }
1607
1608      return order === ORDER_PREV ? DIRECTION_RIGHT : DIRECTION_LEFT;
1609    } // Static
1610
1611
1612    static jQueryInterface(config) {
1613      return this.each(function () {
1614        const data = Carousel.getOrCreateInstance(this, config);
1615
1616        if (typeof config === 'number') {
1617          data.to(config);
1618          return;
1619        }
1620
1621        if (typeof config === 'string') {
1622          if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {

1623            throw new TypeError(`No method named "${config}"`);
1624          }
1625
1626          data[config]();
1627        }
1628      });
1629    }
1630
1631  }
1632  /**
1633   * Data API implementation
1634   */
1635
1636
1637  EventHandler.on(document, EVENT_CLICK_DATA_API$5, SELECTOR_DATA_SLIDE, function (event) {
1638    const target = getElementFromSelector(this);
1639
1640    if (!target || !target.classList.contains(CLASS_NAME_CAROUSEL)) {
1641      return;
1642    }
1643
1644    event.preventDefault();
1645    const carousel = Carousel.getOrCreateInstance(target);
1646    const slideIndex = this.getAttribute('data-bs-slide-to');
1647
1648    if (slideIndex) {
1649      carousel.to(slideIndex);
1650
1651      carousel._maybeEnableCycle();
1652
1653      return;
1654    }
1655
1656    if (Manipulator.getDataAttribute(this, 'slide') === 'next') {
1657      carousel.next();
1658
1659      carousel._maybeEnableCycle();
1660
1661      return;
1662    }
1663
1664    carousel.prev();
1665
1666    carousel._maybeEnableCycle();
1667  });
1668  EventHandler.on(window, EVENT_LOAD_DATA_API$3, () => {
1669    const carousels = SelectorEngine.find(SELECTOR_DATA_RIDE);
1670
1671    for (const carousel of carousels) {

1672      Carousel.getOrCreateInstance(carousel);
1673    }
1674  });
1675  /**
1676   * jQuery
1677   */
1678
1679  defineJQueryPlugin(Carousel);
1680
1681  /**
1682   * --------------------------------------------------------------------------
1683   * Bootstrap (v5.2.0): collapse.js
1684   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
1685   * --------------------------------------------------------------------------
1686   */
1687  /**
1688   * Constants
1689   */
1690
1691  const NAME$b = 'collapse';
1692  const DATA_KEY$7 = 'bs.collapse';
1693  const EVENT_KEY$7 = `.${DATA_KEY$7}`;
1694  const DATA_API_KEY$4 = '.data-api';
1695  const EVENT_SHOW$6 = `show${EVENT_KEY$7}`;
1696  const EVENT_SHOWN$6 = `shown${EVENT_KEY$7}`;
1697  const EVENT_HIDE$6 = `hide${EVENT_KEY$7}`;
1698  const EVENT_HIDDEN$6 = `hidden${EVENT_KEY$7}`;
1699  const EVENT_CLICK_DATA_API$4 = `click${EVENT_KEY$7}${DATA_API_KEY$4}`;
1700  const CLASS_NAME_SHOW$7 = 'show';
1701  const CLASS_NAME_COLLAPSE = 'collapse';
1702  const CLASS_NAME_COLLAPSING = 'collapsing';
1703  const CLASS_NAME_COLLAPSED = 'collapsed';
1704  const CLASS_NAME_DEEPER_CHILDREN = `:scope .${CLASS_NAME_COLLAPSE} .${CLASS_NAME_COLLAPSE}`;
1705  const CLASS_NAME_HORIZONTAL = 'collapse-horizontal';
1706  const WIDTH = 'width';
1707  const HEIGHT = 'height';
1708  const SELECTOR_ACTIVES = '.collapse.show, .collapse.collapsing';
1709  const SELECTOR_DATA_TOGGLE$4 = '[data-bs-toggle="collapse"]';
1710  const Default$a = {
1711    parent: null,
1712    toggle: true
1713  };
1714  const DefaultType$a = {
1715    parent: '(null|element)',
1716    toggle: 'boolean'
1717  };
1718  /**
1719   * Class definition
1720   */
1721
1722  class Collapse extends BaseComponent {
1723    constructor(element, config) {
1724      super(element, config);
1725      this._isTransitioning = false;
1726      this._triggerArray = [];
1727      const toggleList = SelectorEngine.find(SELECTOR_DATA_TOGGLE$4);
1728
1729      for (const elem of toggleList) {
1730        const selector = getSelectorFromElement(elem);
1731        const filterElement = SelectorEngine.find(selector).filter(foundElement => foundElement === this._element);
1732
1733        if (selector !== null && filterElement.length) {
1734          this._triggerArray.push(elem);
1735        }
1736      }
1737
1738      this._initializeChildren();
1739
1740      if (!this._config.parent) {
1741        this._addAriaAndCollapsedClass(this._triggerArray, this._isShown());
1742      }
1743
1744      if (this._config.toggle) {
1745        this.toggle();
1746      }
1747    } // Getters
1748
1749
1750    static get Default() {
1751      return Default$a;
1752    }
1753
1754    static get DefaultType() {
1755      return DefaultType$a;
1756    }
1757
1758    static get NAME() {
1759      return NAME$b;
1760    } // Public
1761
1762
1763    toggle() {
1764      if (this._isShown()) {
1765        this.hide();
1766      } else {
1767        this.show();
1768      }
1769    }
1770
1771    show() {
1772      if (this._isTransitioning || this._isShown()) {
1773        return;
1774      }
1775
1776      let activeChildren = []; // find active children
1777
1778      if (this._config.parent) {
1779        activeChildren = this._getFirstLevelChildren(SELECTOR_ACTIVES).filter(element => element !== this._element).map(element => Collapse.getOrCreateInstance(element, {
1780          toggle: false
1781        }));
1782      }
1783
1784      if (activeChildren.length && activeChildren[0]._isTransitioning) {
1785        return;
1786      }
1787
1788      const startEvent = EventHandler.trigger(this._element, EVENT_SHOW$6);
1789
1790      if (startEvent.defaultPrevented) {
1791        return;
1792      }
1793
1794      for (const activeInstance of activeChildren) {
1795        activeInstance.hide();
1796      }
1797
1798      const dimension = this._getDimension();
1799
1800      this._element.classList.remove(CLASS_NAME_COLLAPSE);
1801
1802      this._element.classList.add(CLASS_NAME_COLLAPSING);
1803
1804      this._element.style[dimension] = 0;
1805
1806      this._addAriaAndCollapsedClass(this._triggerArray, true);
1807
1808      this._isTransitioning = true;
1809
1810      const complete = () => {
1811        this._isTransitioning = false;
1812
1813        this._element.classList.remove(CLASS_NAME_COLLAPSING);
1814
1815        this._element.classList.add(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW$7);
1816
1817        this._element.style[dimension] = '';
1818        EventHandler.trigger(this._element, EVENT_SHOWN$6);
1819      };
1820
1821      const capitalizedDimension = dimension[0].toUpperCase() + dimension.slice(1);
1822      const scrollSize = `scroll${capitalizedDimension}`;
1823
1824      this._queueCallback(complete, this._element, true);
1825
1826      this._element.style[dimension] = `${this._element[scrollSize]}px`;
1827    }
1828
1829    hide() {
1830      if (this._isTransitioning || !this._isShown()) {
1831        return;
1832      }
1833
1834      const startEvent = EventHandler.trigger(this._element, EVENT_HIDE$6);
1835
1836      if (startEvent.defaultPrevented) {
1837        return;
1838      }
1839
1840      const dimension = this._getDimension();
1841
1842      this._element.style[dimension] = `${this._element.getBoundingClientRect()[dimension]}px`;
1843      reflow(this._element);
1844
1845      this._element.classList.add(CLASS_NAME_COLLAPSING);
1846
1847      this._element.classList.remove(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW$7);
1848
1849      for (const trigger of this._triggerArray) {
1850        const element = getElementFromSelector(trigger);
1851
1852        if (element && !this._isShown(element)) {
1853          this._addAriaAndCollapsedClass([trigger], false);
1854        }
1855      }
1856
1857      this._isTransitioning = true;
1858
1859      const complete = () => {
1860        this._isTransitioning = false;
1861
1862        this._element.classList.remove(CLASS_NAME_COLLAPSING);
1863
1864        this._element.classList.add(CLASS_NAME_COLLAPSE);
1865
1866        EventHandler.trigger(this._element, EVENT_HIDDEN$6);
1867      };
1868
1869      this._element.style[dimension] = '';
1870
1871      this._queueCallback(complete, this._element, true);
1872    }
1873
1874    _isShown(element = this._element) {
1875      return element.classList.contains(CLASS_NAME_SHOW$7);
1876    } // Private
1877
1878
1879    _configAfterMerge(config) {
1880      config.toggle = Boolean(config.toggle); // Coerce string values
1881
1882      config.parent = getElement(config.parent);
1883      return config;
1884    }
1885
1886    _getDimension() {
1887      return this._element.classList.contains(CLASS_NAME_HORIZONTAL) ? WIDTH : HEIGHT;
1888    }
1889
1890    _initializeChildren() {
1891      if (!this._config.parent) {
1892        return;
1893      }
1894
1895      const children = this._getFirstLevelChildren(SELECTOR_DATA_TOGGLE$4);
1896
1897      for (const element of children) {
1898        const selected = getElementFromSelector(element);
1899
1900        if (selected) {
1901          this._addAriaAndCollapsedClass([element], this._isShown(selected));
1902        }
1903      }
1904    }
1905
1906    _getFirstLevelChildren(selector) {
1907      const children = SelectorEngine.find(CLASS_NAME_DEEPER_CHILDREN, this._config.parent); // remove children if greater depth
1908
1909      return SelectorEngine.find(selector, this._config.parent).filter(element => !children.includes(element));
1910    }
1911
1912    _addAriaAndCollapsedClass(triggerArray, isOpen) {
1913      if (!triggerArray.length) {
1914        return;
1915      }
1916
1917      for (const element of triggerArray) {
1918        element.classList.toggle(CLASS_NAME_COLLAPSED, !isOpen);
1919        element.setAttribute('aria-expanded', isOpen);
1920      }
1921    } // Static
1922
1923
1924    static jQueryInterface(config) {
1925      const _config = {};
1926
1927      if (typeof config === 'string' && /show|hide/.test(config)) {
1928        _config.toggle = false;
1929      }
1930
1931      return this.each(function () {
1932        const data = Collapse.getOrCreateInstance(this, _config);
1933
1934        if (typeof config === 'string') {
1935          if (typeof data[config] === 'undefined') {
1936            throw new TypeError(`No method named "${config}"`);
1937          }
1938
1939          data[config]();
1940        }
1941      });
1942    }
1943
1944  }
1945  /**
1946   * Data API implementation
1947   */
1948
1949
1950  EventHandler.on(document, EVENT_CLICK_DATA_API$4, SELECTOR_DATA_TOGGLE$4, function (event) {
1951    // preventDefault only for <a> elements (which change the URL) not inside the collapsible element
1952    if (event.target.tagName === 'A' || event.delegateTarget && event.delegateTarget.tagName === 'A') {
1953      event.preventDefault();
1954    }
1955
1956    const selector = getSelectorFromElement(this);
1957    const selectorElements = SelectorEngine.find(selector);
1958
1959    for (const element of selectorElements) {
1960      Collapse.getOrCreateInstance(element, {
1961        toggle: false
1962      }).toggle();
1963    }
1964  });
1965  /**
1966   * jQuery
1967   */
1968
1969  defineJQueryPlugin(Collapse);
1970
1971  var top = 'top';
1972  var bottom = 'bottom';
1973  var right = 'right';
1974  var left = 'left';
1975  var auto = 'auto';
1976  var basePlacements = [top, bottom, right, left];
1977  var start = 'start';
1978  var end = 'end';
1979  var clippingParents = 'clippingParents';
1980  var viewport = 'viewport';
1981  var popper = 'popper';
1982  var reference = 'reference';
1983  var variationPlacements = /*#__PURE__*/basePlacements.reduce(function (acc, placement) {
1984    return acc.concat([placement + "-" + start, placement + "-" + end]);
1985  }, []);
1986  var placements = /*#__PURE__*/[].concat(basePlacements, [auto]).reduce(function (acc, placement) {
1987    return acc.concat([placement, placement + "-" + start, placement + "-" + end]);
1988  }, []); // modifiers that need to read the DOM
1989
1990  var beforeRead = 'beforeRead';
1991  var read = 'read';
1992  var afterRead = 'afterRead'; // pure-logic modifiers
1993
1994  var beforeMain = 'beforeMain';
1995  var main = 'main';
1996  var afterMain = 'afterMain'; // modifier with the purpose to write to the DOM (or write into a framework state)
1997
1998  var beforeWrite = 'beforeWrite';
1999  var write = 'write';
2000  var afterWrite = 'afterWrite';
2001  var modifierPhases = [beforeRead, read, afterRead, beforeMain, main, afterMain, beforeWrite, write, afterWrite];
2002
2003  function getNodeName(element) {
2004    return element ? (element.nodeName || '').toLowerCase() : null;
2005  }
2006
2007  function getWindow(node) {
2008    if (node == null) {
2009      return window;
2010    }
2011
2012    if (node.toString() !== '[object Window]') {
2013      var ownerDocument = node.ownerDocument;
2014      return ownerDocument ? ownerDocument.defaultView || window : window;
2015    }
2016
2017    return node;
2018  }
2019
2020  function isElement(node) {
2021    var OwnElement = getWindow(node).Element;
2022    return node instanceof OwnElement || node instanceof Element;
2023  }
2024
2025  function isHTMLElement(node) {
2026    var OwnElement = getWindow(node).HTMLElement;
2027    return node instanceof OwnElement || node instanceof HTMLElement;
2028  }
2029
2030  function isShadowRoot(node) {
2031    // IE 11 has no ShadowRoot
2032    if (typeof ShadowRoot === 'undefined') {
2033      return false;
2034    }
2035
2036    var OwnElement = getWindow(node).ShadowRoot;
2037    return node instanceof OwnElement || node instanceof ShadowRoot;
2038  }
2039
2040  // and applies them to the HTMLElements such as popper and arrow
2041
2042  function applyStyles(_ref) {
2043    var state = _ref.state;

2044    Object.keys(state.elements).forEach(function (name) {
2045      var style = state.styles[name] || {};
2046      var attributes = state.attributes[name] || {};
2047      var element = state.elements[name]; // arrow is optional + virtual elements
2048
2049      if (!isHTMLElement(element) || !getNodeName(element)) {
2050        return;
2051      } // Flow doesn't support to extend this property, but it's the most
2052      // effective way to apply styles to an HTMLElement
2053      // $FlowFixMe[cannot-write]
2054
2055
2056      Object.assign(element.style, style);
2057      Object.keys(attributes).forEach(function (name) {
2058        var value = attributes[name];
2059
2060        if (value === false) {
2061          element.removeAttribute(name);
2062        } else {
2063          element.setAttribute(name, value === true ? '' : value);
2064        }
2065      });
2066    });
2067  }
2068
2069  function effect$2(_ref2) {
2070    var state = _ref2.state;
2071    var initialStyles = {
2072      popper: {
2073        position: state.options.strategy,
2074        left: '0',
2075        top: '0',
2076        margin: '0'
2077      },
2078      arrow: {
2079        position: 'absolute'
2080      },
2081      reference: {}
2082    };
2083    Object.assign(state.elements.popper.style, initialStyles.popper);
2084    state.styles = initialStyles;
2085
2086    if (state.elements.arrow) {
2087      Object.assign(state.elements.arrow.style, initialStyles.arrow);
2088    }
2089
2090    return function () {
2091      Object.keys(state.elements).forEach(function (name) {
2092        var element = state.elements[name];
2093        var attributes = state.attributes[name] || {};
2094        var styleProperties = Object.keys(state.styles.hasOwnProperty(name) ? state.styles[name] : initialStyles[name]); // Set all values to an empty string to unset them
2095
2096        var style = styleProperties.reduce(function (style, property) {
2097          style[property] = '';
2098          return style;
2099        }, {}); // arrow is optional + virtual elements
2100
2101        if (!isHTMLElement(element) || !getNodeName(element)) {
2102          return;
2103        }
2104
2105        Object.assign(element.style, style);
2106        Object.keys(attributes).forEach(function (attribute) {
2107          element.removeAttribute(attribute);
2108        });
2109      });
2110    };
2111  } // eslint-disable-next-line import/no-unused-modules
2112
2113
2114  const applyStyles$1 = {
2115    name: 'applyStyles',
2116    enabled: true,
2117    phase: 'write',
2118    fn: applyStyles,
2119    effect: effect$2,
2120    requires: ['computeStyles']
2121  };
2122
2123  function getBasePlacement(placement) {
2124    return placement.split('-')[0];
2125  }
2126
2127  var max = Math.max;
2128  var min = Math.min;
2129  var round = Math.round;
2130
2131  function getBoundingClientRect(element, includeScale) {
2132    if (includeScale === void 0) {
2133      includeScale = false;
2134    }
2135
2136    var rect = element.getBoundingClientRect();
2137    var scaleX = 1;
2138    var scaleY = 1;
2139
2140    if (isHTMLElement(element) && includeScale) {
2141      var offsetHeight = element.offsetHeight;
2142      var offsetWidth = element.offsetWidth; // Do not attempt to divide by 0, otherwise we get `Infinity` as scale
2143      // Fallback to 1 in case both values are `0`
2144
2145      if (offsetWidth > 0) {
2146        scaleX = round(rect.width) / offsetWidth || 1;
2147      }
2148
2149      if (offsetHeight > 0) {
2150        scaleY = round(rect.height) / offsetHeight || 1;
2151      }
2152    }
2153
2154    return {
2155      width: rect.width / scaleX,
2156      height: rect.height / scaleY,
2157      top: rect.top / scaleY,
2158      right: rect.right / scaleX,
2159      bottom: rect.bottom / scaleY,
2160      left: rect.left / scaleX,
2161      x: rect.left / scaleX,
2162      y: rect.top / scaleY
2163    };
2164  }
2165
2166  // means it doesn't take into account transforms.
2167
2168  function getLayoutRect(element) {
2169    var clientRect = getBoundingClientRect(element); // Use the clientRect sizes if it's not been transformed.
2170    // Fixes https://github.com/popperjs/popper-core/issues/1223
2171
2172    var width = element.offsetWidth;
2173    var height = element.offsetHeight;
2174
2175    if (Math.abs(clientRect.width - width) <= 1) {
2176      width = clientRect.width;
2177    }
2178
2179    if (Math.abs(clientRect.height - height) <= 1) {
2180      height = clientRect.height;
2181    }
2182
2183    return {
2184      x: element.offsetLeft,
2185      y: element.offsetTop,
2186      width: width,
2187      height: height
2188    };
2189  }
2190
2191  function contains(parent, child) {
2192    var rootNode = child.getRootNode && child.getRootNode(); // First, attempt with faster native method
2193
2194    if (parent.contains(child)) {
2195      return true;
2196    } // then fallback to custom implementation with Shadow DOM support
2197    else if (rootNode && isShadowRoot(rootNode)) {
2198        var next = child;
2199
2200        do {
2201          if (next && parent.isSameNode(next)) {
2202            return true;
2203          } // $FlowFixMe[prop-missing]: need a better way to handle this...
2204
2205
2206          next = next.parentNode || next.host;
2207        } while (next);
2208      } // Give up, the result is false
2209
2210
2211    return false;
2212  }
2213
2214  function getComputedStyle$1(element) {
2215    return getWindow(element).getComputedStyle(element);
2216  }
2217
2218  function isTableElement(element) {
2219    return ['table', 'td', 'th'].indexOf(getNodeName(element)) >= 0;
2220  }
2221
2222  function getDocumentElement(element) {
2223    // $FlowFixMe[incompatible-return]: assume body is always available
2224    return ((isElement(element) ? element.ownerDocument : // $FlowFixMe[prop-missing]
2225    element.document) || window.document).documentElement;
2226  }
2227
2228  function getParentNode(element) {
2229    if (getNodeName(element) === 'html') {
2230      return element;
2231    }
2232
2233    return (// this is a quicker (but less type safe) way to save quite some bytes from the bundle
2234      // $FlowFixMe[incompatible-return]
2235      // $FlowFixMe[prop-missing]
2236      element.assignedSlot || // step into the shadow DOM of the parent of a slotted node
2237      element.parentNode || ( // DOM Element detected
2238      isShadowRoot(element) ? element.host : null) || // ShadowRoot detected
2239      // $FlowFixMe[incompatible-call]: HTMLElement is a Node
2240      getDocumentElement(element) // fallback
2241
2242    );
2243  }
2244
2245  function getTrueOffsetParent(element) {
2246    if (!isHTMLElement(element) || // https://github.com/popperjs/popper-core/issues/837
2247    getComputedStyle$1(element).position === 'fixed') {
2248      return null;
2249    }
2250
2251    return element.offsetParent;
2252  } // `.offsetParent` reports `null` for fixed elements, while absolute elements
2253  // return the containing block
2254
2255
2256  function getContainingBlock(element) {
2257    var isFirefox = navigator.userAgent.toLowerCase().indexOf('firefox') !== -1;
2258    var isIE = navigator.userAgent.indexOf('Trident') !== -1;
2259
2260    if (isIE && isHTMLElement(element)) {
2261      // In IE 9, 10 and 11 fixed elements containing block is always established by the viewport
2262      var elementCss = getComputedStyle$1(element);
2263
2264      if (elementCss.position === 'fixed') {
2265        return null;
2266      }
2267    }
2268
2269    var currentNode = getParentNode(element);
2270
2271    if (isShadowRoot(currentNode)) {
2272      currentNode = currentNode.host;
2273    }
2274
2275    while (isHTMLElement(currentNode) && ['html', 'body'].indexOf(getNodeName(currentNode)) < 0) {
2276      var css = getComputedStyle$1(currentNode); // This is non-exhaustive but covers the most common CSS properties that
2277      // create a containing block.
2278      // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
2279
2280      if (css.transform !== 'none' || css.perspective !== 'none' || css.contain === 'paint' || ['transform', 'perspective'].indexOf(css.willChange) !== -1 || isFirefox && css.willChange === 'filter' || isFirefox && css.filter && css.filter !== 'none') {
2281        return currentNode;
2282      } else {
2283        currentNode = currentNode.parentNode;
2284      }
2285    }
2286
2287    return null;
2288  } // Gets the closest ancestor positioned element. Handles some edge cases,
2289  // such as table ancestors and cross browser bugs.
2290
2291
2292  function getOffsetParent(element) {
2293    var window = getWindow(element);
2294    var offsetParent = getTrueOffsetParent(element);
2295
2296    while (offsetParent && isTableElement(offsetParent) && getComputedStyle$1(offsetParent).position === 'static') {
2297      offsetParent = getTrueOffsetParent(offsetParent);
2298    }
2299
2300    if (offsetParent && (getNodeName(offsetParent) === 'html' || getNodeName(offsetParent) === 'body' && getComputedStyle$1(offsetParent).position === 'static')) {
2301      return window;
2302    }
2303
2304    return offsetParent || getContainingBlock(element) || window;
2305  }
2306
2307  function getMainAxisFromPlacement(placement) {
2308    return ['top', 'bottom'].indexOf(placement) >= 0 ? 'x' : 'y';
2309  }
2310
2311  function within(min$1, value, max$1) {
2312    return max(min$1, min(value, max$1));
2313  }
2314  function withinMaxClamp(min, value, max) {
2315    var v = within(min, value, max);
2316    return v > max ? max : v;
2317  }
2318
2319  function getFreshSideObject() {
2320    return {
2321      top: 0,
2322      right: 0,
2323      bottom: 0,
2324      left: 0
2325    };
2326  }
2327
2328  function mergePaddingObject(paddingObject) {
2329    return Object.assign({}, getFreshSideObject(), paddingObject);
2330  }
2331
2332  function expandToHashMap(value, keys) {
2333    return keys.reduce(function (hashMap, key) {
2334      hashMap[key] = value;
2335      return hashMap;
2336    }, {});
2337  }
2338
2339  var toPaddingObject = function toPaddingObject(padding, state) {
2340    padding = typeof padding === 'function' ? padding(Object.assign({}, state.rects, {
2341      placement: state.placement
2342    })) : padding;
2343    return mergePaddingObject(typeof padding !== 'number' ? padding : expandToHashMap(padding, basePlacements));
2344  };
2345
2346  function arrow(_ref) {
2347    var _state$modifiersData$;
2348
2349    var state = _ref.state,
2350        name = _ref.name,
2351        options = _ref.options;
2352    var arrowElement = state.elements.arrow;
2353    var popperOffsets = state.modifiersData.popperOffsets;
2354    var basePlacement = getBasePlacement(state.placement);
2355    var axis = getMainAxisFromPlacement(basePlacement);
2356    var isVertical = [left, right].indexOf(basePlacement) >= 0;
2357    var len = isVertical ? 'height' : 'width';
2358
2359    if (!arrowElement || !popperOffsets) {
2360      return;
2361    }
2362
2363    var paddingObject = toPaddingObject(options.padding, state);
2364    var arrowRect = getLayoutRect(arrowElement);
2365    var minProp = axis === 'y' ? top : left;
2366    var maxProp = axis === 'y' ? bottom : right;
2367    var endDiff = state.rects.reference[len] + state.rects.reference[axis] - popperOffsets[axis] - state.rects.popper[len];
2368    var startDiff = popperOffsets[axis] - state.rects.reference[axis];
2369    var arrowOffsetParent = getOffsetParent(arrowElement);
2370    var clientSize = arrowOffsetParent ? axis === 'y' ? arrowOffsetParent.clientHeight || 0 : arrowOffsetParent.clientWidth || 0 : 0;
2371    var centerToReference = endDiff / 2 - startDiff / 2; // Make sure the arrow doesn't overflow the popper if the center point is
2372    // outside of the popper bounds
2373
2374    var min = paddingObject[minProp];
2375    var max = clientSize - arrowRect[len] - paddingObject[maxProp];
2376    var center = clientSize / 2 - arrowRect[len] / 2 + centerToReference;
2377    var offset = within(min, center, max); // Prevents breaking syntax highlighting...
2378
2379    var axisProp = axis;
2380    state.modifiersData[name] = (_state$modifiersData$ = {}, _state$modifiersData$[axisProp] = offset, _state$modifiersData$.centerOffset = offset - center, _state$modifiersData$);
2381  }
2382
2383  function effect$1(_ref2) {
2384    var state = _ref2.state,
2385        options = _ref2.options;
2386    var _options$element = options.element,
2387        arrowElement = _options$element === void 0 ? '[data-popper-arrow]' : _options$element;
2388
2389    if (arrowElement == null) {
2390      return;
2391    } // CSS selector
2392
2393
2394    if (typeof arrowElement === 'string') {
2395      arrowElement = state.elements.popper.querySelector(arrowElement);
2396
2397      if (!arrowElement) {
2398        return;
2399      }
2400    }
2401
2402    if (!contains(state.elements.popper, arrowElement)) {
2403
2404      return;
2405    }
2406
2407    state.elements.arrow = arrowElement;
2408  } // eslint-disable-next-line import/no-unused-modules
2409
2410
2411  const arrow$1 = {
2412    name: 'arrow',
2413    enabled: true,
2414    phase: 'main',
2415    fn: arrow,
2416    effect: effect$1,
2417    requires: ['popperOffsets'],
2418    requiresIfExists: ['preventOverflow']
2419  };
2420
2421  function getVariation(placement) {
2422    return placement.split('-')[1];
2423  }
2424
2425  var unsetSides = {
2426    top: 'auto',
2427    right: 'auto',
2428    bottom: 'auto',
2429    left: 'auto'
2430  }; // Round the offsets to the nearest suitable subpixel based on the DPR.
2431  // Zooming can change the DPR, but it seems to report a value that will
2432  // cleanly divide the values into the appropriate subpixels.
2433
2434  function roundOffsetsByDPR(_ref) {
2435    var x = _ref.x,
2436        y = _ref.y;
2437    var win = window;
2438    var dpr = win.devicePixelRatio || 1;
2439    return {
2440      x: round(x * dpr) / dpr || 0,
2441      y: round(y * dpr) / dpr || 0
2442    };
2443  }
2444
2445  function mapToStyles(_ref2) {
2446    var _Object$assign2;
2447
2448    var popper = _ref2.popper,
2449        popperRect = _ref2.popperRect,
2450        placement = _ref2.placement,
2451        variation = _ref2.variation,
2452        offsets = _ref2.offsets,
2453        position = _ref2.position,
2454        gpuAcceleration = _ref2.gpuAcceleration,
2455        adaptive = _ref2.adaptive,
2456        roundOffsets = _ref2.roundOffsets,
2457        isFixed = _ref2.isFixed;
2458    var _offsets$x = offsets.x,
2459        x = _offsets$x === void 0 ? 0 : _offsets$x,
2460        _offsets$y = offsets.y,
2461        y = _offsets$y === void 0 ? 0 : _offsets$y;
2462
2463    var _ref3 = typeof roundOffsets === 'function' ? roundOffsets({

2464      x: x,
2465      y: y
2466    }) : {
2467      x: x,
2468      y: y
2469    };
2470
2471    x = _ref3.x;
2472    y = _ref3.y;
2473    var hasX = offsets.hasOwnProperty('x');
2474    var hasY = offsets.hasOwnProperty('y');
2475    var sideX = left;
2476    var sideY = top;
2477    var win = window;
2478
2479    if (adaptive) {
2480      var offsetParent = getOffsetParent(popper);
2481      var heightProp = 'clientHeight';
2482      var widthProp = 'clientWidth';
2483
2484      if (offsetParent === getWindow(popper)) {
2485        offsetParent = getDocumentElement(popper);
2486
2487        if (getComputedStyle$1(offsetParent).position !== 'static' && position === 'absolute') {
2488          heightProp = 'scrollHeight';
2489          widthProp = 'scrollWidth';
2490        }
2491      } // $FlowFixMe[incompatible-cast]: force type refinement, we compare offsetParent with window above, but Flow doesn't detect it
2492
2493
2494      offsetParent = offsetParent;
2495
2496      if (placement === top || (placement === left || placement === right) && variation === end) {
2497        sideY = bottom;
2498        var offsetY = isFixed && offsetParent === win && win.visualViewport ? win.visualViewport.height : // $FlowFixMe[prop-missing]
2499        offsetParent[heightProp];
2500        y -= offsetY - popperRect.height;
2501        y *= gpuAcceleration ? 1 : -1;
2502      }
2503
2504      if (placement === left || (placement === top || placement === bottom) && variation === end) {
2505        sideX = right;
2506        var offsetX = isFixed && offsetParent === win && win.visualViewport ? win.visualViewport.width : // $FlowFixMe[prop-missing]
2507        offsetParent[widthProp];
2508        x -= offsetX - popperRect.width;
2509        x *= gpuAcceleration ? 1 : -1;
2510      }
2511    }
2512
2513    var commonStyles = Object.assign({
2514      position: position
2515    }, adaptive && unsetSides);
2516
2517    var _ref4 = roundOffsets === true ? roundOffsetsByDPR({
2518      x: x,
2519      y: y
2520    }) : {
2521      x: x,
2522      y: y
2523    };
2524
2525    x = _ref4.x;
2526    y = _ref4.y;
2527
2528    if (gpuAcceleration) {
2529      var _Object$assign;
2530
2531      return Object.assign({}, commonStyles, (_Object$assign = {}, _Object$assign[sideY] = hasY ? '0' : '', _Object$assign[sideX] = hasX ? '0' : '', _Object$assign.transform = (win.devicePixelRatio || 1) <= 1 ? "translate(" + x + "px, " + y + "px)" : "translate3d(" + x + "px, " + y + "px, 0)", _Object$assign));
2532    }
2533
2534    return Object.assign({}, commonStyles, (_Object$assign2 = {}, _Object$assign2[sideY] = hasY ? y + "px" : '', _Object$assign2[sideX] = hasX ? x + "px" : '', _Object$assign2.transform = '', _Object$assign2));
2535  }
2536
2537  function computeStyles(_ref5) {
2538    var state = _ref5.state,
2539        options = _ref5.options;
2540    var _options$gpuAccelerat = options.gpuAcceleration,
2541        gpuAcceleration = _options$gpuAccelerat === void 0 ? true : _options$gpuAccelerat,
2542        _options$adaptive = options.adaptive,
2543        adaptive = _options$adaptive === void 0 ? true : _options$adaptive,
2544        _options$roundOffsets = options.roundOffsets,
2545        roundOffsets = _options$roundOffsets === void 0 ? true : _options$roundOffsets;
2546
2547    var commonStyles = {
2548      placement: getBasePlacement(state.placement),
2549      variation: getVariation(state.placement),
2550      popper: state.elements.popper,
2551      popperRect: state.rects.popper,
2552      gpuAcceleration: gpuAcceleration,
2553      isFixed: state.options.strategy === 'fixed'
2554    };
2555
2556    if (state.modifiersData.popperOffsets != null) {
2557      state.styles.popper = Object.assign({}, state.styles.popper, mapToStyles(Object.assign({}, commonStyles, {
2558        offsets: state.modifiersData.popperOffsets,
2559        position: state.options.strategy,
2560        adaptive: adaptive,
2561        roundOffsets: roundOffsets
2562      })));
2563    }
2564
2565    if (state.modifiersData.arrow != null) {
2566      state.styles.arrow = Object.assign({}, state.styles.arrow, mapToStyles(Object.assign({}, commonStyles, {
2567        offsets: state.modifiersData.arrow,
2568        position: 'absolute',
2569        adaptive: false,
2570        roundOffsets: roundOffsets
2571      })));
2572    }
2573
2574    state.attributes.popper = Object.assign({}, state.attributes.popper, {
2575      'data-popper-placement': state.placement
2576    });

2577  } // eslint-disable-next-line import/no-unused-modules
2578
2579
2580  const computeStyles$1 = {
2581    name: 'computeStyles',
2582    enabled: true,
2583    phase: 'beforeWrite',
2584    fn: computeStyles,
2585    data: {}
2586  };
2587
2588  var passive = {
2589    passive: true
2590  };
2591
2592  function effect(_ref) {
2593    var state = _ref.state,
2594        instance = _ref.instance,
2595        options = _ref.options;
2596    var _options$scroll = options.scroll,
2597        scroll = _options$scroll === void 0 ? true : _options$scroll,
2598        _options$resize = options.resize,
2599        resize = _options$resize === void 0 ? true : _options$resize;
2600    var window = getWindow(state.elements.popper);
2601    var scrollParents = [].concat(state.scrollParents.reference, state.scrollParents.popper);
2602
2603    if (scroll) {
2604      scrollParents.forEach(function (scrollParent) {
2605        scrollParent.addEventListener('scroll', instance.update, passive);
2606      });
2607    }
2608
2609    if (resize) {
2610      window.addEventListener('resize', instance.update, passive);
2611    }
2612
2613    return function () {
2614      if (scroll) {
2615        scrollParents.forEach(function (scrollParent) {
2616          scrollParent.removeEventListener('scroll', instance.update, passive);
2617        });
2618      }
2619
2620      if (resize) {
2621        window.removeEventListener('resize', instance.update, passive);
2622      }
2623    };
2624  } // eslint-disable-next-line import/no-unused-modules
2625
2626
2627  const eventListeners = {
2628    name: 'eventListeners',
2629    enabled: true,
2630    phase: 'write',
2631    fn: function fn() {},
2632    effect: effect,
2633    data: {}
2634  };
2635
2636  var hash$1 = {
2637    left: 'right',
2638    right: 'left',
2639    bottom: 'top',
2640    top: 'bottom'
2641  };
2642  function getOppositePlacement(placement) {
2643    return placement.replace(/left|right|bottom|top/g, function (matched) {
2644      return hash$1[matched];
2645    });
2646  }
2647
2648  var hash = {
2649    start: 'end',
2650    end: 'start'
2651  };
2652  function getOppositeVariationPlacement(placement) {
2653    return placement.replace(/start|end/g, function (matched) {
2654      return hash[matched];
2655    });
2656  }
2657
2658  function getWindowScroll(node) {
2659    var win = getWindow(node);
2660    var scrollLeft = win.pageXOffset;
2661    var scrollTop = win.pageYOffset;
2662    return {
2663      scrollLeft: scrollLeft,
2664      scrollTop: scrollTop
2665    };
2666  }
2667
2668  function getWindowScrollBarX(element) {
2669    // If <html> has a CSS width greater than the viewport, then this will be
2670    // incorrect for RTL.
2671    // Popper 1 is broken in this case and never had a bug report so let's assume
2672    // it's not an issue. I don't think anyone ever specifies width on <html>
2673    // anyway.
2674    // Browsers where the left scrollbar doesn't cause an issue report `0` for
2675    // this (e.g. Edge 2019, IE11, Safari)
2676    return getBoundingClientRect(getDocumentElement(element)).left + getWindowScroll(element).scrollLeft;
2677  }
2678
2679  function getViewportRect(element) {
2680    var win = getWindow(element);
2681    var html = getDocumentElement(element);
2682    var visualViewport = win.visualViewport;
2683    var width = html.clientWidth;
2684    var height = html.clientHeight;
2685    var x = 0;
2686    var y = 0; // NB: This isn't supported on iOS <= 12. If the keyboard is open, the popper
2687    // can be obscured underneath it.
2688    // Also, `html.clientHeight` adds the bottom bar height in Safari iOS, even
2689    // if it isn't open, so if this isn't available, the popper will be detected
2690    // to overflow the bottom of the screen too early.
2691
2692    if (visualViewport) {
2693      width = visualViewport.width;