https://korfez.bel.tr/tasarim/bootstrap.bundle2.js

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  const NODE_TEXT = 3;
760  const SelectorEngine = {
761    find(selector, element = document.documentElement) {
762      return [].concat(...Element.prototype.querySelectorAll.call(element, selector));
763    },
764
765    findOne(selector, element = document.documentElement) {
766      return Element.prototype.querySelector.call(element, selector);
767    },
768
769    children(element, selector) {
770      return [].concat(...element.children).filter(child => child.matches(selector));
771    },
772
773    parents(element, selector) {
774      const parents = [];
775      let ancestor = element.parentNode;
776
777      while (ancestor && ancestor.nodeType === Node.ELEMENT_NODE && ancestor.nodeType !== NODE_TEXT) {
778        if (ancestor.matches(selector)) {
779          parents.push(ancestor);
780        }
781
782        ancestor = ancestor.parentNode;
783      }
784
785      return parents;
786    },
787
788    prev(element, selector) {
789      let previous = element.previousElementSibling;
790
791      while (previous) {
792        if (previous.matches(selector)) {
793          return [previous];
794        }
795
796        previous = previous.previousElementSibling;
797      }
798
799      return [];
800    },
801
802    next(element, selector) {
803      let next = element.nextElementSibling;
804
805      while (next) {
806        if (next.matches(selector)) {
807          return [next];
808        }
809
810        next = next.nextElementSibling;
811      }
812
813      return [];
814    },
815
816    focusableChildren(element) {
817      const focusables = ['a', 'button', 'input', 'textarea', 'select', 'details', '[tabindex]', '[contenteditable="true"]'].map(selector => `${selector}:not([tabindex^="-"])`).join(', ');
818      return this.find(focusables, element).filter(el => !isDisabled(el) && isVisible(el));
819    }
820
821  };
822
823  
824  /**
825   * ------------------------------------------------------------------------
826   * Constants
827   * ------------------------------------------------------------------------
828   */
829
830  const NAME$a = 'collapse';
831  const DATA_KEY$9 = 'bs.collapse';
832  const EVENT_KEY$9 = `.${DATA_KEY$9}`;
833  const DATA_API_KEY$5 = '.data-api';
834  const Default$9 = {
835    toggle: true,
836    parent: null
837  };
838  const DefaultType$9 = {
839    toggle: 'boolean',
840    parent: '(null|element)'
841  };
842  const EVENT_SHOW$5 = `show${EVENT_KEY$9}`;
843  const EVENT_SHOWN$5 = `shown${EVENT_KEY$9}`;
844  const EVENT_HIDE$5 = `hide${EVENT_KEY$9}`;
845  const EVENT_HIDDEN$5 = `hidden${EVENT_KEY$9}`;
846  const EVENT_CLICK_DATA_API$4 = `click${EVENT_KEY$9}${DATA_API_KEY$5}`;
847  const CLASS_NAME_SHOW$7 = 'show';
848  const CLASS_NAME_COLLAPSE = 'collapse';
849  const CLASS_NAME_COLLAPSING = 'collapsing';
850  const CLASS_NAME_COLLAPSED = 'collapsed';
851  const CLASS_NAME_DEEPER_CHILDREN = `:scope .${CLASS_NAME_COLLAPSE} .${CLASS_NAME_COLLAPSE}`;
852  const CLASS_NAME_HORIZONTAL = 'collapse-horizontal';
853  const WIDTH = 'width';
854  const HEIGHT = 'height';

