https://smartdev.ai/assets/vendor/bootstrap/js/bootstrap.bundle.js

1/*!
2  * Bootstrap v5.0.1 (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.0.1): dom/selector-engine.js
15   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
16   * --------------------------------------------------------------------------
17   */
18
19  /**
20   * ------------------------------------------------------------------------
21   * Constants
22   * ------------------------------------------------------------------------
23   */
24  const NODE_TEXT = 3;
25  const SelectorEngine = {
26    find(selector, element = document.documentElement) {
27      return [].concat(...Element.prototype.querySelectorAll.call(element, selector));
28    },
29
30    findOne(selector, element = document.documentElement) {
31      return Element.prototype.querySelector.call(element, selector);
32    },
33
34    children(element, selector) {
35      return [].concat(...element.children).filter(child => child.matches(selector));
36    },
37
38    parents(element, selector) {
39      const parents = [];
40      let ancestor = element.parentNode;
41
42      while (ancestor && ancestor.nodeType === Node.ELEMENT_NODE && ancestor.nodeType !== NODE_TEXT) {
43        if (ancestor.matches(selector)) {
44          parents.push(ancestor);
45        }
46
47        ancestor = ancestor.parentNode;
48      }
49
50      return parents;
51    },
52
53    prev(element, selector) {
54      let previous = element.previousElementSibling;
55
56      while (previous) {
57        if (previous.matches(selector)) {
58          return [previous];
59        }
60
61        previous = previous.previousElementSibling;
62      }
63
64      return [];
65    },
66
67    next(element, selector) {
68      let next = element.nextElementSibling;
69
70      while (next) {
71        if (next.matches(selector)) {
72          return [next];
73        }
74
75        next = next.nextElementSibling;
76      }
77
78      return [];
79    }
80
81  };
82
83  /**
84   * --------------------------------------------------------------------------
85   * Bootstrap (v5.0.1): util/index.js
86   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
87   * --------------------------------------------------------------------------
88   */
89
90  const MAX_UID = 1000000;
91  const MILLISECONDS_MULTIPLIER = 1000;
92  const TRANSITION_END = 'transitionend'; // Shoutout AngusCroll (https://goo.gl/pxwQGp)
93
94  const toType = obj => {
95    if (obj === null || obj === undefined) {
96      return `${obj}`;
97    }
98
99    return {}.toString.call(obj).match(/\s([a-z]+)/i)[1].toLowerCase();
100  };
101  /**
102   * --------------------------------------------------------------------------
103   * Public Util Api
104   * --------------------------------------------------------------------------
105   */
106
107
108  const getUID = prefix => {
109    do {
110      prefix += Math.floor(Math.random() * MAX_UID);
111    } while (document.getElementById(prefix));
112
113    return prefix;
114  };
115
116  const getSelector = element => {
117    let selector = element.getAttribute('data-bs-target');
118
119    if (!selector || selector === '#') {
120      let hrefAttr = element.getAttribute('href'); // The only valid content that could double as a selector are IDs or classes,
121      // so everything starting with `#` or `.`. If a "real" URL is used as the selector,
122      // `document.querySelector` will rightfully complain it is invalid.
123      // See https://github.com/twbs/bootstrap/issues/32273
124
125      if (!hrefAttr || !hrefAttr.includes('#') && !hrefAttr.startsWith('.')) {
126        return null;
127      } // Just in case some CMS puts out a full URL with the anchor appended
128
129
130      if (hrefAttr.includes('#') && !hrefAttr.startsWith('#')) {
131        hrefAttr = `#${hrefAttr.split('#')[1]}`;
132      }
133
134      selector = hrefAttr && hrefAttr !== '#' ? hrefAttr.trim() : null;
135    }
136
137    return selector;
138  };
139
140  const getSelectorFromElement = element => {
141    const selector = getSelector(element);
142
143    if (selector) {
144      return document.querySelector(selector) ? selector : null;
145    }
146
147    return null;
148  };
149
150  const getElementFromSelector = element => {
151    const selector = getSelector(element);
152    return selector ? document.querySelector(selector) : null;
153  };
154
155  const getTransitionDurationFromElement = element => {
156    if (!element) {
157      return 0;
158    } // Get transition-duration of the element
159
160
161    let {
162      transitionDuration,
163      transitionDelay
164    } = window.getComputedStyle(element);
165    const floatTransitionDuration = Number.parseFloat(transitionDuration);
166    const floatTransitionDelay = Number.parseFloat(transitionDelay); // Return 0 if element or transition duration is not found
167
168    if (!floatTransitionDuration && !floatTransitionDelay) {
169      return 0;
170    } // If multiple durations are defined, take the first
171
172
173    transitionDuration = transitionDuration.split(',')[0];
174    transitionDelay = transitionDelay.split(',')[0];
175    return (Number.parseFloat(transitionDuration) + Number.parseFloat(transitionDelay)) * MILLISECONDS_MULTIPLIER;
176  };
177
178  const triggerTransitionEnd = element => {
179    element.dispatchEvent(new Event(TRANSITION_END));
180  };
181
182  const isElement$1 = obj => {
183    if (!obj || typeof obj !== 'object') {
184      return false;

417  const customEventsRegex = /^(mouseenter|mouseleave)/i;
418  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']);
419  /**
420   * ------------------------------------------------------------------------
421   * Private methods
422   * ------------------------------------------------------------------------
423   */
424
425  function getUidEvent(element, uid) {
426    return uid && `${uid}::${uidEvent++}` || element.uidEvent || uidEvent++;
427  }
428
429  function getEvent(element) {
430    const uid = getUidEvent(element);
431    element.uidEvent = uid;
432    eventRegistry[uid] = eventRegistry[uid] || {};
433    return eventRegistry[uid];
434  }
435
436  function bootstrapHandler(element, fn) {
437    return function handler(event) {
438      event.delegateTarget = element;
439
440      if (handler.oneOff) {
441        EventHandler.off(element, event.type, fn);
442      }
443
444      return fn.apply(element, [event]);
445    };
446  }
447
448  function bootstrapDelegationHandler(element, selector, fn) {
449    return function handler(event) {
450      const domElements = element.querySelectorAll(selector);
451
452      for (let {
453        target
454      } = event; target && target !== this; target = target.parentNode) {
455        for (let i = domElements.length; i--;) {
456          if (domElements[i] === target) {
457            event.delegateTarget = target;
458
459            if (handler.oneOff) {
460              // eslint-disable-next-line unicorn/consistent-destructuring
461              EventHandler.off(element, event.type, selector, fn);
462            }
463
464            return fn.apply(target, [event]);
465          }
466        }
467      } // To please ESLint
468
469
470      return null;
471    };
472  }
473
474  function findHandler(events, handler, delegationSelector = null) {
475    const uidEventList = Object.keys(events);
476
477    for (let i = 0, len = uidEventList.length; i < len; i++) {
478      const event = events[uidEventList[i]];
479
480      if (event.originalHandler === handler && event.delegationSelector === delegationSelector) {
481        return event;
482      }
483    }
484
485    return null;
486  }
487
488  function normalizeParams(originalTypeEvent, handler, delegationFn) {
489    const delegation = typeof handler === 'string';
490    const originalHandler = delegation ? delegationFn : handler;
491    let typeEvent = getTypeEvent(originalTypeEvent);
492    const isNative = nativeEvents.has(typeEvent);
493
494    if (!isNative) {
495      typeEvent = originalTypeEvent;
496    }
497
498    return [delegation, originalHandler, typeEvent];
499  }
500
501  function addHandler(element, originalTypeEvent, handler, delegationFn, oneOff) {
502    if (typeof originalTypeEvent !== 'string' || !element) {
503      return;
504    }
505
506    if (!handler) {
507      handler = delegationFn;
508      delegationFn = null;
509    } // in case of mouseenter or mouseleave wrap the handler within a function that checks for its DOM position
510    // this prevents the handler from being dispatched the same way as mouseover or mouseout does
511
512
513    if (customEventsRegex.test(originalTypeEvent)) {
514      const wrapFn = fn => {
515        return function (event) {
516          if (!event.relatedTarget || event.relatedTarget !== event.delegateTarget && !event.delegateTarget.contains(event.relatedTarget)) {
517            return fn.call(this, event);
518          }
519        };
520      };
521
522      if (delegationFn) {
523        delegationFn = wrapFn(delegationFn);
524      } else {
525        handler = wrapFn(handler);
526      }
527    }
528
529    const [delegation, originalHandler, typeEvent] = normalizeParams(originalTypeEvent, handler, delegationFn);
530    const events = getEvent(element);
531    const handlers = events[typeEvent] || (events[typeEvent] = {});
532    const previousFn = findHandler(handlers, originalHandler, delegation ? handler : null);
533
534    if (previousFn) {
535      previousFn.oneOff = previousFn.oneOff && oneOff;
536      return;
537    }
538
539    const uid = getUidEvent(originalHandler, originalTypeEvent.replace(namespaceRegex, ''));
540    const fn = delegation ? bootstrapDelegationHandler(element, handler, delegationFn) : bootstrapHandler(element, handler);
541    fn.delegationSelector = delegation ? handler : null;
542    fn.originalHandler = originalHandler;
543    fn.oneOff = oneOff;
544    fn.uidEvent = uid;
545    handlers[uid] = fn;
546    element.addEventListener(typeEvent, fn, delegation);
547  }
548
549  function removeHandler(element, events, typeEvent, handler, delegationSelector) {
550    const fn = findHandler(events[typeEvent], handler, delegationSelector);
551
552    if (!fn) {
553      return;
554    }
555
556    element.removeEventListener(typeEvent, fn, Boolean(delegationSelector));
557    delete events[typeEvent][fn.uidEvent];
558  }
559
560  function removeNamespacedHandlers(element, events, typeEvent, namespace) {
561    const storeElementEvent = events[typeEvent] || {};
562    Object.keys(storeElementEvent).forEach(handlerKey => {
563      if (handlerKey.includes(namespace)) {
564        const event = storeElementEvent[handlerKey];
565        removeHandler(element, events, typeEvent, event.originalHandler, event.delegationSelector);
566      }
567    });
568  }
569
570  function getTypeEvent(event) {
571    // allow to get the native events from namespaced events ('click.bs.button' --> 'click')
572    event = event.replace(stripNameRegex, '');
573    return customEvents[event] || event;
574  }
575
576  const EventHandler = {
577    on(element, event, handler, delegationFn) {
578      addHandler(element, event, handler, delegationFn, false);
579    },
580
581    one(element, event, handler, delegationFn) {
582      addHandler(element, event, handler, delegationFn, true);
583    },
584
585    off(element, originalTypeEvent, handler, delegationFn) {
586      if (typeof originalTypeEvent !== 'string' || !element) {
587        return;
588      }
589
590      const [delegation, originalHandler, typeEvent] = normalizeParams(originalTypeEvent, handler, delegationFn);
591      const inNamespace = typeEvent !== originalTypeEvent;
592      const events = getEvent(element);
593      const isNamespace = originalTypeEvent.startsWith('.');
594
595      if (typeof originalHandler !== 'undefined') {
596        // Simplest case: handler is passed, remove that listener ONLY.
597        if (!events || !events[typeEvent]) {
598          return;
599        }
600
601        removeHandler(element, events, typeEvent, originalHandler, delegation ? handler : null);
602        return;
603      }
604
605      if (isNamespace) {
606        Object.keys(events).forEach(elementEvent => {
607          removeNamespacedHandlers(element, events, elementEvent, originalTypeEvent.slice(1));
608        });
609      }
610
611      const storeElementEvent = events[typeEvent] || {};
612      Object.keys(storeElementEvent).forEach(keyHandlers => {
613        const handlerKey = keyHandlers.replace(stripUidRegex, '');
614
615        if (!inNamespace || originalTypeEvent.includes(handlerKey)) {
616          const event = storeElementEvent[keyHandlers];
617          removeHandler(element, events, typeEvent, event.originalHandler, event.delegationSelector);
618        }
619      });
620    },
621
622    trigger(element, event, args) {
623      if (typeof event !== 'string' || !element) {
624        return null;
625      }
626
627      const $ = getjQuery();
628      const typeEvent = getTypeEvent(event);
629      const inNamespace = event !== typeEvent;
630      const isNative = nativeEvents.has(typeEvent);
631      let jQueryEvent;
632      let bubbles = true;
633      let nativeDispatch = true;
634      let defaultPrevented = false;
635      let evt = null;
636
637      if (inNamespace && $) {
638        jQueryEvent = $.Event(event, args);
639        $(element).trigger(jQueryEvent);
640        bubbles = !jQueryEvent.isPropagationStopped();
641        nativeDispatch = !jQueryEvent.isImmediatePropagationStopped();
642        defaultPrevented = jQueryEvent.isDefaultPrevented();
643      }
644
645      if (isNative) {
646        evt = document.createEvent('HTMLEvents');
647        evt.initEvent(typeEvent, bubbles, true);
648      } else {
649        evt = new CustomEvent(event, {
650          bubbles,
651          cancelable: true
652        });
653      } // merge custom information in our event
654
655
656      if (typeof args !== 'undefined') {
657        Object.keys(args).forEach(key => {
658          Object.defineProperty(evt, key, {
659            get() {
660              return args[key];
661            }
662
663          });
664        });
665      }
666
667      if (defaultPrevented) {
668        evt.preventDefault();
669      }
670
671      if (nativeDispatch) {
672        element.dispatchEvent(evt);
673      }
674
675      if (evt.defaultPrevented && typeof jQueryEvent !== 'undefined') {
676        jQueryEvent.preventDefault();
677      }
678
679      return evt;
680    }
681
682  };
683
684  /**
685   * --------------------------------------------------------------------------
686   * Bootstrap (v5.0.1): base-component.js
687   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
688   * --------------------------------------------------------------------------
689   */
690  /**
691   * ------------------------------------------------------------------------
692   * Constants
693   * ------------------------------------------------------------------------
694   */
695
696  const VERSION = '5.0.1';
697
698  class BaseComponent {
699    constructor(element) {
700      element = getElement(element);
701
702      if (!element) {
703        return;
704      }
705
706      this._element = element;
707      Data.set(this._element, this.constructor.DATA_KEY, this);
708    }
709
710    dispose() {
711      Data.remove(this._element, this.constructor.DATA_KEY);
712      EventHandler.off(this._element, this.constructor.EVENT_KEY);

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

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

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

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

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