https://abcas3.auditedmedia.com/PFCenter/lib/bootstrap/dist/js/bootstrap.bundle.js

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

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

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

2011      Object.keys(attributes).forEach(function (name) {
2012        var value = attributes[name];
2013
2014        if (value === false) {
2015          element.removeAttribute(name);
2016        } else {
2017          element.setAttribute(name, value === true ? '' : value);
2018        }
2019      });
2020    });
2021  }
2022
2023  function effect$2(_ref2) {
2024    var state = _ref2.state;
2025    var initialStyles = {
2026      popper: {
2027        position: state.options.strategy,
2028        left: '0',
2029        top: '0',
2030        margin: '0'
2031      },
2032      arrow: {
2033        position: 'absolute'
2034      },
2035      reference: {}
2036    };
2037    Object.assign(state.elements.popper.style, initialStyles.popper);
2038    state.styles = initialStyles;
2039
2040    if (state.elements.arrow) {
2041      Object.assign(state.elements.arrow.style, initialStyles.arrow);
2042    }
2043
2044    return function () {
2045      Object.keys(state.elements).forEach(function (name) {
2046        var element = state.elements[name];
2047        var attributes = state.attributes[name] || {};
2048        var styleProperties = Object.keys(state.styles.hasOwnProperty(name) ? state.styles[name] : initialStyles[name]); // Set all values to an empty string to unset them
2049
2050        var style = styleProperties.reduce(function (style, property) {
2051          style[property] = '';
2052          return style;
2053        }, {}); // arrow is optional + virtual elements
2054
2055        if (!isHTMLElement(element) || !getNodeName(element)) {
2056          return;
2057        }
2058
2059        Object.assign(element.style, style);
2060        Object.keys(attributes).forEach(function (attribute) {
2061          element.removeAttribute(attribute);
2062        });
2063      });
2064    };
2065  } // eslint-disable-next-line import/no-unused-modules
2066
2067
2068  var applyStyles$1 = {
2069    name: 'applyStyles',
2070    enabled: true,
2071    phase: 'write',
2072    fn: applyStyles,
2073    effect: effect$2,
2074    requires: ['computeStyles']
2075  };
2076
2077  function getBasePlacement(placement) {
2078    return placement.split('-')[0];
2079  }
2080
2081  var round$1 = Math.round;
2082  function getBoundingClientRect(element, includeScale) {
2083    if (includeScale === void 0) {
2084      includeScale = false;
2085    }
2086
2087    var rect = element.getBoundingClientRect();
2088    var scaleX = 1;
2089    var scaleY = 1;
2090
2091    if (isHTMLElement(element) && includeScale) {
2092      // Fallback to 1 in case both values are `0`
2093      scaleX = rect.width / element.offsetWidth || 1;
2094      scaleY = rect.height / element.offsetHeight || 1;
2095    }
2096
2097    return {
2098      width: round$1(rect.width / scaleX),
2099      height: round$1(rect.height / scaleY),
2100      top: round$1(rect.top / scaleY),
2101      right: round$1(rect.right / scaleX),
2102      bottom: round$1(rect.bottom / scaleY),
2103      left: round$1(rect.left / scaleX),
2104      x: round$1(rect.left / scaleX),
2105      y: round$1(rect.top / scaleY)
2106    };
2107  }
2108
2109  // means it doesn't take into account transforms.
2110
2111  function getLayoutRect(element) {
2112    var clientRect = getBoundingClientRect(element); // Use the clientRect sizes if it's not been transformed.
2113    // Fixes https://github.com/popperjs/popper-core/issues/1223
2114
2115    var width = element.offsetWidth;
2116    var height = element.offsetHeight;
2117
2118    if (Math.abs(clientRect.width - width) <= 1) {
2119      width = clientRect.width;
2120    }
2121
2122    if (Math.abs(clientRect.height - height) <= 1) {
2123      height = clientRect.height;
2124    }
2125
2126    return {
2127      x: element.offsetLeft,
2128      y: element.offsetTop,
2129      width: width,
2130      height: height
2131    };
2132  }
2133
2134  function contains(parent, child) {
2135    var rootNode = child.getRootNode && child.getRootNode(); // First, attempt with faster native method
2136
2137    if (parent.contains(child)) {
2138      return true;
2139    } // then fallback to custom implementation with Shadow DOM support
2140    else if (rootNode && isShadowRoot(rootNode)) {
2141        var next = child;
2142
2143        do {
2144          if (next && parent.isSameNode(next)) {
2145            return true;
2146          } // $FlowFixMe[prop-missing]: need a better way to handle this...
2147
2148
2149          next = next.parentNode || next.host;
2150        } while (next);
2151      } // Give up, the result is false
2152
2153
2154    return false;
2155  }
2156
2157  function getComputedStyle$1(element) {
2158    return getWindow(element).getComputedStyle(element);
2159  }
2160
2161  function isTableElement(element) {
2162    return ['table', 'td', 'th'].indexOf(getNodeName(element)) >= 0;
2163  }
2164
2165  function getDocumentElement(element) {
2166    // $FlowFixMe[incompatible-return]: assume body is always available
2167    return ((isElement(element) ? element.ownerDocument : // $FlowFixMe[prop-missing]
2168    element.document) || window.document).documentElement;
2169  }
2170
2171  function getParentNode(element) {
2172    if (getNodeName(element) === 'html') {
2173      return element;
2174    }
2175
2176    return (// this is a quicker (but less type safe) way to save quite some bytes from the bundle
2177      // $FlowFixMe[incompatible-return]
2178      // $FlowFixMe[prop-missing]
2179      element.assignedSlot || // step into the shadow DOM of the parent of a slotted node
2180      element.parentNode || ( // DOM Element detected
2181      isShadowRoot(element) ? element.host : null) || // ShadowRoot detected
2182      // $FlowFixMe[incompatible-call]: HTMLElement is a Node
2183      getDocumentElement(element) // fallback
2184
2185    );
2186  }
2187
2188  function getTrueOffsetParent(element) {
2189    if (!isHTMLElement(element) || // https://github.com/popperjs/popper-core/issues/837
2190    getComputedStyle$1(element).position === 'fixed') {
2191      return null;
2192    }
2193
2194    return element.offsetParent;
2195  } // `.offsetParent` reports `null` for fixed elements, while absolute elements
2196  // return the containing block
2197
2198
2199  function getContainingBlock(element) {
2200    var isFirefox = navigator.userAgent.toLowerCase().indexOf('firefox') !== -1;
2201    var isIE = navigator.userAgent.indexOf('Trident') !== -1;
2202
2203    if (isIE && isHTMLElement(element)) {
2204      // In IE 9, 10 and 11 fixed elements containing block is always established by the viewport
2205      var elementCss = getComputedStyle$1(element);
2206
2207      if (elementCss.position === 'fixed') {
2208        return null;
2209      }
2210    }
2211
2212    var currentNode = getParentNode(element);
2213
2214    while (isHTMLElement(currentNode) && ['html', 'body'].indexOf(getNodeName(currentNode)) < 0) {
2215      var css = getComputedStyle$1(currentNode); // This is non-exhaustive but covers the most common CSS properties that
2216      // create a containing block.
2217      // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
2218
2219      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') {
2220        return currentNode;
2221      } else {
2222        currentNode = currentNode.parentNode;
2223      }
2224    }
2225
2226    return null;
2227  } // Gets the closest ancestor positioned element. Handles some edge cases,
2228  // such as table ancestors and cross browser bugs.
2229
2230
2231  function getOffsetParent(element) {
2232    var window = getWindow(element);
2233    var offsetParent = getTrueOffsetParent(element);
2234
2235    while (offsetParent && isTableElement(offsetParent) && getComputedStyle$1(offsetParent).position === 'static') {
2236      offsetParent = getTrueOffsetParent(offsetParent);
2237    }
2238
2239    if (offsetParent && (getNodeName(offsetParent) === 'html' || getNodeName(offsetParent) === 'body' && getComputedStyle$1(offsetParent).position === 'static')) {
2240      return window;
2241    }
2242
2243    return offsetParent || getContainingBlock(element) || window;
2244  }
2245
2246  function getMainAxisFromPlacement(placement) {
2247    return ['top', 'bottom'].indexOf(placement) >= 0 ? 'x' : 'y';
2248  }
2249
2250  var max = Math.max;
2251  var min = Math.min;
2252  var round = Math.round;
2253
2254  function within(min$1, value, max$1) {
2255    return max(min$1, min(value, max$1));
2256  }
2257
2258  function getFreshSideObject() {
2259    return {
2260      top: 0,
2261      right: 0,
2262      bottom: 0,
2263      left: 0
2264    };
2265  }
2266