1020
1021        this._element.classList.remove(CLASS_NAME_COLLAPSING);
1022
1023        this._element.classList.add(CLASS_NAME_COLLAPSE);
1024
1025        EventHandler.trigger(this._element, EVENT_HIDDEN$5);
1026      };
1027
1028      this._element.style[dimension] = '';
1029
1030      this._queueCallback(complete, this._element, true);
1031    }
1032
1033    _isShown(element = this._element) {
1034      return element.classList.contains(CLASS_NAME_SHOW$7);
1035    } // Private
1036
1037
1038    _getConfig(config) {
1039      config = { ...Default$9,
1040        ...Manipulator.getDataAttributes(this._element),
1041        ...config
1042      };
1043      config.toggle = Boolean(config.toggle); // Coerce string values
1044
1045      config.parent = getElement(config.parent);
1046      typeCheckConfig(NAME$a, config, DefaultType$9);
1047      return config;
1048    }
1049
1050    _getDimension() {
1051      return this._element.classList.contains(CLASS_NAME_HORIZONTAL) ? WIDTH : HEIGHT;
1052    }
1053
1054    _initializeChildren() {
1055      if (!this._config.parent) {
1056        return;
1057      }
1058
1059      const children = SelectorEngine.find(CLASS_NAME_DEEPER_CHILDREN, this._config.parent);
1060      SelectorEngine.find(SELECTOR_DATA_TOGGLE$4, this._config.parent).filter(elem => !children.includes(elem)).forEach(element => {
1061        const selected = getElementFromSelector(element);
1062
1063        if (selected) {
1064          this._addAriaAndCollapsedClass([element], this._isShown(selected));
1065        }
1066      });
1067    }
1068
1069    _addAriaAndCollapsedClass(triggerArray, isOpen) {
1070      if (!triggerArray.length) {
1071        return;
1072      }
1073
1074      triggerArray.forEach(elem => {
1075        if (isOpen) {
1076          elem.classList.remove(CLASS_NAME_COLLAPSED);
1077        } else {
1078          elem.classList.add(CLASS_NAME_COLLAPSED);
1079        }
1080
1081        elem.setAttribute('aria-expanded', isOpen);
1082      });
1083    } // Static
1084
1085
1086    static jQueryInterface(config) {
1087      return this.each(function () {
1088        const _config = {};
1089
1090        if (typeof config === 'string' && /show|hide/.test(config)) {
1091          _config.toggle = false;
1092        }
1093
1094        const data = Collapse.getOrCreateInstance(this, _config);
1095
1096        if (typeof config === 'string') {
1097          if (typeof data[config] === 'undefined') {
1098            throw new TypeError(`No method named "${config}"`);
1099          }
1100
1101          data[config]();
1102        }
1103      });
1104    }
1105
1106  }
1107  /**
1108   * ------------------------------------------------------------------------
1109   * Data Api implementation
1110   * ------------------------------------------------------------------------
1111   */
1112
1113
1114  EventHandler.on(document, EVENT_CLICK_DATA_API$4, SELECTOR_DATA_TOGGLE$4, function (event) {
1115    // preventDefault only for <a> elements (which change the URL) not inside the collapsible element
1116    if (event.target.tagName === 'A' || event.delegateTarget && event.delegateTarget.tagName === 'A') {
1117      event.preventDefault();
1118    }
1119
1120    const selector = getSelectorFromElement(this);
1121    const selectorElements = SelectorEngine.find(selector);
1122    selectorElements.forEach(element => {
1123      Collapse.getOrCreateInstance(element, {
1124        toggle: false
1125      }).toggle();
1126    });
1127  });
1128  /**
1129   * ------------------------------------------------------------------------
1130   * jQuery
1131   * ------------------------------------------------------------------------
1132   * add .Collapse to jQuery only if jQuery is present
1133   */
1134
1135  defineJQueryPlugin(Collapse);
1136
1137  var top = 'top';
1138  var bottom = 'bottom';
1139  var right = 'right';
1140  var left = 'left';
1141  var auto = 'auto';
1142  var basePlacements = [top, bottom, right, left];
1143  var start = 'start';
1144  var end = 'end';
1145  var clippingParents = 'clippingParents';
1146  var viewport = 'viewport';
1147  var popper = 'popper';
1148  var reference = 'reference';
1149  var variationPlacements = /*#__PURE__*/basePlacements.reduce(function (acc, placement) {
1150    return acc.concat([placement + "-" + start, placement + "-" + end]);
1151  }, []);
1152  var placements = /*#__PURE__*/[].concat(basePlacements, [auto]).reduce(function (acc, placement) {
1153    return acc.concat([placement, placement + "-" + start, placement + "-" + end]);
1154  }, []); // modifiers that need to read the DOM
1155
1156  var beforeRead = 'beforeRead';
1157  var read = 'read';
1158  var afterRead = 'afterRead'; // pure-logic modifiers
1159
1160  var beforeMain = 'beforeMain';
1161  var main = 'main';
1162  var afterMain = 'afterMain'; // modifier with the purpose to write to the DOM (or write into a framework state)
1163
1164  var beforeWrite = 'beforeWrite';
1165  var write = 'write';
1166  var afterWrite = 'afterWrite';
1167  var modifierPhases = [beforeRead, read, afterRead, beforeMain, main, afterMain, beforeWrite, write, afterWrite];
1168
1169  function getNodeName(element) {
1170    return element ? (element.nodeName || '').toLowerCase() : null;
1171  }
1172
1173  function getWindow(node) {
1174    if (node == null) {
1175      return window;
1176    }
1177
1178    if (node.toString() !== '[object Window]') {
1179      var ownerDocument = node.ownerDocument;
1180      return ownerDocument ? ownerDocument.defaultView || window : window;
1181    }
1182
1183    return node;
1184  }
1185
1186  function isElement(node) {
1187    var OwnElement = getWindow(node).Element;
1188    return node instanceof OwnElement || node instanceof Element;
1189  }
1190
1191  function isHTMLElement(node) {
1192    var OwnElement = getWindow(node).HTMLElement;
1193    return node instanceof OwnElement || node instanceof HTMLElement;
1194  }
1195
1196  function isShadowRoot(node) {
1197    // IE 11 has no ShadowRoot
1198    if (typeof ShadowRoot === 'undefined') {
1199      return false;

1200    }
1201
1202    var OwnElement = getWindow(node).ShadowRoot;
1203    return node instanceof OwnElement || node instanceof ShadowRoot;
1204  }
1205
1206  // and applies them to the HTMLElements such as popper and arrow
1207
1208  function applyStyles(_ref) {
1209    var state = _ref.state;
1210    Object.keys(state.elements).forEach(function (name) {
1211      var style = state.styles[name] || {};
1212      var attributes = state.attributes[name] || {};
1213      var element = state.elements[name]; // arrow is optional + virtual elements
1214
1215      if (!isHTMLElement(element) || !getNodeName(element)) {
1216        return;
1217      } // Flow doesn't support to extend this property, but it's the most
1218      // effective way to apply styles to an HTMLElement
1219      // $FlowFixMe[cannot-write]
1220
1221
1222      Object.assign(element.style, style);
1223      Object.keys(attributes).forEach(function (name) {
1224        var value = attributes[name];
1225
1226        if (value === false) {
1227          element.removeAttribute(name);
1228        } else {
1229          element.setAttribute(name, value === true ? '' : value);
1230        }
1231      });
1232    });
1233  }
1234
1235  function effect$2(_ref2) {
1236    var state = _ref2.state;
1237    var initialStyles = {
1238      popper: {
1239        position: state.options.strategy,
1240        left: '0',
1241        top: '0',
1242        margin: '0'
1243      },
1244      arrow: {
1245        position: 'absolute'
1246      },
1247      reference: {}
1248    };
1249    Object.assign(state.elements.popper.style, initialStyles.popper);
1250    state.styles = initialStyles;
1251
1252    if (state.elements.arrow) {
1253      Object.assign(state.elements.arrow.style, initialStyles.arrow);
1254    }
1255
1256    return function () {
1257      Object.keys(state.elements).forEach(function (name) {
1258        var element = state.elements[name];
1259        var attributes = state.attributes[name] || {};
1260        var styleProperties = Object.keys(state.styles.hasOwnProperty(name) ? state.styles[name] : initialStyles[name]); // Set all values to an empty string to unset them
1261
1262        var style = styleProperties.reduce(function (style, property) {
1263          style[property] = '';
1264          return style;
1265        }, {}); // arrow is optional + virtual elements
1266
1267        if (!isHTMLElement(element) || !getNodeName(element)) {
1268          return;
1269        }
1270
1271        Object.assign(element.style, style);
1272        Object.keys(attributes).forEach(function (attribute) {
1273          element.removeAttribute(attribute);
1274        });
1275      });
1276    };
1277  } // eslint-disable-next-line import/no-unused-modules
1278
1279
1280  const applyStyles$1 = {
1281    name: 'applyStyles',
1282    enabled: true,
1283    phase: 'write',
1284    fn: applyStyles,
1285    effect: effect$2,
1286    requires: ['computeStyles']
1287  };
1288
1289  function getBasePlacement(placement) {
1290    return placement.split('-')[0];
1291  }
1292
1293  // import { isHTMLElement } from './instanceOf';
1294  function getBoundingClientRect(element, // eslint-disable-next-line unused-imports/no-unused-vars
1295  includeScale) {
1296
1297    var rect = element.getBoundingClientRect();
1298    var scaleX = 1;
1299    var scaleY = 1; // FIXME:
1300    // `offsetWidth` returns an integer while `getBoundingClientRect`
1301    // returns a float. This results in `scaleX` or `scaleY` being
1302    // non-1 when it should be for elements that aren't a full pixel in
1303    // width or height.
1304    // if (isHTMLElement(element) && includeScale) {
1305    //   const offsetHeight = element.offsetHeight;
1306    //   const offsetWidth = element.offsetWidth;
1307    //   // Do not attempt to divide by 0, otherwise we get `Infinity` as scale
1308    //   // Fallback to 1 in case both values are `0`
1309    //   if (offsetWidth > 0) {
1310    //     scaleX = rect.width / offsetWidth || 1;
1311    //   }
1312    //   if (offsetHeight > 0) {
1313    //     scaleY = rect.height / offsetHeight || 1;
1314    //   }
1315    // }
1316
1317    return {
1318      width: rect.width / scaleX,
1319      height: rect.height / scaleY,
1320      top: rect.top / scaleY,
1321      right: rect.right / scaleX,
1322      bottom: rect.bottom / scaleY,
1323      left: rect.left / scaleX,
1324      x: rect.left / scaleX,
1325      y: rect.top / scaleY
1326    };
1327  }
1328
1329  // means it doesn't take into account transforms.
1330
1331  function getLayoutRect(element) {
1332    var clientRect = getBoundingClientRect(element); // Use the clientRect sizes if it's not been transformed.
1333    // Fixes https://github.com/popperjs/popper-core/issues/1223
1334
1335    var width = element.offsetWidth;
1336    var height = element.offsetHeight;
1337
1338    if (Math.abs(clientRect.width - width) <= 1) {
1339      width = clientRect.width;
1340    }
1341
1342    if (Math.abs(clientRect.height - height) <= 1) {
1343      height = clientRect.height;
1344    }
1345
1346    return {
1347      x: element.offsetLeft,
1348      y: element.offsetTop,
1349      width: width,
1350      height: height
1351    };
1352  }
1353
1354  function contains(parent, child) {
1355    var rootNode = child.getRootNode && child.getRootNode(); // First, attempt with faster native method
1356
1357    if (parent.contains(child)) {
1358      return true;
1359    } // then fallback to custom implementation with Shadow DOM support
1360    else if (rootNode && isShadowRoot(rootNode)) {
1361        var next = child;
1362
1363        do {
1364          if (next && parent.isSameNode(next)) {
1365            return true;
1366          } // $FlowFixMe[prop-missing]: need a better way to handle this...
1367
1368
1369          next = next.parentNode || next.host;
1370        } while (next);
1371      } // Give up, the result is false
1372
1373
1374    return false;

1375  }
1376
1377  function getComputedStyle$1(element) {
1378    return getWindow(element).getComputedStyle(element);
1379  }
1380
1381  function isTableElement(element) {
1382    return ['table', 'td', 'th'].indexOf(getNodeName(element)) >= 0;
1383  }
1384
1385  function getDocumentElement(element) {
1386    // $FlowFixMe[incompatible-return]: assume body is always available
1387    return ((isElement(element) ? element.ownerDocument : // $FlowFixMe[prop-missing]
1388    element.document) || window.document).documentElement;
1389  }
1390
1391  function getParentNode(element) {
1392    if (getNodeName(element) === 'html') {
1393      return element;
1394    }
1395
1396    return (// this is a quicker (but less type safe) way to save quite some bytes from the bundle
1397      // $FlowFixMe[incompatible-return]
1398      // $FlowFixMe[prop-missing]
1399      element.assignedSlot || // step into the shadow DOM of the parent of a slotted node
1400      element.parentNode || ( // DOM Element detected
1401      isShadowRoot(element) ? element.host : null) || // ShadowRoot detected
1402      // $FlowFixMe[incompatible-call]: HTMLElement is a Node
1403      getDocumentElement(element) // fallback
1404
1405    );
1406  }
1407
1408  function getTrueOffsetParent(element) {
1409    if (!isHTMLElement(element) || // https://github.com/popperjs/popper-core/issues/837
1410    getComputedStyle$1(element).position === 'fixed') {
1411      return null;
1412    }
1413
1414    return element.offsetParent;
1415  } // `.offsetParent` reports `null` for fixed elements, while absolute elements
1416  // return the containing block
1417
1418
1419  function getContainingBlock(element) {
1420    var isFirefox = navigator.userAgent.toLowerCase().indexOf('firefox') !== -1;
1421    var isIE = navigator.userAgent.indexOf('Trident') !== -1;
1422
1423    if (isIE && isHTMLElement(element)) {
1424      // In IE 9, 10 and 11 fixed elements containing block is always established by the viewport
1425      var elementCss = getComputedStyle$1(element);
1426
1427      if (elementCss.position === 'fixed') {
1428        return null;
1429      }
1430    }
1431
1432    var currentNode = getParentNode(element);
1433
1434    while (isHTMLElement(currentNode) && ['html', 'body'].indexOf(getNodeName(currentNode)) < 0) {
1435      var css = getComputedStyle$1(currentNode); // This is non-exhaustive but covers the most common CSS properties that
1436      // create a containing block.
1437      // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
1438
1439      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') {
1440        return currentNode;
1441      } else {
1442        currentNode = currentNode.parentNode;
1443      }
1444    }
1445
1446    return null;
1447  } // Gets the closest ancestor positioned element. Handles some edge cases,
1448  // such as table ancestors and cross browser bugs.
1449
1450
1451  function getOffsetParent(element) {
1452    var window = getWindow(element);
1453    var offsetParent = getTrueOffsetParent(element);
1454
1455    while (offsetParent && isTableElement(offsetParent) && getComputedStyle$1(offsetParent).position === 'static') {
1456      offsetParent = getTrueOffsetParent(offsetParent);
1457    }
1458
1459    if (offsetParent && (getNodeName(offsetParent) === 'html' || getNodeName(offsetParent) === 'body' && getComputedStyle$1(offsetParent).position === 'static')) {
1460      return window;
1461    }
1462
1463    return offsetParent || getContainingBlock(element) || window;
1464  }
1465
1466  function getMainAxisFromPlacement(placement) {
1467    return ['top', 'bottom'].indexOf(placement) >= 0 ? 'x' : 'y';
1468  }
1469
1470  var max = Math.max;
1471  var min = Math.min;
1472  var round = Math.round;
1473
1474  function within(min$1, value, max$1) {
1475    return max(min$1, min(value, max$1));
1476  }
1477
1478  function getFreshSideObject() {
1479    return {
1480      top: 0,
1481      right: 0,
1482      bottom: 0,
1483      left: 0
1484    };
1485  }
1486
1487  function mergePaddingObject(paddingObject) {
1488    return Object.assign({}, getFreshSideObject(), paddingObject);
1489  }
1490
1491  function expandToHashMap(value, keys) {
1492    return keys.reduce(function (hashMap, key) {
1493      hashMap[key] = value;
1494      return hashMap;
1495    }, {});
1496  }
1497
1498  var toPaddingObject = function toPaddingObject(padding, state) {
1499    padding = typeof padding === 'function' ? padding(Object.assign({}, state.rects, {
1500      placement: state.placement
1501    })) : padding;
1502    return mergePaddingObject(typeof padding !== 'number' ? padding : expandToHashMap(padding, basePlacements));
1503  };
1504
1505  function arrow(_ref) {
1506    var _state$modifiersData$;
1507
1508    var state = _ref.state,
1509        name = _ref.name,
1510        options = _ref.options;
1511    var arrowElement = state.elements.arrow;
1512    var popperOffsets = state.modifiersData.popperOffsets;
1513    var basePlacement = getBasePlacement(state.placement);
1514    var axis = getMainAxisFromPlacement(basePlacement);
1515    var isVertical = [left, right].indexOf(basePlacement) >= 0;
1516    var len = isVertical ? 'height' : 'width';
1517
1518    if (!arrowElement || !popperOffsets) {
1519      return;
1520    }
1521
1522    var paddingObject = toPaddingObject(options.padding, state);
1523    var arrowRect = getLayoutRect(arrowElement);
1524    var minProp = axis === 'y' ? top : left;
1525    var maxProp = axis === 'y' ? bottom : right;
1526    var endDiff = state.rects.reference[len] + state.rects.reference[axis] - popperOffsets[axis] - state.rects.popper[len];
1527    var startDiff = popperOffsets[axis] - state.rects.reference[axis];
1528    var arrowOffsetParent = getOffsetParent(arrowElement);
1529    var clientSize = arrowOffsetParent ? axis === 'y' ? arrowOffsetParent.clientHeight || 0 : arrowOffsetParent.clientWidth || 0 : 0;
1530    var centerToReference = endDiff / 2 - startDiff / 2; // Make sure the arrow doesn't overflow the popper if the center point is
1531    // outside of the popper bounds
1532
1533    var min = paddingObject[minProp];
1534    var max = clientSize - arrowRect[len] - paddingObject[maxProp];
1535    var center = clientSize / 2 - arrowRect[len] / 2 + centerToReference;
1536    var offset = within(min, center, max); // Prevents breaking syntax highlighting...
1537
1538    var axisProp = axis;
1539    state.modifiersData[name] = (_state$modifiersData$ = {}, _state$modifiersData$[axisProp] = offset, _state$modifiersData$.centerOffset = offset - center, _state$modifiersData$);
1540  }
1541
1542  function effect$1(_ref2) {
1543    var state = _ref2.state,
1544        options = _ref2.options;
1545    var _options$element = options.element,
1546        arrowElement = _options$element === void 0 ? '[data-popper-arrow]' : _options$element;
1547
1548    if (arrowElement == null) {
1549      return;
1550    } // CSS selector
1551
1552
1553    if (typeof arrowElement === 'string') {
1554      arrowElement = state.elements.popper.querySelector(arrowElement);
1555
1556      if (!arrowElement) {
1557        return;
1558      }
1559    }
1560
1561    if (!contains(state.elements.popper, arrowElement)) {
1562
1563      return;
1564    }
1565
1566    state.elements.arrow = arrowElement;
1567  } // eslint-disable-next-line import/no-unused-modules
1568
1569
1570  const arrow$1 = {
1571    name: 'arrow',
1572    enabled: true,
1573    phase: 'main',
1574    fn: arrow,
1575    effect: effect$1,
1576    requires: ['popperOffsets'],
1577    requiresIfExists: ['preventOverflow']
1578  };
1579
1580  function getVariation(placement) {
1581    return placement.split('-')[1];
1582  }
1583
1584  var unsetSides = {
1585    top: 'auto',
1586    right: 'auto',
1587    bottom: 'auto',
1588    left: 'auto'
1589  }; // Round the offsets to the nearest suitable subpixel based on the DPR.
1590  // Zooming can change the DPR, but it seems to report a value that will
1591  // cleanly divide the values into the appropriate subpixels.
1592
1593  function roundOffsetsByDPR(_ref) {
1594    var x = _ref.x,
1595        y = _ref.y;
1596    var win = window;
1597    var dpr = win.devicePixelRatio || 1;
1598    return {
1599      x: round(round(x * dpr) / dpr) || 0,
1600      y: round(round(y * dpr) / dpr) || 0
1601    };
1602  }
1603
1604  function mapToStyles(_ref2) {
1605    var _Object$assign2;
1606
1607    var popper = _ref2.popper,
1608        popperRect = _ref2.popperRect,
1609        placement = _ref2.placement,
1610        variation = _ref2.variation,
1611        offsets = _ref2.offsets,
1612        position = _ref2.position,
1613        gpuAcceleration = _ref2.gpuAcceleration,
1614        adaptive = _ref2.adaptive,
1615        roundOffsets = _ref2.roundOffsets;
1616
1617    var _ref3 = roundOffsets === true ? roundOffsetsByDPR(offsets) : typeof roundOffsets === 'function' ? roundOffsets(offsets) : offsets,
1618        _ref3$x = _ref3.x,
1619        x = _ref3$x === void 0 ? 0 : _ref3$x,
1620        _ref3$y = _ref3.y,
1621        y = _ref3$y === void 0 ? 0 : _ref3$y;
1622
1623    var hasX = offsets.hasOwnProperty('x');
1624    var hasY = offsets.hasOwnProperty('y');
1625    var sideX = left;
1626    var sideY = top;
1627    var win = window;
1628
1629    if (adaptive) {
1630      var offsetParent = getOffsetParent(popper);
1631      var heightProp = 'clientHeight';

1632      var widthProp = 'clientWidth';
1633
1634      if (offsetParent === getWindow(popper)) {
1635        offsetParent = getDocumentElement(popper);
1636
1637        if (getComputedStyle$1(offsetParent).position !== 'static' && position === 'absolute') {
1638          heightProp = 'scrollHeight';
1639          widthProp = 'scrollWidth';
1640        }
1641      } // $FlowFixMe[incompatible-cast]: force type refinement, we compare offsetParent with window above, but Flow doesn't detect it
1642
1643
1644      offsetParent = offsetParent;
1645
1646      if (placement === top || (placement === left || placement === right) && variation === end) {
1647        sideY = bottom; // $FlowFixMe[prop-missing]
1648
1649        y -= offsetParent[heightProp] - popperRect.height;
1650        y *= gpuAcceleration ? 1 : -1;
1651      }
1652
1653      if (placement === left || (placement === top || placement === bottom) && variation === end) {
1654        sideX = right; // $FlowFixMe[prop-missing]
1655
1656        x -= offsetParent[widthProp] - popperRect.width;
1657        x *= gpuAcceleration ? 1 : -1;
1658      }
1659    }
1660
1661    var commonStyles = Object.assign({
1662      position: position
1663    }, adaptive && unsetSides);
1664
1665    if (gpuAcceleration) {
1666      var _Object$assign;
1667
1668      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));
1669    }
1670
1671    return Object.assign({}, commonStyles, (_Object$assign2 = {}, _Object$assign2[sideY] = hasY ? y + "px" : '', _Object$assign2[sideX] = hasX ? x + "px" : '', _Object$assign2.transform = '', _Object$assign2));
1672  }
1673
1674  function computeStyles(_ref4) {
1675    var state = _ref4.state,
1676        options = _ref4.options;
1677    var _options$gpuAccelerat = options.gpuAcceleration,
1678        gpuAcceleration = _options$gpuAccelerat === void 0 ? true : _options$gpuAccelerat,
1679        _options$adaptive = options.adaptive,
1680        adaptive = _options$adaptive === void 0 ? true : _options$adaptive,
1681        _options$roundOffsets = options.roundOffsets,
1682        roundOffsets = _options$roundOffsets === void 0 ? true : _options$roundOffsets;
1683
1684    var commonStyles = {
1685      placement: getBasePlacement(state.placement),
1686      variation: getVariation(state.placement),
1687      popper: state.elements.popper,
1688      popperRect: state.rects.popper,
1689      gpuAcceleration: gpuAcceleration
1690    };
1691
1692    if (state.modifiersData.popperOffsets != null) {
1693      state.styles.popper = Object.assign({}, state.styles.popper, mapToStyles(Object.assign({}, commonStyles, {
1694        offsets: state.modifiersData.popperOffsets,
1695        position: state.options.strategy,
1696        adaptive: adaptive,
1697        roundOffsets: roundOffsets
1698      })));
1699    }
1700
1701    if (state.modifiersData.arrow != null) {
1702      state.styles.arrow = Object.assign({}, state.styles.arrow, mapToStyles(Object.assign({}, commonStyles, {
1703        offsets: state.modifiersData.arrow,
1704        position: 'absolute',
1705        adaptive: false,
1706        roundOffsets: roundOffsets
1707      })));
1708    }
1709
1710    state.attributes.popper = Object.assign({}, state.attributes.popper, {
1711      'data-popper-placement': state.placement
1712    });
1713  } // eslint-disable-next-line import/no-unused-modules
1714
1715
1716  const computeStyles$1 = {
1717    name: 'computeStyles',
1718    enabled: true,
1719    phase: 'beforeWrite',
1720    fn: computeStyles,
1721    data: {}
1722  };
1723
1724  var passive = {
1725    passive: true
1726  };
1727
1728  function effect(_ref) {
1729    var state = _ref.state,
1730        instance = _ref.instance,
1731        options = _ref.options;
1732    var _options$scroll = options.scroll,
1733        scroll = _options$scroll === void 0 ? true : _options$scroll,
1734        _options$resize = options.resize,
1735        resize = _options$resize === void 0 ? true : _options$resize;
1736    var window = getWindow(state.elements.popper);
1737    var scrollParents = [].concat(state.scrollParents.reference, state.scrollParents.popper);
1738
1739    if (scroll) {
1740      scrollParents.forEach(function (scrollParent) {
1741        scrollParent.addEventListener('scroll', instance.update, passive);
1742      });
1743    }
1744
1745    if (resize) {
1746      window.addEventListener('resize', instance.update, passive);
1747    }
1748
1749    return function () {
1750      if (scroll) {

1830      height = visualViewport.height; // Uses Layout Viewport (like Chrome; Safari does not currently)
1831      // In Chrome, it returns a value very close to 0 (+/-) but contains rounding
1832      // errors due to floating point numbers, so we need to check precision.
1833      // Safari returns a number <= 0, usually < -1 when pinch-zoomed
1834      // Feature detection fails in mobile emulation mode in Chrome.
1835      // Math.abs(win.innerWidth / visualViewport.scale - visualViewport.width) <
1836      // 0.001
1837      // Fallback here: "Not Safari" userAgent
1838
1839      if (!/^((?!chrome|android).)*safari/i.test(navigator.userAgent)) {
1840        x = visualViewport.offsetLeft;
1841        y = visualViewport.offsetTop;
1842      }
1843    }
1844
1845    return {
1846      width: width,
1847      height: height,
1848      x: x + getWindowScrollBarX(element),
1849      y: y
1850    };
1851  }
1852
1853  // of the `<html>` and `<body>` rect bounds if horizontally scrollable
1854
1855  function getDocumentRect(element) {
1856    var _element$ownerDocumen;
1857
1858    var html = getDocumentElement(element);
1859    var winScroll = getWindowScroll(element);
1860    var body = (_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body;
1861    var width = max(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0);
1862    var height = max(html.scrollHeight, html.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0);
1863    var x = -winScroll.scrollLeft + getWindowScrollBarX(element);
1864    var y = -winScroll.scrollTop;
1865
1866    if (getComputedStyle$1(body || html).direction === 'rtl') {
1867      x += max(html.clientWidth, body ? body.clientWidth : 0) - width;
1868    }
1869
1870    return {
1871      width: width,
1872      height: height,
1873      x: x,
1874      y: y
1875    };
1876  }
1877
1878  function isScrollParent(element) {
1879    // Firefox wants us to check `-x` and `-y` variations as well
1880    var _getComputedStyle = getComputedStyle$1(element),
1881        overflow = _getComputedStyle.overflow,
1882        overflowX = _getComputedStyle.overflowX,
1883        overflowY = _getComputedStyle.overflowY;
1884
1885    return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX);
1886  }
1887
1888  function getScrollParent(node) {
1889    if (['html', 'body', '#document'].indexOf(getNodeName(node)) >= 0) {
1890      // $FlowFixMe[incompatible-return]: assume body is always available
1891      return node.ownerDocument.body;
1892    }
1893
1894    if (isHTMLElement(node) && isScrollParent(node)) {
1895      return node;
1896    }
1897
1898    return getScrollParent(getParentNode(node));
1899  }
1900
1901  /*
1902  given a DOM element, return the list of all scroll parents, up the list of ancesors
1903  until we get to the top window object. This list is what we attach scroll listeners
1904  to, because if any of these parent elements scroll, we'll need to re-calculate the
1905  reference element's position.
1906  */
1907
1908  function listScrollParents(element, list) {
1909    var _element$ownerDocumen;
1910
1911    if (list === void 0) {
1912      list = [];
1913    }
1914
1915    var scrollParent = getScrollParent(element);
1916    var isBody = scrollParent === ((_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body);
1917    var win = getWindow(scrollParent);
1918    var target = isBody ? [win].concat(win.visualViewport || [], isScrollParent(scrollParent) ? scrollParent : []) : scrollParent;
1919    var updatedList = list.concat(target);
1920    return isBody ? updatedList : // $FlowFixMe[incompatible-call]: isBody tells us target will be an HTMLElement here
1921    updatedList.concat(listScrollParents(getParentNode(target)));
1922  }
1923
1924  function rectToClientRect(rect) {
1925    return Object.assign({}, rect, {
1926      left: rect.x,
1927      top: rect.y,
1928      right: rect.x + rect.width,
1929      bottom: rect.y + rect.height
1930    });
1931  }
1932
1933  function getInnerBoundingClientRect(element) {
1934    var rect = getBoundingClientRect(element);
1935    rect.top = rect.top + element.clientTop;
1936    rect.left = rect.left + element.clientLeft;
1937    rect.bottom = rect.top + element.clientHeight;
1938    rect.right = rect.left + element.clientWidth;
1939    rect.width = element.clientWidth;
1940    rect.height = element.clientHeight;
1941    rect.x = rect.left;
1942    rect.y = rect.top;
1943    return rect;
1944  }
1945
1946  function getClientRectFromMixedType(element, clippingParent) {
1947    return clippingParent === viewport ? rectToClientRect(getViewportRect(element)) : isHTMLElement(clippingParent) ? getInnerBoundingClientRect(clippingParent) : rectToClientRect(getDocumentRect(getDocumentElement(element)));
1948  } // A "clipping parent" is an overflowable container with the characteristic of
1949  // clipping (or hiding) overflowing elements with a position different from
1950  // `initial`
1951
1952
1953  function getClippingParents(element) {
1954    var clippingParents = listScrollParents(getParentNode(element));
1955    var canEscapeClipping = ['absolute', 'fixed'].indexOf(getComputedStyle$1(element).position) >= 0;
1956    var clipperElement = canEscapeClipping && isHTMLElement(element) ? getOffsetParent(element) : element;
1957
1958    if (!isElement(clipperElement)) {
1959      return [];
1960    } // $FlowFixMe[incompatible-return]: https://github.com/facebook/flow/issues/1414
1961
1962
1963    return clippingParents.filter(function (clippingParent) {
1964      return isElement(clippingParent) && contains(clippingParent, clipperElement) && getNodeName(clippingParent) !== 'body'

1964;
1965    });
1966  } // Gets the maximum area that the element is visible in due to any number of
1967  // clipping parents
1968
1969
1970  function getClippingRect(element, boundary, rootBoundary) {
1971    var mainClippingParents = boundary === 'clippingParents' ? getClippingParents(element) : [].concat(boundary);
1972    var clippingParents = [].concat(mainClippingParents, [rootBoundary]);
1973    var firstClippingParent = clippingParents[0];
1974    var clippingRect = clippingParents.reduce(function (accRect, clippingParent) {
1975      var rect = getClientRectFromMixedType(element, clippingParent);
1976      accRect.top = max(rect.top, accRect.top);
1977      accRect.right = min(rect.right, accRect.right);
1978      accRect.bottom = min(rect.bottom, accRect.bottom);
1979      accRect.left = max(rect.left, accRect.left);
1980      return accRect;
1981    }, getClientRectFromMixedType(element, firstClippingParent));
1982    clippingRect.width = clippingRect.right - clippingRect.left;
1983    clippingRect.height = clippingRect.bottom - clippingRect.top;
1984    clippingRect.x = clippingRect.left;
1985    clippingRect.y = clippingRect.top;
1986    return clippingRect;
1987  }
1988
1989  function computeOffsets(_ref) {
1990    var reference = _ref.reference,
1991        element = _ref.element,
1992        placement = _ref.placement;
1993    var basePlacement = placement ? getBasePlacement(placement) : null;
1994    var variation = placement ? getVariation(placement) : null;
1995    var commonX = reference.x + reference.width / 2 - element.width / 2;
1996    var commonY = reference.y + reference.height / 2 - element.height / 2;
1997    var offsets;
1998
1999    switch (basePlacement) {
2000      case top:
2001        offsets = {
2002          x: commonX,
2003          y: reference.y - element.height
2004        };
2005        break;
2006
2007      case bottom:
2008        offsets = {
2009          x: commonX,
2010          y: reference.y + reference.height
2011        };
2012        break;
2013
2014      case right:
2015        offsets = {
2016          x: reference.x + reference.width,
2017          y: commonY
2018        };
2019        break;
2020
2021      case left:
2022        offsets = {
2023          x: reference.x - element.width,
2024          y: commonY
2025        };
2026        break;
2027
2028      default:
2029        offsets = {
2030          x: reference.x,
2031          y: reference.y
2032        };
2033    }
2034
2035    var mainAxis = basePlacement ? getMainAxisFromPlacement(basePlacement) : null;
2036
2037    if (mainAxis != null) {
2038      var len = mainAxis === 'y' ? 'height' : 'width';
2039
2040      switch (variation) {
2041        case start:
2042          offsets[mainAxis] = offsets[mainAxis] - (reference[len] / 2 - element[len] / 2);
2043          break;
2044
2045        case end:
2046          offsets[mainAxis] = offsets[mainAxis] + (reference[len] / 2 - element[len] / 2);
2047          break;
2048      }
2049    }
2050
2051    return offsets;
2052  }
2053
2054  function detectOverflow(state, options) {
2055    if (options === void 0) {
2056      options = {};
2057    }
2058
2059    var _options = options,
2060        _options$placement = _options.placement,
2061        placement = _options$placement === void 0 ? state.placement : _options$placement,
2062        _options$boundary = _options.boundary,
2063        boundary = _options$boundary === void 0 ? clippingParents : _options$boundary,
2064        _options$rootBoundary = _options.rootBoundary,
2065        rootBoundary = _options$rootBoundary === void 0 ? viewport : _options$rootBoundary,
2066        _options$elementConte = _options.elementContext,
2067        elementContext = _options$elementConte === void 0 ? popper : _options$elementConte,
2068        _options$altBoundary = _options.altBoundary,
2069        altBoundary = _options$altBoundary === void 0 ? false : _options$altBoundary,
2070        _options$padding = _options.padding,
2071        padding = _options$padding === void 0 ? 0 : _options$padding;
2072    var paddingObject = mergePaddingObject(typeof padding !== 'number' ? padding : expandToHashMap(padding, basePlacements));
2073    var altContext = elementContext === popper ? reference : popper;
2074    var popperRect = state.rects.popper;
2075    var element = state.elements[altBoundary ? altContext : elementContext];
2076    var clippingClientRect = getClippingRect(isElement(element) ? element : element.contextElement || getDocumentElement(state.elements.popper), boundary, rootBoundary);
2077    var referenceClientRect = getBoundingClientRect(state.elements.reference);
2078    var popperOffsets = computeOffsets({
2079      reference: referenceClientRect,
2080      element: popperRect,
2081      strategy: 'absolute',
2082      placement: placement
2083    });
2084    var popperClientRect = rectToClientRect(Object.assign({}, popperRect, popperOffsets));
2085    var elementClientRect = elementContext === popper ? popperClientRect : referenceClientRect; // positive = overflowing the clipping rect
2086    // 0 or negative = within the clipping rect
2087
2088    var overflowOffsets = {
2089      top: clippingClientRect.top - elementClientRect.top + paddingObject.top,
2090      bottom: elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom,
2091      left: clippingClientRect.left - elementClientRect.left + paddingObject.left,
2092      right: elementClientRect.right - clippingClientRect.right + paddingObject.right
2093    };
2094    var offsetData = state.modifiersData.offset; // Offsets can be applied only to the popper element
2095
2096    if (elementContext === popper && offsetData) {
2097      var offset = offsetData[placement];

2098      Object.keys(overflowOffsets).forEach(function (key) {
2099        var multiply = [right, bottom].indexOf(key) >= 0 ? 1 : -1;
2100        var axis = [top, bottom].indexOf(key) >= 0 ? 'y' : 'x';
2101        overflowOffsets[key] += offset[axis] * multiply;
2102      });
2103    }
2104
2105    return overflowOffsets;
2106  }
2107
2108  function computeAutoPlacement(state, options) {
2109    if (options === void 0) {
2110      options = {};
2111    }
2112
2113    var _options = options,
2114        placement = _options.placement,
2115        boundary = _options.boundary,
2116        rootBoundary = _options.rootBoundary,
2117        padding = _options.padding,
2118        flipVariations = _options.flipVariations,
2119        _options$allowedAutoP = _options.allowedAutoPlacements,
2120        allowedAutoPlacements = _options$allowedAutoP === void 0 ? placements : _options$allowedAutoP;
2121    var variation = getVariation(placement);
2122    var placements$1 = variation ? flipVariations ? variationPlacements : variationPlacements.filter(function (placement) {
2123      return getVariation(placement) === variation;
2124    }) : basePlacements;
2125    var allowedPlacements = placements$1.filter(function (placement) {
2126      return allowedAutoPlacements.indexOf(placement) >= 0;
2127    });
2128
2129    if (allowedPlacements.length === 0) {
2130      allowedPlacements = placements$1;
2131    } // $FlowFixMe[incompatible-type]: Flow seems to have problems with two array unions...
2132
2133
2134    var overflows = allowedPlacements.reduce(function (acc, placement) {
2135      acc[placement] = detectOverflow(state, {
2136        placement: placement,
2137        boundary: boundary,
2138        rootBoundary: rootBoundary,
2139        padding: padding
2140      })[getBasePlacement(placement)];
2141      return acc;
2142    }, {});
2143    return Object.keys(overflows).sort(function (a, b) {
2144      return overflows[a] - overflows[b];
2145    });
2146  }
2147
2148  function getExpandedFallbackPlacements(placement) {
2149    if (getBasePlacement(placement) === auto) {
2150      return [];
2151    }
2152
2153    var oppositePlacement = getOppositePlacement(placement);
2154    return [getOppositeVariationPlacement(placement), oppositePlacement, getOppositeVariationPlacement(oppositePlacement)];
2155  }
2156
2157  function flip(_ref) {
2158    var state = _ref.state,
2159        options = _ref.options,
2160        name = _ref.name;
2161
2162    if (state.modifiersData[name]._skip) {
2163      return;
2164    }
2165
2166    var _options$mainAxis = options.mainAxis,
2167        checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis,
2168        _options$altAxis = options.altAxis,
2169        checkAltAxis = _options$altAxis === void 0 ? true : _options$altAxis,
2170        specifiedFallbackPlacements = options.fallbackPlacements,
2171        padding = options.padding,
2172        boundary = options.boundary,
2173        rootBoundary = options.rootBoundary,
2174        altBoundary = options.altBoundary,
2175        _options$flipVariatio = options.flipVariations,
2176        flipVariations = _options$flipVariatio === void 0 ? true : _options$flipVariatio,
2177        allowedAutoPlacements = options.allowedAutoPlacements;
2178    var preferredPlacement = state.options.placement;
2179    var basePlacement = getBasePlacement(preferredPlacement);
2180    var isBasePlacement = basePlacement === preferredPlacement;
2181    var fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipVariations ? [getOppositePlacement(preferredPlacement)] : getExpandedFallbackPlacements(preferredPlacement));
2182    var placements = [preferredPlacement].concat(fallbackPlacements).reduce(function (acc, placement) {
2183      return acc.concat(getBasePlacement(placement) === auto ? computeAutoPlacement(state, {
2184        placement: placement,
2185        boundary: boundary,
2186        rootBoundary: rootBoundary,
2187        padding: padding,
2188        flipVariations: flipVariations,
2189        allowedAutoPlacements: allowedAutoPlacements
2190      }) : placement);
2191    }, []);
2192    var referenceRect = state.rects.reference;
2193    var popperRect = state.rects.popper;
2194    var checksMap = new Map();
2195    var makeFallbackChecks = true;
2196    var firstFittingPlacement = placements[0];
2197
2198    for (var i = 0; i < placements.length; i++) {
2199      var placement = placements[i];
2200
2201      var _basePlacement = getBasePlacement(placement);
2202
2203      var isStartVariation = getVariation(placement) === start;
2204      var isVertical = [top, bottom].indexOf(_basePlacement) >= 0;
2205      var len = isVertical ? 'width' : 'height';
2206      var overflow = detectOverflow(state, {
2207        placement: placement,
2208        boundary: boundary,
2209        rootBoundary: rootBoundary,
2210        altBoundary: altBoundary,
2211        padding: padding
2212      });
2213      var mainVariationSide = isVertical ? isStartVariation ? right : left : isStartVariation ? bottom : top;
2214
2215      if (referenceRect[len] > popperRect[len]) {
2216        mainVariationSide = getOppositePlacement(mainVariationSide);
2217      }
2218
2219      var altVariationSide = getOppositePlacement(mainVariationSide);
2220      var checks = [];
2221
2222      if (checkMainAxis) {
2223        checks.push(overflow[_basePlacement] <= 0);
2224      }
2225
2226      if (checkAltAxis) {
2227        checks.push(overflow[mainVariationSide] <= 0, overflow[altVariationSide] <= 0);
2228      }
2229
2230      if (checks.every(function (check) {
2231        return check;
2232      })) {
2233        firstFittingPlacement = placement;
2234        makeFallbackChecks = false;
2235        break;
2236      }
2237
2238      checksMap.set(placement, checks);
2239    }
2240
2241    if (makeFallbackChecks) {
2242      // `2` may be desired in some cases – research later
2243      var numberOfChecks = flipVariations ? 3 : 1;
2244
2245      var _loop = function _loop(_i) {
2246        var fittingPlacement = placements.find(function (placement) {
2247          var checks = checksMap.get(placement);
2248
2249          if (checks) {
2250            return checks.slice(0, _i).every(function (check) {
2251              return check;
2252            });
2253          }
2254        });
2255
2256        if (fittingPlacement) {
2257          firstFittingPlacement = fittingPlacement;
2258          return "break";
2259        }
2260      };
2261
2262      for (var _i = numberOfChecks; _i > 0; _i--) {
2263        var _ret = _loop(_i);
2264
2265        if (_ret === "break") break;
2266      }
2267    }
2268
2269    if (state.placement !== firstFittingPlacement) {
2270      state.modifiersData[name]._skip = true;
2271      state.placement = firstFittingPlacement;
2272      state.reset = true;
2273    }
2274  } // eslint-disable-next-line import/no-unused-modules
2275
2276
2277  const flip$1 = {
2278    name: 'flip',
2279    enabled: true,
2280    phase: 'main',
2281    fn: flip,
2282    requiresIfExists: ['offset'],
2283    data: {
2284      _skip: false
2285    }
2286  };
2287
2288  function getSideOffsets(overflow, rect, preventedOffsets) {
2289    if (preventedOffsets === void 0) {
2290      preventedOffsets = {
2291        x: 0,
2292        y: 0
2293      };
2294    }
2295
2296    return {
2297      top: overflow.top - rect.height - preventedOffsets.y,
2298      right: overflow.right - rect.width + preventedOffsets.x,
2299      bottom: overflow.bottom - rect.height + preventedOffsets.y,
2300      left: overflow.left - rect.width - preventedOffsets.x
2301    };
2302  }
2303
2304  function isAnySideFullyClipped(overflow) {
2305    return [top, right, bottom, left].some(function (side) {
2306      return overflow[side] >= 0;
2307    });
2308  }
2309
2310  function hide(_ref) {
2311    var state = _ref.state,
2312        name = _ref.name;
2313    var referenceRect = state.rects.reference;
2314    var popperRect = state.rects.popper;
2315    var preventedOffsets = state.modifiersData.preventOverflow;
2316    var referenceOverflow = detectOverflow(state, {
2317      elementContext: 'reference'
2318    });
2319    var popperAltOverflow = detectOverflow(state, {
2320      altBoundary: true
2321    });
2322    var referenceClippingOffsets = getSideOffsets(referenceOverflow, referenceRect);
2323    var popperEscapeOffsets = getSideOffsets(popperAltOverflow, popperRect, preventedOffsets);
2324    var isReferenceHidden = isAnySideFullyClipped(referenceClippingOffsets);
2325    var hasPopperEscaped = isAnySideFullyClipped(popperEscapeOffsets);
2326    state.modifiersData[name] = {
2327      referenceClippingOffsets: referenceClippingOffsets,
2328      popperEscapeOffsets: popperEscapeOffsets,
2329      isReferenceHidden: isReferenceHidden,
2330      hasPopperEscaped: hasPopperEscaped
2331    };
2332    state.attributes.popper = Object.assign({}, state.attributes.popper, {
2333      'data-popper-reference-hidden': isReferenceHidden,
2334      'data-popper-escaped': hasPopperEscaped
2335    });
2336  } // eslint-disable-next-line import/no-unused-modules
2337
2338
2339  const hide$1 = {
2340    name: 'hide',
2341    enabled: true,
2342    phase: 'main',
2343    requiresIfExists: ['preventOverflow'],
2344    fn: hide
2345  };
2346
2347  function distanceAndSkiddingToXY(placement, rects, offset) {
2348    var basePlacement = getBasePlacement(placement);
2349    var invertDistance = [left, top].indexOf(basePlacement) >= 0 ? -1 : 1;
2350
2351    var _ref = typeof offset === 'function' ? offset(Object.assign({}, rects, {
2352      placement: placement
2353    })) : offset,
2354        skidding = _ref[0],
2355        distance = _ref[1];
2356
2357    skidding = skidding || 0;
2358    distance = (distance || 0) * invertDistance;
2359    return [left, right].indexOf(basePlacement) >= 0 ? {
2360      x: distance,
2361      y: skidding
2362    } : {
2363      x: skidding,
2364      y: distance
2365    };
2366  }
2367
2368  function offset(_ref2) {
2369    var state = _ref2.state,
2370        options = _ref2.options,
2371        name = _ref2.name;
2372    var _options$offset = options.offset,
2373        offset = _options$offset === void 0 ? [0, 0] : _options$offset;
2374    var data = placements.reduce(function (acc, placement) {
2375      acc[placement] = distanceAndSkiddingToXY(placement, state.rects, offset);
2376      return acc;
2377    }, {});
2378    var _data$state$placement = data[state.placement],
2379        x = _data$state$placement.x,
2380        y = _data$state$placement.y;
2381
2382    if (state.modifiersData.popperOffsets != null) {
2383      state.modifiersData.popperOffsets.x += x;
2384      state.modifiersData.popperOffsets.y += y;
2385    }
2386
2387    state.modifiersData[name] = data;
2388  } // eslint-disable-next-line import/no-unused-modules
2389
2390
2391  const offset$1 = {
2392    name: 'offset',
2393    enabled: true,
2394    phase: 'main',
2395    requires: ['popperOffsets'],
2396    fn: offset
2397  };
2398
2399  function popperOffsets(_ref) {
2400    var state = _ref.state,
2401        name = _ref.name;
2402    // Offsets are the actual position the popper needs to have to be
2403    // properly positioned near its reference element
2404    // This is the most basic placement, and will be adjusted by
2405    // the modifiers in the next step
2406    state.modifiersData[name] = computeOffsets({
2407      reference: state.rects.reference,
2408      element: state.rects.popper,
2409      strategy: 'absolute',
2410      placement: state.placement
2411    });
2412  } // eslint-disable-next-line import/no-unused-modules
2413
2414
2415  const popperOffsets$1 = {
2416    name: 'popperOffsets',
2417    enabled: true,
2418    phase: 'read',
2419    fn: popperOffsets,
2420    data: {}
2421  };
2422
2423  function getAltAxis(axis) {
2424    return axis === 'x' ? 'y' : 'x';
2425  }
2426
2427  function preventOverflow(_ref) {
2428    var state = _ref.state,
2429        options = _ref.options,
2430        name = _ref.name;
2431    var _options$mainAxis = options.mainAxis,
2432        checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis,
2433        _options$altAxis = options.altAxis,
2434        checkAltAxis = _options$altAxis === void 0 ? false : _options$altAxis,
2435        boundary = options.boundary,
2436        rootBoundary = options.rootBoundary,
2437        altBoundary = options.altBoundary,
2438        padding = options.padding,
2439        _options$tether = options.tether,
2440        tether = _options$tether === void 0 ? true : _options$tether,
2441        _options$tetherOffset = options.tetherOffset,
2442        tetherOffset = _options$tetherOffset === void 0 ? 0 : _options$tetherOffset;
2443    var overflow = detectOverflow(state, {
2444      boundary: boundary,
2445      rootBoundary: rootBoundary,
2446      padding: padding,
2447      altBoundary: altBoundary
2448    });
2449    var basePlacement = getBasePlacement(state.placement);
2450    var variation = getVariation(state.placement);
2451    var isBasePlacement = !variation;
2452    var mainAxis = getMainAxisFromPlacement(basePlacement);
2453    var altAxis = getAltAxis(mainAxis);
2454    var popperOffsets = state.modifiersData.popperOffsets;
2455    var referenceRect = state.rects.reference;
2456    var popperRect = state.rects.popper;
2457    var tetherOffsetValue = typeof tetherOffset === 'function' ? tetherOffset(Object.assign({}, state.rects, {
2458      placement: state.placement
2459    })) : tetherOffset;
2460    var 

2460data = {
2461      x: 0,
2462      y: 0
2463    };
2464
2465    if (!popperOffsets) {
2466      return;
2467    }
2468
2469    if (checkMainAxis || checkAltAxis) {
2470      var mainSide = mainAxis === 'y' ? top : left;
2471      var altSide = mainAxis === 'y' ? bottom : right;
2472      var len = mainAxis === 'y' ? 'height' : 'width';
2473      var offset = popperOffsets[mainAxis];
2474      var min$1 = popperOffsets[mainAxis] + overflow[mainSide];
2475      var max$1 = popperOffsets[mainAxis] - overflow[altSide];
2476      var additive = tether ? -popperRect[len] / 2 : 0;
2477      var minLen = variation === start ? referenceRect[len] : popperRect[len];
2478      var maxLen = variation === start ? -popperRect[len] : -referenceRect[len]; // We need to include the arrow in the calculation so the arrow doesn't go
2479      // outside the reference bounds
2480
2481      var arrowElement = state.elements.arrow;
2482      var arrowRect = tether && arrowElement ? getLayoutRect(arrowElement) : {
2483        width: 0,
2484        height: 0
2485      };

2486      var arrowPaddingObject = state.modifiersData['arrow#persistent'] ? state.modifiersData['arrow#persistent'].padding : getFreshSideObject();
2487      var arrowPaddingMin = arrowPaddingObject[mainSide];
2488      var arrowPaddingMax = arrowPaddingObject[altSide]; // If the reference length is smaller than the arrow length, we don't want
2489      // to include its full size in the calculation. If the reference is small
2490      // and near the edge of a boundary, the popper can overflow even if the
2491      // reference is not overflowing as well (e.g. virtual elements with no
2492      // width or height)
2493
2494      var arrowLen = within(0, referenceRect[len], arrowRect[len]);
2495      var minOffset = isBasePlacement ? referenceRect[len] / 2 - additive - arrowLen - arrowPaddingMin - tetherOffsetValue : minLen - arrowLen - arrowPaddingMin - tetherOffsetValue;
2496      var maxOffset = isBasePlacement ? -referenceRect[len] / 2 + additive + arrowLen + arrowPaddingMax + tetherOffsetValue : maxLen + arrowLen + arrowPaddingMax + tetherOffsetValue;
2497      var arrowOffsetParent = state.elements.arrow && getOffsetParent(state.elements.arrow);
2498      var clientOffset = arrowOffsetParent ? mainAxis === 'y' ? arrowOffsetParent.clientTop || 0 : arrowOffsetParent.clientLeft || 0 : 0;
2499      var offsetModifierValue = state.modifiersData.offset ? state.modifiersData.offset[state.placement][mainAxis] : 0;
2500      var tetherMin = popperOffsets[mainAxis] + minOffset - offsetModifierValue - clientOffset;
2501      var tetherMax = popperOffsets[mainAxis] + maxOffset - offsetModifierValue;
2502
2503      if (checkMainAxis) {
2504        var preventedOffset = within(tether ? min(min$1, tetherMin) : min$1, offset, tether ? max(max$1, tetherMax) : max$1);
2505        popperOffsets[mainAxis] = preventedOffset;
2506        data[mainAxis] = preventedOffset - offset;
2507      }
2508
2509      if (checkAltAxis) {
2510        var _mainSide = mainAxis === 'x' ? top : left;
2511
2512        var _altSide = mainAxis === 'x' ? bottom : right;
2513
2514        var _offset = popperOffsets[altAxis];
2515
2516        var _min = _offset + overflow[_mainSide];
2517
2518        var _max = _offset - overflow[_altSide];
2519
2520        var _preventedOffset = within(tether ? min(_min, tetherMin) : _min, _offset, tether ? max(_max, tetherMax) : _max);
2521
2522        popperOffsets[altAxis] = _preventedOffset;
2523        data[altAxis] = _preventedOffset - _offset;
2524      }
2525    }
2526
2527    state.modifiersData[name] = data;
2528  } // eslint-disable-next-line import/no-unused-modules
2529
2530
2531  const preventOverflow$1 = {
2532    name: 'preventOverflow',
2533    enabled: true,
2534    phase: 'main',
2535    fn: preventOverflow,
2536    requiresIfExists: ['offset']
2537  };
2538
2539  function getHTMLElementScroll(element) {
2540    return {
2541      scrollLeft: element.scrollLeft,
2542      scrollTop: element.scrollTop
2543    };
2544  }
2545
2546  function getNodeScroll(node) {
2547    if (node === getWindow(node) || !isHTMLElement(node)) {
2548      return getWindowScroll(node);
2549    } else {
2550      return getHTMLElementScroll(node);
2551    }
2552  }
2553
2554  function isElementScaled(element) {
2555    var rect = element.getBoundingClientRect();
2556    var scaleX = rect.width / element.offsetWidth || 1;
2557    var scaleY = rect.height / element.offsetHeight || 1;
2558    return scaleX !== 1 || scaleY !== 1;
2559  } // Returns the composite rect of an element relative to its offsetParent.
2560  // Composite means it takes into account transforms as well as layout.
2561
2562
2563  function getCompositeRect(elementOrVirtualElement, offsetParent, isFixed) {
2564    if (isFixed === void 0) {
2565      isFixed = false;
2566    }
2567
2568    var isOffsetParentAnElement = isHTMLElement(offsetParent);
2569    isHTMLElement(offsetParent) && isElementScaled(offsetParent);
2570    var documentElement = getDocumentElement(offsetParent);
2571    var rect = getBoundingClientRect(elementOrVirtualElement);
2572    var scroll = {
2573      scrollLeft: 0,
2574      scrollTop: 0
2575    };
2576    var offsets = {
2577      x: 0,
2578      y: 0
2579    };
2580
2581    if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
2582      if (getNodeName(offsetParent) !== 'body' || // https://github.com/popperjs/popper-core/issues/1078
2583      isScrollParent(documentElement)) {
2584        scroll = getNodeScroll(offsetParent);
2585      }
2586
2587      if (isHTMLElement(offsetParent)) {
2588        offsets = getBoundingClientRect(offsetParent);
2589        offsets.x += offsetParent.clientLeft;
2590        offsets.y += offsetParent.clientTop;
2591      } else if (documentElement) {
2592        offsets.x = getWindowScrollBarX(documentElement);
2593      }
2594    }
2595
2596    return {
2597      x: rect.left + scroll.scrollLeft - offsets.x,
2598      y: rect.top + scroll.scrollTop - offsets.y,
2599      width: rect.width,
2600      height: rect.height
2601    };
2602  }
2603
2604  function order(modifiers) {
2605    var map = new Map();
2606    var visited = new Set();
2607    var result = [];

2608    modifiers.forEach(function (modifier) {
2609      map.set(modifier.name, modifier);
2610    }); // On visiting object, check for its dependencies and visit them recursively
2611
2612    function sort(modifier) {
2613      visited.add(modifier.name);
2614      var requires = [].concat(modifier.requires || [], modifier.requiresIfExists || []);
2615      requires.forEach(function (dep) {
2616        if (!visited.has(dep)) {
2617          var depModifier = map.get(dep);
2618
2619          if (depModifier) {
2620            sort(depModifier);
2621          }
2622        }
2623      });
2624      result.push(modifier);
2625    }
2626
2627    modifiers.forEach(function (modifier) {
2628      if (!visited.has(modifier.name)) {
2629        // check for visited object
2630        sort(modifier);
2631      }
2632    });
2633    return result;
2634  }
2635
2636  function orderModifiers(modifiers) {
2637    // order based on dependencies
2638    var orderedModifiers = order(modifiers); // order based on phase
2639
2640    return modifierPhases.reduce(function (acc, phase) {
2641      return acc.concat(orderedModifiers.filter(function (modifier) {
2642        return modifier.phase === phase;
2643      }));
2644    }, []);
2645  }
2646
2647  function debounce(fn) {
2648    var pending;
2649    return function () {
2650      if (!pending) {
2651        pending = new Promise(function (resolve) {
2652          Promise.resolve().then(function () {
2653            pending = undefined;
2654            resolve(fn());
2655          });
2656        });
2657      }
2658
2659      return pending;
2660    };
2661  }
2662
2663  function mergeByName(modifiers) {
2664    var merged = modifiers.reduce(function (merged, current) {
2665      var existing = merged[current.name];
2666      merged[current.name] = existing ? Object.assign({}, existing, current, {
2667        options: Object.assign({}, existing.options, current.options),
2668        data: Object.assign({}, existing.data, current.data)
2669      }) : current;
2670      return merged;
2671    }, {}); // IE11 does not support Object.values
2672
2673    return Object.keys(merged).map(function (key) {
2674      return merged[key];
2675    });
2676  }
2677
2678  var DEFAULT_OPTIONS = {
2679    placement: 'bottom',
2680    modifiers: [],
2681    strategy: 'absolute'
2682  };
2683
2684  function areValidElements() {
2685    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
2686      args[_key] = arguments[_key];
2687    }
2688
2689    return !args.some(function (element) {
2690      return !(element && typeof element.getBoundingClientRect === 'function');
2691    });
2692  }
2693
2694  function popperGenerator(generatorOptions) {
2695    if (generatorOptions === void 0) {
2696      generatorOptions = {};
2697    }
2698
2699    var _generatorOptions = generatorOptions,
2700        _generatorOptions$def = _generatorOptions.defaultModifiers,
2701        defaultModifiers = _generatorOptions$def === void 0 ? [] : _generatorOptions$def,
2702        _generatorOptions$def2 = _generatorOptions.defaultOptions,
2703        defaultOptions = _generatorOptions$def2 === void 0 ? DEFAULT_OPTIONS : _generatorOptions$def2;
2704    return function createPopper(reference, popper, options) {
2705      if (options === void 0) {
2706        options = defaultOptions;
2707      }
2708
2709      var state = {
2710        placement: 'bottom',
2711        orderedModifiers: [],
2712        options: Object.assign({}, DEFAULT_OPTIONS, defaultOptions),
2713        modifiersData: {},
2714        elements: {
2715          reference: reference,
2716          popper: popper
2717        },
2718        attributes: {},
2719        styles: {}
2720      };
2721      var effectCleanupFns = [];
2722      var isDestroyed = false;
2723      var instance = {
2724        state: state,
2725        setOptions: function setOptions(setOptionsAction) {
2726          var options = typeof setOptionsAction === 'function' ? setOptionsAction(state.options) : setOptionsAction;
2727          cleanupModifierEffects();
2728          state.options = Object.assign({}, defaultOptions, state.options, options);
2729          state.scrollParents = {
2730            reference: isElement(reference) ? listScrollParents(reference) : reference.contextElement ? listScrollParents(reference.contextElement) : [],
2731            popper: listScrollParents(popper)
2732          }; // Orders the modifiers based on their dependencies and `phase`
2733          // properties
2734
2735          var orderedModifiers = orderModifiers(mergeByName([].concat(defaultModifiers, state.options.modifiers))); // Strip out disabled modifiers
2736
2737          state.orderedModifiers = orderedModifiers.filter(function (m) {
2738            return m.enabled;
2739          }); // Validate the provided modifiers so that the consumer will get warned
2740
2741          runModifierEffects();
2742          return instance.update();
2743        },
2744        // Sync update – it will always be executed, even if not necessary. This
2745        // is useful for low frequency updates where sync behavior simplifies the
2746        // logic.
2747        // For high frequency updates (e.g. `resize` and `scroll` events), always
2748        // prefer the async Popper#update method
2749        forceUpdate: function forceUpdate() {
2750          if (isDestroyed) {
2751            return;
2752          }
2753
2754          var _state$elements = state.elements,
2755              reference = _state$elements.reference,
2756              popper = _state$elements.popper; // Don't proceed if `reference` or `popper` are not valid elements
2757          // anymore
2758
2759          if (!areValidElements(reference, popper)) {
2760
2761            return;
2762          } // Store the reference and popper rects to be read by modifiers
2763
2764
2765          state.rects = {
2766            reference: getCompositeRect(reference, getOffsetParent(popper), state.options.strategy === 'fixed'),
2767            popper: getLayoutRect(popper)
2768          }; // Modifiers have the ability to reset the current update cycle. The
2769          // most common use case for this is the `flip` modifier changing the
2770          // placement, which then needs to re-run all the modifiers, because the
2771          // logic was previously ran for the previous placement and is therefore
2772          // stale/incorrect
2773
2774          state.reset = false;
2775          state.placement = state.options.placement; // On each update cycle, the `modifiersData` property for each modifier
2776          // is filled with the initial data specified by the modifier. This means
2777          // it doesn't persist and is fresh on each update.
2778          // To ensure persistent data, use `${name}#persistent`
2779
2780          state.orderedModifiers.forEach(function (modifier) {
2781            return state.modifiersData[modifier.name] = Object.assign({}, modifier.data);
2782          });
2783
2784          for (var index = 0; index < state.orderedModifiers.length; index++) {
2785
2786            if (state.reset === true) {
2787              state.reset = false;
2788              index = -1;
2789              continue;
2790            }
2791
2792            var _state$orderedModifie = state.orderedModifiers[index],
2793                fn = _state$orderedModifie.fn,
2794                _state$orderedModifie2 = _state$orderedModifie.options,
2795                _options = _state$orderedModifie2 === void 0 ? {} : _state$orderedModifie2,
2796                name = _state$orderedModifie.name;
2797
2798            if (typeof fn === 'function') {
2799              state = fn({
2800                state: state,
2801                options: _options,
2802                name: name,
2803                instance: instance
2804              }) || state;
2805            }
2806          }
2807        },
2808        // Async and optimistically optimized update – it will not be executed if
2809        // not necessary (debounced to run at most once-per-tick)
2810        update: debounce(function () {
2811          return new Promise(function (resolve) {
2812            instance.forceUpdate();
2813            resolve(state);
2814          });
2815        }),
2816        destroy: function destroy() {
2817          cleanupModifierEffects();
2818          isDestroyed = true;
2819        }
2820      };
2821
2822      if (!areValidElements(reference, popper)) {
2823
2824        return instance;
2825      }
2826
2827      instance.setOptions(options).then(function (state) {
2828        if (!isDestroyed && options.onFirstUpdate) {
2829          options.onFirstUpdate(state);
2830        }
2831      }); // Modifiers have the ability to execute arbitrary code before the first
2832      // update cycle runs. They will be executed in the same order as the update
2833      // cycle. This is useful when a modifier adds some persistent data that
2834      // other modifiers need to use, but the modifier is run after the dependent
2835      // one.
2836
2837      function runModifierEffects() {
2838        state.orderedModifiers.forEach(function (_ref3) {
2839          var name = _ref3.name,
2840              _ref3$options = _ref3.options,
2841              options = _ref3$options === void 0 ? {} : _ref3$options,
2842              effect = _ref3.effect;
2843
2844          if (typeof effect === 'function') {
2845            var cleanupFn = effect({
2846              state: state,
2847              name: name,
2848              instance: instance,
2849              options: options
2850            });
2851
2852            var noopFn = function noopFn() {};
2853
2854            effectCleanupFns.push(cleanupFn || noopFn);
2855          }
2856        });
2857      }
2858
2859      function cleanupModifierEffects() {
2860        effectCleanupFns.forEach(function (fn) {
2861          return fn();
2862        });
2863        effectCleanupFns = [];
2864      }
2865
2866      return instance;
2867    };
2868  }
2869  var createPopper$2 = /*#__PURE__*/popperGenerator(); // eslint-disable-next-line import/no-unused-modules
2870
2871  var defaultModifiers$1 = [eventListeners, popperOffsets$1, computeStyles$1, applyStyles$1];
2872  var createPopper$1 = /*#__PURE__*/popperGenerator({
2873    defaultModifiers: defaultModifiers$1
2874  }); // eslint-disable-next-line import/no-unused-modules
2875
2876  var defaultModifiers = [eventListeners, popperOffsets$1, computeStyles$1, applyStyles$1, offset$1, flip$1, preventOverflow$1, arrow$1, hide$1];
2877  var createPopper = /*#__PURE__*/popperGenerator({
2878    defaultModifiers: defaultModifiers
2879  }); // eslint-disable-next-line import/no-unused-modules
2880
2881  const Popper = /*#__PURE__*/Object.freeze({
2882    __proto__: null,
2883    popperGenerator,
2884    detectOverflow,
2885    createPopperBase: createPopper$2,
2886    createPopper,
2887    createPopperLite: createPopper$1,
2888    top,
2889    bottom,
2890    right,
2891    left,
2892    auto,
2893    basePlacements,
2894    start,
2895    end,
2896    clippingParents,
2897    viewport,
2898    popper,
2899    reference,
2900    variationPlacements,
2901    placements,
2902    beforeRead,
2903    read,
2904    afterRead,
2905    beforeMain,
2906    main,
2907    afterMain,
2908    beforeWrite,
2909    write,
2910    afterWrite,
2911    modifierPhases,
2912    applyStyles: applyStyles$1,
2913    arrow: arrow$1,
2914    computeStyles: computeStyles$1,
2915    eventListeners,
2916    flip: flip$1,
2917    hide: hide$1,
2918    offset: offset$1,
2919    popperOffsets: popperOffsets$1,
2920    preventOverflow: preventOverflow$1
2921  });
2922
2923  /**
2924   * --------------------------------------------------------------------------
2925   * Bootstrap (v5.1.3): dropdown.js
2926   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
2927   * --------------------------------------------------------------------------
2928   */
2929  /**
2930   * ------------------------------------------------------------------------
2931   * Constants
2932   * ------------------------------------------------------------------------
2933   */
2934
2935  const NAME$9 = 'dropdown';
2936  const DATA_KEY$8 = 'bs.dropdown';
2937  const EVENT_KEY$8 = `.${DATA_KEY$8}`;