https://electriccityroasting.com/wp-content/themes/porto/js/bootstrap.js?ver=5.0.1

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;
185    }
186
187    if (typeof obj.jquery !== 'undefined') {
188      obj = obj[0];
189    }
190
191    return typeof obj.nodeType !== 'undefined';
192  };
193
194  const getElement = obj => {
195    if (isElement$1(obj)) {
196      // it's a jQuery object or a node element
197      return obj.jquery ? obj[0] : obj;
198    }
199
200    if (typeof obj === 'string' && obj.length > 0) {
201      return SelectorEngine.findOne(obj);
202    }
203
204    return null;
205  };
206
207  const emulateTransitionEnd = (element, duration) => {
208    let called = false;
209    const durationPadding = 5;
210    const emulatedDuration = duration + durationPadding;
211
212    function listener() {
213      called = true;
214      element.removeEventListener(TRANSITION_END, listener);
215    }
216
217    element.addEventListener(TRANSITION_END, listener);
218    setTimeout(() => {
219      if (!called) {
220        triggerTransitionEnd(element);
221      }
222    }, emulatedDuration);
223  };
224
225  const typeCheckConfig = (componentName, config, configTypes) => {
226    Object.keys(configTypes).forEach(property => {
227      const expectedTypes = configTypes[property];
228      const value = config[property];
229      const valueType = value && isElement$1(value) ? 'element' : toType(value);
230
231      if (!new RegExp(expectedTypes).test(valueType)) {
232        throw new TypeError(`${componentName.toUpperCase()}: Option "${property}" provided type "${valueType}" but expected type "${expectedTypes}".`);
233      }
234    });
235  };
236
237  const isVisible = element => {
238    if (!element) {
239      return false;
240    }
241
242    if (element.style && element.parentNode && element.parentNode.style) {
243      const elementStyle = getComputedStyle(element);
244      const parentNodeStyle = getComputedStyle(element.parentNode);
245      return elementStyle.display !== 'none' && parentNodeStyle.display !== 'none' && elementStyle.visibility !== 'hidden';
246    }
247
248    return false;
249  };
250
251  const isDisabled = element => {
252    if (!element || element.nodeType !== Node.ELEMENT_NODE) {
253      return true;
254    }
255
256    if (element.classList.contains('disabled')) {
257      return true;
258    }
259
260    if (typeof element.disabled !== 'undefined') {
261      return element.disabled;
262    }
263
264    return element.hasAttribute('disabled') && element.getAttribute('disabled') !== 'false';
265  };
266
267  const findShadowRoot = element => {
268    if (!document.documentElement.attachShadow) {
269      return null;
270    } // Can find the shadow root otherwise it'll return the document
271
272
273    if (typeof element.getRootNode === 'function') {
274      const root = element.getRootNode();
275      return root instanceof ShadowRoot ? root : null;
276    }
277
278    if (element instanceof ShadowRoot) {
279      return element;
280    } // when we don't find a shadow root
281
282
283    if (!element.parentNode) {
284      return null;
285    }
286
287    return findShadowRoot(element.parentNode);
288  };
289
290  const noop = () => {};
291
292  const reflow = element => element.offsetHeight;
293
294  const getjQuery = () => {
295    const {
296      jQuery
297    } = window;
298
299    if (jQuery && !document.body.hasAttribute('data-bs-no-jquery')) {
300      return jQuery;
301    }
302
303    return null;
304  };
305
306  const onDOMContentLoaded = callback => {
307    if (document.readyState === 'loading') {
308      document.addEventListener('DOMContentLoaded', callback);
309    } else {
310      callback();
311    }
312  };
313
314  const isRTL = () => document.documentElement.dir === 'rtl';
315
316  const defineJQueryPlugin = plugin => {
317    onDOMContentLoaded(() => {
318      const $ = getjQuery();
319      /* istanbul ignore if */
320
321      if ($) {
322        const name = plugin.NAME;
323        const JQUERY_NO_CONFLICT = $.fn[name];
324        $.fn[name] = plugin.jQueryInterface;
325        $.fn[name].Constructor = plugin;
326
327        $.fn[name].noConflict = () => {
328          $.fn[name] = JQUERY_NO_CONFLICT;
329          return plugin.jQueryInterface;
330        };
331      }
332    });
333  };
334
335  const execute = callback => {
336    if (typeof callback === 'function') {
337      callback();
338    }
339  };
340
341  /**
342   * --------------------------------------------------------------------------
343   * Bootstrap (v5.0.1): dom/data.js
344   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
345   * --------------------------------------------------------------------------
346   */
347
348  /**
349   * ------------------------------------------------------------------------
350   * Constants
351   * ------------------------------------------------------------------------
352   */
353  const elementMap = new Map();
354  var Data = {
355    set(element, key, instance) {
356      if (!elementMap.has(element)) {
357        elementMap.set(element, new Map());
358      }
359
360      const instanceMap = elementMap.get(element); // make it clear we only want one instance per element
361      // can be removed later when multiple key/instances are fine to be used
362
363      if (!instanceMap.has(key) && instanceMap.size !== 0) {
364        // eslint-disable-next-line no-console
365        console.error(`Bootstrap doesn't allow more than one instance per element. Bound instance: ${Array.from(instanceMap.keys())[0]}.`);
366        return;
367      }
368
369      instanceMap.set(key, instance);
370    },
371
372    get(element, key) {
373      if (elementMap.has(element)) {
374        return elementMap.get(element).get(key) || null;
375      }
376
377      return null;
378    },
379
380    remove(element, key) {
381      if (!elementMap.has(element)) {
382        return;
383      }
384
385      const instanceMap = elementMap.get(element);
386      instanceMap.delete(key); // free up element references if there are no instances left for an element
387
388      if (instanceMap.size === 0) {
389        elementMap.delete(element);
390      }
391    }
392
393  };
394
395  /**
396   * --------------------------------------------------------------------------
397   * Bootstrap (v5.0.1): dom/event-handler.js
398   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
399   * --------------------------------------------------------------------------
400   */
401  /**
402   * ------------------------------------------------------------------------
403   * Constants
404   * ------------------------------------------------------------------------
405   */
406
407  const namespaceRegex = /[^.]*(?=\..*)\.|.*/;
408  const stripNameRegex = /\..*/;
409  const stripUidRegex = /::\d+$/;
410  const eventRegistry = {}; // Events storage
411
412  let uidEvent = 1;
413  const customEvents = {
414    mouseenter: 'mouseover',
415    mouseleave: 'mouseout'
416  };

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);

