https://n-e-f.org/templates/nef/vendor/twbs/bootstrap/dist/js/bootstrap.bundle.js?70a1b4

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

345  const customEventsRegex = /^(mouseenter|mouseleave)/i;
346  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']);
347  /**
348   * ------------------------------------------------------------------------
349   * Private methods
350   * ------------------------------------------------------------------------
351   */
352
353  function getUidEvent(element, uid) {
354    return uid && `${uid}::${uidEvent++}` || element.uidEvent || uidEvent++;
355  }
356
357  function getEvent(element) {
358    const uid = getUidEvent(element);
359    element.uidEvent = uid;
360    eventRegistry[uid] = eventRegistry[uid] || {};
361    return eventRegistry[uid];
362  }
363
364  function bootstrapHandler(element, fn) {
365    return function handler(event) {
366      event.delegateTarget = element;
367
368      if (handler.oneOff) {
369        EventHandler.off(element, event.type, fn);
370      }
371
372      return fn.apply(element, [event]);
373    };
374  }
375
376  function bootstrapDelegationHandler(element, selector, fn) {
377    return function handler(event) {
378      const domElements = element.querySelectorAll(selector);
379
380      for (let {
381        target
382      } = event; target && target !== this; target = target.parentNode) {
383        for (let i = domElements.length; i--;) {
384          if (domElements[i] === target) {
385            event.delegateTarget = target;
386
387            if (handler.oneOff) {
388              EventHandler.off(element, event.type, selector, fn);
389            }
390
391            return fn.apply(target, [event]);
392          }
393        }
394      } // To please ESLint
395
396
397      return null;
398    };
399  }
400
401  function findHandler(events, handler, delegationSelector = null) {
402    const uidEventList = Object.keys(events);
403
404    for (let i = 0, len = uidEventList.length; i < len; i++) {
405      const event = events[uidEventList[i]];
406
407      if (event.originalHandler === handler && event.delegationSelector === delegationSelector) {
408        return event;
409      }
410    }
411
412    return null;
413  }
414
415  function normalizeParams(originalTypeEvent, handler, delegationFn) {
416    const delegation = typeof handler === 'string';
417    const originalHandler = delegation ? delegationFn : handler;
418    let typeEvent = getTypeEvent(originalTypeEvent);
419    const isNative = nativeEvents.has(typeEvent);
420
421    if (!isNative) {
422      typeEvent = originalTypeEvent;
423    }
424
425    return [delegation, originalHandler, typeEvent];
426  }
427
428  function addHandler(element, originalTypeEvent, handler, delegationFn, oneOff) {
429    if (typeof originalTypeEvent !== 'string' || !element) {
430      return;
431    }
432
433    if (!handler) {
434      handler = delegationFn;
435      delegationFn = null;
436    } // in case of mouseenter or mouseleave wrap the handler within a function that checks for its DOM position
437    // this prevents the handler from being dispatched the same way as mouseover or mouseout does
438
439
440    if (customEventsRegex.test(originalTypeEvent)) {
441      const wrapFn = fn => {
442        return function (event) {
443          if (!event.relatedTarget || event.relatedTarget !== event.delegateTarget && !event.delegateTarget.contains(event.relatedTarget)) {
444            return fn.call(this, event);
445          }
446        };
447      };
448
449      if (delegationFn) {
450        delegationFn = wrapFn(delegationFn);
451      } else {
452        handler = wrapFn(handler);
453      }
454    }
455
456    const [delegation, originalHandler, typeEvent] = normalizeParams(originalTypeEvent, handler, delegationFn);
457    const events = getEvent(element);
458    const handlers = events[typeEvent] || (events[typeEvent] = {});
459    const previousFn = findHandler(handlers, originalHandler, delegation ? handler : null);
460
461    if (previousFn) {
462      previousFn.oneOff = previousFn.oneOff && oneOff;
463      return;
464    }
465
466    const uid = getUidEvent(originalHandler, originalTypeEvent.replace(namespaceRegex, ''));
467    const fn = delegation ? bootstrapDelegationHandler(element, handler, delegationFn) : bootstrapHandler(element, handler);
468    fn.delegationSelector = delegation ? handler : null;
469    fn.originalHandler = originalHandler;
470    fn.oneOff = oneOff;
471    fn.uidEvent = uid;
472    handlers[uid] = fn;
473    element.addEventListener(typeEvent, fn, delegation);
474  }
475
476  function removeHandler(element, events, typeEvent, handler, delegationSelector) {
477    const fn = findHandler(events[typeEvent], handler, delegationSelector);
478
479    if (!fn) {
480      return;
481    }
482
483    element.removeEventListener(typeEvent, fn, Boolean(delegationSelector));
484    delete events[typeEvent][fn.uidEvent];
485  }
486
487  function removeNamespacedHandlers(element, events, typeEvent, namespace) {
488    const storeElementEvent = events[typeEvent] || {};
489    Object.keys(storeElementEvent).forEach(handlerKey => {
490      if (handlerKey.includes(namespace)) {
491        const event = storeElementEvent[handlerKey];
492        removeHandler(element, events, typeEvent, event.originalHandler, event.delegationSelector);
493      }
494    });
495  }
496
497  function getTypeEvent(event) {
498    // allow to get the native events from namespaced events ('click.bs.button' --> 'click')
499    event = event.replace(stripNameRegex, '');
500    return customEvents[event] || event;
501  }
502
503  const EventHandler = {
504    on(element, event, handler, delegationFn) {
505      addHandler(element, event, handler, delegationFn, false);
506    },
507
508    one(element, event, handler, delegationFn) {
509      addHandler(element, event, handler, delegationFn, true);
510    },
511
512    off(element, originalTypeEvent, handler, delegationFn) {
513      if (typeof originalTypeEvent !== 'string' || !element) {
514        return;
515      }
516
517      const [delegation, originalHandler, typeEvent] = normalizeParams(originalTypeEvent, handler, delegationFn);
518      const inNamespace = typeEvent !== originalTypeEvent;
519      const events = getEvent(element);
520      const isNamespace = originalTypeEvent.startsWith('.');
521
522      if (typeof originalHandler !== 'undefined') {
523        // Simplest case: handler is passed, remove that listener ONLY.
524        if (!events || !events[typeEvent]) {
525          return;
526        }
527
528        removeHandler(element, events, typeEvent, originalHandler, delegation ? handler : null);
529        return;
530      }
531
532      if (isNamespace) {
533        Object.keys(events).forEach(elementEvent => {
534          removeNamespacedHandlers(element, events, elementEvent, originalTypeEvent.slice(1));
535        });
536      }
537
538      const storeElementEvent = events[typeEvent] || {};
539      Object.keys(storeElementEvent).forEach(keyHandlers => {
540        const handlerKey = keyHandlers.replace(stripUidRegex, '');
541
542        if (!inNamespace || originalTypeEvent.includes(handlerKey)) {
543          const event = storeElementEvent[keyHandlers];
544          removeHandler(element, events, typeEvent, event.originalHandler, event.delegationSelector);
545        }
546      });
547    },
548
549    trigger(element, event, args) {
550      if (typeof event !== 'string' || !element) {
551        return null;
552      }
553
554      const $ = getjQuery();
555      const typeEvent = getTypeEvent(event);
556      const inNamespace = event !== typeEvent;
557      const isNative = nativeEvents.has(typeEvent);
558      let jQueryEvent;
559      let bubbles = true;
560      let nativeDispatch = true;
561      let defaultPrevented = false;
562      let evt = null;
563
564      if (inNamespace && $) {
565        jQueryEvent = $.Event(event, args);
566        $(element).trigger(jQueryEvent);
567        bubbles = !jQueryEvent.isPropagationStopped();
568        nativeDispatch = !jQueryEvent.isImmediatePropagationStopped();
569        defaultPrevented = jQueryEvent.isDefaultPrevented();
570      }
571
572      if (isNative) {
573        evt = document.createEvent('HTMLEvents');
574        evt.initEvent(typeEvent, bubbles, true);
575      } else {
576        evt = new CustomEvent(event, {
577          bubbles,
578          cancelable: true
579        });
580      } // merge custom information in our event
581
582
583      if (typeof args !== 'undefined') {
584        Object.keys(args).forEach(key => {
585          Object.defineProperty(evt, key, {
586            get() {
587              return args[key];
588            }
589
590          });
591        });
592      }
593
594      if (defaultPrevented) {
595        evt.preventDefault();
596      }
597
598      if (nativeDispatch) {
599        element.dispatchEvent(evt);
600      }
601
602      if (evt.defaultPrevented && typeof jQueryEvent !== 'undefined') {
603        jQueryEvent.preventDefault();
604      }
605
606      return evt;
607    }
608
609  };
610
611  /**
612   * --------------------------------------------------------------------------
613   * Bootstrap (v5.1.3): dom/data.js
614   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
615   * --------------------------------------------------------------------------
616   */
617
618  /**
619   * ------------------------------------------------------------------------
620   * Constants
621   * ------------------------------------------------------------------------
622   */
623  const elementMap = new Map();
624  const Data = {
625    set(element, key, instance) {
626      if (!elementMap.has(element)) {
627        elementMap.set(element, new Map());
628      }
629
630      const instanceMap = elementMap.get(element); // make it clear we only want one instance per element
631      // can be removed later when multiple key/instances are fine to be used
632
633      if (!instanceMap.has(key) && instanceMap.size !== 0) {
634        // eslint-disable-next-line no-console
635        console.error(`Bootstrap doesn't allow more than one instance per element. Bound instance: ${Array.from(instanceMap.keys())[0]}.`);
636        return;
637      }
638
639      instanceMap.set(key, instance);
640    },
641
642    get(element, key) {
643      if (elementMap.has(element)) {
644        return elementMap.get(element).get(key) || null;
645      }
646
647      return null;
648    },
649
650    remove(element, key) {
651      if (!elementMap.has(element)) {
652        return;
653      }
654
655      const instanceMap = elementMap.get(element);
656      instanceMap.delete(key); // free up element references if there are no instances left for an element
657
658      if (instanceMap.size === 0) {
659        elementMap.delete(element);
660      }
661    }
662
663  };
664
665  /**
666   * --------------------------------------------------------------------------
667   * Bootstrap (v5.1.3): base-component.js
668   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
669   * --------------------------------------------------------------------------
670   */
671  /**
672   * ------------------------------------------------------------------------
673   * Constants
674   * ------------------------------------------------------------------------
675   */
676
677  const VERSION = '5.1.3';
678
679  class BaseComponent {
680    constructor(element) {
681      element = getElement(element);
682
683      if (!element) {
684        return;
685      }
686
687      this._element = element;
688      Data.set(this._element, this.constructor.DATA_KEY, this);
689    }
690
691    dispose() {
692      Data.remove(this._element, this.constructor.DATA_KEY);
693      EventHandler.off(this._element, this.constructor.EVENT_KEY);
694      Object.getOwnPropertyNames(this).forEach(propertyName => {
695        this[propertyName] = null;
696      });
697    }
698
699    _queueCallback(callback, element, isAnimated = true) {
700      executeAfterTransition(callback, element, isAnimated);
701    }
702    /** Static */
703
704
705    static getInstance(element) {
706      return Data.get(getElement(element), this.DATA_KEY);
707    }
708
709    static getOrCreateInstance(element, config = {}) {
710      return this.getInstance(element) || new this(element, typeof config === 'object' ? config : null);
711    }
712
713    static get VERSION() {
714      return VERSION;
715    }
716
717    static get NAME() {
718      throw new Error('You have to implement the static method "NAME", for each component!');
719    }
720
721    static get DATA_KEY() {
722      return `bs.${this.NAME}`;
723    }
724
725    static get EVENT_KEY() {
726      return `.${this.DATA_KEY}`;
727    }
728
729  }
730
731  /**
732   * --------------------------------------------------------------------------
733   * Bootstrap (v5.1.3): util/component-functions.js
734   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
735   * --------------------------------------------------------------------------
736   */
737
738  const enableDismissTrigger = (component, method = 'hide') => {
739    const clickEvent = `click.dismiss${component.EVENT_KEY}`;
740    const name = component.NAME;
741    EventHandler.on(document, clickEvent, `[data-bs-dismiss="${name}"]`, function (event) {
742      if (['A', 'AREA'].includes(this.tagName)) {
743        event.preventDefault();
744      }
745
746      if (isDisabled(this)) {
747        return;
748      }
749
750      const target = getElementFromSelector(this) || this.closest(`.${name}`);
751      const instance = component.getOrCreateInstance(target); // Method argument is left, for Alert and only, as it doesn't implement the 'hide' method
752
753      instance[method]();
754    });
755  };
756
757  /**
758   * --------------------------------------------------------------------------
759   * Bootstrap (v5.1.3): alert.js
760   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
761   * --------------------------------------------------------------------------
762   */
763  /**
764   * ------------------------------------------------------------------------
765   * Constants
766   * ------------------------------------------------------------------------
767   */
768
769  const NAME$d = 'alert';
770  const DATA_KEY$c = 'bs.alert';
771  const EVENT_KEY$c = `.${DATA_KEY$c}`;
772  const EVENT_CLOSE = `close${EVENT_KEY$c}`;
773  const EVENT_CLOSED = `closed${EVENT_KEY$c}`;
774  const CLASS_NAME_FADE$5 = 'fade';

