https://www.phatconsulting.de/wp-content/themes/phat/js/child-theme.js?ver=1.0.1

1/*!
2  * Understrap v1.0.1 (https://understrap.com)
3  * Copyright 2013-2025 The Understrap Authors (https://github.com/understrap/understrap/graphs/contributors)
4  * Licensed under GPL (http://www.gnu.org/licenses/old-licenses/gpl-2.0.en.html)
5  */
6(function (global, factory) {
7  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('jquery')) :
8  typeof define === 'function' && define.amd ? define(['exports', 'jquery'], factory) :
9  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.understrap = {}, global.jQuery));
10})(this, (function (exports, $) { 'use strict';
11
12  function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
13
14  var $__default = /*#__PURE__*/_interopDefaultLegacy($);
15
16  /**!
17   * @fileOverview Kickass library to create and place poppers near their reference elements.
18   * @version 1.16.1
19   * @license
20   * Copyright (c) 2016 Federico Zivolo and contributors
21   *
22   * Permission is hereby granted, free of charge, to any person obtaining a copy
23   * of this software and associated documentation files (the "Software"), to deal
24   * in the Software without restriction, including without limitation the rights
25   * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
26   * copies of the Software, and to permit persons to whom the Software is
27   * furnished to do so, subject to the following conditions:
28   *
29   * The above copyright notice and this permission notice shall be included in all
30   * copies or substantial portions of the Software.
31   *
32   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
33   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
34   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
35   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
36   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
37   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
38   * SOFTWARE.
39   */
40  var isBrowser$1 = typeof window !== 'undefined' && typeof document !== 'undefined' && typeof navigator !== 'undefined';
41
42  const timeoutDuration$1 = function () {
43    const longerTimeoutBrowsers = ['Edge', 'Trident', 'Firefox'];
44    for (let i = 0; i < longerTimeoutBrowsers.length; i += 1) {
45      if (isBrowser$1 && navigator.userAgent.indexOf(longerTimeoutBrowsers[i]) >= 0) {
46        return 1;
47      }
48    }
49    return 0;
50  }();
51
52  function microtaskDebounce$1(fn) {

53    let called = false;
54    return () => {
55      if (called) {
56        return;
57      }
58      called = true;
59      window.Promise.resolve().then(() => {
60        called = false;
61        fn();
62      });
63    };
64  }
65
66  function taskDebounce$1(fn) {
67    let scheduled = false;
68    return () => {
69      if (!scheduled) {
70        scheduled = true;
71        setTimeout(() => {
72          scheduled = false;
73          fn();
74        }, timeoutDuration$1);
75      }
76    };
77  }
78
79  const supportsMicroTasks$1 = isBrowser$1 && window.Promise;
80
81  /**
82  * Create a debounced version of a method, that's asynchronously deferred
83  * but called in the minimum time possible.
84  *
85  * @method
86  * @memberof Popper.Utils
87  * @argument {Function} fn
88  * @returns {Function}
89  */
90  var debounce$1 = supportsMicroTasks$1 ? microtaskDebounce$1 : taskDebounce$1;
91
92  /**
93   * Check if the given variable is a function
94   * @method
95   * @memberof Popper.Utils
96   * @argument {Any} functionToCheck - variable to check
97   * @returns {Boolean} answer to: is a function?
98   */
99  function isFunction$1(functionToCheck) {
100    const getType = {};
101    return functionToCheck && getType.toString.call(functionToCheck) === '[object Function]';
102  }
103
104  /**
105   * Get CSS computed property of the given element
106   * @method
107   * @memberof Popper.Utils
108   * @argument {Eement} element
109   * @argument {String} property
110   */
111  function getStyleComputedProperty$1(element, property) {
112    if (element.nodeType !== 1) {
113      return [];
114    }
115    // NOTE: 1 DOM access here
116    const window = element.ownerDocument.defaultView;
117    const css = window.getComputedStyle(element, null);
118    return property ? css[property] : css;
119  }
120
121  /**
122   * Returns the parentNode or the host of the element
123   * @method
124   * @memberof Popper.Utils
125   * @argument {Element} element
126   * @returns {Element} parent
127   */
128  function getParentNode$1(element) {
129    if (element.nodeName === 'HTML') {
130      return element;
131    }
132    return element.parentNode || element.host;
133  }
134
135  /**
136   * Returns the scrolling parent of the given element
137   * @method
138   * @memberof Popper.Utils
139   * @argument {Element} element
140   * @returns {Element} scroll parent
141   */
142  function getScrollParent$1(element) {
143    // Return body, `getScroll` will take care to get the correct `scrollTop` from it
144    if (!element) {
145      return document.body;
146    }
147
148    switch (element.nodeName) {
149      case 'HTML':
150      case 'BODY':
151        return element.ownerDocument.body;
152      case '#document':
153        return element.body;
154    }
155
156    // Firefox want us to check `-x` and `-y` variations as well
157    const { overflow, overflowX, overflowY } = getStyleComputedProperty$1(element);
158    if (/(auto|scroll|overlay)/.test(overflow + overflowY + overflowX)) {
159      return element;
160    }
161
162    return getScrollParent$1(getParentNode$1(element));
163  }
164
165  /**
166   * Returns the reference node of the reference object, or the reference object itself.
167   * @method
168   * @memberof Popper.Utils
169   * @param {Element|Object} reference - the reference element (the popper will be relative to this)
170   * @returns {Element} parent
171   */
172  function getReferenceNode$1(reference) {
173    return reference && reference.referenceNode ? reference.referenceNode : reference;
174  }
175
176  const isIE11$1 = isBrowser$1 && !!(window.MSInputMethodContext && document.documentMode);
177  const isIE10$1 = isBrowser$1 && /MSIE 10/.test(navigator.userAgent);
178
179  /**
180   * Determines if the browser is Internet Explorer
181   * @method
182   * @memberof Popper.Utils
183   * @param {Number} version to check
184   * @returns {Boolean} isIE
185   */
186  function isIE$1(version) {
187    if (version === 11) {
188      return isIE11$1;
189    }
190    if (version === 10) {
191      return isIE10$1;
192    }
193    return isIE11$1 || isIE10$1;
194  }
195
196  /**
197   * Returns the offset parent of the given element
198   * @method
199   * @memberof Popper.Utils
200   * @argument {Element} element
201   * @returns {Element} offset parent
202   */
203  function getOffsetParent$1(element) {
204    if (!element) {
205      return document.documentElement;
206    }
207
208    const noOffsetParent = isIE$1(10) ? document.body : null;
209
210    // NOTE: 1 DOM access here
211    let offsetParent = element.offsetParent || null;
212    // Skip hidden elements which don't have an offsetParent
213    while (offsetParent === noOffsetParent && element.nextElementSibling) {
214      offsetParent = (element = element.nextElementSibling).offsetParent;
215    }
216

217    const nodeName = offsetParent && offsetParent.nodeName;
218
219    if (!nodeName || nodeName === 'BODY' || nodeName === 'HTML') {
220      return element ? element.ownerDocument.documentElement : document.documentElement;
221    }
222
223    // .offsetParent will return the closest TH, TD or TABLE in case
224    // no offsetParent is present, I hate this job...
225    if (['TH', 'TD', 'TABLE'].indexOf(offsetParent.nodeName) !== -1 && getStyleComputedProperty$1(offsetParent, 'position') === 'static') {
226      return getOffsetParent$1(offsetParent);
227    }
228
229    return offsetParent;
230  }
231
232  function isOffsetContainer$1(element) {
233    const { nodeName } = element;
234    if (nodeName === 'BODY') {
235      return false;
236    }
237    return nodeName === 'HTML' || getOffsetParent$1(element.firstElementChild) === element;
238  }
239
240  /**
241   * Finds the root node (document, shadowDOM root) of the given element
242   * @method
243   * @memberof Popper.Utils
244   * @argument {Element} node
245   * @returns {Element} root node
246   */
247  function getRoot$1(node) {
248    if (node.parentNode !== null) {
249      return getRoot$1(node.parentNode);
250    }
251
252    return node;
253  }
254
255  /**
256   * Finds the offset parent common to the two provided nodes
257   * @method
258   * @memberof Popper.Utils
259   * @argument {Element} element1
260   * @argument {Element} element2
261   * @returns {Element} common offset parent
262   */
263  function findCommonOffsetParent$1(element1, element2) {
264    // This check is needed to avoid errors in case one of the elements isn't defined for any reason
265    if (!element1 || !element1.nodeType || !element2 || !element2.nodeType) {
266      return document.documentElement;
267    }
268
269    // Here we make sure to give as "start" the element that comes first in the DOM
270    const order = element1.compareDocumentPosition(element2) & Node.DOCUMENT_POSITION_FOLLOWING;
271    const start = order ? element1 : element2;
272    const end = order ? element2 : element1;
273
274    // Get common ancestor container
275    const range = document.createRange();
276    range.setStart(start, 0);
277    range.setEnd(end, 0);
278    const { commonAncestorContainer } = range;
279
280    // Both nodes are inside #document
281    if (element1 !== commonAncestorContainer && element2 !== commonAncestorContainer || start.contains(end)) {
282      if (isOffsetContainer$1(commonAncestorContainer)) {
283        return commonAncestorContainer;
284      }
285
286      return getOffsetParent$1(commonAncestorContainer);
287    }
288
289    // one of the nodes is inside shadowDOM, find which one
290    const element1root = getRoot$1(element1);
291    if (element1root.host) {
292      return findCommonOffsetParent$1(element1root.host, element2);
293    } else {
294      return findCommonOffsetParent$1(element1, getRoot$1(element2).host);
295    }
296  }
297
298  /**
299   * Gets the scroll value of the given element in the given side (top and left)
300   * @method
301   * @memberof Popper.Utils
302   * @argument {Element} element
303   * @argument {String} side `top` or `left`
304   * @returns {number} amount of scrolled pixels
305   */
306  function getScroll$1(element, side = 'top') {
307    const upperSide = side === 'top' ? 'scrollTop' : 'scrollLeft';
308    const nodeName = element.nodeName;
309
310    if (nodeName === 'BODY' || nodeName === 'HTML') {
311      const html = element.ownerDocument.documentElement;
312      const scrollingElement = element.ownerDocument.scrollingElement || html;
313      return scrollingElement[upperSide];
314    }
315
316    return element[upperSide];
317  }
318
319  /*
320   * Sum or subtract the element scroll values (left and top) from a given rect object
321   * @method
322   * @memberof Popper.Utils
323   * @param {Object} rect - Rect object you want to change
324   * @param {HTMLElement} element - The element from the function reads the scroll values
325   * @param {Boolean} subtract - set to true if you want to subtract the scroll values
326   * @return {Object} rect - The modifier rect object
327   */
328  function includeScroll$1(rect, element, subtract = false) {
329    const scrollTop = getScroll$1(element, 'top');
330    const scrollLeft = getScroll$1(element, 'left');
331    const modifier = subtract ? -1 : 1;
332    rect.top += scrollTop * modifier;
333    rect.bottom += scrollTop * modifier;
334    rect.left += scrollLeft * modifier;
335    rect.right += scrollLeft * modifier;
336    return rect;
337  }
338
339  /*
340   * Helper to detect borders of a given element
341   * @method
342   * @memberof Popper.Utils
343   * @param {CSSStyleDeclaration} styles
344   * Result of `getStyleComputedProperty` on the given element
345   * @param {String} axis - `x` or `y`
346   * @return {number} borders - The borders size of the given axis
347   */
348
349  function getBordersSize$1(styles, axis) {
350    const sideA = axis === 'x' ? 'Left' : 'Top';
351    const sideB = sideA === 'Left' ? 'Right' : 'Bottom';
352
353    return parseFloat(styles[`border${sideA}Width`]) + parseFloat(styles[`border${sideB}Width`]);
354  }
355
356  function getSize$1(axis, body, html, computedStyle) {
357    return Math.max(body[`offset${axis}`], body[`scroll${axis}`], html[`client${axis}`], html[`offset${axis}`], html[`scroll${axis}`], isIE$1(10) ? parseInt(html[`offset${axis}`]) + parseInt(computedStyle[`margin${axis === 'Height' ? 'Top' : 'Left'}`]) + parseInt(computedStyle[`margin${axis === 'Height' ? 'Bottom' : 'Right'}`]) : 0);
358  }
359
360  function getWindowSizes$1(document) {
361    const body = document.body;
362    const html = document.documentElement;
363    const computedStyle = isIE$1(10) && getComputedStyle(html);
364
365    return {
366      height: getSize$1('Height', body, html, computedStyle),
367      width: getSize$1('Width', body, html, computedStyle)
368    };
369  }
370
371  var _extends$1 = Object.assign || function (target) {
372    for (var i = 1; i < arguments.length; i++) {
373      var source = arguments[i];
374
375      for (var key in source) {
376        if (Object.prototype.hasOwnProperty.call(source, key)) {
377          target[key] = source[key];
378        }
379      }
380    }
381
382    return target;
383  };
384
385  /**
386   * Given element offsets, generate an output similar to getBoundingClientRect
387   * @method
388   * @memberof Popper.Utils
389   * @argument {Object} offsets
390   * @returns {Object} ClientRect like output
391   */
392  function getClientRect$1(offsets) {
393    return _extends$1({}, offsets, {
394      right: offsets.left + offsets.width,
395      bottom: offsets.top + offsets.height
396    });
397  }
398
399  /**
400   * Get bounding client rect of given element
401   * @method
402   * @memberof Popper.Utils
403   * @param {HTMLElement} element
404   * @return {Object} client rect
405   */
406  function getBoundingClientRect$1(element) {
407    let rect = {};
408
409    // IE10 10 FIX: Please, don't ask, the element isn't
410    // considered in DOM in some circumstances...
411    // This isn't reproducible in IE10 compatibility mode of IE11
412    try {
413      if (isIE$1(10)) {
414        rect = element.getBoundingClientRect();
415        const scrollTop = getScroll$1(element, 'top');
416        const scrollLeft = getScroll$1(element, 'left');
417        rect.top += scrollTop;
418        rect.left += scrollLeft;
419        rect.bottom += scrollTop;
420        rect.right += scrollLeft;
421      } else {
422        rect = element.getBoundingClientRect();
423      }
424    } catch (e) {}
425
426    const result = {
427      left: rect.left,
428      top: rect.top,
429      width: rect.right - rect.left,
430      height: rect.bottom - rect.top
431    };
432
433    // subtract scrollbar size from sizes
434    const sizes = element.nodeName === 'HTML' ? getWindowSizes$1(element.ownerDocument) : {};
435    const width = sizes.width || element.clientWidth || result.width;
436    const height = sizes.height || element.clientHeight || result.height;
437
438    let horizScrollbar = element.offsetWidth - width;
439    let vertScrollbar = element.offsetHeight - height;
440
441    // if an hypothetical scrollbar is detected, we must be sure it's not a `border`
442    // we make this check conditional for performance reasons
443    if (horizScrollbar || vertScrollbar) {
444      const styles = getStyleComputedProperty$1(element);
445      horizScrollbar -= getBordersSize$1(styles, 'x');
446      vertScrollbar -= getBordersSize$1(styles, 'y');
447
448      result.width -= horizScrollbar;
449      result.height -= vertScrollbar;
450    }
451
452    return getClientRect$1(result);
453  }
454
455  function getOffsetRectRelativeToArbitraryNode$1(children, parent, fixedPosition = false) {
456    const isIE10 = isIE$1(10);
457    const isHTML = parent.nodeName === 'HTML';
458    const childrenRect = getBoundingClientRect$1(children);
459    const parentRect = getBoundingClientRect$1(parent);
460    const scrollParent = getScrollParent$1(children);
461
462    const styles = getStyleComputedProperty$1(parent);
463    const borderTopWidth = parseFloat(styles.borderTopWidth);
464    const borderLeftWidth = parseFloat(styles.borderLeftWidth);
465
466    // In cases where the parent is fixed, we must ignore negative scroll in offset calc
467    if (fixedPosition && isHTML) {
468      parentRect.top = Math.max(parentRect.top, 0);
469      parentRect.left = Math.max(parentRect.left, 0);
470    }
471    let offsets = getClientRect$1({
472      top: childrenRect.top - parentRect.top - borderTopWidth,
473      left: childrenRect.left - parentRect.left - borderLeftWidth,
474      width: childrenRect.width,
475      height: childrenRect.height
476    });
477    offsets.marginTop = 0;
478    offsets.marginLeft = 0;
479
480    // Subtract margins of documentElement in case it's being used as parent
481    // we do this only on HTML because it's the only element that behaves
482    // differently when margins are applied to it. The margins are included in
483    // the box of the documentElement, in the other cases not.
484    if (!isIE10 && isHTML) {
485      const marginTop = parseFloat(styles.marginTop);
486      const marginLeft = parseFloat(styles.marginLeft);
487
488      offsets.top -= borderTopWidth - marginTop;
489      offsets.bottom -= borderTopWidth - marginTop;
490      offsets.left -= borderLeftWidth - marginLeft;
491      offsets.right -= borderLeftWidth - marginLeft;
492
493      // Attach marginTop and marginLeft because in some circumstances we may need them
494      offsets.marginTop = marginTop;
495      offsets.marginLeft = marginLeft;
496    }
497
498    if (isIE10 && !fixedPosition ? parent.contains(scrollParent) : parent === scrollParent && scrollParent.nodeName !== 'BODY') {
499      offsets = includeScroll$1(offsets, parent);
500    }
501
502    return offsets;
503  }
504
505  function getViewportOffsetRectRelativeToArtbitraryNode$1(element, excludeScroll = false) {
506    const html = element.ownerDocument.documentElement;
507    const relativeOffset = getOffsetRectRelativeToArbitraryNode$1(element, html);
508    const width = Math.max(html.clientWidth, window.innerWidth || 0);
509    const height = Math.max(html.clientHeight, window.innerHeight || 0);
510
511    const scrollTop = !excludeScroll ? getScroll$1(html) : 0;
512    const scrollLeft = !excludeScroll ? getScroll$1(html, 'left') : 0;
513
514    const offset = {
515      top: scrollTop - relativeOffset.top + relativeOffset.marginTop,
516      left: scrollLeft - relativeOffset.left + relativeOffset.marginLeft,
517      width,
518      height
519    };
520
521    return getClientRect$1(offset);
522  }
523
524  /**
525   * Check if the given element is fixed or is inside a fixed parent
526   * @method
527   * @memberof Popper.Utils
528   * @argument {Element} element
529   * @argument {Element} customContainer
530   * @returns {Boolean} answer to "isFixed?"
531   */
532  function isFixed$1(element) {
533    const nodeName = element.nodeName;
534    if (nodeName === 'BODY' || nodeName === 'HTML') {
535      return false;
536    }
537    if (getStyleComputedProperty$1(element, 'position') === 'fixed') {
538      return true;
539    }
540    const parentNode = getParentNode$1(element);
541    if (!parentNode) {
542      return false;
543    }
544    return isFixed$1(parentNode);
545  }
546
547  /**
548   * Finds the first parent of an element that has a transformed property defined
549   * @method
550   * @memberof Popper.Utils
551   * @argument {Element} element
552   * @returns {Element} first transformed parent or documentElement
553   */
554
555  function getFixedPositionOffsetParent$1(element) {
556    // This check is needed to avoid errors in case one of the elements isn't defined for any reason
557    if (!element || !element.parentElement || isIE$1()) {
558      return document.documentElement;
559    }
560    let el = element.parentElement;
561    while (el && getStyleComputedProperty$1(el, 'transform') === 'none') {
562      el = el.parentElement;
563    }
564    return el || document.documentElement;
565  }
566
567  /**
568   * Computed the boundaries limits and return them
569   * @method
570   * @memberof Popper.Utils
571   * @param {HTMLElement} popper
572   * @param {HTMLElement} reference
573   * @param {number} padding
574   * @param {HTMLElement} boundariesElement - Element used to define the boundaries
575   * @param {Boolean} fixedPosition - Is in fixed position mode
576   * @returns {Object} Coordinates of the boundaries
577   */
578  function getBoundaries$1(popper, reference, padding, boundariesElement, fixedPosition = false) {
579    // NOTE: 1 DOM access here
580
581    let boundaries = { top: 0, left: 0 };
582    const offsetParent = fixedPosition ? getFixedPositionOffsetParent$1(popper) : findCommonOffsetParent$1(popper, getReferenceNode$1(reference));
583
584    // Handle viewport case
585    if (boundariesElement === 'viewport') {
586      boundaries = getViewportOffsetRectRelativeToArtbitraryNode$1(offsetParent, fixedPosition);
587    } else {
588      // Handle other cases based on DOM element used as boundaries
589      let boundariesNode;
590      if (boundariesElement === 'scrollParent') {
591        boundariesNode = getScrollParent$1(getParentNode$1(reference));
592        if (boundariesNode.nodeName === 'BODY') {
593          boundariesNode = popper.ownerDocument.documentElement;
594        }
595      } else if (boundariesElement === 'window') {
596        boundariesNode = popper.ownerDocument.documentElement;
597      } else {
598        boundariesNode = boundariesElement;
599      }
600
601      const offsets = getOffsetRectRelativeToArbitraryNode$1(boundariesNode, offsetParent, fixedPosition);
602
603      // In case of HTML, we need a different computation
604      if (boundariesNode.nodeName === 'HTML' && !isFixed$1(offsetParent)) {
605        const { height, width } = getWindowSizes$1(popper.ownerDocument);
606        boundaries.top += offsets.top - offsets.marginTop;
607        boundaries.bottom = height + offsets.top;
608        boundaries.left += offsets.left - offsets.marginLeft;
609        boundaries.right = width + offsets.left;
610      } else {
611        // for all the other DOM elements, this one is good
612        boundaries = offsets;
613      }
614    }
615
616    // Add paddings
617    padding = padding || 0;
618    const isPaddingNumber = typeof padding === 'number';
619    boundaries.left += isPaddingNumber ? padding : padding.left || 0;
620    boundaries.top += isPaddingNumber ? padding : padding.top || 0;
621    boundaries.right -= isPaddingNumber ? padding : padding.right || 0;
622    boundaries.bottom -= isPaddingNumber ? padding : padding.bottom || 0;
623
624    return boundaries;
625  }
626
627  function getArea$1({ width, height }) {
628    return width * height;
629  }
630
631  /**
632   * Utility used to transform the `auto` placement to the placement with more
633   * available space.
634   * @method
635   * @memberof Popper.Utils
636   * @argument {Object} data - The data object generated by update method
637   * @argument {Object} options - Modifiers configuration and options
638   * @returns {Object} The data object, properly modified
639   */
640  function computeAutoPlacement$1(placement, refRect, popper, reference, boundariesElement, padding = 0) {
641    if (placement.indexOf('auto') === -1) {
642      return placement;
643    }
644
645    const boundaries = getBoundaries$1(popper, reference, padding, boundariesElement);
646
647    const rects = {
648      top: {
649        width: boundaries.width,
650        height: refRect.top - boundaries.top
651      },
652      right: {
653        width: boundaries.right - refRect.right,
654        height: boundaries.height
655      },
656      bottom: {
657        width: boundaries.width,
658        height: boundaries.bottom - refRect.bottom
659      },
660      left: {
661        width: refRect.left - boundaries.left,
662        height: boundaries.height
663      }
664    };
665
666    const sortedAreas = Object.keys(rects).map(key => _extends$1({
667      key
668    }, rects[key], {
669      area: getArea$1(rects[key])
670    })).sort((a, b) => b.area - a.area);
671
672    const filteredAreas = sortedAreas.filter(({ width, height }) => width >= popper.clientWidth && height >= popper.clientHeight);
673
674    const computedPlacement = filteredAreas.length > 0 ? filteredAreas[0].key : sortedAreas[0].key;
675
676    const variation = placement.split('-')[1];
677
678    return computedPlacement + (variation ? `-${variation}` : '');
679  }
680
681  /**
682   * Get offsets to the reference element
683   * @method
684   * @memberof Popper.Utils
685   * @param {Object} state
686   * @param {Element} popper - the popper element
687   * @param {Element} reference - the reference element (the popper will be relative to this)
688   * @param {Element} fixedPosition - is in fixed position mode
689   * @returns {Object} An object containing the offsets which will be applied to the popper
690   */
691  function getReferenceOffsets$1(state, popper, reference, fixedPosition = null) {
692    const commonOffsetParent = fixedPosition ? getFixedPositionOffsetParent$1(popper) : findCommonOffsetParent$1(popper, getReferenceNode$1(reference));
693    return getOffsetRectRelativeToArbitraryNode$1(reference, commonOffsetParent, fixedPosition);
694  }
695
696  /**
697   * Get the outer sizes of the given element (offset size + margins)
698   * @method
699   * @memberof Popper.Utils
700   * @argument {Element} element
701   * @returns {Object} object containing width and height properties
702   */
703  function getOuterSizes$1(element) {
704    const window = element.ownerDocument.defaultView;
705    const styles = window.getComputedStyle(element);
706    const x = parseFloat(styles.marginTop || 0) + parseFloat(styles.marginBottom || 0);
707    const y = parseFloat(styles.marginLeft || 0) + parseFloat(styles.marginRight || 0);
708    const result = {
709      width: element.offsetWidth + y,
710      height: element.offsetHeight + x
711    };
712    return result;
713  }
714
715  /**
716   * Get the opposite placement of the given one
717   * @method
718   * @memberof Popper.Utils
719   * @argument {String} placement
720   * @returns {String} flipped placement
721   */
722  function getOppositePlacement$1(placement) {
723    const hash = { left: 'right', right: 'left', bottom: 'top', top: 'bottom' };
724    return placement.replace(/left|right|bottom|top/g, matched => hash[matched]);
725  }
726
727  /**
728   * Get offsets to the popper
729   * @method
730   * @memberof Popper.Utils
731   * @param {Object} position - CSS position the Popper will get applied
732   * @param {HTMLElement} popper - the popper element
733   * @param {Object} referenceOffsets - the reference offsets (the popper will be relative to this)
734   * @param {String} placement - one of the valid placement options
735   * @returns {Object} popperOffsets - An object containing the offsets which will be applied to the popper
736   */
737  function getPopperOffsets$1(popper, referenceOffsets, placement) {
738    placement = placement.split('-')[0];
739
740    // Get popper node sizes
741    const popperRect = getOuterSizes$1(popper);
742
743    // Add position, width and height to our offsets object
744    const popperOffsets = {
745      width: popperRect.width,
746      height: popperRect.height
747    };
748
749    // depending by the popper placement we have to compute its offsets slightly differently
750    const isHoriz = ['right', 'left'].indexOf(placement) !== -1;
751    const mainSide = isHoriz ? 'top' : 'left';
752    const secondarySide = isHoriz ? 'left' : 'top';
753    const measurement = isHoriz ? 'height' : 'width';
754    const secondaryMeasurement = !isHoriz ? 'height' : 'width';
755
756    popperOffsets[mainSide] = referenceOffsets[mainSide] + referenceOffsets[measurement] / 2 - popperRect[measurement] / 2;
757    if (placement === secondarySide) {
758      popperOffsets[secondarySide] = referenceOffsets[secondarySide] - popperRect[secondaryMeasurement];
759    } else {
760      popperOffsets[secondarySide] = referenceOffsets[getOppositePlacement$1(secondarySide)];
761    }
762
763    return popperOffsets;
764  }
765
766  /**
767   * Mimics the `find` method of Array
768   * @method
769   * @memberof Popper.Utils
770   * @argument {Array} arr
771   * @argument prop
772   * @argument value
773   * @returns index or -1
774   */
775  function find$1(arr, check) {
776    // use native find if supported
777    if (Array.prototype.find) {
778      return arr.find(check);
779    }
780
781    // use `filter` to obtain the same behavior of `find`
782    return arr.filter(check)[0];
783  }
784
785  /**
786   * Return the index of the matching object
787   * @method
788   * @memberof Popper.Utils
789   * @argument {Array} arr
790   * @argument prop
791   * @argument value
792   * @returns index or -1
793   */
794  function findIndex$1(arr, prop, value) {
795    // use native findIndex if supported
796    if (Array.prototype.findIndex) {
797      return arr.findIndex(cur => cur[prop] === value);
798    }
799
800    // use `find` + `indexOf` if `findIndex` isn't supported
801    const match = find$1(arr, obj => obj[prop] === value);
802    return arr.indexOf(match);
803  }
804
805  /**
806   * Loop trough the list of modifiers and run them in order,
807   * each of them will then edit the data object.
808   * @method
809   * @memberof Popper.Utils
810   * @param {dataObject} data
811   * @param {Array} modifiers
812   * @param {String} ends - Optional modifier name used as stopper
813   * @returns {dataObject}
814   */
815  function runModifiers$1(modifiers, data, ends) {
816    const modifiersToRun = ends === undefined ? modifiers : modifiers.slice(0, findIndex$1(modifiers, 'name', ends));
817

818    modifiersToRun.forEach(modifier => {
819      if (modifier['function']) {
820        // eslint-disable-line dot-notation
821        console.warn('`modifier.function` is deprecated, use `modifier.fn`!');
822      }
823      const fn = modifier['function'] || modifier.fn; // eslint-disable-line dot-notation
824      if (modifier.enabled && isFunction$1(fn)) {
825        // Add properties to offsets to make them a complete clientRect object
826        // we do this before each modifier to make sure the previous one doesn't
827        // mess with these values
828        data.offsets.popper = getClientRect$1(data.offsets.popper);
829        data.offsets.reference = getClientRect$1(data.offsets.reference);
830
831        data = fn(data, modifier);
832      }
833    });
834
835    return data;
836  }
837
838  /**
839   * Updates the position of the popper, computing the new offsets and applying
840   * the new style.<br />
841   * Prefer `scheduleUpdate` over `update` because of performance reasons.
842   * @method
843   * @memberof Popper
844   */
845  function update$1() {
846    // if popper is destroyed, don't perform any further update
847    if (this.state.isDestroyed) {
848      return;
849    }
850
851    let data = {
852      instance: this,
853      styles: {},
854      arrowStyles: {},
855      attributes: {},
856      flipped: false,
857      offsets: {}
858    };
859
860    // compute reference element offsets
861    data.offsets.reference = getReferenceOffsets$1(this.state, this.popper, this.reference, this.options.positionFixed);
862
863    // compute auto placement, store placement inside the data object,
864    // modifiers will be able to edit `placement` if needed
865    // and refer to originalPlacement to know the original value
866    data.placement = computeAutoPlacement$1(this.options.placement, data.offsets.reference, this.popper, this.reference, this.options.modifiers.flip.boundariesElement, this.options.modifiers.flip.padding);
867
868    // store the computed placement inside `originalPlacement`
869    data.originalPlacement = data.placement;
870
871    data.positionFixed = this.options.positionFixed;
872
873    // compute the popper offsets
874    data.offsets.popper = getPopperOffsets$1(this.popper, data.offsets.reference, data.placement);
875
876    data.offsets.popper.position = this.options.positionFixed ? 'fixed' : 'absolute';
877
878    // run the modifiers
879    data = runModifiers$1(this.modifiers, data);
880
881    // the first `update` will call `onCreate` callback
882    // the other ones will call `onUpdate` callback
883    if (!this.state.isCreated) {
884      this.state.isCreated = true;
885      this.options.onCreate(data);
886    } else {
887      this.options.onUpdate(data);
888    }
889  }
890
891  /**
892   * Helper used to know if the given modifier is enabled.
893   * @method
894   * @memberof Popper.Utils
895   * @returns {Boolean}
896   */
897  function isModifierEnabled$1(modifiers, modifierName) {
898    return modifiers.some(({ name, enabled }) => enabled && name === modifierName);
899  }
900
901  /**
902   * Get the prefixed supported property name
903   * @method
904   * @memberof Popper.Utils
905   * @argument {String} property (camelCase)
906   * @returns {String} prefixed property (camelCase or PascalCase, depending on the vendor prefix)
907   */
908  function getSupportedPropertyName$1(property) {
909    const prefixes = [false, 'ms', 'Webkit', 'Moz', 'O'];
910    const upperProp = property.charAt(0).toUpperCase() + property.slice(1);
911
912    for (let i = 0; i < prefixes.length; i++) {
913      const prefix = prefixes[i];
914      const toCheck = prefix ? `${prefix}${upperProp}` : property;
915      if (typeof document.body.style[toCheck] !== 'undefined') {
916        return toCheck;
917      }
918    }
919    return null;
920  }
921
922  /**
923   * Destroys the popper.
924   * @method
925   * @memberof Popper
926   */
927  function destroy$1() {
928    this.state.isDestroyed = true;
929
930    // touch DOM only if `applyStyle` modifier is enabled
931    if (isModifierEnabled$1(this.modifiers, 'applyStyle')) {
932      this.popper.removeAttribute('x-placement');
933      this.popper.style.position = '';
934      this.popper.style.top = '';
935      this.popper.style.left = '';
936      this.popper.style.right = '';
937      this.popper.style.bottom = '';
938      this.popper.style.willChange = '';
939      this.popper.style[getSupportedPropertyName$1('transform')] = '';
940    }
941
942    this.disableEventListeners();
943
944    // remove the popper if user explicitly asked for the deletion on destroy
945    // do not use `remove` because IE11 doesn't support it
946    if (this.options.removeOnDestroy) {
947      this.popper.parentNode.removeChild(this.popper);
948    }
949    return this;
950  }
951
952  /**
953   * Get the window associated with the element
954   * @argument {Element} element
955   * @returns {Window}
956   */
957  function getWindow$1(element) {
958    const ownerDocument = element.ownerDocument;
959    return ownerDocument ? ownerDocument.defaultView : window;
960  }
961
962  function attachToScrollParents$1(scrollParent, event, callback, scrollParents) {
963    const isBody = scrollParent.nodeName === 'BODY';
964    const target = isBody ? scrollParent.ownerDocument.defaultView : scrollParent;
965    target.addEventListener(event, callback, { passive: true });
966
967    if (!isBody) {
968      attachToScrollParents$1(getScrollParent$1(target.parentNode), event, callback, scrollParents);
969    }
970    scrollParents.push(target);
971  }
972
973  /**
974   * Setup needed event listeners used to update the popper position
975   * @method
976   * @memberof Popper.Utils
977   * @private
978   */
979  function setupEventListeners$1(reference, options, state, updateBound) {
980    // Resize event listener on window
981    state.updateBound = updateBound;
982    getWindow$1(reference).addEventListener('resize', state.updateBound, { passive: true });
983
984    // Scroll event listener on scroll parents
985    const scrollElement = getScrollParent$1(reference);
986    attachToScrollParents$1(scrollElement, 'scroll', state.updateBound, state.scrollParents);
987    state.scrollElement = scrollElement;
988    state.eventsEnabled = true;
989
990    return state;
991  }
992
993  /**
994   * It will add resize/scroll events and start recalculating
995   * position of the popper element when they are triggered.
996   * @method
997   * @memberof Popper
998   */
999  function enableEventListeners$1() {
1000    if (!this.state.eventsEnabled) {
1001      this.state = setupEventListeners$1(this.reference, this.options, this.state, this.scheduleUpdate);
1002    }
1003  }
1004
1005  /**
1006   * Remove event listeners used to update the popper position
1007   * @method
1008   * @memberof Popper.Utils
1009   * @private
1010   */
1011  function removeEventListeners$1(reference, state) {
1012    // Remove resize event listener on window
1013    getWindow$1(reference).removeEventListener('resize', state.updateBound);
1014
1015    // Remove scroll event listener on scroll parents
1016    state.scrollParents.forEach(target => {
1017      target.removeEventListener('scroll', state.updateBound);
1018    });
1019
1020    // Reset state
1021    state.updateBound = null;
1022    state.scrollParents = [];
1023    state.scrollElement = null;
1024    state.eventsEnabled = false;
1025    return state;
1026  }
1027
1028  /**
1029   * It will remove resize/scroll events and won't recalculate popper position
1030   * when they are triggered. It also won't trigger `onUpdate` callback anymore,
1031   * unless you call `update` method manually.
1032   * @method
1033   * @memberof Popper
1034   */
1035  function disableEventListeners$1() {
1036    if (this.state.eventsEnabled) {
1037      cancelAnimationFrame(this.scheduleUpdate);
1038      this.state = removeEventListeners$1(this.reference, this.state);
1039    }
1040  }
1041
1042  /**
1043   * Tells if a given input is a number
1044   * @method
1045   * @memberof Popper.Utils
1046   * @param {*} input to check
1047   * @return {Boolean}
1048   */
1049  function isNumeric$1(n) {
1050    return n !== '' && !isNaN(parseFloat(n)) && isFinite(n);
1051  }
1052
1053  /**
1054   * Set the style to the given popper
1055   * @method
1056   * @memberof Popper.Utils
1057   * @argument {Element} element - Element to apply the style to
1058   * @argument {Object} styles
1059   * Object with a list of properties and values which will be applied to the element
1060   */
1061  function setStyles$1(element, styles) {
1062    Object.keys(styles).forEach(prop => {
1063      let unit = '';
1064      // add unit if the value is numeric and is one of the following
1065      if (['width', 'height', 'top', 'right', 'bottom', 'left'].indexOf(prop) !== -1 && isNumeric$1(styles[prop])) {
1066        unit = 'px';
1067      }
1068      element.style[prop] = styles[prop] + unit;
1069    });
1070  }
1071
1072  /**
1073   * Set the attributes to the given popper
1074   * @method
1075   * @memberof Popper.Utils
1076   * @argument {Element} element - Element to apply the attributes to
1077   * @argument {Object} styles
1078   * Object with a list of properties and values which will be applied to the element
1079   */
1080  function setAttributes$1(element, attributes) {

1112    if (data.arrowElement && Object.keys(data.arrowStyles).length) {
1113      setStyles$1(data.arrowElement, data.arrowStyles);
1114    }
1115
1116    return data;
1117  }
1118
1119  /**
1120   * Set the x-placement attribute before everything else because it could be used
1121   * to add margins to the popper margins needs to be calculated to get the
1122   * correct popper offsets.
1123   * @method
1124   * @memberof Popper.modifiers
1125   * @param {HTMLElement} reference - The reference element used to position the popper
1126   * @param {HTMLElement} popper - The HTML element used as popper
1127   * @param {Object} options - Popper.js options
1128   */
1129  function applyStyleOnLoad$1(reference, popper, options, modifierOptions, state) {
1130    // compute reference element offsets
1131    const referenceOffsets = getReferenceOffsets$1(state, popper, reference, options.positionFixed);
1132
1133    // compute auto placement, store placement inside the data object,
1134    // modifiers will be able to edit `placement` if needed
1135    // and refer to originalPlacement to know the original value
1136    const placement = computeAutoPlacement$1(options.placement, referenceOffsets, popper, reference, options.modifiers.flip.boundariesElement, options.modifiers.flip.padding);
1137
1138    popper.setAttribute('x-placement', placement);
1139
1140    // Apply `position` to popper before anything else because
1141    // without the position applied we can't guarantee correct computations
1142    setStyles$1(popper, { position: options.positionFixed ? 'fixed' : 'absolute' });
1143
1144    return options;
1145  }
1146
1147  /**
1148   * @function
1149   * @memberof Popper.Utils
1150   * @argument {Object} data - The data object generated by `update` method
1151   * @argument {Boolean} shouldRound - If the offsets should be rounded at all
1152   * @returns {Object} The popper's position offsets rounded
1153   *
1154   * The tale of pixel-perfect positioning. It's still not 100% perfect, but as
1155   * good as it can be within reason.
1156   * Discussion here: https://github.com/FezVrasta/popper.js/pull/715
1157   *
1158   * Low DPI screens cause a popper to be blurry if not using full pixels (Safari
1159   * as well on High DPI screens).
1160   *
1161   * Firefox prefers no rounding for positioning and does not have blurriness on
1162   * high DPI screens.
1163   *
1164   * Only horizontal placement and left/right values need to be considered.
1165   */
1166  function getRoundedOffsets$1(data, shouldRound) {
1167    const { popper, reference } = data.offsets;
1168    const { round, floor } = Math;
1169    const noRound = v => v;
1170
1171    const referenceWidth = round(reference.width);
1172    const popperWidth = round(popper.width);
1173
1174    const isVertical = ['left', 'right'].indexOf(data.placement) !== -1;
1175    const isVariation = data.placement.indexOf('-') !== -1;
1176    const sameWidthParity = referenceWidth % 2 === popperWidth % 2;
1177    const bothOddWidth = referenceWidth % 2 === 1 && popperWidth % 2 === 1;
1178
1179    const horizontalToInteger = !shouldRound ? noRound : isVertical || isVariation || sameWidthParity ? round : floor;
1180    const verticalToInteger = !shouldRound ? noRound : round;
1181
1182    return {
1183      left: horizontalToInteger(bothOddWidth && !isVariation && shouldRound ? popper.left - 1 : popper.left),
1184      top: verticalToInteger(popper.top),
1185      bottom: verticalToInteger(popper.bottom),
1186      right: horizontalToInteger(popper.right)
1187    };
1188  }
1189
1190  const isFirefox$1 = isBrowser$1 && /Firefox/i.test(navigator.userAgent);
1191
1192  /**
1193   * @function
1194   * @memberof Modifiers
1195   * @argument {Object} data - The data object generated by `update` method
1196   * @argument {Object} options - Modifiers configuration and options
1197   * @returns {Object} The data object, properly modified
1198   */
1199  function computeStyle$1(data, options) {
1200    const { x, y } = options;
1201    const { popper } = data.offsets;
1202
1203    // Remove this legacy support in Popper.js v2
1204    const legacyGpuAccelerationOption = find$1(data.instance.modifiers, modifier => modifier.name === 'applyStyle').gpuAcceleration;
1205    if (legacyGpuAccelerationOption !== undefined) {
1206      console.warn('WARNING: `gpuAcceleration` option moved to `computeStyle` modifier and will not be supported in future versions of Popper.js!');
1207    }
1208    const gpuAcceleration = legacyGpuAccelerationOption !== undefined ? legacyGpuAccelerationOption : options.gpuAcceleration;
1209
1210    const offsetParent = getOffsetParent$1(data.instance.popper);
1211    const offsetParentRect = getBoundingClientRect$1(offsetParent);
1212
1213    // Styles
1214    const styles = {
1215      position: popper.position
1216    };
1217
1218    const offsets = getRoundedOffsets$1(data, window.devicePixelRatio < 2 || !isFirefox$1);
1219
1220    const sideA = x === 'bottom' ? 'top' : 'bottom';
1221    const sideB = y === 'right' ? 'left' : 'right';
1222
1223    // if gpuAcceleration is set to `true` and transform is supported,
1224    //  we use `translate3d` to apply the position to the popper we
1225    // automatically use the supported prefixed version if needed
1226    const prefixedProperty = getSupportedPropertyName$1('transform');
1227
1228    // now, let's make a step back and look at this code closely (wtf?)
1229    // If the content of the popper grows once it's been positioned, it
1230    // may happen that the popper gets misplaced because of the new content
1231    // overflowing its reference element
1232    // To avoid this problem, we provide two options (x and y), which allow
1233    // the consumer to define the offset origin.
1234    // If we position a popper on top of a reference element, we can set
1235    // `x` to `top` to make the popper grow towards its top instead of
1236    // its bottom.
1237    let left, top;
1238    if (sideA === 'bottom') {
1239      // when offsetParent is <html> the positioning is relative to the bottom of the screen (excluding the scrollbar)
1240      // and not the bottom of the html element
1241      if (offsetParent.nodeName === 'HTML') {
1242        top = -offsetParent.clientHeight + offsets.bottom;
1243      } else {
1244        top = -offsetParentRect.height + offsets.bottom;
1245      }
1246    } else {
1247      top = offsets.top;
1248    }
1249    if (sideB === 'right') {
1250      if (offsetParent.nodeName === 'HTML') {
1251        left = -offsetParent.clientWidth + offsets.right;
1252      } else {
1253        left = -offsetParentRect.width + offsets.right;
1254      }
1255    } else {
1256      left = offsets.left;
1257    }
1258    if (gpuAcceleration && prefixedProperty) {
1259      styles[prefixedProperty] = `translate3d(${left}px, ${top}px, 0)`;
1260      styles[sideA] = 0;
1261      styles[sideB] = 0;
1262      styles.willChange = 'transform';
1263    } else {
1264      // othwerise, we use the standard `top`, `left`, `bottom` and `right` properties
1265      const invertTop = sideA === 'bottom' ? -1 : 1;
1266      const invertLeft = sideB === 'right' ? -1 : 1;
1267      styles[sideA] = top * invertTop;
1268      styles[sideB] = left * invertLeft;
1269      styles.willChange = `${sideA}, ${sideB}`;
1270    }
1271
1272    // Attributes
1273    const attributes = {
1274      'x-placement': data.placement
1275    };
1276
1277    // Update `data` attributes, styles and arrowStyles
1278    data.attributes = _extends$1({}, attributes, data.attributes);
1279    data.styles = _extends$1({}, styles, data.styles);
1280    data.arrowStyles = _extends$1({}, data.offsets.arrow, data.arrowStyles);
1281
1282    return data;
1283  }
1284
1285  /**
1286   * Helper used to know if the given modifier depends from another one.<br />
1287   * It checks if the needed modifier is listed and enabled.
1288   * @method
1289   * @memberof Popper.Utils
1290   * @param {Array} modifiers - list of modifiers
1291   * @param {String} requestingName - name of requesting modifier
1292   * @param {String} requestedName - name of requested modifier
1293   * @returns {Boolean}
1294   */
1295  function isModifierRequired$1(modifiers, requestingName, requestedName) {
1296    const requesting = find$1(modifiers, ({ name }) => name === requestingName);
1297
1298    const isRequired = !!requesting && modifiers.some(modifier => {
1299      return modifier.name === requestedName && modifier.enabled && modifier.order < requesting.order;
1300    });
1301
1302    if (!isRequired) {
1303      const requesting = `\`${requestingName}\``;
1304      const requested = `\`${requestedName}\``;
1305      console.warn(`${requested} modifier is required by ${requesting} modifier in order to work, be sure to include it before ${requesting}!`);
1306    }
1307    return isRequired;
1308  }
1309
1310  /**
1311   * @function
1312   * @memberof Modifiers
1313   * @argument {Object} data - The data object generated by update method
1314   * @argument {Object} options - Modifiers configuration and options
1315   * @returns {Object} The data object, properly modified
1316   */
1317  function arrow$1(data, options) {
1318    // arrow depends on keepTogether in order to work
1319    if (!isModifierRequired$1(data.instance.modifiers, 'arrow', 'keepTogether')) {
1320      return data;
1321    }
1322
1323    let arrowElement = options.element;
1324
1325    // if arrowElement is a string, suppose it's a CSS selector
1326    if (typeof arrowElement === 'string') {
1327      arrowElement = data.instance.popper.querySelector(arrowElement);
1328
1329      // if arrowElement is not found, don't run the modifier
1330      if (!arrowElement) {
1331        return data;
1332      }
1333    } else {
1334      // if the arrowElement isn't a query selector we must check that the
1335      // provided DOM node is child of its popper node
1336      if (!data.instance.popper.contains(arrowElement)) {
1337        console.warn('WARNING: `arrow.element` must be child of its popper element!');
1338        return data;
1339      }
1340    }
1341
1342    const placement = data.placement.split('-')[0];
1343    const { popper, reference } = data.offsets;
1344    const isVertical = ['left', 'right'].indexOf(placement) !== -1;
1345
1346    const len = isVertical ? 'height' : 'width';
1347    const sideCapitalized = isVertical ? 'Top' : 'Left';
1348    const side = sideCapitalized.toLowerCase();
1349    const altSide = isVertical ? 'left' : 'top';
1350    const opSide = isVertical ? 'bottom' : 'right';
1351    const arrowElementSize = getOuterSizes$1(arrowElement)[len];
1352
1353    //
1354    // extends keepTogether behavior making sure the popper and its
1355    // reference have enough pixels in conjunction
1356    //
1357
1358    // top/left side
1359    if (reference[opSide] - arrowElementSize < popper[side]) {
1360      data.offsets.popper[side] -= popper[side] - (reference[opSide] - arrowElementSize);
1361    }
1362    // bottom/right side
1363    if (reference[side] + arrowElementSize > popper[opSide]) {
1364      data.offsets.popper[side] += reference[side] + arrowElementSize - popper[opSide];
1365    }
1366    data.offsets.popper = getClientRect$1(data.offsets.popper);
1367
1368    // compute center of the popper
1369    const center = reference[side] + reference[len] / 2 - arrowElementSize / 2;
1370
1371    // Compute the sideValue using the updated popper offsets
1372    // take popper margin in account because we don't have this info available
1373    const css = getStyleComputedProperty$1(data.instance.popper);
1374    const popperMarginSide = parseFloat(css[`margin${sideCapitalized}`]);
1375    const popperBorderSide = parseFloat(css[`border${sideCapitalized}Width`]);
1376    let sideValue = center - data.offsets.popper[side] - popperMarginSide - popperBorderSide;
1377
1378    // prevent arrowElement from being placed not contiguously to its popper
1379    sideValue = Math.max(Math.min(popper[len] - arrowElementSize, sideValue), 0);
1380
1381    data.arrowElement = arrowElement;
1382    data.offsets.arrow = {
1383      [side]: Math.round(sideValue),
1384      [altSide]: '' // make sure to unset any eventual altSide value from the DOM node
1385    };
1386
1387    return data;
1388  }
1389
1390  /**
1391   * Get the opposite placement variation of the given one
1392   * @method
1393   * @memberof Popper.Utils
1394   * @argument {String} placement variation
1395   * @returns {String} flipped placement variation
1396   */
1397  function getOppositeVariation$1(variation) {
1398    if (variation === 'end') {
1399      return 'start';
1400    } else if (variation === 'start') {
1401      return 'end';
1402    }
1403    return variation;
1404  }
1405
1406  /**
1407   * List of accepted placements to use as values of the `placement` option.<br />
1408   * Valid placements are:
1409   * - `auto`
1410   * - `top`
1411   * - `right`
1412   * - `bottom`
1413   * - `left`
1414   *
1415   * Each placement can have a variation from this list:
1416   * - `-start`
1417   * - `-end`
1418   *
1419   * Variations are interpreted easily if you think of them as the left to right
1420   * written languages. Horizontally (`top` and `bottom`), `start` is left and `end`
1421   * is right.<br />
1422   * Vertically (`left` and `right`), `start` is top and `end` is bottom.
1423   *
1424   * Some valid examples are:
1425   * - `top-end` (on top of reference, right aligned)
1426   * - `right-start` (on right of reference, top aligned)
1427   * - `bottom` (on bottom, centered)
1428   * - `auto-end` (on the side with more space available, alignment depends by placement)
1429   *
1430   * @static
1431   * @type {Array}
1432   * @enum {String}
1433   * @readonly
1434   * @method placements
1435   * @memberof Popper
1436   */
1437  var placements$1 = ['auto-start', 'auto', 'auto-end', 'top-start', 'top', 'top-end', 'right-start', 'right', 'right-end', 'bottom-end', 'bottom', 'bottom-start', 'left-end', 'left', 'left-start'];
1438
1439  // Get rid of `auto` `auto-start` and `auto-end`
1440  const validPlacements$1 = placements$1.slice(3);
1441
1442  /**
1443   * Given an initial placement, returns all the subsequent placements
1444   * clockwise (or counter-clockwise).
1445   *
1446   * @method
1447   * @memberof Popper.Utils
1448   * @argument {String} placement - A valid placement (it accepts variations)
1449   * @argument {Boolean} counter - Set to true to walk the placements counterclockwise
1450   * @returns {Array} placements including their variations
1451   */
1452  function clockwise$1(placement, counter = false) {
1453    const index = validPlacements$1.indexOf(placement);
1454    const arr = validPlacements$1.slice(index + 1).concat(validPlacements$1.slice(0, index));
1455    return counter ? arr.reverse() : arr;
1456  }
1457
1458  const BEHAVIORS$1 = {
1459    FLIP: 'flip',
1460    CLOCKWISE: 'clockwise',
1461    COUNTERCLOCKWISE: 'counterclockwise'
1462  };
1463
1464  /**
1465   * @function
1466   * @memberof Modifiers
1467   * @argument {Object} data - The data object generated by update method
1468   * @argument {Object} options - Modifiers configuration and options
1469   * @returns {Object} The data object, properly modified
1470   */
1471  function flip$1(data, options) {
1472    // if `inner` modifier is enabled, we can't use the `flip` modifier
1473    if (isModifierEnabled$1(data.instance.modifiers, 'inner')) {
1474      return data;
1475    }
1476
1477    if (data.flipped && data.placement === data.originalPlacement) {
1478      // seems like flip is trying to loop, probably there's not enough space on any of the flippable sides
1479      return data;
1480    }
1481
1482    const boundaries = getBoundaries$1(data.instance.popper, data.instance.reference, options.padding, options.boundariesElement, data.positionFixed);
1483
1484    let placement = data.placement.split('-')[0];
1485    let placementOpposite = getOppositePlacement$1(placement);
1486    let variation = data.placement.split('-')[1] || '';
1487
1488    let flipOrder = [];
1489
1490    switch (options.behavior) {
1491      case BEHAVIORS$1.FLIP:
1492        flipOrder = [placement, placementOpposite];
1493        break;
1494      case BEHAVIORS$1.CLOCKWISE:
1495        flipOrder = clockwise$1(placement);
1496        break;
1497      case BEHAVIORS$1.COUNTERCLOCKWISE:
1498        flipOrder = clockwise$1(placement, true);
1499        break;
1500      default:
1501        flipOrder = options.behavior;
1502    }
1503
1504    flipOrder.forEach((step, index) => {
1505      if (placement !== step || flipOrder.length === index + 1) {
1506        return data;
1507      }
1508
1509      placement = data.placement.split('-')[0];
1510      placementOpposite = getOppositePlacement$1(placement);
1511
1512      const popperOffsets = data.offsets.popper;
1513      const refOffsets = data.offsets.reference;
1514
1515      // using floor because the reference offsets may contain decimals we are not going to consider here
1516      const floor = Math.floor;
1517      const overlapsRef = placement === 'left' && floor(popperOffsets.right) > floor(refOffsets.left) || placement === 'right' && floor(popperOffsets.left) < floor(refOffsets.right) || placement === 'top' && floor(popperOffsets.bottom) > floor(refOffsets.top) || placement === 'bottom' && floor(popperOffsets.top) < floor(refOffsets.bottom);
1518
1519      const overflowsLeft = floor(popperOffsets.left) < floor(boundaries.left);
1520      const overflowsRight = floor(popperOffsets.right) > floor(boundaries.right);
1521      const overflowsTop = floor(popperOffsets.top) < floor(boundaries.top);
1522      const overflowsBottom = floor(popperOffsets.bottom) > floor(boundaries.bottom);
1523
1524      const overflowsBoundaries = placement === 'left' && overflowsLeft || placement === 'right' && overflowsRight || placement === 'top' && overflowsTop || placement === 'bottom' && overflowsBottom;
1525
1526      // flip the variation if required
1527      const isVertical = ['top', 'bottom'].indexOf(placement) !== -1;
1528
1529      // flips variation if reference element overflows boundaries
1530      const flippedVariationByRef = !!options.flipVariations && (isVertical && variation === 'start' && overflowsLeft || isVertical && variation === 'end' && overflowsRight || !isVertical && variation === 'start' && overflowsTop || !isVertical && variation === 'end' && overflowsBottom);
1531
1532      // flips variation if popper content overflows boundaries
1533      const flippedVariationByContent = !!options.flipVariationsByContent && (isVertical && variation === 'start' && overflowsRight || isVertical && variation === 'end' && overflowsLeft || !isVertical && variation === 'start' && overflowsBottom || !isVertical && variation === 'end' && overflowsTop);
1534
1535      const flippedVariation = flippedVariationByRef || flippedVariationByContent;
1536
1537      if (overlapsRef || overflowsBoundaries || flippedVariation) {
1538        // this boolean to detect any flip loop
1539        data.flipped = true;
1540
1541        if (overlapsRef || overflowsBoundaries) {
1542          placement = flipOrder[index + 1];
1543        }
1544
1545        if (flippedVariation) {
1546          variation = getOppositeVariation$1(variation);
1547        }
1548
1549        data.placement = placement + (variation ? '-' + variation : '');
1550
1551        // this object contains `position`, we want to preserve it along with
1552        // any additional property we may add in the future
1553        data.offsets.popper = _extends$1({}, data.offsets.popper, getPopperOffsets$1(data.instance.popper, data.offsets.reference, data.placement));
1554
1555        data = runModifiers$1(data.instance.modifiers, data, 'flip');
1556      }
1557    });
1558    return data;
1559  }
1560
1561  /**
1562   * @function
1563   * @memberof Modifiers
1564   * @argument {Object} data - The data object generated by update method
1565   * @argument {Object} options - Modifiers configuration and options
1566   * @returns {Object} The data object, properly modified
1567   */
1568  function keepTogether$1(data) {
1569    const { popper, reference } = data.offsets;
1570    const placement = data.placement.split('-')[0];
1571    const floor = Math.floor;
1572    const isVertical = ['top', 'bottom'].indexOf(placement) !== -1;
1573    const side = isVertical ? 'right' : 'bottom';
1574    const opSide = isVertical ? 'left' : 'top';
1575    const measurement = isVertical ? 'width' : 'height';
1576
1577    if (popper[side] < floor(reference[opSide])) {
1578      data.offsets.popper[opSide] = floor(reference[opSide]) - popper[measurement];
1579    }
1580    if (popper[opSide] > floor(reference[side])) {
1581      data.offsets.popper[opSide] = floor(reference[side]);
1582    }
1583
1584    return data;
1585  }
1586
1587  /**
1588   * Converts a string containing value + unit into a px value number
1589   * @function
1590   * @memberof {modifiers~offset}
1591   * @private
1592   * @argument {String} str - Value + unit string
1593   * @argument {String} measurement - `height` or `width`
1594   * @argument {Object} popperOffsets
1595   * @argument {Object} referenceOffsets
1596   * @returns {Number|String}
1597   * Value in pixels, or original string if no values were extracted
1598   */
1599  function toValue$1(str, measurement, popperOffsets, referenceOffsets) {
1600    // separate value from unit
1601    const split = str.match(/((?:\-|\+)?\d*\.?\d*)(.*)/);
1602    const value = +split[1];
1603    const unit = split[2];
1604
1605    // If it's not a number it's an operator, I guess
1606    if (!value) {
1607      return str;
1608    }
1609
1610    if (unit.indexOf('%') === 0) {
1611      let element;
1612      switch (unit) {
1613        case '%p':
1614          element = popperOffsets;
1615          break;
1616        case '%':
1617        case '%r':
1618        default:
1619          element = referenceOffsets;
1620      }
1621
1622      const rect = getClientRect$1(element);
1623      return rect[measurement] / 100 * value;
1624    } else if (unit === 'vh' || unit === 'vw') {
1625      // if is a vh or vw, we calculate the size based on the viewport
1626      let size;
1627      if (unit === 'vh') {
1628        size = Math.max(document.documentElement.clientHeight, window.innerHeight || 0);
1629      } else {
1630        size = Math.max(document.documentElement.clientWidth, window.innerWidth || 0);
1631      }
1632      return size / 100 * value;
1633    } else {
1634      // if is an explicit pixel unit, we get rid of the unit and keep the value
1635      // if is an implicit unit, it's px, and we return just the value
1636      return value;
1637    }
1638  }
1639
1640  /**
1641   * Parse an `offset` string to extrapolate `x` and `y` numeric offsets.
1642   * @function
1643   * @memberof {modifiers~offset}
1644   * @private
1645   * @argument {String} offset
1646   * @argument {Object} popperOffsets
1647   * @argument {Object} referenceOffsets
1648   * @argument {String} basePlacement
1649   * @returns {Array} a two cells array with x and y offsets in numbers
1650   */
1651  function parseOffset$1(offset, popperOffsets, referenceOffsets, basePlacement) {
1652    const offsets = [0, 0];
1653
1654    // Use height if placement is left or right and index is 0 otherwise use width
1655    // in this way the first offset will use an axis and the second one
1656    // will use the other one
1657    const useHeight = ['right', 'left'].indexOf(basePlacement) !== -1;
1658
1659    // Split the offset string to obtain a list of values and operands
1660    // The regex addresses values with the plus or minus sign in front (+10, -20, etc)
1661    const fragments = offset.split(/(\+|\-)/).map(frag => frag.trim());
1662
1663    // Detect if the offset string contains a pair of values or a single one
1664    // they could be separated by comma or space
1665    const divider = fragments.indexOf(find$1(fragments, frag => frag.search(/,|\s/) !== -1));
1666
1667    if (fragments[divider] && fragments[divider].indexOf(',') === -1) {
1668      console.warn('Offsets separated by white space(s) are deprecated, use a comma (,) instead.');
1669    }
1670
1671    // If divider is found, we divide the list of values and operands to divide
1672    // them by ofset X and Y.
1673    const splitRegex = /\s*,\s*|\s+/;
1674    let ops = divider !== -1 ? [fragments.slice(0, divider).concat([fragments[divider].split(splitRegex)[0]]), [fragments[divider].split(splitRegex)[1]].concat(fragments.slice(divider + 1))] : [fragments];
1675
1676    // Convert the values with units to absolute pixels to allow our computations
1677    ops = ops.map((op, index) => {
1678      // Most of the units rely on the orientation of the popper
1679      const measurement = (index === 1 ? !useHeight : useHeight) ? 'height' : 'width';
1680      let mergeWithPrevious = false;
1681      return op
1682      // This aggregates any `+` or `-` sign that aren't considered operators
1683      // e.g.: 10 + +5 => [10, +, +5]
1684      .reduce((a, b) => {
1685        if (a[a.length - 1] === '' && ['+', '-'].indexOf(b) !== -1) {
1686          a[a.length - 1] = b;
1687          mergeWithPrevious = true;
1688          return a;
1689        } else if (mergeWithPrevious) {
1690          a[a.length - 1] += b;
1691          mergeWithPrevious = false;
1692          return a;
1693        } else {
1694          return a.concat(b);
1695        }
1696      }, [])
1697      // Here we convert the string values into number values (in px)
1698      .map(str => toValue$1(str, measurement, popperOffsets, referenceOffsets));
1699    });
1700
1701    // Loop trough the offsets arrays and execute the operations
1702    ops.forEach((op, index) => {
1703      op.forEach((frag, index2) => {
1704        if (isNumeric$1(frag)) {
1705          offsets[index] += frag * (op[index2 - 1] === '-' ? -1 : 1);
1706        }
1707      });
1708    });
1709    return offsets;
1710  }
1711
1712  /**
1713   * @function
1714   * @memberof Modifiers
1715   * @argument {Object} data - The data object generated by update method
1716   * @argument {Object} options - Modifiers configuration and options
1717   * @argument {Number|String} options.offset=0
1718   * The offset value as described in the modifier description
1719   * @returns {Object} The data object, properly modified
1720   */
1721  function offset$1(data, { offset }) {
1722    const { placement, offsets: { popper, reference } } = data;
1723    const basePlacement = placement.split('-')[0];
1724
1725    let offsets;
1726    if (isNumeric$1(+offset)) {
1727      offsets = [+offset, 0];
1728    } else {
1729      offsets = parseOffset$1(offset, popper, reference, basePlacement);
1730    }
1731
1732    if (basePlacement === 'left') {
1733      popper.top += offsets[0];
1734      popper.left -= offsets[1];
1735    } else if (basePlacement === 'right') {
1736      popper.top += offsets[0];
1737      popper.left += offsets[1];
1738    } else if (basePlacement === 'top') {
1739      popper.left += offsets[0];
1740      popper.top -= offsets[1];
1741    } else if (basePlacement === 'bottom') {
1742      popper.left += offsets[0];
1743      popper.top += offsets[1];
1744    }
1745
1746    data.popper = popper;
1747    return data;
1748  }
1749
1750  /**
1751   * @function
1752   * @memberof Modifiers
1753   * @argument {Object} data - The data object generated by `update` method
1754   * @argument {Object} options - Modifiers configuration and options
1755   * @returns {Object} The data object, properly modified
1756   */
1757  function preventOverflow$1(data, options) {
1758    let boundariesElement = options.boundariesElement || getOffsetParent$1(data.instance.popper);
1759
1760    // If offsetParent is the reference element, we really want to
1761    // go one step up and use the next offsetParent as reference to
1762    // avoid to make this modifier completely useless and look like broken
1763    if (data.instance.reference === boundariesElement) {
1764      boundariesElement = getOffsetParent$1(boundariesElement);
1765    }
1766
1767    // NOTE: DOM access here
1768    // resets the popper's position so that the document size can be calculated excluding
1769    // the size of the popper element itself
1770    const transformProp = getSupportedPropertyName$1('transform');
1771    const popperStyles = data.instance.popper.style; // assignment to help minification
1772    const { top, left, [transformProp]: transform } = popperStyles;
1773    popperStyles.top = '';
1774    popperStyles.left = '';
1775    popperStyles[transformProp] = '';
1776
1777    const boundaries = getBoundaries$1(data.instance.popper, data.instance.reference, options.padding, boundariesElement, data.positionFixed);
1778
1779    // NOTE: DOM access here
1780    // restores the original style properties after the offsets have been computed
1781    popperStyles.top = top;
1782    popperStyles.left = left;
1783    popperStyles[transformProp] = transform;
1784
1785    options.boundaries = boundaries;
1786
1787    const order = options.priority;
1788    let popper = data.offsets.popper;
1789
1790    const check = {
1791      primary(placement) {
1792        let value = popper[placement];
1793        if (popper[placement] < boundaries[placement] && !options.escapeWithReference) {
1794          value = Math.max(popper[placement], boundaries[placement]);
1795        }
1796        return { [placement]: value };
1797      },
1798      secondary(placement) {
1799        const mainSide = placement === 'right' ? 'left' : 'top';
1800        let value = popper[mainSide];
1801        if (popper[placement] > boundaries[placement] && !options.escapeWithReference) {
1802          value = Math.min(popper[mainSide], boundaries[placement] - (placement === 'right' ? popper.width : popper.height));
1803        }
1804        return { [mainSide]: value };
1805      }
1806    };
1807
1808    order.forEach(placement => {
1809      const side = ['left', 'top'].indexOf(placement) !== -1 ? 'primary' : 'secondary';
1810      popper = _extends$1({}, popper, check[side](placement));
1811    });
1812
1813    data.offsets.popper = popper;
1814
1815    return data;
1816  }
1817
1818  /**
1819   * @function
1820   * @memberof Modifiers
1821   * @argument {Object} data - The data object generated by `update` method
1822   * @argument {Object} options - Modifiers configuration and options
1823   * @returns {Object} The data object, properly modified
1824   */
1825  function shift$1(data) {
1826    const placement = data.placement;
1827    const basePlacement = placement.split('-')[0];
1828    const shiftvariation = placement.split('-')[1];
1829
1830    // if shift shiftvariation is specified, run the modifier
1831    if (shiftvariation) {
1832      const { reference, popper } = data.offsets;
1833      const isVertical = ['bottom', 'top'].indexOf(basePlacement) !== -1;
1834      const side = isVertical ? 'left' : 'top';
1835      const measurement = isVertical ? 'width' : 'height';
1836
1837      const shiftOffsets = {
1838        start: { [side]: reference[side] },
1839        end: {
1840          [side]: reference[side] + reference[measurement] - popper[measurement]
1841        }
1842      };
1843
1844      data.offsets.popper = _extends$1({}, popper, shiftOffsets[shiftvariation]);
1845    }
1846
1847    return data;
1848  }
1849
1850  /**
1851   * @function
1852   * @memberof Modifiers
1853   * @argument {Object} data - The data object generated by update method
1854   * @argument {Object} options - Modifiers configuration and options
1855   * @returns {Object} The data object, properly modified
1856   */
1857  function hide$1(data) {
1858    if (!isModifierRequired$1(data.instance.modifiers, 'hide', 'preventOverflow')) {
1859      return data;
1860    }
1861
1862    const refRect = data.offsets.reference;
1863    const bound = find$1(data.instance.modifiers, modifier => modifier.name === 'preventOverflow').boundaries;
1864
1865    if (refRect.bottom < bound.top || refRect.left > bound.right || refRect.top > bound.bottom || refRect.right < bound.left) {
1866      // Avoid unnecessary DOM access if visibility hasn't changed
1867      if (data.hide === true) {
1868        return data;
1869      }
1870
1871      data.hide = true;
1872      data.attributes['x-out-of-boundaries'] = '';
1873    } else {
1874      // Avoid unnecessary DOM access if visibility hasn't changed
1875      if (data.hide === false) {
1876        return data;
1877      }
1878
1879      data.hide = false;
1880      data.attributes['x-out-of-boundaries'] = false;
1881    }
1882
1883    return data;
1884  }
1885
1886  /**
1887   * @function
1888   * @memberof Modifiers
1889   * @argument {Object} data - The data object generated by `update` method
1890   * @argument {Object} options - Modifiers configuration and options
1891   * @returns {Object} The data object, properly modified
1892   */
1893  function inner$1(data) {
1894    const placement = data.placement;
1895    const basePlacement = placement.split('-')[0];
1896    const { popper, reference } = data.offsets;
1897    const isHoriz = ['left', 'right'].indexOf(basePlacement) !== -1;
1898
1899    const subtractLength = ['top', 'left'].indexOf(basePlacement) === -1;
1900
1901    popper[isHoriz ? 'left' : 'top'] = reference[basePlacement] - (subtractLength ? popper[isHoriz ? 'width' : 'height'] : 0);
1902
1903    data.placement = getOppositePlacement$1(placement);
1904    data.offsets.popper = getClientRect$1(popper);
1905
1906    return data;
1907  }
1908
1909  /**
1910   * Modifier function, each modifier can have a function of this type assigned
1911   * to its `fn` property.<br />
1912   * These functions will be called on each update, this means that you must
1913   * make sure they are performant enough to avoid performance bottlenecks.
1914   *
1915   * @function ModifierFn
1916   * @argument {dataObject} data - The data object generated by `update` method
1917   * @argument {Object} options - Modifiers configuration and options
1918   * @returns {dataObject} The data object, properly modified
1919   */
1920
1921  /**
1922   * Modifiers are plugins used to alter the behavior of your poppers.<br />
1923   * Popper.js uses a set of 9 modifiers to provide all the basic functionalities
1924   * needed by the library.
1925   *
1926   * Usually you don't want to override the `order`, `fn` and `onLoad` props.
1927   * All the other properties are configurations that could be tweaked.
1928   * @namespace modifiers
1929   */
1930  var modifiers$1 = {
1931    /**
1932     * Modifier used to shift the popper on the start or end of its reference
1933     * element.<br />
1934     * It will read the variation of the `placement` property.<br />
1935     * It can be one either `-end` or `-start`.
1936     * @memberof modifiers
1937     * @inner
1938     */
1939    shift: {
1940      /** @prop {number} order=100 - Index used to define the order of execution */
1941      order: 100,
1942      /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
1943      enabled: true,
1944      /** @prop {ModifierFn} */
1945      fn: shift$1
1946    },
1947
1948    /**
1949     * The `offset` modifier can shift your popper on both its axis.
1950     *
1951     * It accepts the following units:
1952     * - `px` or unit-less, interpreted as pixels
1953     * - `%` or `%r`, percentage relative to the length of the reference element
1954     * - `%p`, percentage relative to the length of the popper element
1955     * - `vw`, CSS viewport width unit
1956     * - `vh`, CSS viewport height unit
1957     *
1958     * For length is intended the main axis relative to the placement of the popper.<br />
1959     * This means that if the placement is `top` or `bottom`, the length will be the
1960     * `width`. In case of `left` or `right`, it will be the `height`.
1961     *
1962     * You can provide a single value (as `Number` or `String`), or a pair of values
1963     * as `String` divided by a comma or one (or more) white space

2236      fn: applyStyle$1,
2237      /** @prop {Function} */
2238      onLoad: applyStyleOnLoad$1,
2239      /**
2240       * @deprecated since version 1.10.0, the property moved to `computeStyle` modifier
2241       * @prop {Boolean} gpuAcceleration=true
2242       * If true, it uses the CSS 3D transformation to position the popper.
2243       * Otherwise, it will use the `top` and `left` properties
2244       */
2245      gpuAcceleration: undefined
2246    }
2247  };
2248
2249  /**
2250   * The `dataObject` is an object containing all the information used by Popper.js.
2251   * This object is passed to modifiers and to the `onCreate` and `onUpdate` callbacks.
2252   * @name dataObject
2253   * @property {Object} data.instance The Popper.js instance
2254   * @property {String} data.placement Placement applied to popper
2255   * @property {String} data.originalPlacement Placement originally defined on init
2256   * @property {Boolean} data.flipped True if popper has been flipped by flip modifier
2257   * @property {Boolean} data.hide True if the reference element is out of boundaries, useful to know when to hide the popper
2258   * @property {HTMLElement} data.arrowElement Node used as arrow by arrow modifier
2259   * @property {Object} data.styles Any CSS property defined here will be applied to the popper. It expects the JavaScript nomenclature (eg. `marginBottom`)
2260   * @property {Object} data.arrowStyles Any CSS property defined here will be applied to the popper arrow. It expects the JavaScript nomenclature (eg. `marginBottom`)
2261   * @property {Object} data.boundaries Offsets of the popper boundaries
2262   * @property {Object} data.offsets The measurements of popper, reference and arrow elements
2263   * @property {Object} data.offsets.popper `top`, `left`, `width`, `height` values
2264   * @property {Object} data.offsets.reference `top`, `left`, `width`, `height` values
2265   * @property {Object} data.offsets.arrow] `top` and `left` offsets, only one of them will be different from 0
2266   */
2267
2268  /**
2269   * Default options provided to Popper.js constructor.<br />
2270   * These can be overridden using the `options` argument of Popper.js.<br />
2271   * To override an option, simply pass an object with the same
2272   * structure of the `options` object, as the 3rd argument. For example:
2273   * ```
2274   * new Popper(ref, pop, {
2275   *   modifiers: {
2276   *     preventOverflow: { enabled: false }
2277   *   }
2278   * })
2279   * ```
2280   * @type {Object}
2281   * @static
2282   * @memberof Popper
2283   */
2284  var Defaults$1 = {
2285    /**
2286     * Popper's placement.
2287     * @prop {Popper.placements} placement='bottom'
2288     */
2289    placement: 'bottom',
2290
2291    /**
2292     * Set this to true if you want popper to position it self in 'fixed' mode
2293     * @prop {Boolean} positionFixed=false
2294     */
2295    positionFixed: false,
2296
2297    /**
2298     * Whether events (resize, scroll) are initially enabled.
2299     * @prop {Boolean} eventsEnabled=true
2300     */
2301    eventsEnabled: true,
2302
2303    /**
2304     * Set to true if you want to automatically remove the popper when
2305     * you call the `destroy` method.
2306     * @prop {Boolean} removeOnDestroy=false
2307     */
2308    removeOnDestroy: false,
2309
2310    /**
2311     * Callback called when the popper is created.<br />
2312     * By default, it is set to no-op.<br />
2313     * Access Popper.js instance with `data.instance`.
2314     * @prop {onCreate}
2315     */
2316    onCreate: () => {},
2317
2318    /**
2319     * Callback called when the popper is updated. This callback is not called
2320     * on the initialization/creation of the popper, but only on subsequent
2321     * updates.<br />
2322     * By default, it is set to no-op.<br />
2323     * Access Popper.js instance with `data.instance`.
2324     * @prop {onUpdate}
2325     */
2326    onUpdate: () => {},
2327
2328    /**
2329     * List of modifiers used to modify the offsets before they are applied to the popper.
2330     * They provide most of the functionalities of Popper.js.
2331     * @prop {modifiers}
2332     */
2333    modifiers: modifiers$1
2334  };
2335
2336  /**
2337   * @callback onCreate
2338   * @param {dataObject} data
2339   */
2340
2341  /**
2342   * @callback onUpdate
2343   * @param {dataObject} data
2344   */
2345
2346  // Utils
2347  // Methods
2348  class Popper$2 {
2349    /**
2350     * Creates a new Popper.js instance.
2351     * @class Popper
2352     * @param {Element|referenceObject} reference - The reference element used to position the popper
2353     * @param {Element} popper - The HTML / XML element used as the popper
2354     * @param {Object} options - Your custom options to override the ones defined in [Defaults](#defaults)
2355     * @return {Object} instance - The generated Popper.js instance
2356     */
2357    constructor(reference, popper, options = {}) {
2358      this.scheduleUpdate = () => requestAnimationFrame(this.update);
2359
2360      // make update() debounced, so that it only runs at most once-per-tick
2361      this.update = debounce$1(this.update.bind(this));
2362
2363      // with {} we create a new object with the options inside it
2364      this.options = _extends$1({}, Popper$2.Defaults, options);
2365
2366      // init state
2367      this.state = {