1450    Object.keys(state.elements).forEach(function (name) {
1451      var style = state.styles[name] || {};
1452      var attributes = state.attributes[name] || {};
1453      var element = state.elements[name]; // arrow is optional + virtual elements
1454
1455      if (!isHTMLElement(element) || !getNodeName(element)) {
1456        return;
1457      } // Flow doesn't support to extend this property, but it's the most
1458      // effective way to apply styles to an HTMLElement
1459      // $FlowFixMe[cannot-write]
1460
1461
1462      Object.assign(element.style, style);
1463      Object.keys(attributes).forEach(function (name) {
1464        var value = attributes[name];
1465
1466        if (value === false) {
1467          element.removeAttribute(name);
1468        } else {
1469          element.setAttribute(name, value === true ? '' : value);
1470        }
1471      });
1472    });
1473  }
1474
1475  function effect$2(_ref2) {
1476    var state = _ref2.state;
1477    var initialStyles = {
1478      popper: {
1479        position: state.options.strategy,
1480        left: '0',
1481        top: '0',
1482        margin: '0'
1483      },
1484      arrow: {
1485        position: 'absolute'
1486      },
1487      reference: {}
1488    };
1489    Object.assign(state.elements.popper.style, initialStyles.popper);
1490    state.styles = initialStyles;
1491
1492    if (state.elements.arrow) {
1493      Object.assign(state.elements.arrow.style, initialStyles.arrow);
1494    }
1495
1496    return function () {
1497      Object.keys(state.elements).forEach(function (name) {
1498        var element = state.elements[name];
1499        var attributes = state.attributes[name] || {};
1500        var styleProperties = Object.keys(state.styles.hasOwnProperty(name) ? state.styles[name] : initialStyles[name]); // Set all values to an empty string to unset them
1501
1502        var style = styleProperties.reduce(function (style, property) {
1503          style[property] = '';
1504          return style;
1505        }, {}); // arrow is optional + virtual elements
1506
1507        if (!isHTMLElement(element) || !getNodeName(element)) {
1508          return;
1509        }
1510
1511        Object.assign(element.style, style);
1512        Object.keys(attributes).forEach(function (attribute) {
1513          element.removeAttribute(attribute);
1514        });
1515      });
1516    };
1517  } // eslint-disable-next-line import/no-unused-modules
1518
1519
1520  var applyStyles$1 = {
1521    name: 'applyStyles',
1522    enabled: true,
1523    phase: 'write',
1524    fn: applyStyles,
1525    effect: effect$2,
1526    requires: ['computeStyles']
1527  };
1528
1529  function getBasePlacement(placement) {
1530    return placement.split('-')[0];
1531  }
1532
1533  function getBoundingClientRect(element) {
1534    var rect = element.getBoundingClientRect();
1535    return {
1536      width: rect.width,
1537      height: rect.height,
1538      top: rect.top,
1539      right: rect.right,
1540      bottom: rect.bottom,
1541      left: rect.left,
1542      x: rect.left,
1543      y: rect.top
1544    };
1545  }
1546
1547  // means it doesn't take into account transforms.
1548
1549  function getLayoutRect(element) {
1550    var clientRect = getBoundingClientRect(element); // Use the clientRect sizes if it's not been transformed.
1551    // Fixes https://github.com/popperjs/popper-core/issues/1223
1552
1553    var width = element.offsetWidth;
1554    var height = element.offsetHeight;
1555
1556    if (Math.abs(clientRect.width - width) <= 1) {
1557      width = clientRect.width;
1558    }
1559
1560    if (Math.abs(clientRect.height - height) <= 1) {
1561      height = clientRect.height;
1562    }
1563
1564    return {
1565      x: element.offsetLeft,
1566      y: element.offsetTop,
1567      width: width,
1568      height: height
1569    };
1570  }
1571
1572  function contains(parent, child) {
1573    var rootNode = child.getRootNode && child.getRootNode(); // First, attempt with faster native method
1574
1575    if (parent.contains(child)) {
1576      return true;
1577    } // then fallback to custom implementation with Shadow DOM support
1578    else if (rootNode && isShadowRoot(rootNode)) {
1579        var next = child;
1580
1581        do {
1582          if (next && parent.isSameNode(next)) {
1583            return true;
1584          } // $FlowFixMe[prop-missing]: need a better way to handle this...
1585
1586
1587          next = next.parentNode || next.host;
1588        } while (next);
1589      } // Give up, the result is false
1590
1591
1592    return false;
1593  }
1594
1595  function getComputedStyle$1(element) {
1596    return getWindow(element).getComputedStyle(element);
1597  }
1598
1599  function isTableElement(element) {
1600    return ['table', 'td', 'th'].indexOf(getNodeName(element)) >= 0;
1601  }
1602
1603  function getDocumentElement(element) {
1604    // $FlowFixMe[incompatible-return]: assume body is always available
1605    return ((isElement(element) ? element.ownerDocument : // $FlowFixMe[prop-missing]
1606    element.document) || window.document).documentElement;
1607  }
1608
1609  function getParentNode(element) {
1610    if (getNodeName(element) === 'html') {
1611      return element;
1612    }
1613
1614    return (// this is a quicker (but less type safe) way to save quite some bytes from the bundle
1615      // $FlowFixMe[incompatible-return]
1616      // $FlowFixMe[prop-missing]
1617      element.assignedSlot || // step into the shadow DOM of the parent of a slotted node
1618      element.parentNode || ( // DOM Element detected
1619      isShadowRoot(element) ? element.host : null) || // ShadowRoot detected
1620      // $FlowFixMe[incompatible-call]: HTMLElement is a Node
1621      getDocumentElement(element) // fallback
1622
1623    );
1624  }
1625
1626  function getTrueOffsetParent(element) {
1627    if (!isHTMLElement(element) || // https://github.com/popperjs/popper-core/issues/837
1628    getComputedStyle$1(element).position === 'fixed') {
1629      return null;
1630    }
1631
1632    return element.offsetParent;
1633  } // `.offsetParent` reports `null` for fixed elements, while absolute elements
1634  // return the containing block
1635
1636
1637  function getContainingBlock(element) {
1638    var isFirefox = navigator.userAgent.toLowerCase().indexOf('firefox') !== -1;
1639    var isIE = navigator.userAgent.indexOf('Trident') !== -1;
1640
1641    if (isIE && isHTMLElement(element)) {
1642      // In IE 9, 10 and 11 fixed elements containing block is always established by the viewport
1643      var elementCss = getComputedStyle$1(element);
1644
1645      if (elementCss.position === 'fixed') {
1646        return null;
1647      }
1648    }
1649
1650    var currentNode = getParentNode(element);
1651
1652    while (isHTMLElement(currentNode) && ['html', 'body'].indexOf(getNodeName(currentNode)) < 0) {
1653      var css = getComputedStyle$1(currentNode); // This is non-exhaustive but covers the most common CSS properties that
1654      // create a containing block.
1655      // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
1656
1657      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') {
1658        return currentNode;
1659      } else {
1660        currentNode = currentNode.parentNode;
1661      }
1662    }
1663
1664    return null;
1665  } // Gets the closest ancestor positioned element. Handles some edge cases,
1666  // such as table ancestors and cross browser bugs.
1667
1668
1669  function getOffsetParent(element) {
1670    var window = getWindow(element);
1671    var offsetParent = getTrueOffsetParent(element);
1672
1673    while (offsetParent && isTableElement(offsetParent) && getComputedStyle$1(offsetParent).position === 'static') {
1674      offsetParent = getTrueOffsetParent(offsetParent);
1675    }
1676
1677    if (offsetParent && (getNodeName(offsetParent) === 'html' || getNodeName(offsetParent) === 'body' && getComputedStyle$1(offsetParent).position === 'static')) {
1678      return window;
1679    }
1680
1681    return offsetParent || getContainingBlock(element) || window;
1682  }
1683
1684  function getMainAxisFromPlacement(placement) {
1685    return ['top', 'bottom'].indexOf(placement) >= 0 ? 'x' : 'y';
1686  }
1687
1688  var max = Math.max;
1689  var min = Math.min;
1690  var round = Math.round;
1691
1692  function within(min$1, value, max$1) {
1693    return max(min$1, min(value, max$1));
1694  }
1695
1696  function getFreshSideObject() {
1697    return {
1698      top: 0,
1699      right: 0,
1700      bottom: 0,
1701      left: 0
1702    };
1703  }
1704