775  const CLASS_NAME_SHOW$8 = 'show';
776  /**
777   * ------------------------------------------------------------------------
778   * Class Definition
779   * ------------------------------------------------------------------------
780   */
781
782  class Alert extends BaseComponent {
783    // Getters
784    static get NAME() {
785      return NAME$d;
786    } // Public
787
788
789    close() {
790      const closeEvent = EventHandler.trigger(this._element, EVENT_CLOSE);
791
792      if (closeEvent.defaultPrevented) {
793        return;
794      }
795
796      this._element.classList.remove(CLASS_NAME_SHOW$8);
797
798      const isAnimated = this._element.classList.contains(CLASS_NAME_FADE$5);
799
800      this._queueCallback(() => this._destroyElement(), this._element, isAnimated);
801    } // Private
802
803
804    _destroyElement() {
805      this._element.remove();
806
807      EventHandler.trigger(this._element, EVENT_CLOSED);
808      this.dispose();
809    } // Static
810
811
812    static jQueryInterface(config) {
813      return this.each(function () {
814        const data = Alert.getOrCreateInstance(this);
815
816        if (typeof config !== 'string') {
817          return;
818        }
819
820        if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {
821          throw new TypeError(`No method named "${config}"`);
822        }
823
824        data[config](this);
825      });
826    }
827
828  }
829  /**
830   * ------------------------------------------------------------------------
831   * Data Api implementation
832   * ------------------------------------------------------------------------
833   */
834
835
836  enableDismissTrigger(Alert, 'close');
837  /**
838   * ------------------------------------------------------------------------
839   * jQuery
840   * ------------------------------------------------------------------------
841   * add .Alert to jQuery only if jQuery is present
842   */
843
844  defineJQueryPlugin(Alert);
845
846  /**
847   * --------------------------------------------------------------------------
848   * Bootstrap (v5.1.3): button.js
849   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
850   * --------------------------------------------------------------------------
851   */
852  /**
853   * ------------------------------------------------------------------------
854   * Constants
855   * ------------------------------------------------------------------------
856   */
857
858  const NAME$c = 'button';
859  const DATA_KEY$b = 'bs.button';
860  const EVENT_KEY$b = `.${DATA_KEY$b}`;
861  const DATA_API_KEY$7 = '.data-api';
862  const CLASS_NAME_ACTIVE$3 = 'active';
863  const SELECTOR_DATA_TOGGLE$5 = '[data-bs-toggle="button"]';
864  const EVENT_CLICK_DATA_API$6 = `click${EVENT_KEY$b}${DATA_API_KEY$7}`;
865  /**
866   * ------------------------------------------------------------------------
867   * Class Definition
868   * ------------------------------------------------------------------------
869   */
870
871  class Button extends BaseComponent {
872    // Getters
873    static get NAME() {
874      return NAME$c;
875    } // Public
876
877
878    toggle() {
879      // Toggle class and sync the `aria-pressed` attribute with the return value of the `.toggle()` method
880      this._element.setAttribute('aria-pressed', this._element.classList.toggle(CLASS_NAME_ACTIVE$3));
881    } // Static
882
883
884    static jQueryInterface(config) {
885      return this.each(function () {
886        const data = Button.getOrCreateInstance(this);
887
888        if (config === 'toggle') {
889          data[config]();
890        }
891      });
892    }
893
894  }
895  /**
896   * ------------------------------------------------------------------------
897   * Data Api implementation
898   * ------------------------------------------------------------------------
899   */
900
901
902  EventHandler.on(document, EVENT_CLICK_DATA_API$6, SELECTOR_DATA_TOGGLE$5, event => {
903    event.preventDefault();
904    const button = event.target.closest(SELECTOR_DATA_TOGGLE$5);
905    const data = Button.getOrCreateInstance(button);
906    data.toggle();
907  });
908  /**
909   * ------------------------------------------------------------------------
910   * jQuery
911   * ------------------------------------------------------------------------
912   * add .Button to jQuery only if jQuery is present
913   */
914
915  defineJQueryPlugin(Button);
916
917  /**
918   * --------------------------------------------------------------------------
919   * Bootstrap (v5.1.3): dom/manipulator.js
920   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
921   * --------------------------------------------------------------------------
922   */
923  function normalizeData(val) {
924    if (val === 'true') {
925      return true;
926    }
927
928    if (val === 'false') {
929      return false;

1884        }
1885
1886        const data = Collapse.getOrCreateInstance(this, _config);
1887
1888        if (typeof config === 'string') {
1889          if (typeof data[config] === 'undefined') {
1890            throw new TypeError(`No method named "${config}"`);
1891          }
1892
1893          data[config]();
1894        }
1895      });
1896    }
1897
1898  }
1899  /**
1900   * ------------------------------------------------------------------------
1901   * Data Api implementation
1902   * ------------------------------------------------------------------------
1903   */
1904
1905
1906  EventHandler.on(document, EVENT_CLICK_DATA_API$4, SELECTOR_DATA_TOGGLE$4, function (event) {
1907    // preventDefault only for <a> elements (which change the URL) not inside the collapsible element
1908    if (event.target.tagName === 'A' || event.delegateTarget && event.delegateTarget.tagName === 'A') {
1909      event.preventDefault();
1910    }
1911
1912    const selector = getSelectorFromElement(this);
1913    const selectorElements = SelectorEngine.find(selector);
1914    selectorElements.forEach(element => {
1915      Collapse.getOrCreateInstance(element, {
1916        toggle: false
1917      }).toggle();
1918    });
1919  });
1920  /**
1921   * ------------------------------------------------------------------------
1922   * jQuery
1923   * ------------------------------------------------------------------------
1924   * add .Collapse to jQuery only if jQuery is present
1925   */
1926
1927  defineJQueryPlugin(Collapse);
1928
1929  var top = 'top';
1930  var bottom = 'bottom';
1931  var right = 'right';
1932  var left = 'left';
1933  var auto = 'auto';
1934  var basePlacements = [top, bottom, right, left];
1935  var start = 'start';
1936  var end = 'end';
1937  var clippingParents = 'clippingParents';
1938  var viewport = 'viewport';
1939  var popper = 'popper';
1940  var reference = 'reference';
1941  var variationPlacements = /*#__PURE__*/basePlacements.reduce(function (acc, placement) {
1942    return acc.concat([placement + "-" + start, placement + "-" + end]);
1943  }, []);
1944  var placements = /*#__PURE__*/[].concat(basePlacements, [auto]).reduce(function (acc, placement) {
1945    return acc.concat([placement, placement + "-" + start, placement + "-" + end]);
1946  }, []); // modifiers that need to read the DOM
1947
1948  var beforeRead = 'beforeRead';
1949  var read = 'read';
1950  var afterRead = 'afterRead'; // pure-logic modifiers
1951
1952  var beforeMain = 'beforeMain';
1953  var main = 'main';
1954  var afterMain = 'afterMain'; // modifier with the purpose to write to the DOM (or write into a framework state)
1955
1956  var beforeWrite = 'beforeWrite';
1957  var write = 'write';
1958  var afterWrite = 'afterWrite';
1959  var modifierPhases = [beforeRead, read, afterRead, beforeMain, main, afterMain, beforeWrite, write, afterWrite];
1960
1961  function getNodeName(element) {
1962    return element ? (element.nodeName || '').toLowerCase() : null;
1963  }
1964
1965  function getWindow(node) {
1966    if (node == null) {
1967      return window;
1968    }
1969
1970    if (node.toString() !== '[object Window]') {
1971      var ownerDocument = node.ownerDocument;
1972      return ownerDocument ? ownerDocument.defaultView || window : window;
1973    }
1974
1975    return node;
1976  }
1977
1978  function isElement(node) {
1979    var OwnElement = getWindow(node).Element;
1980    return node instanceof OwnElement || node instanceof Element;
1981  }
1982
1983  function isHTMLElement(node) {
1984    var OwnElement = getWindow(node).HTMLElement;
1985    return node instanceof OwnElement || node instanceof HTMLElement;
1986  }
1987
1988  function isShadowRoot(node) {
1989    // IE 11 has no ShadowRoot
1990    if (typeof ShadowRoot === 'undefined') {
1991      return false;
1992    }
1993
1994    var OwnElement = getWindow(node).ShadowRoot;
1995    return node instanceof OwnElement || node instanceof ShadowRoot;
1996  }
1997
1998  // and applies them to the HTMLElements such as popper and arrow
1999
2000  function applyStyles(_ref) {
2001    var state = _ref.state;
2002    Object.keys(state.elements).forEach(function (name) {
2003      var style = state.styles[name] || {};
2004      var attributes = state.attributes[name] || {};
2005      var element = state.elements[name]; // arrow is optional + virtual elements
2006
2007      if (!isHTMLElement(element) || !getNodeName(element)) {
2008        return;
2009      } // Flow doesn't support to extend this property, but it's the most
2010      // effective way to apply styles to an HTMLElement
2011      // $FlowFixMe[cannot-write]
2012
2013
2014      Object.assign(element.style, style);

2015      Object.keys(attributes).forEach(function (name) {
2016        var value = attributes[name];
2017
2018        if (value === false) {
2019          element.removeAttribute(name);
2020        } else {
2021          element.setAttribute(name, value === true ? '' : value);
2022        }
2023      });
2024    });
2025  }
2026
2027  function effect$2(_ref2) {
2028    var state = _ref2.state;
2029    var initialStyles = {
2030      popper: {
2031        position: state.options.strategy,
2032        left: '0',
2033        top: '0',
2034        margin: '0'
2035      },
2036      arrow: {
2037        position: 'absolute'
2038      },
2039      reference: {}
2040    };
2041    Object.assign(state.elements.popper.style, initialStyles.popper);
2042    state.styles = initialStyles;
2043
2044    if (state.elements.arrow) {
2045      Object.assign(state.elements.arrow.style, initialStyles.arrow);
2046    }
2047
2048    return function () {
2049      Object.keys(state.elements).forEach(function (name) {
2050        var element = state.elements[name];
2051        var attributes = state.attributes[name] || {};
2052        var styleProperties = Object.keys(state.styles.hasOwnProperty(name) ? state.styles[name] : initialStyles[name]); // Set all values to an empty string to unset them
2053
2054        var style = styleProperties.reduce(function (style, property) {
2055          style[property] = '';
2056          return style;
2057        }, {}); // arrow is optional + virtual elements
2058
2059        if (!isHTMLElement(element) || !getNodeName(element)) {
2060          return;
2061        }
2062
2063        Object.assign(element.style, style);
2064        Object.keys(attributes).forEach(function (attribute) {
2065          element.removeAttribute(attribute);
2066        });
2067      });
2068    };
2069  } // eslint-disable-next-line import/no-unused-modules
2070
2071
2072  const applyStyles$1 = {
2073    name: 'applyStyles',
2074    enabled: true,
2075    phase: 'write',
2076    fn: applyStyles,
2077    effect: effect$2,
2078    requires: ['computeStyles']
2079  };
2080
2081  function getBasePlacement(placement) {
2082    return placement.split('-')[0];
2083  }
2084
2085  // import { isHTMLElement } from './instanceOf';
2086  function getBoundingClientRect(element, // eslint-disable-next-line unused-imports/no-unused-vars
2087  includeScale) {
2088
2089    var rect = element.getBoundingClientRect();
2090    var scaleX = 1;
2091    var scaleY = 1; // FIXME:
2092    // `offsetWidth` returns an integer while `getBoundingClientRect`
2093    // returns a float. This results in `scaleX` or `scaleY` being
2094    // non-1 when it should be for elements that aren't a full pixel in
2095    // width or height.
2096    // if (isHTMLElement(element) && includeScale) {
2097    //   const offsetHeight = element.offsetHeight;
2098    //   const offsetWidth = element.offsetWidth;
2099    //   // Do not attempt to divide by 0, otherwise we get `Infinity` as scale
2100    //   // Fallback to 1 in case both values are `0`
2101    //   if (offsetWidth > 0) {
2102    //     scaleX = rect.width / offsetWidth || 1;
2103    //   }
2104    //   if (offsetHeight > 0) {
2105    //     scaleY = rect.height / offsetHeight || 1;
2106    //   }
2107    // }
2108
2109    return {
2110      width: rect.width / scaleX,
2111      height: rect.height / scaleY,
2112      top: rect.top / scaleY,
2113      right: rect.right / scaleX,
2114      bottom: rect.bottom / scaleY,
2115      left: rect.left / scaleX,
2116      x: rect.left / scaleX,
2117      y: rect.top / scaleY
2118    };
2119  }
2120
2121  // means it doesn't take into account transforms.
2122
2123  function getLayoutRect(element) {
2124    var clientRect = getBoundingClientRect(element); // Use the clientRect sizes if it's not been transformed.
2125    // Fixes https://github.com/popperjs/popper-core/issues/1223
2126
2127    var width = element.offsetWidth;
2128    var height = element.offsetHeight;
2129
2130    if (Math.abs(clientRect.width - width) <= 1) {
2131      width = clientRect.width;
2132    }
2133
2134    if (Math.abs(clientRect.height - height) <= 1) {
2135      height = clientRect.height;
2136    }
2137
2138    return {
2139      x: element.offsetLeft,
2140      y: element.offsetTop,
2141      width: width,
2142      height: height
2143    };
2144  }
2145
2146  function contains(parent, child) {
2147    var rootNode = child.getRootNode && child.getRootNode(); // First, attempt with faster native method
2148
2149    if (parent.contains(child)) {
2150      return true;
2151    } // then fallback to custom implementation with Shadow DOM support
2152    else if (rootNode && isShadowRoot(rootNode)) {
2153        var next = child;
2154
2155        do {
2156          if (next && parent.isSameNode(next)) {
2157            return true;
2158          } // $FlowFixMe[prop-missing]: need a better way to handle this...
2159
2160
2161          next = next.parentNode || next.host;
2162        } while (next);
2163      } // Give up, the result is false
2164
2165
2166    return false;

2167  }
2168
2169  function getComputedStyle$1(element) {
2170    return getWindow(element).getComputedStyle(element);
2171  }
2172
2173  function isTableElement(element) {
2174    return ['table', 'td', 'th'].indexOf(getNodeName(element)) >= 0;
2175  }
2176
2177  function getDocumentElement(element) {
2178    // $FlowFixMe[incompatible-return]: assume body is always available
2179    return ((isElement(element) ? element.ownerDocument : // $FlowFixMe[prop-missing]
2180    element.document) || window.document).documentElement;
2181  }
2182
2183  function getParentNode(element) {
2184    if (getNodeName(element) === 'html') {
2185      return element;
2186    }
2187
2188    return (// this is a quicker (but less type safe) way to save quite some bytes from the bundle
2189      // $FlowFixMe[incompatible-return]
2190      // $FlowFixMe[prop-missing]
2191      element.assignedSlot || // step into the shadow DOM of the parent of a slotted node
2192      element.parentNode || ( // DOM Element detected
2193      isShadowRoot(element) ? element.host : null) || // ShadowRoot detected
2194      // $FlowFixMe[incompatible-call]: HTMLElement is a Node
2195      getDocumentElement(element) // fallback
2196
2197    );
2198  }
2199
2200  function getTrueOffsetParent(element) {
2201    if (!isHTMLElement(element) || // https://github.com/popperjs/popper-core/issues/837
2202    getComputedStyle$1(element).position === 'fixed') {
2203      return null;
2204    }
2205
2206    return element.offsetParent;
2207  } // `.offsetParent` reports `null` for fixed elements, while absolute elements
2208  // return the containing block
2209
2210
2211  function getContainingBlock(element) {
2212    var isFirefox = navigator.userAgent.toLowerCase().indexOf('firefox') !== -1;
2213    var isIE = navigator.userAgent.indexOf('Trident') !== -1;
2214
2215    if (isIE && isHTMLElement(element)) {
2216      // In IE 9, 10 and 11 fixed elements containing block is always established by the viewport
2217      var elementCss = getComputedStyle$1(element);
2218
2219      if (elementCss.position === 'fixed') {
2220        return null;
2221      }
2222    }
2223
2224    var currentNode = getParentNode(element);
2225
2226    while (isHTMLElement(currentNode) && ['html', 'body'].indexOf(getNodeName(currentNode)) < 0) {
2227      var css = getComputedStyle$1(currentNode); // This is non-exhaustive but covers the most common CSS properties that
2228      // create a containing block.
2229      // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
2230
2231      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') {
2232        return currentNode;
2233      } else {
2234        currentNode = currentNode.parentNode;
2235      }
2236    }
2237
2238    return null;
2239  } // Gets the closest ancestor positioned element. Handles some edge cases,
2240  // such as table ancestors and cross browser bugs.
2241
2242
2243  function getOffsetParent(element) {
2244    var window = getWindow(element);
2245    var offsetParent = getTrueOffsetParent(element);
2246
2247    while (offsetParent && isTableElement(offsetParent) && getComputedStyle$1(offsetParent).position === 'static') {
2248      offsetParent = getTrueOffsetParent(offsetParent);
2249    }
2250
2251    if (offsetParent && (getNodeName(offsetParent) === 'html' || getNodeName(offsetParent) === 'body' && getComputedStyle$1(offsetParent).position === 'static')) {
2252      return window;
2253    }
2254
2255    return offsetParent || getContainingBlock(element) || window;
2256  }
2257
2258  function getMainAxisFromPlacement(placement) {
2259    return ['top', 'bottom'].indexOf(placement) >= 0 ? 'x' : 'y';
2260  }
2261
2262  var max = Math.max;
2263  var min = Math.min;
2264  var round = Math.round;
2265
2266  function within(min$1, value, max$1) {
2267    return max(min$1, min(value, max$1));
2268  }
2269
2270  function getFreshSideObject() {
2271    return {
2272      top: 0,
2273      right: 0,
2274      bottom: 0,
2275      left: 0
2276    };
2277  }
2278
2279  function mergePaddingObject(paddingObject) {
2280    return Object.assign({}, getFreshSideObject(), paddingObject);
2281  }
2282
2283  function expandToHashMap(value, keys) {
2284    return keys.reduce(function (hashMap, key) {
2285      hashMap[key] = value;
2286      return hashMap;
2287    }, {});
2288  }
2289
2290  var toPaddingObject = function toPaddingObject(padding, state) {
2291    padding = typeof padding === 'function' ? padding(Object.assign({}, state.rects, {
2292      placement: state.placement
2293    })) : padding;
2294    return mergePaddingObject(typeof padding !== 'number' ? padding : expandToHashMap(padding, basePlacements));
2295  };
2296
2297  function arrow(_ref) {
2298    var _state$modifiersData$;
2299
2300    var state = _ref.state,
2301        name = _ref.name,
2302        options = _ref.options;
2303    var arrowElement = state.elements.arrow;
2304    var popperOffsets = state.modifiersData.popperOffsets;
2305    var basePlacement = getBasePlacement(state.placement);
2306    var axis = getMainAxisFromPlacement(basePlacement);
2307    var isVertical = [left, right].indexOf(basePlacement) >= 0;
2308    var len = isVertical ? 'height' : 'width';
2309
2310    if (!arrowElement || !popperOffsets) {
2311      return;
2312    }
2313
2314    var paddingObject = toPaddingObject(options.padding, state);
2315    var arrowRect = getLayoutRect(arrowElement);
2316    var minProp = axis === 'y' ? top : left;
2317    var maxProp = axis === 'y' ? bottom : right;
2318    var endDiff = state.rects.reference[len] + state.rects.reference[axis] - popperOffsets[axis] - state.rects.popper[len];
2319    var startDiff = popperOffsets[axis] - state.rects.reference[axis];
2320    var arrowOffsetParent = getOffsetParent(arrowElement);
2321    var clientSize = arrowOffsetParent ? axis === 'y' ? arrowOffsetParent.clientHeight || 0 : arrowOffsetParent.clientWidth || 0 : 0;
2322    var centerToReference = endDiff / 2 - startDiff / 2; // Make sure the arrow doesn't overflow the popper if the center point is
2323    // outside of the popper bounds
2324
2325    var min = paddingObject[minProp];
2326    var max = clientSize - arrowRect[len] - paddingObject[maxProp];
2327    var center = clientSize / 2 - arrowRect[len] / 2 + centerToReference;
2328    var offset = within(min, center, max); // Prevents breaking syntax highlighting...
2329
2330    var axisProp = axis;
2331    state.modifiersData[name] = (_state$modifiersData$ = {}, _state$modifiersData$[axisProp] = offset, _state$modifiersData$.centerOffset = offset - center, _state$modifiersData$);
2332  }
2333
2334  function effect$1(_ref2) {
2335    var state = _ref2.state,
2336        options = _ref2.options;
2337    var _options$element = options.element,
2338        arrowElement = _options$element === void 0 ? '[data-popper-arrow]' : _options$element;
2339
2340    if (arrowElement == null) {
2341      return;
2342    } // CSS selector
2343
2344
2345    if (typeof arrowElement === 'string') {
2346      arrowElement = state.elements.popper.querySelector(arrowElement);
2347
2348      if (!arrowElement) {
2349        return;
2350      }
2351    }
2352
2353    if (!contains(state.elements.popper, arrowElement)) {
2354
2355      return;
2356    }
2357
2358    state.elements.arrow = arrowElement;
2359  } // eslint-disable-next-line import/no-unused-modules
2360
2361
2362  const arrow$1 = {
2363    name: 'arrow',
2364    enabled: true,
2365    phase: 'main',
2366    fn: arrow,
2367    effect: effect$1,
2368    requires: ['popperOffsets'],
2369    requiresIfExists: ['preventOverflow']
2370  };
2371
2372  function getVariation(placement) {
2373    return placement.split('-')[1];
2374  }
2375
2376  var unsetSides = {
2377    top: 'auto',
2378    right: 'auto',
2379    bottom: 'auto',
2380    left: 'auto'
2381  }; // Round the offsets to the nearest suitable subpixel based on the DPR.
2382  // Zooming can change the DPR, but it seems to report a value that will
2383  // cleanly divide the values into the appropriate subpixels.
2384
2385  function roundOffsetsByDPR(_ref) {
2386    var x = _ref.x,
2387        y = _ref.y;
2388    var win = window;
2389    var dpr = win.devicePixelRatio || 1;
2390    return {
2391      x: round(round(x * dpr) / dpr) || 0,
2392      y: round(round(y * dpr) / dpr) || 0
2393    };
2394  }
2395
2396  function mapToStyles(_ref2) {
2397    var _Object$assign2;
2398
2399    var popper = _ref2.popper,
2400        popperRect = _ref2.popperRect,
2401        placement = _ref2.placement,
2402        variation = _ref2.variation,
2403        offsets = _ref2.offsets,
2404        position = _ref2.position,
2405        gpuAcceleration = _ref2.gpuAcceleration,
2406        adaptive = _ref2.adaptive,
2407        roundOffsets = _ref2.roundOffsets;
2408
2409    var _ref3 = roundOffsets === true ? roundOffsetsByDPR(offsets) : typeof roundOffsets === 'function' ? roundOffsets(offsets) : offsets,
2410        _ref3$x = _ref3.x,
2411        x = _ref3$x === void 0 ? 0 : _ref3$x,
2412        _ref3$y = _ref3.y,
2413        y = _ref3$y === void 0 ? 0 : _ref3$y;
2414
2415    var hasX = offsets.hasOwnProperty('x');
2416    var hasY = offsets.hasOwnProperty('y');
2417    var sideX = left;
2418    var sideY = top;
2419    var win = window;
2420
2421    if (adaptive) {
2422      var offsetParent = getOffsetParent(popper);
2423      var heightProp = 'clientHeight';

2424      var widthProp = 'clientWidth';
2425
2426      if (offsetParent === getWindow(popper)) {
2427        offsetParent = getDocumentElement(popper);
2428
2429        if (getComputedStyle$1(offsetParent).position !== 'static' && position === 'absolute') {
2430          heightProp = 'scrollHeight';
2431          widthProp = 'scrollWidth';
2432        }
2433      } // $FlowFixMe[incompatible-cast]: force type refinement, we compare offsetParent with window above, but Flow doesn't detect it
2434
2435
2436      offsetParent = offsetParent;
2437
2438      if (placement === top || (placement === left || placement === right) && variation === end) {
2439        sideY = bottom; // $FlowFixMe[prop-missing]
2440
2441        y -= offsetParent[heightProp] - popperRect.height;
2442        y *= gpuAcceleration ? 1 : -1;
2443      }
2444
2445      if (placement === left || (placement === top || placement === bottom) && variation === end) {
2446        sideX = right; // $FlowFixMe[prop-missing]
2447
2448        x -= offsetParent[widthProp] - popperRect.width;
2449        x *= gpuAcceleration ? 1 : -1;
2450      }
2451    }
2452
2453    var commonStyles = Object.assign({
2454      position: position
2455    }, adaptive && unsetSides);
2456
2457    if (gpuAcceleration) {
2458      var _Object$assign;
2459
2460      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));
2461    }
2462
2463    return Object.assign({}, commonStyles, (_Object$assign2 = {}, _Object$assign2[sideY] = hasY ? y + "px" : '', _Object$assign2[sideX] = hasX ? x + "px" : '', _Object$assign2.transform = '', _Object$assign2));
2464  }
2465
2466  function computeStyles(_ref4) {
2467    var state = _ref4.state,
2468        options = _ref4.options;
2469    var _options$gpuAccelerat = options.gpuAcceleration,
2470        gpuAcceleration = _options$gpuAccelerat === void 0 ? true : _options$gpuAccelerat,
2471        _options$adaptive = options.adaptive,
2472        adaptive = _options$adaptive === void 0 ? true : _options$adaptive,
2473        _options$roundOffsets = options.roundOffsets,
2474        roundOffsets = _options$roundOffsets === void 0 ? true : _options$roundOffsets;
2475
2476    var commonStyles = {
2477      placement: getBasePlacement(state.placement),
2478      variation: getVariation(state.placement),
2479      popper: state.elements.popper,
2480      popperRect: state.rects.popper,
2481      gpuAcceleration: gpuAcceleration
2482    };
2483
2484    if (state.modifiersData.popperOffsets != null) {
2485      state.styles.popper = Object.assign({}, state.styles.popper, mapToStyles(Object.assign({}, commonStyles, {
2486        offsets: state.modifiersData.popperOffsets,
2487        position: state.options.strategy,
2488        adaptive: adaptive,
2489        roundOffsets: roundOffsets
2490      })));
2491    }
2492
2493    if (state.modifiersData.arrow != null) {
2494      state.styles.arrow = Object.assign({}, state.styles.arrow, mapToStyles(Object.assign({}, commonStyles, {
2495        offsets: state.modifiersData.arrow,
2496        position: 'absolute',
2497        adaptive: false,
2498        roundOffsets: roundOffsets
2499      })));
2500    }
2501
2502    state.attributes.popper = Object.assign({}, state.attributes.popper, {
2503      'data-popper-placement': state.placement
2504    });
2505  } // eslint-disable-next-line import/no-unused-modules
2506
2507
2508  const computeStyles$1 = {
2509    name: 'computeStyles',
2510    enabled: true,
2511    phase: 'beforeWrite',
2512    fn: computeStyles,
2513    data: {}
2514  };
2515
2516  var passive = {
2517    passive: true
2518  };
2519
2520  function effect(_ref) {
2521    var state = _ref.state,
2522        instance = _ref.instance,
2523        options = _ref.options;
2524    var _options$scroll = options.scroll,
2525        scroll = _options$scroll === void 0 ? true : _options$scroll,
2526        _options$resize = options.resize,
2527        resize = _options$resize === void 0 ? true : _options$resize;
2528    var window = getWindow(state.elements.popper);
2529    var scrollParents = [].concat(state.scrollParents.reference, state.scrollParents.popper);
2530
2531    if (scroll) {
2532      scrollParents.forEach(function (scrollParent) {
2533        scrollParent.addEventListener('scroll', instance.update, passive);
2534      });
2535    }
2536
2537    if (resize) {
2538      window.addEventListener('resize', instance.update, passive);
2539    }
2540
2541    return function () {
2542      if (scroll) {

2622      height = visualViewport.height; // Uses Layout Viewport (like Chrome; Safari does not currently)
2623      // In Chrome, it returns a value very close to 0 (+/-) but contains rounding
2624      // errors due to floating point numbers, so we need to check precision.
2625      // Safari returns a number <= 0, usually < -1 when pinch-zoomed
2626      // Feature detection fails in mobile emulation mode in Chrome.
2627      // Math.abs(win.innerWidth / visualViewport.scale - visualViewport.width) <
2628      // 0.001
2629      // Fallback here: "Not Safari" userAgent
2630
2631      if (!/^((?!chrome|android).)*safari/i.test(navigator.userAgent)) {
2632        x = visualViewport.offsetLeft;
2633        y = visualViewport.offsetTop;
2634      }
2635    }
2636
2637    return {
2638      width: width,
2639      height: height,
2640      x: x + getWindowScrollBarX(element),
2641      y: y
2642    };
2643  }
2644
2645  // of the `<html>` and `<body>` rect bounds if horizontally scrollable
2646
2647  function getDocumentRect(element) {
2648    var _element$ownerDocumen;
2649
2650    var html = getDocumentElement(element);
2651    var winScroll = getWindowScroll(element);
2652    var body = (_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body;
2653    var width = max(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0);
2654    var height = max(html.scrollHeight, html.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0);
2655    var x = -winScroll.scrollLeft + getWindowScrollBarX(element);
2656    var y = -winScroll.scrollTop;
2657
2658    if (getComputedStyle$1(body || html).direction === 'rtl') {
2659      x += max(html.clientWidth, body ? body.clientWidth : 0) - width;
2660    }
2661
2662    return {
2663      width: width,
2664      height: height,
2665      x: x,
2666      y: y
2667    };
2668  }
2669
2670  function isScrollParent(element) {
2671    // Firefox wants us to check `-x` and `-y` variations as well
2672    var _getComputedStyle = getComputedStyle$1(element),
2673        overflow = _getComputedStyle.overflow,
2674        overflowX = _getComputedStyle.overflowX,
2675        overflowY = _getComputedStyle.overflowY;
2676
2677    return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX);
2678  }
2679
2680  function getScrollParent(node) {
2681    if (['html', 'body', '#document'].indexOf(getNodeName(node)) >= 0) {
2682      // $FlowFixMe[incompatible-return]: assume body is always available
2683      return node.ownerDocument.body;
2684    }
2685
2686    if (isHTMLElement(node) && isScrollParent(node)) {
2687      return node;
2688    }
2689
2690    return getScrollParent(getParentNode(node));
2691  }
2692
2693  /*
2694  given a DOM element, return the list of all scroll parents, up the list of ancesors
2695  until we get to the top window object. This list is what we attach scroll listeners
2696  to, because if any of these parent elements scroll, we'll need to re-calculate the
2697  reference element's position.
2698  */
2699
2700  function listScrollParents(element, list) {
2701    var _element$ownerDocumen;
2702
2703    if (list === void 0) {
2704      list = [];
2705    }
2706
2707    var scrollParent = getScrollParent(element);
2708    var isBody = scrollParent === ((_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body);
2709    var win = getWindow(scrollParent);
2710    var target = isBody ? [win].concat(win.visualViewport || [], isScrollParent(scrollParent) ? scrollParent : []) : scrollParent;
2711    var updatedList = list.concat(target);
2712    return isBody ? updatedList : // $FlowFixMe[incompatible-call]: isBody tells us target will be an HTMLElement here
2713    updatedList.concat(listScrollParents(getParentNode(target)));
2714  }
2715
2716  function rectToClientRect(rect) {
2717    return Object.assign({}, rect, {
2718      left: rect.x,
2719      top: rect.y,
2720      right: rect.x + rect.width,
2721      bottom: rect.y + rect.height
2722    });
2723  }
2724
2725  function getInnerBoundingClientRect(element) {
2726    var rect = getBoundingClientRect(element);
2727    rect.top = rect.top + element.clientTop;
2728    rect.left = rect.left + element.clientLeft;
2729    rect.bottom = rect.top + element.clientHeight;
2730    rect.right = rect.left + element.clientWidth;
2731    rect.width = element.clientWidth;
2732    rect.height = element.clientHeight;
2733    rect.x = rect.left;
2734    rect.y = rect.top;
2735    return rect;
2736  }
2737
2738  function getClientRectFromMixedType(element, clippingParent) {
2739    return clippingParent === viewport ? rectToClientRect(getViewportRect(element)) : isHTMLElement(clippingParent) ? getInnerBoundingClientRect(clippingParent) : rectToClientRect(getDocumentRect(getDocumentElement(element)));
2740  } // A "clipping parent" is an overflowable container with the characteristic of
2741  // clipping (or hiding) overflowing elements with a position different from
2742  // `initial`
2743
2744
2745  function getClippingParents(element) {
2746    var clippingParents = listScrollParents(getParentNode(element));
2747    var canEscapeClipping = ['absolute', 'fixed'].indexOf(getComputedStyle$1(element).position) >= 0;
2748    var clipperElement = canEscapeClipping && isHTMLElement(element) ? getOffsetParent(element) : element;
2749
2750    if (!isElement(clipperElement)) {
2751      return [];
2752    } // $FlowFixMe[incompatible-return]: https://github.com/facebook/flow/issues/1414
2753
2754
2755    return clippingParents.filter(function (clippingParent) {
2756      return isElement(clippingParent) && contains(clippingParent, clipperElement) && getNodeName(clippingParent) !== 'body'