2267  function mergePaddingObject(paddingObject) {
2268    return Object.assign({}, getFreshSideObject(), paddingObject);
2269  }
2270
2271  function expandToHashMap(value, keys) {
2272    return keys.reduce(function (hashMap, key) {
2273      hashMap[key] = value;
2274      return hashMap;
2275    }, {});
2276  }
2277
2278  var toPaddingObject = function toPaddingObject(padding, state) {
2279    padding = typeof padding === 'function' ? padding(Object.assign({}, state.rects, {
2280      placement: state.placement
2281    })) : padding;
2282    return mergePaddingObject(typeof padding !== 'number' ? padding : expandToHashMap(padding, basePlacements));
2283  };
2284
2285  function arrow(_ref) {
2286    var _state$modifiersData$;
2287
2288    var state = _ref.state,
2289        name = _ref.name,
2290        options = _ref.options;
2291    var arrowElement = state.elements.arrow;
2292    var popperOffsets = state.modifiersData.popperOffsets;
2293    var basePlacement = getBasePlacement(state.placement);
2294    var axis = getMainAxisFromPlacement(basePlacement);
2295    var isVertical = [left, right].indexOf(basePlacement) >= 0;
2296    var len = isVertical ? 'height' : 'width';
2297
2298    if (!arrowElement || !popperOffsets) {
2299      return;
2300    }
2301
2302    var paddingObject = toPaddingObject(options.padding, state);
2303    var arrowRect = getLayoutRect(arrowElement);
2304    var minProp = axis === 'y' ? top : left;
2305    var maxProp = axis === 'y' ? bottom : right;
2306    var endDiff = state.rects.reference[len] + state.rects.reference[axis] - popperOffsets[axis] - state.rects.popper[len];
2307    var startDiff = popperOffsets[axis] - state.rects.reference[axis];
2308    var arrowOffsetParent = getOffsetParent(arrowElement);
2309    var clientSize = arrowOffsetParent ? axis === 'y' ? arrowOffsetParent.clientHeight || 0 : arrowOffsetParent.clientWidth || 0 : 0;
2310    var centerToReference = endDiff / 2 - startDiff / 2; // Make sure the arrow doesn't overflow the popper if the center point is
2311    // outside of the popper bounds
2312
2313    var min = paddingObject[minProp];
2314    var max = clientSize - arrowRect[len] - paddingObject[maxProp];
2315    var center = clientSize / 2 - arrowRect[len] / 2 + centerToReference;
2316    var offset = within(min, center, max); // Prevents breaking syntax highlighting...
2317
2318    var axisProp = axis;
2319    state.modifiersData[name] = (_state$modifiersData$ = {}, _state$modifiersData$[axisProp] = offset, _state$modifiersData$.centerOffset = offset - center, _state$modifiersData$);
2320  }
2321
2322  function effect$1(_ref2) {
2323    var state = _ref2.state,
2324        options = _ref2.options;
2325    var _options$element = options.element,
2326        arrowElement = _options$element === void 0 ? '[data-popper-arrow]' : _options$element;
2327
2328    if (arrowElement == null) {
2329      return;
2330    } // CSS selector
2331
2332
2333    if (typeof arrowElement === 'string') {
2334      arrowElement = state.elements.popper.querySelector(arrowElement);
2335
2336      if (!arrowElement) {
2337        return;
2338      }
2339    }
2340
2341    if (!contains(state.elements.popper, arrowElement)) {
2342
2343      return;
2344    }
2345
2346    state.elements.arrow = arrowElement;
2347  } // eslint-disable-next-line import/no-unused-modules
2348
2349
2350  var arrow$1 = {
2351    name: 'arrow',
2352    enabled: true,
2353    phase: 'main',
2354    fn: arrow,
2355    effect: effect$1,
2356    requires: ['popperOffsets'],
2357    requiresIfExists: ['preventOverflow']
2358  };
2359
2360  var unsetSides = {
2361    top: 'auto',
2362    right: 'auto',
2363    bottom: 'auto',
2364    left: 'auto'
2365  }; // Round the offsets to the nearest suitable subpixel based on the DPR.
2366  // Zooming can change the DPR, but it seems to report a value that will
2367  // cleanly divide the values into the appropriate subpixels.
2368
2369  function roundOffsetsByDPR(_ref) {
2370    var x = _ref.x,
2371        y = _ref.y;
2372    var win = window;
2373    var dpr = win.devicePixelRatio || 1;
2374    return {
2375      x: round(round(x * dpr) / dpr) || 0,
2376      y: round(round(y * dpr) / dpr) || 0
2377    };
2378  }
2379
2380  function mapToStyles(_ref2) {
2381    var _Object$assign2;
2382
2383    var popper = _ref2.popper,
2384        popperRect = _ref2.popperRect,
2385        placement = _ref2.placement,
2386        offsets = _ref2.offsets,
2387        position = _ref2.position,
2388        gpuAcceleration = _ref2.gpuAcceleration,
2389        adaptive = _ref2.adaptive,
2390        roundOffsets = _ref2.roundOffsets;
2391
2392    var _ref3 = roundOffsets === true ? roundOffsetsByDPR(offsets) : typeof roundOffsets === 'function' ? roundOffsets(offsets) : offsets,
2393        _ref3$x = _ref3.x,
2394        x = _ref3$x === void 0 ? 0 : _ref3$x,
2395        _ref3$y = _ref3.y,
2396        y = _ref3$y === void 0 ? 0 : _ref3$y;
2397
2398    var hasX = offsets.hasOwnProperty('x');
2399    var hasY = offsets.hasOwnProperty('y');
2400    var sideX = left;
2401    var sideY = top;
2402    var win = window;
2403
2404    if (adaptive) {
2405      var offsetParent = getOffsetParent(popper);
2406      var heightProp = 'clientHeight';

2407      var widthProp = 'clientWidth';
2408
2409      if (offsetParent === getWindow(popper)) {
2410        offsetParent = getDocumentElement(popper);
2411
2412        if (getComputedStyle$1(offsetParent).position !== 'static') {
2413          heightProp = 'scrollHeight';
2414          widthProp = 'scrollWidth';
2415        }
2416      } // $FlowFixMe[incompatible-cast]: force type refinement, we compare offsetParent with window above, but Flow doesn't detect it
2417
2418
2419      offsetParent = offsetParent;
2420
2421      if (placement === top) {
2422        sideY = bottom; // $FlowFixMe[prop-missing]
2423
2424        y -= offsetParent[heightProp] - popperRect.height;
2425        y *= gpuAcceleration ? 1 : -1;
2426      }
2427
2428      if (placement === left) {
2429        sideX = right; // $FlowFixMe[prop-missing]
2430
2431        x -= offsetParent[widthProp] - popperRect.width;
2432        x *= gpuAcceleration ? 1 : -1;
2433      }
2434    }
2435
2436    var commonStyles = Object.assign({
2437      position: position
2438    }, adaptive && unsetSides);
2439
2440    if (gpuAcceleration) {
2441      var _Object$assign;
2442
2443      return Object.assign({}, commonStyles, (_Object$assign = {}, _Object$assign[sideY] = hasY ? '0' : '', _Object$assign[sideX] = hasX ? '0' : '', _Object$assign.transform = (win.devicePixelRatio || 1) < 2 ? "translate(" + x + "px, " + y + "px)" : "translate3d(" + x + "px, " + y + "px, 0)", _Object$assign));
2444    }
2445
2446    return Object.assign({}, commonStyles, (_Object$assign2 = {}, _Object$assign2[sideY] = hasY ? y + "px" : '', _Object$assign2[sideX] = hasX ? x + "px" : '', _Object$assign2.transform = '', _Object$assign2));
2447  }
2448
2449  function computeStyles(_ref4) {
2450    var state = _ref4.state,
2451        options = _ref4.options;
2452    var _options$gpuAccelerat = options.gpuAcceleration,
2453        gpuAcceleration = _options$gpuAccelerat === void 0 ? true : _options$gpuAccelerat,
2454        _options$adaptive = options.adaptive,
2455        adaptive = _options$adaptive === void 0 ? true : _options$adaptive,
2456        _options$roundOffsets = options.roundOffsets,
2457        roundOffsets = _options$roundOffsets === void 0 ? true : _options$roundOffsets;
2458
2459    var commonStyles = {
2460      placement: getBasePlacement(state.placement),
2461      popper: state.elements.popper,
2462      popperRect: state.rects.popper,
2463      gpuAcceleration: gpuAcceleration
2464    };
2465
2466    if (state.modifiersData.popperOffsets != null) {
2467      state.styles.popper = Object.assign({}, state.styles.popper, mapToStyles(Object.assign({}, commonStyles, {
2468        offsets: state.modifiersData.popperOffsets,
2469        position: state.options.strategy,
2470        adaptive: adaptive,
2471        roundOffsets: roundOffsets
2472      })));
2473    }
2474
2475    if (state.modifiersData.arrow != null) {
2476      state.styles.arrow = Object.assign({}, state.styles.arrow, mapToStyles(Object.assign({}, commonStyles, {
2477        offsets: state.modifiersData.arrow,
2478        position: 'absolute',
2479        adaptive: false,
2480        roundOffsets: roundOffsets
2481      })));
2482    }
2483
2484    state.attributes.popper = Object.assign({}, state.attributes.popper, {
2485      'data-popper-placement': state.placement
2486    });
2487  } // eslint-disable-next-line import/no-unused-modules
2488
2489
2490  var computeStyles$1 = {
2491    name: 'computeStyles',
2492    enabled: true,
2493    phase: 'beforeWrite',
2494    fn: computeStyles,
2495    data: {}
2496  };
2497
2498  var passive = {
2499    passive: true
2500  };
2501
2502  function effect(_ref) {
2503    var state = _ref.state,
2504        instance = _ref.instance,
2505        options = _ref.options;
2506    var _options$scroll = options.scroll,
2507        scroll = _options$scroll === void 0 ? true : _options$scroll,
2508        _options$resize = options.resize,
2509        resize = _options$resize === void 0 ? true : _options$resize;
2510    var window = getWindow(state.elements.popper);
2511    var scrollParents = [].concat(state.scrollParents.reference, state.scrollParents.popper);
2512
2513    if (scroll) {
2514      scrollParents.forEach(function (scrollParent) {
2515        scrollParent.addEventListener('scroll', instance.update, passive);
2516      });
2517    }
2518
2519    if (resize) {
2520      window.addEventListener('resize', instance.update, passive);
2521    }
2522
2523    return function () {
2524      if (scroll) {
2525        scrollParents.forEach(function (scrollParent) {
2526          scrollParent.removeEventListener('scroll', instance.update, passive);
2527        });
2528      }
2529
2530      if (resize) {
2531        window.removeEventListener('resize', instance.update, passive);
2532      }
2533    };
2534  } // eslint-disable-next-line import/no-unused-modules
2535
2536
2537  var eventListeners = {
2538    name: 'eventListeners',
2539    enabled: true,
2540    phase: 'write',
2541    fn: function fn() {},
2542    effect: effect,
2543    data: {}
2544  };
2545
2546  var hash$1 = {
2547    left: 'right',
2548    right: 'left',
2549    bottom: 'top',
2550    top: 'bottom'
2551  };
2552  function getOppositePlacement(placement) {
2553    return placement.replace(/left|right|bottom|top/g, function (matched) {
2554      return hash$1[matched];
2555    });
2556  }
2557
2558  var hash = {
2559    start: 'end',
2560    end: 'start'
2561  };
2562  function getOppositeVariationPlacement(placement) {
2563    return placement.replace(/start|end/g, function (matched) {
2564      return hash[matched];
2565    });
2566  }
2567
2568  function getWindowScroll(node) {
2569    var win = getWindow(node);
2570    var scrollLeft = win.pageXOffset;
2571    var scrollTop = win.pageYOffset;
2572    return {
2573      scrollLeft: scrollLeft,
2574      scrollTop: scrollTop
2575    };
2576  }
2577
2578  function getWindowScrollBarX(element) {
2579    // If <html> has a CSS width greater than the viewport, then this will be
2580    // incorrect for RTL.
2581    // Popper 1 is broken in this case and never had a bug report so let's assume
2582    // it's not an issue. I don't think anyone ever specifies width on <html>
2583    // anyway.
2584    // Browsers where the left scrollbar doesn't cause an issue report `0` for
2585    // this (e.g. Edge 2019, IE11, Safari)
2586    return getBoundingClientRect(getDocumentElement(element)).left + getWindowScroll(element).scrollLeft;
2587  }
2588
2589  function getViewportRect(element) {
2590    var win = getWindow(element);
2591    var html = getDocumentElement(element);

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