1705  function mergePaddingObject(paddingObject) {
1706    return Object.assign({}, getFreshSideObject(), paddingObject);
1707  }
1708
1709  function expandToHashMap(value, keys) {
1710    return keys.reduce(function (hashMap, key) {
1711      hashMap[key] = value;
1712      return hashMap;
1713    }, {});
1714  }
1715
1716  var toPaddingObject = function toPaddingObject(padding, state) {
1717    padding = typeof padding === 'function' ? padding(Object.assign({}, state.rects, {
1718      placement: state.placement
1719    })) : padding;
1720    return mergePaddingObject(typeof padding !== 'number' ? padding : expandToHashMap(padding, basePlacements));
1721  };
1722
1723  function arrow(_ref) {
1724    var _state$modifiersData$;
1725
1726    var state = _ref.state,
1727        name = _ref.name,
1728        options = _ref.options;
1729    var arrowElement = state.elements.arrow;
1730    var popperOffsets = state.modifiersData.popperOffsets;
1731    var basePlacement = getBasePlacement(state.placement);
1732    var axis = getMainAxisFromPlacement(basePlacement);
1733    var isVertical = [left, right].indexOf(basePlacement) >= 0;
1734    var len = isVertical ? 'height' : 'width';
1735
1736    if (!arrowElement || !popperOffsets) {
1737      return;
1738    }
1739
1740    var paddingObject = toPaddingObject(options.padding, state);
1741    var arrowRect = getLayoutRect(arrowElement);
1742    var minProp = axis === 'y' ? top : left;
1743    var maxProp = axis === 'y' ? bottom : right;
1744    var endDiff = state.rects.reference[len] + state.rects.reference[axis] - popperOffsets[axis] - state.rects.popper[len];
1745    var startDiff = popperOffsets[axis] - state.rects.reference[axis];
1746    var arrowOffsetParent = getOffsetParent(arrowElement);
1747    var clientSize = arrowOffsetParent ? axis === 'y' ? arrowOffsetParent.clientHeight || 0 : arrowOffsetParent.clientWidth || 0 : 0;
1748    var centerToReference = endDiff / 2 - startDiff / 2; // Make sure the arrow doesn't overflow the popper if the center point is
1749    // outside of the popper bounds
1750
1751    var min = paddingObject[minProp];
1752    var max = clientSize - arrowRect[len] - paddingObject[maxProp];
1753    var center = clientSize / 2 - arrowRect[len] / 2 + centerToReference;
1754    var offset = within(min, center, max); // Prevents breaking syntax highlighting...
1755
1756    var axisProp = axis;
1757    state.modifiersData[name] = (_state$modifiersData$ = {}, _state$modifiersData$[axisProp] = offset, _state$modifiersData$.centerOffset = offset - center, _state$modifiersData$);
1758  }
1759
1760  function effect$1(_ref2) {
1761    var state = _ref2.state,
1762        options = _ref2.options;
1763    var _options$element = options.element,
1764        arrowElement = _options$element === void 0 ? '[data-popper-arrow]' : _options$element;
1765
1766    if (arrowElement == null) {
1767      return;
1768    } // CSS selector
1769
1770
1771    if (typeof arrowElement === 'string') {
1772      arrowElement = state.elements.popper.querySelector(arrowElement);
1773
1774      if (!arrowElement) {
1775        return;
1776      }
1777    }
1778
1779    if (!contains(state.elements.popper, arrowElement)) {
1780
1781      return;
1782    }
1783
1784    state.elements.arrow = arrowElement;
1785  } // eslint-disable-next-line import/no-unused-modules
1786
1787
1788  var arrow$1 = {
1789    name: 'arrow',
1790    enabled: true,
1791    phase: 'main',
1792    fn: arrow,
1793    effect: effect$1,
1794    requires: ['popperOffsets'],
1795    requiresIfExists: ['preventOverflow']
1796  };
1797
1798  var unsetSides = {
1799    top: 'auto',
1800    right: 'auto',
1801    bottom: 'auto',
1802    left: 'auto'
1803  }; // Round the offsets to the nearest suitable subpixel based on the DPR.
1804  // Zooming can change the DPR, but it seems to report a value that will
1805  // cleanly divide the values into the appropriate subpixels.
1806
1807  function roundOffsetsByDPR(_ref) {
1808    var x = _ref.x,
1809        y = _ref.y;
1810    var win = window;
1811    var dpr = win.devicePixelRatio || 1;
1812    return {
1813      x: round(round(x * dpr) / dpr) || 0,
1814      y: round(round(y * dpr) / dpr) || 0
1815    };
1816  }
1817
1818  function mapToStyles(_ref2) {
1819    var _Object$assign2;
1820
1821    var popper = _ref2.popper,
1822        popperRect = _ref2.popperRect,
1823        placement = _ref2.placement,
1824        offsets = _ref2.offsets,
1825        position = _ref2.position,
1826        gpuAcceleration = _ref2.gpuAcceleration,
1827        adaptive = _ref2.adaptive,
1828        roundOffsets = _ref2.roundOffsets;
1829
1830    var _ref3 = roundOffsets === true ? roundOffsetsByDPR(offsets) : typeof roundOffsets === 'function' ? roundOffsets(offsets) : offsets,
1831        _ref3$x = _ref3.x,
1832        x = _ref3$x === void 0 ? 0 : _ref3$x,
1833        _ref3$y = _ref3.y,
1834        y = _ref3$y === void 0 ? 0 : _ref3$y;
1835
1836    var hasX = offsets.hasOwnProperty('x');
1837    var hasY = offsets.hasOwnProperty('y');
1838    var sideX = left;
1839    var sideY = top;
1840    var win = window;
1841
1842    if (adaptive) {
1843      var offsetParent = getOffsetParent(popper);
1844      var heightProp = 'clientHeight';
1845      var widthProp = 'clientWidth';
1846

1847      if (offsetParent === getWindow(popper)) {
1848        offsetParent = getDocumentElement(popper);
1849
1850        if (getComputedStyle$1(offsetParent).position !== 'static') {
1851          heightProp = 'scrollHeight';
1852          widthProp = 'scrollWidth';
1853        }
1854      } // $FlowFixMe[incompatible-cast]: force type refinement, we compare offsetParent with window above, but Flow doesn't detect it
1855
1856
1857      offsetParent = offsetParent;
1858
1859      if (placement === top) {
1860        sideY = bottom; // $FlowFixMe[prop-missing]
1861
1862        y -= offsetParent[heightProp] - popperRect.height;
1863        y *= gpuAcceleration ? 1 : -1;
1864      }
1865
1866      if (placement === left) {
1867        sideX = right; // $FlowFixMe[prop-missing]
1868
1869        x -= offsetParent[widthProp] - popperRect.width;
1870        x *= gpuAcceleration ? 1 : -1;
1871      }
1872    }
1873
1874    var commonStyles = Object.assign({
1875      position: position
1876    }, adaptive && unsetSides);
1877
1878    if (gpuAcceleration) {
1879      var _Object$assign;
1880
1881      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));
1882    }
1883
1884    return Object.assign({}, commonStyles, (_Object$assign2 = {}, _Object$assign2[sideY] = hasY ? y + "px" : '', _Object$assign2[sideX] = hasX ? x + "px" : '', _Object$assign2.transform = '', _Object$assign2));
1885  }
1886
1887  function computeStyles(_ref4) {
1888    var state = _ref4.state,
1889        options = _ref4.options;
1890    var _options$gpuAccelerat = options.gpuAcceleration,
1891        gpuAcceleration = _options$gpuAccelerat === void 0 ? true : _options$gpuAccelerat,
1892        _options$adaptive = options.adaptive,
1893        adaptive = _options$adaptive === void 0 ? true : _options$adaptive,
1894        _options$roundOffsets = options.roundOffsets,
1895        roundOffsets = _options$roundOffsets === void 0 ? true : _options$roundOffsets;
1896
1897    var commonStyles = {
1898      placement: getBasePlacement(state.placement),
1899      popper: state.elements.popper,
1900      popperRect: state.rects.popper,
1901      gpuAcceleration: gpuAcceleration
1902    };
1903
1904    if (state.modifiersData.popperOffsets != null) {
1905      state.styles.popper = Object.assign({}, state.styles.popper, mapToStyles(Object.assign({}, commonStyles, {
1906        offsets: state.modifiersData.popperOffsets,
1907        position: state.options.strategy,
1908        adaptive: adaptive,
1909        roundOffsets: roundOffsets
1910      })));
1911    }
1912
1913    if (state.modifiersData.arrow != null) {
1914      state.styles.arrow = Object.assign({}, state.styles.arrow, mapToStyles(Object.assign({}, commonStyles, {
1915        offsets: state.modifiersData.arrow,
1916        position: 'absolute',
1917        adaptive: false,
1918        roundOffsets: roundOffsets
1919      })));
1920    }
1921
1922    state.attributes.popper = Object.assign({}, state.attributes.popper, {
1923      'data-popper-placement': state.placement
1924    });
1925  } // eslint-disable-next-line import/no-unused-modules
1926
1927
1928  var computeStyles$1 = {
1929    name: 'computeStyles',
1930    enabled: true,
1931    phase: 'beforeWrite',
1932    fn: computeStyles,
1933    data: {}
1934  };
1935
1936  var passive = {
1937    passive: true
1938  };
1939
1940  function effect(_ref) {
1941    var state = _ref.state,
1942        instance = _ref.instance,
1943        options = _ref.options;
1944    var _options$scroll = options.scroll,
1945        scroll = _options$scroll === void 0 ? true : _options$scroll,
1946        _options$resize = options.resize,
1947        resize = _options$resize === void 0 ? true : _options$resize;
1948    var window = getWindow(state.elements.popper);
1949    var scrollParents = [].concat(state.scrollParents.reference, state.scrollParents.popper);
1950
1951    if (scroll) {
1952      scrollParents.forEach(function (scrollParent) {
1953        scrollParent.addEventListener('scroll', instance.update, passive);
1954      });
1955    }
1956
1957    if (resize) {
1958      window.addEventListener('resize', instance.update, passive);
1959    }
1960
1961    return function () {
1962      if (scroll) {

1963        scrollParents.forEach(function (scrollParent) {
1964          scrollParent.removeEventListener('scroll', instance.update, passive);
1965        });
1966      }
1967
1968      if (resize) {
1969        window.removeEventListener('resize', instance.update, passive);
1970      }
1971    };
1972  } // eslint-disable-next-line import/no-unused-modules
1973
1974
1975  var eventListeners = {
1976    name: 'eventListeners',
1977    enabled: true,
1978    phase: 'write',
1979    fn: function fn() {},
1980    effect: effect,
1981    data: {}
1982  };
1983
1984  var hash$1 = {
1985    left: 'right',
1986    right: 'left',
1987    bottom: 'top',
1988    top: 'bottom'
1989  };
1990  function getOppositePlacement(placement) {
1991    return placement.replace(/left|right|bottom|top/g, function (matched) {
1992      return hash$1[matched];
1993    });
1994  }
1995
1996  var hash = {
1997    start: 'end',
1998    end: 'start'
1999  };
2000  function getOppositeVariationPlacement(placement) {
2001    return placement.replace(/start|end/g, function (matched) {
2002      return hash[matched];
2003    });
2004  }
2005
2006  function getWindowScroll(node) {
2007    var win = getWindow(node);
2008    var scrollLeft = win.pageXOffset;
2009    var scrollTop = win.pageYOffset;
2010    return {
2011      scrollLeft: scrollLeft,
2012      scrollTop: scrollTop
2013    };
2014  }
2015
2016  function getWindowScrollBarX(element) {
2017    // If <html> has a CSS width greater than the viewport, then this will be
2018    // incorrect for RTL.
2019    // Popper 1 is broken in this case and never had a bug report so let's assume
2020    // it's not an issue. I don't think anyone ever specifies width on <html>
2021    // anyway.
2022    // Browsers where the left scrollbar doesn't cause an issue report `0` for
2023    // this (e.g. Edge 2019, IE11, Safari)
2024    return getBoundingClientRect(getDocumentElement(element)).left + getWindowScroll(element).scrollLeft;
2025  }
2026
2027  function getViewportRect(element) {
2028    var win = getWindow(element);
2029    var html = getDocumentElement(element);
2030    var visualViewport = win.visualViewport;
2031    var width = html.clientWidth;
2032    var height = html.clientHeight;
2033    var x = 0;
2034    var y = 0; // NB: This isn't supported on iOS <= 12. If the keyboard is open, the popper
2035    // can be obscured underneath it.
2036    // Also, `html.clientHeight` adds the bottom bar height in Safari iOS, even
2037    // if it isn't open, so if this isn't available, the popper will be detected
2038    // to overflow the bottom of the screen too early.
2039
2040    if (visualViewport) {
2041      width = visualViewport.width;

2042      height = visualViewport.height; // Uses Layout Viewport (like Chrome; Safari does not currently)
2043      // In Chrome, it returns a value very close to 0 (+/-) but contains rounding
2044      // errors due to floating point numbers, so we need to check precision.
2045      // Safari returns a number <= 0, usually < -1 when pinch-zoomed
2046      // Feature detection fails in mobile emulation mode in Chrome.
2047      // Math.abs(win.innerWidth / visualViewport.scale - visualViewport.width) <
2048      // 0.001
2049      // Fallback here: "Not Safari" userAgent
2050
2051      if (!/^((?!chrome|android).)*safari/i.test(navigator.userAgent)) {
2052        x = visualViewport.offsetLeft;
2053        y = visualViewport.offsetTop;
2054      }
2055    }
2056
2057    return {
2058      width: width,
2059      height: height,
2060      x: x + getWindowScrollBarX(element),
2061      y: y
2062    };
2063  }
2064
2065  // of the `<html>` and `<body>` rect bounds if horizontally scrollable
2066
2067  function getDocumentRect(element) {
2068    var _element$ownerDocumen;
2069
2070    var html = getDocumentElement(element);
2071    var winScroll = getWindowScroll(element);
2072    var body = (_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body;
2073    var width = max(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0);
2074    var height = max(html.scrollHeight, html.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0);
2075    var x = -winScroll.scrollLeft + getWindowScrollBarX(element);
2076    var y = -winScroll.scrollTop;
2077
2078    if (getComputedStyle$1(body || html).direction === 'rtl') {
2079      x += max(html.clientWidth, body ? body.clientWidth : 0) - width;
2080    }
2081
2082    return {
2083      width: width,
2084      height: height,
2085      x: x,
2086      y: y
2087    };
2088  }
2089
2090  function isScrollParent(element) {
2091    // Firefox wants us to check `-x` and `-y` variations as well
2092    var _getComputedStyle = getComputedStyle$1(element),
2093        overflow = _getComputedStyle.overflow,
2094        overflowX = _getComputedStyle.overflowX,
2095        overflowY = _getComputedStyle.overflowY;
2096
2097    return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX);
2098  }
2099
2100  function getScrollParent(node) {
2101    if (['html', 'body', '#document'].indexOf(getNodeName(node)) >= 0) {
2102      // $FlowFixMe[incompatible-return]: assume body is always available
2103      return node.ownerDocument.body;
2104    }
2105
2106    if (isHTMLElement(node) && isScrollParent(node)) {
2107      return node;
2108    }
2109
2110    return getScrollParent(getParentNode(node));
2111  }
2112
2113  /*
2114  given a DOM element, return the list of all scroll parents, up the list of ancesors
2115  until we get to the top window object. This list is what we attach scroll listeners
2116  to, because if any of these parent elements scroll, we'll need to re-calculate the
2117  reference element's position.
2118  */
2119
2120  function listScrollParents(element, list) {
2121    var _element$ownerDocumen;
2122
2123    if (list === void 0) {
2124      list = [];
2125    }
2126
2127    var scrollParent = getScrollParent(element);
2128    var isBody = scrollParent === ((_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body);
2129    var win = getWindow(scrollParent);
2130    var target = isBody ? [win].concat(win.visualViewport || [], isScrollParent(scrollParent) ? scrollParent : []) : scrollParent;
2131    var updatedList = list.concat(target);
2132    return isBody ? updatedList : // $FlowFixMe[incompatible-call]: isBody tells us target will be an HTMLElement here
2133    updatedList.concat(listScrollParents(getParentNode(target)));
2134  }
2135
2136  function rectToClientRect(rect) {
2137    return Object.assign({}, rect, {
2138      left: rect.x,
2139      top: rect.y,
2140      right: rect.x + rect.width,
2141      bottom: rect.y + rect.height
2142    });
2143  }
2144
2145  function getInnerBoundingClientRect(element) {
2146    var rect = getBoundingClientRect(element);
2147    rect.top = rect.top + element.clientTop;
2148    rect.left = rect.left + element.clientLeft;
2149    rect.bottom = rect.top + element.clientHeight;
2150    rect.right = rect.left + element.clientWidth;
2151    rect.width = element.clientWidth;
2152    rect.height = element.clientHeight;
2153    rect.x = rect.left;
2154    rect.y = rect.top;
2155    return rect;
2156  }
2157
2158  function getClientRectFromMixedType(element, clippingParent) {
2159    return clippingParent === viewport ? rectToClientRect(getViewportRect(element)) : isHTMLElement(clippingParent) ? getInnerBoundingClientRect(clippingParent) : rectToClientRect(getDocumentRect(getDocumentElement(element)));
2160  } // A "clipping parent" is an overflowable container with the characteristic of
2161  // clipping (or hiding) overflowing elements with a position different from
2162  // `initial`
2163
2164
2165  function getClippingParents(element) {
2166    var clippingParents = listScrollParents(getParentNode(element));
2167    var canEscapeClipping = ['absolute', 'fixed'].indexOf(getComputedStyle$1(element).position) >= 0;
2168    var clipperElement = canEscapeClipping && isHTMLElement(element) ? getOffsetParent(element) : element;
2169
2170    if (!isElement(clipperElement)) {
2171      return [];
2172    } // $FlowFixMe[incompatible-return]: https://github.com/facebook/flow/issues/1414
2173
2174
2175    return clippingParents.filter(function (clippingParent) {
2176      return isElement(clippingParent) && contains(clippingParent, clipperElement) && getNodeName(clippingParent) !== 'body';
2177    });

2178  } // Gets the maximum area that the element is visible in due to any number of
2179  // clipping parents
2180
2181
2182  function getClippingRect(element, boundary, rootBoundary) {
2183    var mainClippingParents = boundary === 'clippingParents' ? getClippingParents(element) : [].concat(boundary);
2184    var clippingParents = [].concat(mainClippingParents, [rootBoundary]);
2185    var firstClippingParent = clippingParents[0];
2186    var clippingRect = clippingParents.reduce(function (accRect, clippingParent) {
2187      var rect = getClientRectFromMixedType(element, clippingParent);
2188      accRect.top = max(rect.top, accRect.top);
2189      accRect.right = min(rect.right, accRect.right);
2190      accRect.bottom = min(rect.bottom, accRect.bottom);
2191      accRect.left = max(rect.left, accRect.left);
2192      return accRect;
2193    }, getClientRectFromMixedType(element, firstClippingParent));
2194    clippingRect.width = clippingRect.right - clippingRect.left;
2195    clippingRect.height = clippingRect.bottom - clippingRect.top;
2196    clippingRect.x = clippingRect.left;
2197    clippingRect.y = clippingRect.top;
2198    return clippingRect;
2199  }
2200
2201  function getVariation(placement) {
2202    return placement.split('-')[1];
2203  }
2204
2205  function computeOffsets(_ref) {
2206    var reference = _ref.reference,
2207        element = _ref.element,
2208        placement = _ref.placement;
2209    var basePlacement = placement ? getBasePlacement(placement) : null;
2210    var variation = placement ? getVariation(placement) : null;
2211    var commonX = reference.x + reference.width / 2 - element.width / 2;
2212    var commonY = reference.y + reference.height / 2 - element.height / 2;
2213    var offsets;
2214
2215    switch (basePlacement) {
2216      case top:
2217        offsets = {
2218          x: commonX,
2219          y: reference.y - element.height
2220        };
2221        break;
2222
2223      case bottom:
2224        offsets = {
2225          x: commonX,
2226          y: reference.y + reference.height
2227        };
2228        break;
2229
2230      case right:
2231        offsets = {
2232          x: reference.x + reference.width,
2233          y: commonY
2234        };
2235        break;
2236
2237      case left:
2238        offsets = {
2239          x: reference.x - element.width,
2240          y: commonY
2241        };
2242        break;
2243
2244      default:
2245        offsets = {
2246          x: reference.x,
2247          y: reference.y
2248        };
2249    }
2250
2251    var mainAxis = basePlacement ? getMainAxisFromPlacement(basePlacement) : null;
2252
2253    if (mainAxis != null) {
2254      var len = mainAxis === 'y' ? 'height' : 'width';
2255
2256      switch (variation) {
2257        case start:
2258          offsets[mainAxis] = offsets[mainAxis] - (reference[len] / 2 - element[len] / 2);
2259          break;
2260
2261        case end:
2262          offsets[mainAxis] = offsets[mainAxis] + (reference[len] / 2 - element[len] / 2);
2263          break;
2264      }
2265    }
2266
2267    return offsets;
2268  }
2269
2270  function detectOverflow(state, options) {
2271    if (options === void 0) {
2272      options = {};
2273    }
2274
2275    var _options = options,
2276        _options$placement = _options.placement,
2277        placement = _options$placement === void 0 ? state.placement : _options$placement,
2278        _options$boundary = _options.boundary,
2279        boundary = _options$boundary === void 0 ? clippingParents : _options$boundary,
2280        _options$rootBoundary = _options.rootBoundary,
2281        rootBoundary = _options$rootBoundary === void 0 ? viewport : _options$rootBoundary,
2282        _options$elementConte = _options.elementContext,
2283        elementContext = _options$elementConte === void 0 ? popper : _options$elementConte,
2284        _options$altBoundary = _options.altBoundary,
2285        altBoundary = _options$altBoundary === void 0 ? false : _options$altBoundary,
2286        _options$padding = _options.padding,
2287        padding = _options$padding === void 0 ? 0 : _options$padding;
2288    var paddingObject = mergePaddingObject(typeof padding !== 'number' ? padding : expandToHashMap(padding, basePlacements));
2289    var altContext = elementContext === popper ? reference : popper;
2290    var referenceElement = state.elements.reference;
2291    var popperRect = state.rects.popper;
2292    var element = state.elements[altBoundary ? altContext : elementContext];

2293    var clippingClientRect = getClippingRect(isElement(element) ? element : element.contextElement || getDocumentElement(state.elements.popper), boundary, rootBoundary);
2294    var referenceClientRect = getBoundingClientRect(referenceElement);
2295    var popperOffsets = computeOffsets({
2296      reference: referenceClientRect,
2297      element: popperRect,
2298      strategy: 'absolute',
2299      placement: placement
2300    });
2301    var popperClientRect = rectToClientRect(Object.assign({}, popperRect, popperOffsets));
2302    var elementClientRect = elementContext === popper ? popperClientRect : referenceClientRect; // positive = overflowing the clipping rect
2303    // 0 or negative = within the clipping rect
2304
2305    var overflowOffsets = {
2306      top: clippingClientRect.top - elementClientRect.top + paddingObject.top,
2307      bottom: elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom,
2308      left: clippingClientRect.left - elementClientRect.left + paddingObject.left,
2309      right: elementClientRect.right - clippingClientRect.right + paddingObject.right
2310    };
2311    var offsetData = state.modifiersData.offset; // Offsets can be applied only to the popper element
2312
2313    if (elementContext === popper && offsetData) {
2314      var offset = offsetData[placement];
2315      Object.keys(overflowOffsets).forEach(function (key) {
2316        var multiply = [right, bottom].indexOf(key) >= 0 ? 1 : -1;
2317        var axis = [top, bottom].indexOf(key) >= 0 ? 'y' : 'x';
2318        overflowOffsets[key] += offset[axis] * multiply;
2319      });
2320    }
2321
2322    return overflowOffsets;
2323  }
2324
2325  function computeAutoPlacement(state, options) {
2326    if (options === void 0) {
2327      options = {};
2328    }
2329
2330    var _options = options,
2331        placement = _options.placement,
2332        boundary = _options.boundary,
2333        rootBoundary = _options.rootBoundary,
2334        padding = _options.padding,
2335        flipVariations = _options.flipVariations,
2336        _options$allowedAutoP = _options.allowedAutoPlacements,
2337        allowedAutoPlacements = _options$allowedAutoP === void 0 ? placements : _options$allowedAutoP;
2338    var variation = getVariation(placement);
2339    var placements$1 = variation ? flipVariations ? variationPlacements : variationPlacements.filter(function (placement) {
2340      return getVariation(placement) === variation;
2341    }) : basePlacements;
2342    var allowedPlacements = placements$1.filter(function (placement) {
2343      return allowedAutoPlacements.indexOf(placement) >= 0;
2344    });
2345
2346    if (allowedPlacements.length === 0) {
2347      allowedPlacements = placements$1;
2348    } // $FlowFixMe[incompatible-type]: Flow seems to have problems with two array unions...
2349
2350
2351    var overflows = allowedPlacements.reduce(function (acc, placement) {
2352      acc[placement] = detectOverflow(state, {
2353        placement: placement,
2354        boundary: boundary,
2355        rootBoundary: rootBoundary,
2356        padding: padding
2357      })[getBasePlacement(placement)];
2358      return acc;
2359    }, {});
2360    return Object.keys(overflows).sort(function (a, b) {
2361      return overflows[a] - overflows[b];
2362    });
2363  }
2364
2365  function getExpandedFallbackPlacements(placement) {
2366    if (getBasePlacement(placement) === auto) {
2367      return [];
2368    }
2369
2370    var oppositePlacement = getOppositePlacement(placement);
2371    return [getOppositeVariationPlacement(placement), oppositePlacement, getOppositeVariationPlacement(oppositePlacement)];
2372  }
2373
2374  function flip(_ref) {
2375    var state = _ref.state,
2376        options = _ref.options,
2377        name = _ref.name;
2378
2379    if (state.modifiersData[name]._skip) {
2380      return;
2381    }
2382
2383    var _options$mainAxis = options.mainAxis,
2384        checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis,
2385        _options$altAxis = options.altAxis,
2386        checkAltAxis = _options$altAxis === void 0 ? true : _options$altAxis,
2387        specifiedFallbackPlacements = options.fallbackPlacements,
2388        padding = options.padding,
2389        boundary = options.boundary,
2390        rootBoundary = options.rootBoundary,
2391        altBoundary = options.altBoundary,
2392        _options$flipVariatio = options.flipVariations,
2393        flipVariations = _options$flipVariatio === void 0 ? true : _options$flipVariatio,
2394        allowedAutoPlacements = options.allowedAutoPlacements;
2395    var preferredPlacement = state.options.placement;
2396    var basePlacement = getBasePlacement(preferredPlacement);
2397    var isBasePlacement = basePlacement === preferredPlacement;
2398    var fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipVariations ? [getOppositePlacement(preferredPlacement)] : getExpandedFallbackPlacements(preferredPlacement));
2399    var placements = [preferredPlacement].concat(fallbackPlacements).reduce(function (acc, placement) {
2400      return acc.concat(getBasePlacement(placement) === auto ? computeAutoPlacement(state, {
2401        placement: placement,
2402        boundary: boundary,
2403        rootBoundary: rootBoundary,
2404        padding: padding,
2405        flipVariations: flipVariations,
2406        allowedAutoPlacements: allowedAutoPlacements
2407      }) : placement);
2408    }, []);
2409    var referenceRect = state.rects.reference;
2410    var popperRect = state.rects.popper;
2411    var checksMap = new Map();
2412    var makeFallbackChecks = true;
2413    var firstFittingPlacement = placements[0];
2414
2415    for (var i = 0; i < placements.length; i++) {
2416      var placement = placements[i];
2417
2418      var _basePlacement = getBasePlacement(placement);
2419
2420      var isStartVariation = getVariation(placement) === start;
2421      var isVertical = [top, bottom].indexOf(_basePlacement) >= 0;
2422      var len = isVertical ? 'width' : 'height';
2423      var overflow = detectOverflow(state, {
2424        placement: placement,
2425        boundary: boundary,
2426        rootBoundary: rootBoundary,
2427        altBoundary: altBoundary,
2428        padding: padding
2429      });
2430      var mainVariationSide = isVertical ? isStartVariation ? right : left : isStartVariation ? bottom : top;
2431
2432      if (referenceRect[len] > popperRect[len]) {
2433        mainVariationSide = getOppositePlacement(mainVariationSide);
2434      }
2435
2436      var altVariationSide = getOppositePlacement(mainVariationSide);
2437      var checks = [];
2438
2439      if (checkMainAxis) {
2440        checks.push(overflow[_basePlacement] <= 0);
2441      }
2442
2443      if (checkAltAxis) {
2444        checks.push(overflow[mainVariationSide] <= 0, overflow[altVariationSide] <= 0);
2445      }
2446
2447      if (checks.every(function (check) {
2448        return check;
2449      })) {
2450        firstFittingPlacement = placement;
2451        makeFallbackChecks = false;
2452        break;
2453      }
2454
2455      checksMap.set(placement, checks);
2456    }
2457
2458    if (makeFallbackChecks) {
2459      // `2` may be desired in some cases – research later
2460      var numberOfChecks = flipVariations ? 3 : 1;
2461
2462      var _loop = function _loop(_i) {
2463        var fittingPlacement = placements.find(function (placement) {
2464          var checks = checksMap.get(placement);
2465
2466          if (checks) {
2467            return checks.slice(0, _i).every(function (check) {
2468              return check;
2469            });
2470          }
2471        });
2472
2473        if (fittingPlacement) {
2474          firstFittingPlacement = fittingPlacement;
2475          return "break";
2476        }
2477      };
2478
2479      for (var _i = numberOfChecks; _i > 0; _i--) {
2480        var _ret = _loop(_i);
2481
2482        if (_ret === "break") break;
2483      }
2484    }
2485
2486    if (state.placement !== firstFittingPlacement) {
2487      state.modifiersData[name]._skip = true;
2488      state.placement = firstFittingPlacement;
2489      state.reset = true;
2490    }
2491  } // eslint-disable-next-line import/no-unused-modules
2492
2493
2494  var flip$1 = {
2495    name: 'flip',
2496    enabled: true,
2497    phase: 'main',
2498    fn: flip,
2499    requiresIfExists: ['offset'],
2500    data: {
2501      _skip: false
2502    }
2503  };
2504
2505  function getSideOffsets(overflow, rect, preventedOffsets) {
2506    if (preventedOffsets === void 0) {
2507      preventedOffsets = {
2508        x: 0,
2509        y: 0
2510      };
2511    }
2512
2513    return {
2514      top: overflow.top - rect.height - preventedOffsets.y,
2515      right: overflow.right - rect.width + preventedOffsets.x,
2516      bottom: overflow.bottom - rect.height + preventedOffsets.y,
2517      left: overflow.left - rect.width - preventedOffsets.x
2518    };
2519  }
2520
2521  function isAnySideFullyClipped(overflow) {
2522    return [top, right, bottom, left].some(function (side) {
2523      return overflow[side] >= 0;
2524    });

2525  }
2526
2527  function hide$1(_ref) {
2528    var state = _ref.state,
2529        name = _ref.name;
2530    var referenceRect = state.rects.reference;
2531    var popperRect = state.rects.popper;
2532    var preventedOffsets = state.modifiersData.preventOverflow;
2533    var referenceOverflow = detectOverflow(state, {
2534      elementContext: 'reference'
2535    });
2536    var popperAltOverflow = detectOverflow(state, {
2537      altBoundary: true
2538    });
2539    var referenceClippingOffsets = getSideOffsets(referenceOverflow, referenceRect);
2540    var popperEscapeOffsets = getSideOffsets(popperAltOverflow, popperRect, preventedOffsets);
2541    var isReferenceHidden = isAnySideFullyClipped(referenceClippingOffsets);
2542    var hasPopperEscaped = isAnySideFullyClipped(popperEscapeOffsets);
2543    state.modifiersData[name] = {
2544      referenceClippingOffsets: referenceClippingOffsets,
2545      popperEscapeOffsets: popperEscapeOffsets,
2546      isReferenceHidden: isReferenceHidden,
2547      hasPopperEscaped: hasPopperEscaped
2548    };
2549    state.attributes.popper = Object.assign({}, state.attributes.popper, {
2550      'data-popper-reference-hidden': isReferenceHidden,
2551      'data-popper-escaped': hasPopperEscaped
2552    });
2553  } // eslint-disable-next-line import/no-unused-modules
2554
2555
2556  var hide$2 = {
2557    name: 'hide',
2558    enabled: true,
2559    phase: 'main',
2560    requiresIfExists: ['preventOverflow'],
2561    fn: hide$1
2562  };
2563
2564  function distanceAndSkiddingToXY(placement, rects, offset) {
2565    var basePlacement = getBasePlacement(placement);
2566    var invertDistance = [left, top].indexOf(basePlacement) >= 0 ? -1 : 1;
2567
2568    var _ref = typeof offset === 'function' ? offset(Object.assign({}, rects, {
2569      placement: placement
2570    })) : offset,
2571        skidding = _ref[0],
2572        distance = _ref[1];
2573
2574    skidding = skidding || 0;
2575    distance = (distance || 0) * invertDistance;
2576    return [left, right].indexOf(basePlacement) >= 0 ? {
2577      x: distance,
2578      y: skidding
2579    } : {
2580      x: skidding,
2581      y: distance
2582    };
2583  }
2584
2585  function offset(_ref2) {
2586    var state = _ref2.state,
2587        options = _ref2.options,
2588        name = _ref2.name;
2589    var _options$offset = options.offset,
2590        offset = _options$offset === void 0 ? [0, 0] : _options$offset;
2591    var data = placements.reduce(function (acc, placement) {
2592      acc[placement] = distanceAndSkiddingToXY(placement, state.rects, offset);
2593      return acc;
2594    }, {});
2595    var _data$state$placement = data[state.placement],
2596        x = _data$state$placement.x,
2597        y = _data$state$placement.y;
2598
2599    if (state.modifiersData.popperOffsets != null) {
2600      state.modifiersData.popperOffsets.x += x;
2601      state.modifiersData.popperOffsets.y += y;
2602    }
2603
2604    state.modifiersData[name] = data;
2605  } // eslint-disable-next-line import/no-unused-modules
2606
2607
2608  var offset$1 = {
2609    name: 'offset',
2610    enabled: true,
2611    phase: 'main',
2612    requires: ['popperOffsets'],
2613    fn: offset
2614  };
2615
2616  function popperOffsets(_ref) {
2617    var state = _ref.state,
2618        name = _ref.name;
2619    // Offsets are the actual position the popper needs to have to be
2620    // properly positioned near its reference element
2621    // This is the most basic placement, and will be adjusted by
2622    // the modifiers in the next step
2623    state.modifiersData[name] = computeOffsets({
2624      reference: state.rects.reference,
2625      element: state.rects.popper,
2626      strategy: 'absolute',
2627      placement: state.placement
2628    });
2629  } // eslint-disable-next-line import/no-unused-modules
2630
2631
2632  var popperOffsets$1 = {
2633    name: 'popperOffsets',
2634    enabled: true,
2635    phase: 'read',
2636    fn: popperOffsets,
2637    data: {}
2638  };
2639
2640  function getAltAxis(axis) {
2641    return axis === 'x' ? 'y' : 'x';
2642  }
2643
2644  function preventOverflow(_ref) {
2645    var state = _ref.state,
2646        options = _ref.options,
2647        name = _ref.name;
2648    var _options$mainAxis = options.mainAxis,
2649        checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis,
2650        _options$altAxis = options.altAxis,
2651        checkAltAxis = _options$altAxis === void 0 ? false : _options$altAxis,
2652        boundary = options.boundary,
2653        rootBoundary = options.rootBoundary,
2654        altBoundary = options.altBoundary,
2655        padding = options.padding,
2656        _options$tether = options.tether,
2657        tether = _options$tether === void 0 ? true : _options$tether,
2658        _options$tetherOffset = options.tetherOffset,
2659        tetherOffset = _options$tetherOffset === void 0 ? 0 : _options$tetherOffset;
2660    var overflow = detectOverflow(state, {
2661      boundary: boundary,
2662      rootBoundary: rootBoundary,
2663      padding: padding,
2664      altBoundary: altBoundary
2665    });