https://assets.rockettes.com/wp-content/themes/rockettes/js/dist/build.main.min.js?ver=1785832860

1"use strict";
2
3/*!
4 * JavaScript Cookie v2.2.1
5 * https://github.com/js-cookie/js-cookie
6 *
7 * Copyright 2006, 2015 Klaus Hartl & Fagner Brack
8 * Released under the MIT license
9 */
10;
11(function (factory) {
12  var registeredInModuleLoader;
13  if (typeof define === 'function' && define.amd) {
14    define(factory);
15    registeredInModuleLoader = true;
16  }
17  if (typeof exports === 'object') {
18    module.exports = factory();
19    registeredInModuleLoader = true;
20  }
21  if (!registeredInModuleLoader) {
22    var OldCookies = window.Cookies;
23    var api = window.Cookies = factory();
24    api.noConflict = function () {
25      window.Cookies = OldCookies;
26      return api;
27    };
28  }
29})(function () {
30  function extend() {
31    var i = 0;
32    var result = {};
33    for (; i < arguments.length; i++) {
34      var attributes = arguments[i];
35      for (var key in attributes) {
36        result[key] = attributes[key];
37      }
38    }
39    return result;
40  }
41  function decode(s) {
42    return s.replace(/(%[0-9A-Z]{2})+/g, decodeURIComponent);
43  }
44  function init(converter) {
45    function api() {}
46    function set(key, value, attributes) {
47      if (typeof document === 'undefined') {
48        return;
49      }
50      attributes = extend({
51        path: '/'
52      }, api.defaults, attributes);
53      if (typeof attributes.expires === 'number') {
54        attributes.expires = new Date(new Date() * 1 + attributes.expires * 864e+5);
55      }
56
57      // We're using "expires" because "max-age" is not supported by IE
58      attributes.expires = attributes.expires ? attributes.expires.toUTCString() : '';
59      try {
60        var result = JSON.stringify(value);
61        if (/^[\{\[]/.test(result)) {
62          value = result;
63        }
64      } catch (e) {}
65      value = converter.write ? converter.write(value, key) : encodeURIComponent(String(value)).replace(/%(23|24|26|2B|3A|3C|3E|3D|2F|3F|40|5B|5D|5E|60|7B|7D|7C)/g, decodeURIComponent);
66      key = encodeURIComponent(String(key)).replace(/%(23|24|26|2B|5E|60|7C)/g, decodeURIComponent).replace(/[\(\)]/g, escape);
67      var stringifiedAttributes = '';
68      for (var attributeName in attributes) {
69        if (!attributes[attributeName]) {
70          continue;
71        }
72        stringifiedAttributes += '; ' + attributeName;
73        if (attributes[attributeName] === true) {
74          continue;
75        }
76
77        // Considers RFC 6265 section 5.2:
78        // ...
79        // 3.  If the remaining unparsed-attributes contains a %x3B (";")
80        //     character:
81        // Consume the characters of the unparsed-attributes up to,
82        // not including, the first %x3B (";") character.
83        // ...
84        stringifiedAttributes += '=' + attributes[attributeName].split(';')[0];
85      }
86      return document.cookie = key + '=' + value + stringifiedAttributes;
87    }
88    function get(key, json) {
89      if (typeof document === 'undefined') {
90        return;
91      }
92      var jar = {};
93      // To prevent the for loop in the first place assign an empty array
94      // in case there are no cookies at all.
95      var cookies = document.cookie ? document.cookie.split('; ') : [];
96      var i = 0;
97      for (; i < cookies.length; i++) {
98        var parts = cookies[i].split('=');
99        var cookie = parts.slice(1).join('=');
100        if (!json && cookie.charAt(0) === '"') {
101          cookie = cookie.slice(1, -1);
102        }
103        try {
104          var name = decode(parts[0]);
105          cookie = (converter.read || converter)(cookie, name) || decode(cookie);
106          if (json) {
107            try {
108              cookie = JSON.parse(cookie);
109            } catch (e) {}
110          }
111          jar[name] = cookie;
112          if (key === name) {
113            break;
114          }
115        } catch (e) {}
116      }
117      return key ? jar[key] : jar;
118    }
119    api.set = set;
120    api.get = function (key) {
121      return get(key, false /* read as raw */);
122    };
123    api.getJSON = function (key) {
124      return get(key, true /* read as json */);
125    };
126    api.remove = function (key, attributes) {
127      set(key, '', extend(attributes, {
128        expires: -1
129      }));
130    };
131    api.defaults = {};
132    api.withConverter = init;
133    return api;
134  }
135  return init(function () {});
136});
137
138/*!
139  * Bootstrap v4.6.2 (https://getbootstrap.com/)
140  * Copyright 2011-2022 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)
141  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
142  */
143(function (global, factory) {
144  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('jquery')) : typeof define === 'function' && define.amd ? define(['exports', 'jquery'], factory) : (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.bootstrap = {}, global.jQuery));
145})(void 0, function (exports, $) {
146  'use strict';
147
148  function _interopDefaultLegacy(e) {
149    return e && typeof e === 'object' && 'default' in e ? e : {
150      'default': e
151    };
152  }
153  var $__default = /*#__PURE__*/_interopDefaultLegacy($);
154  function _defineProperties(target, props) {
155    for (var i = 0; i < props.length; i++) {
156      var descriptor = props[i];
157      descriptor.enumerable = descriptor.enumerable || false;
158      descriptor.configurable = true;
159      if ("value" in descriptor) descriptor.writable = true;
160      Object.defineProperty(target, descriptor.key, descriptor);
161    }
162  }
163  function _createClass(Constructor, protoProps, staticProps) {
164    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
165    if (staticProps) _defineProperties(Constructor, staticProps);

1552   * @param {Element|Object} reference - the reference element (the popper will be relative to this)
1553   * @returns {Element} parent
1554   */
1555  function getReferenceNode(reference) {
1556    return reference && reference.referenceNode ? reference.referenceNode : reference;
1557  }
1558  var isIE11 = isBrowser && !!(window.MSInputMethodContext && document.documentMode);
1559  var isIE10 = isBrowser && /MSIE 10/.test(navigator.userAgent);
1560
1561  /**
1562   * Determines if the browser is Internet Explorer
1563   * @method
1564   * @memberof Popper.Utils
1565   * @param {Number} version to check
1566   * @returns {Boolean} isIE
1567   */
1568  function isIE(version) {
1569    if (version === 11) {
1570      return isIE11;
1571    }
1572    if (version === 10) {
1573      return isIE10;
1574    }
1575    return isIE11 || isIE10;
1576  }
1577
1578  /**
1579   * Returns the offset parent of the given element
1580   * @method
1581   * @memberof Popper.Utils
1582   * @argument {Element} element
1583   * @returns {Element} offset parent
1584   */
1585  function getOffsetParent(element) {
1586    if (!element) {
1587      return document.documentElement;
1588    }
1589    var noOffsetParent = isIE(10) ? document.body : null;
1590
1591    // NOTE: 1 DOM access here
1592    var offsetParent = element.offsetParent || null;
1593    // Skip hidden elements which don't have an offsetParent
1594    while (offsetParent === noOffsetParent && element.nextElementSibling) {
1595      offsetParent = (element = element.nextElementSibling).offsetParent;
1596    }
1597    var nodeName = offsetParent && offsetParent.nodeName;
1598    if (!nodeName || nodeName === 'BODY' || nodeName === 'HTML') {
1599      return element ? element.ownerDocument.documentElement : document.documentElement;
1600    }
1601
1602    // .offsetParent will return the closest TH, TD or TABLE in case
1603    // no offsetParent is present, I hate this job...
1604    if (['TH', 'TD', 'TABLE'].indexOf(offsetParent.nodeName) !== -1 && getStyleComputedProperty(offsetParent, 'position') === 'static') {
1605      return getOffsetParent(offsetParent);
1606    }
1607    return offsetParent;
1608  }
1609  function isOffsetContainer(element) {
1610    var nodeName = element.nodeName;
1611    if (nodeName === 'BODY') {
1612      return false;
1613    }
1614    return nodeName === 'HTML' || getOffsetParent(element.firstElementChild) === element;
1615  }
1616
1617  /**
1618   * Finds the root node (document, shadowDOM root) of the given element
1619   * @method
1620   * @memberof Popper.Utils
1621   * @argument {Element} node
1622   * @returns {Element} root node
1623   */
1624  function getRoot(node) {
1625    if (node.parentNode !== null) {
1626      return getRoot(node.parentNode);
1627    }
1628    return node;
1629  }
1630
1631  /**
1632   * Finds the offset parent common to the two provided nodes
1633   * @method
1634   * @memberof Popper.Utils
1635   * @argument {Element} element1
1636   * @argument {Element} element2
1637   * @returns {Element} common offset parent
1638   */
1639  function findCommonOffsetParent(element1, element2) {
1640    // This check is needed to avoid errors in case one of the elements isn't defined for any reason
1641    if (!element1 || !element1.nodeType || !element2 || !element2.nodeType) {
1642      return document.documentElement;
1643    }
1644
1645    // Here we make sure to give as "start" the element that comes first in the DOM
1646    var order = element1.compareDocumentPosition(element2) & Node.DOCUMENT_POSITION_FOLLOWING;
1647    var start = order ? element1 : element2;
1648    var end = order ? element2 : element1;
1649
1650    // Get common ancestor container
1651    var range = document.createRange();
1652    range.setStart(start, 0);
1653    range.setEnd(end, 0);
1654    var commonAncestorContainer = range.commonAncestorContainer;
1655
1656    // Both nodes are inside #document
1657
1658    if (element1 !== commonAncestorContainer && element2 !== commonAncestorContainer || start.contains(end)) {
1659      if (isOffsetContainer(commonAncestorContainer)) {
1660        return commonAncestorContainer;
1661      }
1662      return getOffsetParent(commonAncestorContainer);
1663    }
1664
1665    // one of the nodes is inside shadowDOM, find which one
1666    var element1root = getRoot(element1);
1667    if (element1root.host) {
1668      return findCommonOffsetParent(element1root.host, element2);
1669    } else {
1670      return findCommonOffsetParent(element1, getRoot(element2).host);
1671    }
1672  }
1673
1674  /**
1675   * Gets the scroll value of the given element in the given side (top and left)
1676   * @method
1677   * @memberof Popper.Utils
1678   * @argument {Element} element
1679   * @argument {String} side `top` or `left`
1680   * @returns {number} amount of scrolled pixels
1681   */
1682  function getScroll(element) {
1683    var side = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'top';
1684    var upperSide = side === 'top' ? 'scrollTop' : 'scrollLeft';
1685    var nodeName = element.nodeName;
1686    if (nodeName === 'BODY' || nodeName === 'HTML') {
1687      var html = element.ownerDocument.documentElement;
1688      var scrollingElement = element.ownerDocument.scrollingElement || html;
1689      return scrollingElement[upperSide];
1690    }
1691    return element[upperSide];
1692  }
1693
1694  /*
1695   * Sum or subtract the element scroll values (left and top) from a given rect object
1696   * @method
1697   * @memberof Popper.Utils
1698   * @param {Object} rect - Rect object you want to change
1699   * @param {HTMLElement} element - The element from the function reads the scroll values
1700   * @param {Boolean} subtract - set to true if you want to subtract the scroll values
1701   * @return {Object} rect - The modifier rect object
1702   */
1703  function includeScroll(rect, element) {
1704    var subtract = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;

1705    var scrollTop = getScroll(element, 'top');
1706    var scrollLeft = getScroll(element, 'left');
1707    var modifier = subtract ? -1 : 1;
1708    rect.top += scrollTop * modifier;
1709    rect.bottom += scrollTop * modifier;
1710    rect.left += scrollLeft * modifier;
1711    rect.right += scrollLeft * modifier;
1712    return rect;
1713  }
1714
1715  /*
1716   * Helper to detect borders of a given element
1717   * @method
1718   * @memberof Popper.Utils
1719   * @param {CSSStyleDeclaration} styles
1720   * Result of `getStyleComputedProperty` on the given element
1721   * @param {String} axis - `x` or `y`
1722   * @return {number} borders - The borders size of the given axis
1723   */
1724
1725  function getBordersSize(styles, axis) {
1726    var sideA = axis === 'x' ? 'Left' : 'Top';
1727    var sideB = sideA === 'Left' ? 'Right' : 'Bottom';
1728    return parseFloat(styles['border' + sideA + 'Width']) + parseFloat(styles['border' + sideB + 'Width']);
1729  }
1730  function getSize(axis, body, html, computedStyle) {
1731    return Math.max(body['offset' + axis], body['scroll' + axis], html['client' + axis], html['offset' + axis], html['scroll' + axis], isIE(10) ? parseInt(html['offset' + axis]) + parseInt(computedStyle['margin' + (axis === 'Height' ? 'Top' : 'Left')]) + parseInt(computedStyle['margin' + (axis === 'Height' ? 'Bottom' : 'Right')]) : 0);
1732  }
1733  function getWindowSizes(document) {
1734    var body = document.body;
1735    var html = document.documentElement;
1736    var computedStyle = isIE(10) && getComputedStyle(html);
1737    return {
1738      height: getSize('Height', body, html, computedStyle),
1739      width: getSize('Width', body, html, computedStyle)
1740    };
1741  }
1742  var classCallCheck = function (instance, Constructor) {
1743    if (!(instance instanceof Constructor)) {
1744      throw new TypeError("Cannot call a class as a function");
1745    }
1746  };
1747  var createClass = function () {
1748    function defineProperties(target, props) {
1749      for (var i = 0; i < props.length; i++) {
1750        var descriptor = props[i];
1751        descriptor.enumerable = descriptor.enumerable || false;
1752        descriptor.configurable = true;
1753        if ("value" in descriptor) descriptor.writable = true;
1754        Object.defineProperty(target, descriptor.key, descriptor);
1755      }
1756    }
1757    return function (Constructor, protoProps, staticProps) {
1758      if (protoProps) defineProperties(Constructor.prototype, protoProps);
1759      if (staticProps) defineProperties(Constructor, staticProps);
1760      return Constructor;
1761    };
1762  }();
1763  var defineProperty = function (obj, key, value) {
1764    if (key in obj) {
1765      Object.defineProperty(obj, key, {
1766        value: value,
1767        enumerable: true,
1768        configurable: true,
1769        writable: true
1770      });
1771    } else {
1772      obj[key] = value;
1773    }
1774    return obj;
1775  };
1776  var _extends = Object.assign || function (target) {
1777    for (var i = 1; i < arguments.length; i++) {
1778      var source = arguments[i];
1779      for (var key in source) {
1780        if (Object.prototype.hasOwnProperty.call(source, key)) {
1781          target[key] = source[key];
1782        }
1783      }
1784    }
1785    return target;
1786  };
1787
1788  /**
1789   * Given element offsets, generate an output similar to getBoundingClientRect
1790   * @method
1791   * @memberof Popper.Utils
1792   * @argument {Object} offsets
1793   * @returns {Object} ClientRect like output
1794   */
1795  function getClientRect(offsets) {
1796    return _extends({}, offsets, {
1797      right: offsets.left + offsets.width,
1798      bottom: offsets.top + offsets.height
1799    });
1800  }
1801
1802  /**
1803   * Get bounding client rect of given element
1804   * @method
1805   * @memberof Popper.Utils
1806   * @param {HTMLElement} element
1807   * @return {Object} client rect
1808   */
1809  function getBoundingClientRect(element) {
1810    var rect = {};
1811
1812    // IE10 10 FIX: Please, don't ask, the element isn't
1813    // considered in DOM in some circumstances...
1814    // This isn't reproducible in IE10 compatibility mode of IE11
1815    try {
1816      if (isIE(10)) {
1817        rect = element.getBoundingClientRect();
1818        var scrollTop = getScroll(element, 'top');
1819        var scrollLeft = getScroll(element, 'left');
1820        rect.top += scrollTop;
1821        rect.left += scrollLeft;
1822        rect.bottom += scrollTop;
1823        rect.right += scrollLeft;
1824      } else {
1825        rect = element.getBoundingClientRect();
1826      }
1827    } catch (e) {}
1828    var result = {
1829      left: rect.left,
1830      top: rect.top,
1831      width: rect.right - rect.left,
1832      height: rect.bottom - rect.top
1833    };
1834
1835    // subtract scrollbar size from sizes
1836    var sizes = element.nodeName === 'HTML' ? getWindowSizes(element.ownerDocument) : {};
1837    var width = sizes.width || element.clientWidth || result.width;
1838    var height = sizes.height || element.clientHeight || result.height;
1839    var horizScrollbar = element.offsetWidth - width;
1840    var vertScrollbar = element.offsetHeight - height;
1841
1842    // if an hypothetical scrollbar is detected, we must be sure it's not a `border`
1843    // we make this check conditional for performance reasons
1844    if (horizScrollbar || vertScrollbar) {
1845      var styles = getStyleComputedProperty(element);
1846      horizScrollbar -= getBordersSize(styles, 'x');
1847      vertScrollbar -= getBordersSize(styles, 'y');
1848      result.width -= horizScrollbar;
1849      result.height -= vertScrollbar;
1850    }
1851    return getClientRect(result);
1852  }
1853  function getOffsetRectRelativeToArbitraryNode(children, parent) {
1854    var fixedPosition = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;

1855    var isIE10 = isIE(10);
1856    var isHTML = parent.nodeName === 'HTML';
1857    var childrenRect = getBoundingClientRect(children);
1858    var parentRect = getBoundingClientRect(parent);
1859    var scrollParent = getScrollParent(children);
1860    var styles = getStyleComputedProperty(parent);
1861    var borderTopWidth = parseFloat(styles.borderTopWidth);
1862    var borderLeftWidth = parseFloat(styles.borderLeftWidth);
1863
1864    // In cases where the parent is fixed, we must ignore negative scroll in offset calc
1865    if (fixedPosition && isHTML) {
1866      parentRect.top = Math.max(parentRect.top, 0);
1867      parentRect.left = Math.max(parentRect.left, 0);
1868    }
1869    var offsets = getClientRect({
1870      top: childrenRect.top - parentRect.top - borderTopWidth,
1871      left: childrenRect.left - parentRect.left - borderLeftWidth,
1872      width: childrenRect.width,
1873      height: childrenRect.height
1874    });
1875    offsets.marginTop = 0;
1876    offsets.marginLeft = 0;
1877
1878    // Subtract margins of documentElement in case it's being used as parent
1879    // we do this only on HTML because it's the only element that behaves
1880    // differently when margins are applied to it. The margins are included in
1881    // the box of the documentElement, in the other cases not.
1882    if (!isIE10 && isHTML) {
1883      var marginTop = parseFloat(styles.marginTop);
1884      var marginLeft = parseFloat(styles.marginLeft);
1885      offsets.top -= borderTopWidth - marginTop;
1886      offsets.bottom -= borderTopWidth - marginTop;
1887      offsets.left -= borderLeftWidth - marginLeft;
1888      offsets.right -= borderLeftWidth - marginLeft;
1889
1890      // Attach marginTop and marginLeft because in some circumstances we may need them
1891      offsets.marginTop = marginTop;
1892      offsets.marginLeft = marginLeft;
1893    }
1894    if (isIE10 && !fixedPosition ? parent.contains(scrollParent) : parent === scrollParent && scrollParent.nodeName !== 'BODY') {
1895      offsets = includeScroll(offsets, parent);
1896    }
1897    return offsets;
1898  }
1899  function getViewportOffsetRectRelativeToArtbitraryNode(element) {
1900    var excludeScroll = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
1901    var html = element.ownerDocument.documentElement;
1902    var relativeOffset = getOffsetRectRelativeToArbitraryNode(element, html);
1903    var width = Math.max(html.clientWidth, window.innerWidth || 0);
1904    var height = Math.max(html.clientHeight, window.innerHeight || 0);
1905    var scrollTop = !excludeScroll ? getScroll(html) : 0;
1906    var scrollLeft = !excludeScroll ? getScroll(html, 'left') : 0;
1907    var offset = {
1908      top: scrollTop - relativeOffset.top + relativeOffset.marginTop,
1909      left: scrollLeft - relativeOffset.left + relativeOffset.marginLeft,
1910      width: width,
1911      height: height
1912    };
1913    return getClientRect(offset);
1914  }
1915
1916  /**
1917   * Check if the given element is fixed or is inside a fixed parent
1918   * @method
1919   * @memberof Popper.Utils
1920   * @argument {Element} element
1921   * @argument {Element} customContainer
1922   * @returns {Boolean} answer to "isFixed?"
1923   */
1924  function isFixed(element) {
1925    var nodeName = element.nodeName;
1926    if (nodeName === 'BODY' || nodeName === 'HTML') {
1927      return false;
1928    }
1929    if (getStyleComputedProperty(element, 'position') === 'fixed') {
1930      return true;
1931    }
1932    var parentNode = getParentNode(element);
1933    if (!parentNode) {
1934      return false;
1935    }
1936    return isFixed(parentNode);
1937  }
1938
1939  /**
1940   * Finds the first parent of an element that has a transformed property defined
1941   * @method
1942   * @memberof Popper.Utils
1943   * @argument {Element} element
1944   * @returns {Element} first transformed parent or documentElement
1945   */
1946
1947  function getFixedPositionOffsetParent(element) {
1948    // This check is needed to avoid errors in case one of the elements isn't defined for any reason
1949    if (!element || !element.parentElement || isIE()) {
1950      return document.documentElement;
1951    }
1952    var el = element.parentElement;
1953    while (el && getStyleComputedProperty(el, 'transform') === 'none') {
1954      el = el.parentElement;
1955    }
1956    return el || document.documentElement;
1957  }
1958
1959  /**
1960   * Computed the boundaries limits and return them
1961   * @method
1962   * @memberof Popper.Utils
1963   * @param {HTMLElement} popper
1964   * @param {HTMLElement} reference
1965   * @param {number} padding
1966   * @param {HTMLElement} boundariesElement - Element used to define the boundaries
1967   * @param {Boolean} fixedPosition - Is in fixed position mode
1968   * @returns {Object} Coordinates of the boundaries
1969   */
1970  function getBoundaries(popper, reference, padding, boundariesElement) {
1971    var fixedPosition = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
1972
1973    // NOTE: 1 DOM access here
1974
1975    var boundaries = {
1976      top: 0,
1977      left: 0
1978    };
1979    var offsetParent = fixedPosition ? getFixedPositionOffsetParent(popper) : findCommonOffsetParent(popper, getReferenceNode(reference));
1980
1981    // Handle viewport case
1982    if (boundariesElement === 'viewport') {
1983      boundaries = getViewportOffsetRectRelativeToArtbitraryNode(offsetParent, fixedPosition);
1984    } else {
1985      // Handle other cases based on DOM element used as boundaries
1986      var boundariesNode = void 0;
1987      if (boundariesElement === 'scrollParent') {
1988        boundariesNode = getScrollParent(getParentNode(reference));
1989        if (boundariesNode.nodeName === 'BODY') {
1990          boundariesNode = popper.ownerDocument.documentElement;
1991        }
1992      } else if (boundariesElement === 'window') {
1993        boundariesNode = popper.ownerDocument.documentElement;
1994      } else {
1995        boundariesNode = boundariesElement;
1996      }
1997      var offsets = getOffsetRectRelativeToArbitraryNode(boundariesNode, offsetParent, fixedPosition);
1998
1999      // In case of HTML, we need a different computation
2000      if (boundariesNode.nodeName === 'HTML' && !isFixed(offsetParent)) {
2001        var _getWindowSizes = getWindowSizes(popper.ownerDocument),
2002          height = _getWindowSizes.height,
2003          width = _getWindowSizes.width;
2004        boundaries.top += offsets.top - offsets.marginTop;
2005        boundaries.bottom = height + offsets.top;
2006        boundaries.left += offsets.left - offsets.marginLeft;
2007        boundaries.right = width + offsets.left;
2008      } else {
2009        // for all the other DOM elements, this one is good
2010        boundaries = offsets;
2011      }
2012    }
2013
2014    // Add paddings
2015    padding = padding || 0;
2016    var isPaddingNumber = typeof padding === 'number';
2017    boundaries.left += isPaddingNumber ? padding : padding.left || 0;
2018    boundaries.top += isPaddingNumber ? padding : padding.top || 0;
2019    boundaries.right -= isPaddingNumber ? padding : padding.right || 0;
2020    boundaries.bottom -= isPaddingNumber ? padding : padding.bottom || 0;
2021    return boundaries;
2022  }
2023  function getArea(_ref) {
2024    var width = _ref.width,
2025      height = _ref.height;
2026    return width * height;
2027  }
2028
2029  /**
2030   * Utility used to transform the `auto` placement to the placement with more
2031   * available space.
2032   * @method
2033   * @memberof Popper.Utils
2034   * @argument {Object} data - The data object generated by update method
2035   * @argument {Object} options - Modifiers configuration and options
2036   * @returns {Object} The data object, properly modified
2037   */
2038  function computeAutoPlacement(placement, refRect, popper, reference, boundariesElement) {
2039    var padding = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 0;
2040    if (placement.indexOf('auto') === -1) {
2041      return placement;
2042    }
2043    var boundaries = getBoundaries(popper, reference, padding, boundariesElement);
2044    var rects = {
2045      top: {
2046        width: boundaries.width,
2047        height: refRect.top - boundaries.top
2048      },
2049      right: {
2050        width: boundaries.right - refRect.right,
2051        height: boundaries.height
2052      },
2053      bottom: {
2054        width: boundaries.width,
2055        height: boundaries.bottom - refRect.bottom
2056      },
2057      left: {
2058        width: refRect.left - boundaries.left,
2059        height: boundaries.height
2060      }
2061    };
2062    var sortedAreas = Object.keys(rects).map(function (key) {
2063      return _extends({
2064        key: key
2065      }, rects[key], {
2066        area: getArea(rects[key])
2067      });
2068    }).sort(function (a, b) {
2069      return b.area - a.area;
2070    });
2071    var filteredAreas = sortedAreas.filter(function (_ref2) {
2072      var width = _ref2.width,
2073        height = _ref2.height;
2074      return width >= popper.clientWidth && height >= popper.clientHeight;
2075    });
2076    var computedPlacement = filteredAreas.length > 0 ? filteredAreas[0].key : sortedAreas[0].key;
2077    var variation = placement.split('-')[1];
2078    return computedPlacement + (variation ? '-' + variation : '');
2079  }
2080
2081  /**
2082   * Get offsets to the reference element
2083   * @method
2084   * @memberof Popper.Utils
2085   * @param {Object} state
2086   * @param {Element} popper - the popper element
2087   * @param {Element} reference - the reference element (the popper will be relative to this)
2088   * @param {Element} fixedPosition - is in fixed position mode
2089   * @returns {Object} An object containing the offsets which will be applied to the popper
2090   */
2091  function getReferenceOffsets(state, popper, reference) {
2092    var fixedPosition = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
2093    var commonOffsetParent = fixedPosition ? getFixedPositionOffsetParent(popper) : findCommonOffsetParent(popper, getReferenceNode(reference));
2094    return getOffsetRectRelativeToArbitraryNode(reference, commonOffsetParent, fixedPosition);
2095  }
2096
2097  /**
2098   * Get the outer sizes of the given element (offset size + margins)
2099   * @method
2100   * @memberof Popper.Utils
2101   * @argument {Element} element
2102   * @returns {Object} object containing width and height properties
2103   */
2104  function getOuterSizes(element) {
2105    var window = element.ownerDocument.defaultView;
2106    var styles = window.getComputedStyle(element);
2107    var x = parseFloat(styles.marginTop || 0) + parseFloat(styles.marginBottom || 0);
2108    var y = parseFloat(styles.marginLeft || 0) + parseFloat(styles.marginRight || 0);
2109    var result = {
2110      width: element.offsetWidth + y,
2111      height: element.offsetHeight + x
2112    };
2113    return result;
2114  }
2115
2116  /**
2117   * Get the opposite placement of the given one
2118   * @method
2119   * @memberof Popper.Utils
2120   * @argument {String} placement
2121   * @returns {String} flipped placement
2122   */
2123  function getOppositePlacement(placement) {
2124    var hash = {
2125      left: 'right',
2126      right: 'left',
2127      bottom: 'top',
2128      top: 'bottom'
2129    };
2130    return placement.replace(/left|right|bottom|top/g, function (matched) {
2131      return hash[matched];
2132    });
2133  }
2134
2135  /**
2136   * Get offsets to the popper
2137   * @method
2138   * @memberof Popper.Utils
2139   * @param {Object} position - CSS position the Popper will get applied
2140   * @param {HTMLElement} popper - the popper element
2141   * @param {Object} referenceOffsets - the reference offsets (the popper will be relative to this)
2142   * @param {String} placement - one of the valid placement options
2143   * @returns {Object} popperOffsets - An object containing the offsets which will be applied to the popper
2144   */
2145  function getPopperOffsets(popper, referenceOffsets, placement) {
2146    placement = placement.split('-')[0];
2147
2148    // Get popper node sizes
2149    var popperRect = getOuterSizes(popper);
2150
2151    // Add position, width and height to our offsets object
2152    var popperOffsets = {
2153      width: popperRect.width,
2154      height: popperRect.height
2155    };
2156
2157    // depending by the popper placement we have to compute its offsets slightly differently
2158    var isHoriz = ['right', 'left'].indexOf(placement) !== -1;
2159    var mainSide = isHoriz ? 'top' : 'left';
2160    var secondarySide = isHoriz ? 'left' : 'top';
2161    var measurement = isHoriz ? 'height' : 'width';
2162    var secondaryMeasurement = !isHoriz ? 'height' : 'width';
2163    popperOffsets[mainSide] = referenceOffsets[mainSide] + referenceOffsets[measurement] / 2 - popperRect[measurement] / 2;
2164    if (placement === secondarySide) {
2165      popperOffsets[secondarySide] = referenceOffsets[secondarySide] - popperRect[secondaryMeasurement];
2166    } else {
2167      popperOffsets[secondarySide] = referenceOffsets[getOppositePlacement(secondarySide)];
2168    }
2169    return popperOffsets;
2170  }
2171
2172  /**
2173   * Mimics the `find` method of Array
2174   * @method
2175   * @memberof Popper.Utils
2176   * @argument {Array} arr
2177   * @argument prop
2178   * @argument value
2179   * @returns index or -1
2180   */
2181  function find(arr, check) {
2182    // use native find if supported
2183    if (Array.prototype.find) {
2184      return arr.find(check);
2185    }
2186
2187    // use `filter` to obtain the same behavior of `find`
2188    return arr.filter(check)[0];
2189  }
2190
2191  /**
2192   * Return the index of the matching object
2193   * @method
2194   * @memberof Popper.Utils
2195   * @argument {Array} arr
2196   * @argument prop
2197   * @argument value
2198   * @returns index or -1
2199   */
2200  function findIndex(arr, prop, value) {
2201    // use native findIndex if supported
2202    if (Array.prototype.findIndex) {
2203      return arr.findIndex(function (cur) {
2204        return cur[prop] === value;
2205      });
2206    }
2207
2208    // use `find` + `indexOf` if `findIndex` isn't supported
2209    var match = find(arr, function (obj) {
2210      return obj[prop] === value;
2211    });
2212    return arr.indexOf(match);
2213  }
2214
2215  /**
2216   * Loop trough the list of modifiers and run them in order,
2217   * each of them will then edit the data object.
2218   * @method
2219   * @memberof Popper.Utils
2220   * @param {dataObject} data
2221   * @param {Array} modifiers
2222   * @param {String} ends - Optional modifier name used as stopper
2223   * @returns {dataObject}
2224   */
2225  function runModifiers(modifiers, data, ends) {
2226    var modifiersToRun = ends === undefined ? modifiers : modifiers.slice(0, findIndex(modifiers, 'name', ends));

2227    modifiersToRun.forEach(function (modifier) {
2228      if (modifier['function']) {
2229        // eslint-disable-line dot-notation
2230        console.warn('`modifier.function` is deprecated, use `modifier.fn`!');
2231      }
2232      var fn = modifier['function'] || modifier.fn; // eslint-disable-line dot-notation
2233      if (modifier.enabled && isFunction(fn)) {
2234        // Add properties to offsets to make them a complete clientRect object
2235        // we do this before each modifier to make sure the previous one doesn't
2236        // mess with these values
2237        data.offsets.popper = getClientRect(data.offsets.popper);
2238        data.offsets.reference = getClientRect(data.offsets.reference);
2239        data = fn(data, modifier);
2240      }
2241    });
2242    return data;
2243  }
2244
2245  /**
2246   * Updates the position of the popper, computing the new offsets and applying
2247   * the new style.<br />
2248   * Prefer `scheduleUpdate` over `update` because of performance reasons.
2249   * @method
2250   * @memberof Popper
2251   */
2252  function update() {
2253    // if popper is destroyed, don't perform any further update
2254    if (this.state.isDestroyed) {
2255      return;
2256    }
2257    var data = {
2258      instance: this,
2259      styles: {},
2260      arrowStyles: {},
2261      attributes: {},
2262      flipped: false,
2263      offsets: {}
2264    };
2265
2266    // compute reference element offsets
2267    data.offsets.reference = getReferenceOffsets(this.state, this.popper, this.reference, this.options.positionFixed);
2268
2269    // compute auto placement, store placement inside the data object,
2270    // modifiers will be able to edit `placement` if needed
2271    // and refer to originalPlacement to know the original value
2272    data.placement = computeAutoPlacement(this.options.placement, data.offsets.reference, this.popper, this.reference, this.options.modifiers.flip.boundariesElement, this.options.modifiers.flip.padding);
2273
2274    // store the computed placement inside `originalPlacement`
2275    data.originalPlacement = data.placement;
2276    data.positionFixed = this.options.positionFixed;
2277
2278    // compute the popper offsets
2279    data.offsets.popper = getPopperOffsets(this.popper, data.offsets.reference, data.placement);
2280    data.offsets.popper.position = this.options.positionFixed ? 'fixed' : 'absolute';
2281
2282    // run the modifiers
2283    data = runModifiers(this.modifiers, data);
2284
2285    // the first `update` will call `onCreate` callback
2286    // the other ones will call `onUpdate` callback
2287    if (!this.state.isCreated) {
2288      this.state.isCreated = true;
2289      this.options.onCreate(data);
2290    } else {
2291      this.options.onUpdate(data);
2292    }
2293  }
2294
2295  /**
2296   * Helper used to know if the given modifier is enabled.
2297   * @method
2298   * @memberof Popper.Utils
2299   * @returns {Boolean}
2300   */
2301  function isModifierEnabled(modifiers, modifierName) {
2302    return modifiers.some(function (_ref) {
2303      var name = _ref.name,
2304        enabled = _ref.enabled;
2305      return enabled && name === modifierName;
2306    });
2307  }
2308
2309  /**
2310   * Get the prefixed supported property name
2311   * @method
2312   * @memberof Popper.Utils
2313   * @argument {String} property (camelCase)
2314   * @returns {String} prefixed property (camelCase or PascalCase, depending on the vendor prefix)
2315   */
2316  function getSupportedPropertyName(property) {
2317    var prefixes = [false, 'ms', 'Webkit', 'Moz', 'O'];
2318    var upperProp = property.charAt(0).toUpperCase() + property.slice(1);
2319    for (var i = 0; i < prefixes.length; i++) {
2320      var prefix = prefixes[i];
2321      var toCheck = prefix ? '' + prefix + upperProp : property;
2322      if (typeof document.body.style[toCheck] !== 'undefined') {
2323        return toCheck;
2324      }
2325    }
2326    return null;
2327  }
2328
2329  /**
2330   * Destroys the popper.
2331   * @method
2332   * @memberof Popper
2333   */
2334  function destroy() {
2335    this.state.isDestroyed = true;
2336
2337    // touch DOM only if `applyStyle` modifier is enabled
2338    if (isModifierEnabled(this.modifiers, 'applyStyle')) {
2339      this.popper.removeAttribute('x-placement');
2340      this.popper.style.position = '';
2341      this.popper.style.top = '';
2342      this.popper.style.left = '';
2343      this.popper.style.right = '';
2344      this.popper.style.bottom = '';
2345      this.popper.style.willChange = '';
2346      this.popper.style[getSupportedPropertyName('transform')] = '';
2347    }
2348    this.disableEventListeners();
2349
2350    // remove the popper if user explicitly asked for the deletion on destroy
2351    // do not use `remove` because IE11 doesn't support it
2352    if (this.options.removeOnDestroy) {
2353      this.popper.parentNode.removeChild(this.popper);
2354    }
2355    return this;
2356  }
2357
2358  /**
2359   * Get the window associated with the element
2360   * @argument {Element} element
2361   * @returns {Window}
2362   */
2363  function getWindow(element) {
2364    var ownerDocument = element.ownerDocument;
2365    return ownerDocument ? ownerDocument.defaultView : window;
2366  }
2367  function attachToScrollParents(scrollParent, event, callback, scrollParents) {
2368    var isBody = scrollParent.nodeName === 'BODY';
2369    var target = isBody ? scrollParent.ownerDocument.defaultView : scrollParent;
2370    target.addEventListener(event, callback, {
2371      passive: true
2372    });
2373    if (!isBody) {
2374      attachToScrollParents(getScrollParent(target.parentNode), event, callback, scrollParents);
2375    }
2376    scrollParents.push(target);
2377  }
2378
2379  /**
2380   * Setup needed event listeners used to update the popper position
2381   * @method
2382   * @memberof Popper.Utils
2383   * @private
2384   */
2385  function setupEventListeners(reference, options, state, updateBound) {
2386    // Resize event listener on window
2387    state.updateBound = updateBound;
2388    getWindow(reference).addEventListener('resize', state.updateBound, {
2389      passive: true
2390    });
2391
2392    // Scroll event listener on scroll parents
2393    var scrollElement = getScrollParent(reference);
2394    attachToScrollParents(scrollElement, 'scroll', state.updateBound, state.scrollParents);
2395    state.scrollElement = scrollElement;
2396    state.eventsEnabled = true;

2396
2397    return state;
2398  }
2399
2400  /**
2401   * It will add resize/scroll events and start recalculating
2402   * position of the popper element when they are triggered.
2403   * @method
2404   * @memberof Popper
2405   */
2406  function enableEventListeners() {
2407    if (!this.state.eventsEnabled) {
2408      this.state = setupEventListeners(this.reference, this.options, this.state, this.scheduleUpdate);
2409    }
2410  }
2411
2412  /**
2413   * Remove event listeners used to update the popper position
2414   * @method
2415   * @memberof Popper.Utils
2416   * @private
2417   */
2418  function removeEventListeners(reference, state) {
2419    // Remove resize event listener on window
2420    getWindow(reference).removeEventListener('resize', state.updateBound);
2421
2422    // Remove scroll event listener on scroll parents
2423    state.scrollParents.forEach(function (target) {
2424      target.removeEventListener('scroll', state.updateBound);
2425    });
2426
2427    // Reset state
2428    state.updateBound = null;
2429    state.scrollParents = [];
2430    state.scrollElement = null;
2431    state.eventsEnabled = false;
2432    return state;
2433  }
2434
2435  /**
2436   * It will remove resize/scroll events and won't recalculate popper position
2437   * when they are triggered. It also won't trigger `onUpdate` callback anymore,
2438   * unless you call `update` method manually.
2439   * @method
2440   * @memberof Popper
2441   */
2442  function disableEventListeners() {
2443    if (this.state.eventsEnabled) {
2444      cancelAnimationFrame(this.scheduleUpdate);
2445      this.state = removeEventListeners(this.reference, this.state);
2446    }
2447  }
2448
2449  /**
2450   * Tells if a given input is a number
2451   * @method
2452   * @memberof Popper.Utils
2453   * @param {*} input to check
2454   * @return {Boolean}
2455   */
2456  function isNumeric(n) {
2457    return n !== '' && !isNaN(parseFloat(n)) && isFinite(n);
2458  }
2459
2460  /**
2461   * Set the style to the given popper
2462   * @method
2463   * @memberof Popper.Utils
2464   * @argument {Element} element - Element to apply the style to
2465   * @argument {Object} styles
2466   * Object with a list of properties and values which will be applied to the element
2467   */
2468  function setStyles(element, styles) {
2469    Object.keys(styles).forEach(function (prop) {
2470      var unit = '';
2471      // add unit if the value is numeric and is one of the following
2472      if (['width', 'height', 'top', 'right', 'bottom', 'left'].indexOf(prop) !== -1 && isNumeric(styles[prop])) {
2473        unit = 'px';
2474      }
2475      element.style[prop] = styles[prop] + unit;
2476    });
2477  }
2478
2479  /**
2480   * Set the attributes to the given popper
2481   * @method
2482   * @memberof Popper.Utils
2483   * @argument {Element} element - Element to apply the attributes to
2484   * @argument {Object} styles
2485   * Object with a list of properties and values which will be applied to the element
2486   */
2487  function setAttributes(element, attributes) {
2488    Object.keys(attributes).forEach(function (prop) {
2489      var value = attributes[prop];
2490      if (value !== false) {
2491        element.setAttribute(prop, attributes[prop]);
2492      } else {
2493        element.removeAttribute(prop);
2494      }
2495    });
2496  }
2497
2498  /**
2499   * @function
2500   * @memberof Modifiers
2501   * @argument {Object} data - The data object generated by `update` method
2502   * @argument {Object} data.styles - List of style properties - values to apply to popper element
2503   * @argument {Object} data.attributes - List of attribute properties - values to apply to popper element
2504   * @argument {Object} options - Modifiers configuration and options
2505   * @returns {Object} The same data object
2506   */
2507  function applyStyle(data) {
2508    // any property present in `data.styles` will be applied to the popper,
2509    // in this way we can make the 3rd party modifiers add custom styles to it
2510    // Be aware, modifiers could override the properties defined in the previous
2511    // lines of this modifier!
2512    setStyles(data.instance.popper, data.styles);
2513
2514    // any property present in `data.attributes` will be applied to the popper,
2515    // they will be set as HTML attributes of the element
2516    setAttributes(data.instance.popper, data.attributes);
2517
2518    // if arrowElement is defined and arrowStyles has some properties
2519    if (data.arrowElement && Object.keys(data.arrowStyles).length) {
2520      setStyles(data.arrowElement, data.arrowStyles);
2521    }

2522    return data;
2523  }
2524
2525  /**
2526   * Set the x-placement attribute before everything else because it could be used
2527   * to add margins to the popper margins needs to be calculated to get the
2528   * correct popper offsets.
2529   * @method
2530   * @memberof Popper.modifiers
2531   * @param {HTMLElement} reference - The reference element used to position the popper
2532   * @param {HTMLElement} popper - The HTML element used as popper
2533   * @param {Object} options - Popper.js options
2534   */
2535  function applyStyleOnLoad(reference, popper, options, modifierOptions, state) {
2536    // compute reference element offsets
2537    var referenceOffsets = getReferenceOffsets(state, popper, reference, options.positionFixed);
2538
2539    // compute auto placement, store placement inside the data object,
2540    // modifiers will be able to edit `placement` if needed
2541    // and refer to originalPlacement to know the original value
2542    var placement = computeAutoPlacement(options.placement, referenceOffsets, popper, reference, options.modifiers.flip.boundariesElement, options.modifiers.flip.padding);
2543    popper.setAttribute('x-placement', placement);
2544
2545    // Apply `position` to popper before anything else because
2546    // without the position applied we can't guarantee correct computations
2547    setStyles(popper, {
2548      position: options.positionFixed ? 'fixed' : 'absolute'
2549    });
2550    return options;
2551  }
2552
2553  /**
2554   * @function
2555   * @memberof Popper.Utils
2556   * @argument {Object} data - The data object generated by `update` method
2557   * @argument {Boolean} shouldRound - If the offsets should be rounded at all
2558   * @returns {Object} The popper's position offsets rounded
2559   *
2560   * The tale of pixel-perfect positioning. It's still not 100% perfect, but as
2561   * good as it can be within reason.
2562   * Discussion here: https://github.com/FezVrasta/popper.js/pull/715
2563   *
2564   * Low DPI screens cause a popper to be blurry if not using full pixels (Safari
2565   * as well on High DPI screens).
2566   *
2567   * Firefox prefers no rounding for positioning and does not have blurriness on
2568   * high DPI screens.
2569   *
2570   * Only horizontal placement and left/right values need to be considered.
2571   */
2572  function getRoundedOffsets(data, shouldRound) {
2573    var _data$offsets = data.offsets,
2574      popper = _data$offsets.popper,
2575      reference = _data$offsets.reference;
2576    var round = Math.round,
2577      floor = Math.floor;
2578    var noRound = function noRound(v) {
2579      return v;
2580    };
2581    var referenceWidth = round(reference.width);
2582    var popperWidth = round(popper.width);
2583    var isVertical = ['left', 'right'].indexOf(data.placement) !== -1;
2584    var isVariation = data.placement.indexOf('-') !== -1;
2585    var sameWidthParity = referenceWidth % 2 === popperWidth % 2;
2586    var bothOddWidth = referenceWidth % 2 === 1 && popperWidth % 2 === 1;
2587    var horizontalToInteger = !shouldRound ? noRound : isVertical || isVariation || sameWidthParity ? round : floor;
2588    var verticalToInteger = !shouldRound ? noRound : round;
2589    return {
2590      left: horizontalToInteger(bothOddWidth && !isVariation && shouldRound ? popper.left - 1 : popper.left),
2591      top: verticalToInteger(popper.top),
2592      bottom: verticalToInteger(popper.bottom),
2593      right: horizontalToInteger(popper.right)
2594    };
2595  }
2596  var isFirefox = isBrowser && /Firefox/i.test(navigator.userAgent);
2597
2598  /**
2599   * @function
2600   * @memberof Modifiers
2601   * @argument {Object} data - The data object generated by `update` method
2602   * @argument {Object} options - Modifiers configuration and options
2603   * @returns {Object} The data object, properly modified
2604   */
2605  function computeStyle(data, options) {
2606    var x = options.x,
2607      y = options.y;
2608    var popper = data.offsets.popper;
2609
2610    // Remove this legacy support in Popper.js v2
2611
2612    var legacyGpuAccelerationOption = find(data.instance.modifiers, function (modifier) {
2613      return modifier.name === 'applyStyle';
2614    }).gpuAcceleration;
2615    if (legacyGpuAccelerationOption !== undefined) {
2616      console.warn('WARNING: `gpuAcceleration` option moved to `computeStyle` modifier and will not be supported in future versions of Popper.js!');
2617    }
2618    var gpuAcceleration = legacyGpuAccelerationOption !== undefined ? legacyGpuAccelerationOption : options.gpuAcceleration;
2619    var offsetParent = getOffsetParent(data.instance.popper);
2620    var offsetParentRect = getBoundingClientRect(offsetParent);
2621
2622    // Styles
2623    var styles = {
2624      position: popper.position
2625    };
2626    var offsets = getRoundedOffsets(data, window.devicePixelRatio < 2 || !isFirefox);
2627    var sideA = x === 'bottom' ? 'top' : 'bottom';
2628    var sideB = y === 'right' ? 'left' : 'right';
2629
2630    // if gpuAcceleration is set to `true` and transform is supported,
2631    //  we use `translate3d` to apply the position to the popper we
2632    // automatically use the supported prefixed version if needed
2633    var prefixedProperty = getSupportedPropertyName('transform');
2634
2635    // now, let's make a step back and look at this code closely (wtf?)
2636    // If the content of the popper grows once it's been positioned, it
2637    // may happen that the popper gets misplaced because of the new content
2638    // overflowing its reference element
2639    // To avoid this problem, we provide two options (x and y), which allow
2640    // the consumer to define the offset origin.
2641    // If we position a popper on top of a reference element, we can set
2642    // `x` to `top` to make the popper grow towards its top instead of
2643    // its bottom.
2644    var left = void 0,
2645      top = void 0;
2646    if (sideA === 'bottom') {
2647      // when offsetParent is <html> the positioning is relative to the bottom of the screen (excluding the scrollbar)
2648      // and not the bottom of the html element
2649      if (offsetParent.nodeName === 'HTML') {
2650        top = -offsetParent.clientHeight + offsets.bottom;
2651      } else {
2652        top = -offsetParentRect.height + offsets.bottom;
2653      }
2654    } else {
2655      top = offsets.top;
2656    }
2657    if (sideB === 'right') {
2658      if (offsetParent.nodeName === 'HTML') {
2659        left = -offsetParent.clientWidth + offsets.right;
2660      } else {
2661        left = -offsetParentRect.width + offsets.right;
2662      }
2663    } else {
2664      left = offsets.left;
2665    }
2666    if (gpuAcceleration && prefixedProperty) {
2667      styles[prefixedProperty] = 'translate3d(' + left + 'px, ' + top + 'px, 0)';
2668      styles[sideA] = 0;
2669      styles[sideB] = 0;
2670      styles.willChange = 'transform';
2671    } else {
2672      // othwerise, we use the standard `top`, `left`, `bottom` and `right` properties
2673      var invertTop = sideA === 'bottom' ? -1 : 1;
2674      var invertLeft = sideB === 'right' ? -1 : 1;
2675      styles[sideA] = top * invertTop;
2676      styles[sideB] = left * invertLeft;
2677      styles.willChange = sideA + ', ' + sideB;
2678    }
2679
2680    // Attributes
2681    var attributes = {
2682      'x-placement': data.placement
2683    };
2684
2685    // Update `data` attributes, styles and arrowStyles
2686    data.attributes = _extends({}, attributes, data.attributes);
2687    data.styles = _extends({}, styles, data.styles);
2688    data.arrowStyles = _extends({}, data.offsets.arrow, data.arrowStyles);
2689    return data;
2690  }
2691
2692  /**
2693   * Helper used to know if the given modifier depends from another one.<br />
2694   * It checks if the needed modifier is listed and enabled.
2695   * @method
2696   * @memberof Popper.Utils
2697   * @param {Array} modifiers - list of modifiers
2698   * @param {String} requestingName - name of requesting modifier
2699   * @param {String} requestedName - name of requested modifier
2700   * @returns {Boolean}
2701   */
2702  function isModifierRequired(modifiers, requestingName, requestedName) {
2703    var requesting = find(modifiers, function (_ref) {
2704      var name = _ref.name;
2705      return name === requestingName;
2706    });
2707    var isRequired = !!requesting && modifiers.some(function (modifier) {
2708      return modifier.name === requestedName && modifier.enabled && modifier.order < requesting.order;
2709    });
2710    if (!isRequired) {
2711      var _requesting = '`' + requestingName + '`';
2712      var requested = '`' + requestedName + '`';
2713      console.warn(requested + ' modifier is required by ' + _requesting + ' modifier in order to work, be sure to include it before ' + _requesting + '!');
2714    }
2715    return isRequired;
2716  }
2717
2718  /**
2719   * @function
2720   * @memberof Modifiers
2721   * @argument {Object} data - The data object generated by update method
2722   * @argument {Object} options - Modifiers configuration and options
2723   * @returns {Object} The data object, properly modified
2724   */
2725  function arrow(data, options) {
2726    var _data$offsets$arrow;
2727
2728    // arrow depends on keepTogether in order to work
2729    if (!isModifierRequired(data.instance.modifiers, 'arrow', 'keepTogether')) {
2730      return data;
2731    }
2732    var arrowElement = options.element;
2733
2734    // if arrowElement is a string, suppose it's a CSS selector
2735    if (typeof arrowElement === 'string') {
2736      arrowElement = data.instance.popper.querySelector(arrowElement);
2737
2738      // if arrowElement is not found, don't run the modifier
2739      if (!arrowElement) {
2740        return data;
2741      }
2742    } else {
2743      // if the arrowElement isn't a query selector we must check that the
2744      // provided DOM node is child of its popper node
2745      if (!data.instance.popper.contains(arrowElement)) {
2746        console.warn('WARNING: `arrow.element` must be child of its popper element!');
2747        return data;
2748      }
2749    }
2750    var placement = data.placement.split('-')[0];
2751    var _data$offsets = data.offsets,
2752      popper = _data$offsets.popper,
2753      reference = _data$offsets.reference;
2754    var isVertical = ['left', 'right'].indexOf(placement) !== -1;
2755    var len = isVertical ? 'height' : 'width';
2756    var sideCapitalized = isVertical ? 'Top' : 'Left';
2757    var side = sideCapitalized.toLowerCase();
2758    var altSide = isVertical ? 'left' : 'top';
2759    var opSide = isVertical ? 'bottom' : 'right';
2760    var arrowElementSize = getOuterSizes(arrowElement)[len];
2761
2762    //
2763    // extends keepTogether behavior making sure the popper and its
2764    // reference have enough pixels in conjunction
2765    //
2766
2767    // top/left side
2768    if (reference[opSide] - arrowElementSize < popper[side]) {
2769      data.offsets.popper[side] -= popper[side] - (reference[opSide] - arrowElementSize);
2770    }
2771    // bottom/right side
2772    if (reference[side] + arrowElementSize > popper[opSide]) {
2773      data.offsets.popper[side] += reference[side] + arrowElementSize - popper[opSide];
2774    }
2775    data.offsets.popper = getClientRect(data.offsets.popper);
2776
2777    // compute center of the popper
2778    var center = reference[side] + reference[len] / 2 - arrowElementSize / 2;
2779
2780    // Compute the sideValue using the updated popper offsets
2781    // take popper margin in account because we don't have this info available
2782    var css = getStyleComputedProperty(data.instance.popper);
2783    var popperMarginSide = parseFloat(css['margin' + sideCapitalized]);
2784    var popperBorderSide = parseFloat(css['border' + sideCapitalized + 'Width']);
2785    var sideValue = center - data.offsets.popper[side] - popperMarginSide - popperBorderSide;
2786
2787    // prevent arrowElement from being placed not contiguously to its popper
2788    sideValue = Math.max(Math.min(popper[len] - arrowElementSize, sideValue), 0);
2789    data.arrowElement = arrowElement;
2790    data.offsets.arrow = (_data$offsets$arrow = {}, defineProperty(_data$offsets$arrow, side, Math.round(sideValue)), defineProperty(_data$offsets$arrow, altSide, ''), _data$offsets$arrow);
2791    return data;
2792  }
2793
2794  /**
2795   * Get the opposite placement variation of the given one
2796   * @method
2797   * @memberof Popper.Utils
2798   * @argument {String} placement variation
2799   * @returns {String} flipped placement variation
2800   */
2801  function getOppositeVariation(variation) {
2802    if (variation === 'end') {
2803      return 'start';
2804    } else if (variation === 'start') {
2805      return 'end';
2806    }
2807    return variation;
2808  }
2809
2810  /**
2811   * List of accepted placements to use as values of the `placement` option.<br />
2812   * Valid placements are:
2813   * - `auto`
2814   * - `top`
2815   * - `right`
2816   * - `bottom`
2817   * - `left`
2818   *
2819   * Each placement can have a variation from this list:
2820   * - `-start`
2821   * - `-end`
2822   *
2823   * Variations are interpreted easily if you think of them as the left to right
2824   * written languages. Horizontally (`top` and `bottom`), `start` is left and `end`
2825   * is right.<br />
2826   * Vertically (`left` and `right`), `start` is top and `end` is bottom.
2827   *
2828   * Some valid examples are:
2829   * - `top-end` (on top of reference, right aligned)
2830   * - `right-start` (on right of reference, top aligned)
2831   * - `bottom` (on bottom, centered)
2832   * - `auto-end` (on the side with more space available, alignment depends by placement)
2833   *
2834   * @static
2835   * @type {Array}
2836   * @enum {String}
2837   * @readonly
2838   * @method placements
2839   * @memberof Popper
2840   */
2841  var placements = ['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'];
2842
2843  // Get rid of `auto` `auto-start` and `auto-end`
2844  var validPlacements = placements.slice(3);
2845
2846  /**
2847   * Given an initial placement, returns all the subsequent placements
2848   * clockwise (or counter-clockwise).
2849   *
2850   * @method
2851   * @memberof Popper.Utils
2852   * @argument {String} placement - A valid placement (it accepts variations)
2853   * @argument {Boolean} counter - Set to true to walk the placements counterclockwise
2854   * @returns {Array} placements including their variations
2855   */
2856  function clockwise(placement) {
2857    var counter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
2858    var index = validPlacements.indexOf(placement);
2859    var arr = validPlacements.slice(index + 1).concat(validPlacements.slice(0, index));
2860    return counter ? arr.reverse() : arr;
2861  }
2862  var BEHAVIORS = {
2863    FLIP: 'flip',
2864    CLOCKWISE: 'clockwise',
2865    COUNTERCLOCKWISE: 'counterclockwise'
2866  };
2867
2868  /**
2869   * @function
2870   * @memberof Modifiers
2871   * @argument {Object} data - The data object generated by update method
2872   * @argument {Object} options - Modifiers configuration and options
2873   * @returns {Object} The data object, properly modified
2874   */
2875  function flip(data, options) {
2876    // if `inner` modifier is enabled, we can't use the `flip` modifier
2877    if (isModifierEnabled(data.instance.modifiers, 'inner')) {
2878      return data;
2879    }
2880    if (data.flipped && data.placement === data.originalPlacement) {
2881      // seems like flip is trying to loop, probably there's not enough space on any of the flippable sides
2882      return data;
2883    }
2884    var boundaries = getBoundaries(data.instance.popper, data.instance.reference, options.padding, options.boundariesElement, data.positionFixed);
2885    var placement = data.placement.split('-')[0];
2886    var placementOpposite = getOppositePlacement(placement);
2887    var variation = data.placement.split('-')[1] || '';
2888    var flipOrder = [];
2889    switch (options.behavior) {
2890      case BEHAVIORS.FLIP:
2891        flipOrder = [placement, placementOpposite];
2892        break;
2893      case BEHAVIORS.CLOCKWISE:
2894        flipOrder = clockwise(placement);
2895        break;
2896      case BEHAVIORS.COUNTERCLOCKWISE:
2897        flipOrder = clockwise(placement, true);
2898        break;
2899      default:
2900        flipOrder = options.behavior;
2901    }
2902    flipOrder.forEach(function (step, index) {
2903      if (placement !== step || flipOrder.length === index + 1) {
2904        return data;
2905      }
2906      placement = data.placement.split('-')[0];
2907      placementOpposite = getOppositePlacement(placement);
2908      var popperOffsets = data.offsets.popper;
2909      var refOffsets = data.offsets.reference;
2910
2911      // using floor because the reference offsets may contain decimals we are not going to consider here
2912      var floor = Math.floor;
2913      var 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);
2914      var overflowsLeft = floor(popperOffsets.left) < floor(boundaries.left);
2915      var overflowsRight = floor(popperOffsets.right) > floor(boundaries.right);
2916      var overflowsTop = floor(popperOffsets.top) < floor(boundaries.top);
2917      var overflowsBottom = floor(popperOffsets.bottom) > floor(boundaries.bottom);
2918      var overflowsBoundaries = placement === 'left' && overflowsLeft || placement === 'right' && overflowsRight || placement === 'top' && overflowsTop || placement === 'bottom' && overflowsBottom;
2919
2920      // flip the variation if required
2921      var isVertical = ['top', 'bottom'].indexOf(placement) !== -1;
2922
2923      // flips variation if reference element overflows boundaries
2924      var flippedVariationByRef = !!options.flipVariations && (isVertical && variation === 'start' && overflowsLeft || isVertical && variation === 'end' && overflowsRight || !isVertical && variation === 'start' && overflowsTop || !isVertical && variation === 'end' && overflowsBottom);
2925
2926      // flips variation if popper content overflows boundaries
2927      var flippedVariationByContent = !!options.flipVariationsByContent && (isVertical && variation === 'start' && overflowsRight || isVertical && variation === 'end' && overflowsLeft || !isVertical && variation === 'start' && overflowsBottom || !isVertical && variation === 'end' && overflowsTop);
2928      var flippedVariation = flippedVariationByRef || flippedVariationByContent;
2929      if (overlapsRef || overflowsBoundaries || flippedVariation) {
2930        // this boolean to detect any flip loop
2931        data.flipped = true;
2932        if (overlapsRef || overflowsBoundaries) {
2933          placement = flipOrder[index + 1];
2934        }
2935        if (flippedVariation) {
2936          variation = getOppositeVariation(variation);
2937        }
2938        data.placement = placement + (variation ? '-' + variation : '');
2939
2940        // this object contains `position`, we want to preserve it along with
2941        // any additional property we may add in the future
2942        data.offsets.popper = _extends({}, data.offsets.popper, getPopperOffsets(data.instance.popper, data.offsets.reference, data.placement));
2943        data = runModifiers(data.instance.modifiers, data, 'flip');
2944      }
2945    });
2946    return data;
2947  }
2948
2949  /**
2950   * @function
2951   * @memberof Modifiers
2952   * @argument {Object} data - The data object generated by update method
2953   * @argument {Object} options - Modifiers configuration and options
2954   * @returns {Object} The data object, properly modified
2955   */
2956  function keepTogether(data) {
2957    var _data$offsets = data.offsets,
2958      popper = _data$offsets.popper,
2959      reference = _data$offsets.reference;
2960    var placement = data.placement.split('-')[0];
2961    var floor = Math.floor;
2962    var isVertical = ['top', 'bottom'].indexOf(placement) !== -1;
2963    var side = isVertical ? 'right' : 'bottom';
2964    var opSide = isVertical ? 'left' : 'top';
2965    var measurement = isVertical ? 'width' : 'height';
2966    if (popper[side] < floor(reference[opSide])) {
2967      data.offsets.popper[opSide] = floor(reference[opSide]) - popper[measurement];
2968    }
2969    if (popper[opSide] > floor(reference[side])) {
2970      data.offsets.popper[opSide] = floor(reference[side]);
2971    }
2972    return data;
2973  }
2974
2975  /**
2976   * Converts a string containing value + unit into a px value number
2977   * @function
2978   * @memberof {modifiers~offset}
2979   * @private
2980   * @argument {String} str - Value + unit string
2981   * @argument {String} measurement - `height` or `width`
2982   * @argument {Object} popperOffsets
2983   * @argument {Object} referenceOffsets
2984   * @returns {Number|String}
2985   * Value in pixels, or original string if no values were extracted
2986   */
2987  function toValue(str, measurement, popperOffsets, referenceOffsets) {
2988    // separate value from unit
2989    var split = str.match(/((?:\-|\+)?\d*\.?\d*)(.*)/);
2990    var value = +split[1];
2991    var unit = split[2];
2992
2993    // If it's not a number it's an operator, I guess
2994    if (!value) {
2995      return str;
2996    }
2997    if (unit.indexOf('%') === 0) {
2998      var element = void 0;
2999      switch (unit) {
3000        case '%p':
3001          element = popperOffsets;
3002          break;
3003        case '%':
3004        case '%r':
3005        default:
3006          element = referenceOffsets;
3007      }
3008      var rect = getClientRect(element);
3009      return rect[measurement] / 100 * value;
3010    } else if (unit === 'vh' || unit === 'vw') {
3011      // if is a vh or vw, we calculate the size based on the viewport
3012      var size = void 0;
3013      if (unit === 'vh') {
3014        size = Math.max(document.documentElement.clientHeight, window.innerHeight || 0);
3015      } else {
3016        size = Math.max(document.documentElement.clientWidth, window.innerWidth || 0);
3017      }
3018      return size / 100 * value;
3019    } else {
3020      // if is an explicit pixel unit, we get rid of the unit and keep the value
3021      // if is an implicit unit, it's px, and we return just the value
3022      return value;
3023    }
3024  }
3025
3026  /**
3027   * Parse an `offset` string to extrapolate `x` and `y` numeric offsets.
3028   * @function
3029   * @memberof {modifiers~offset}
3030   * @private
3031   * @argument {String} offset
3032   * @argument {Object} popperOffsets
3033   * @argument {Object} referenceOffsets
3034   * @argument {String} basePlacement
3035   * @returns {Array} a two cells array with x and y offsets in numbers
3036   */
3037  function parseOffset(offset, popperOffsets, referenceOffsets, basePlacement) {
3038    var offsets = [0, 0];
3039
3040    // Use height if placement is left or right and index is 0 otherwise use width
3041    // in this way the first offset will use an axis and the second one
3042    // will use the other one
3043    var useHeight = ['right', 'left'].indexOf(basePlacement) !== -1;
3044
3045    // Split the offset string to obtain a list of values and operands
3046    // The regex addresses values with the plus or minus sign in front (+10, -20, etc)
3047    var fragments = offset.split(/(\+|\-)/).map(function (frag) {
3048      return frag.trim();
3049    });
3050
3051    // Detect if the offset string contains a pair of values or a single one
3052    // they could be separated by comma or space
3053    var divider = fragments.indexOf(find(fragments, function (frag) {
3054      return frag.search(/,|\s/) !== -1;
3055    }));
3056    if (fragments[divider] && fragments[divider].indexOf(',') === -1) {
3057      console.warn('Offsets separated by white space(s) are deprecated, use a comma (,) instead.');
3058    }
3059
3060    // If divider is found, we divide the list of values and operands to divide
3061    // them by ofset X and Y.
3062    var splitRegex = /\s*,\s*|\s+/;
3063    var ops = divider !== -1 ? [fragments.slice(0, divider).concat([fragments[divider].split(splitRegex)[0]]), [fragments[divider].split(splitRegex)[1]].concat(fragments.slice(divider + 1))] : [fragments];
3064
3065    // Convert the values with units to absolute pixels to allow our computations
3066    ops = ops.map(function (op, index) {
3067      // Most of the units rely on the orientation of the popper
3068      var measurement = (index === 1 ? !useHeight : useHeight) ? 'height' : 'width';
3069      var mergeWithPrevious = false;
3070      return op
3071      // This aggregates any `+` or `-` sign that aren't considered operators
3072      // e.g.: 10 + +5 => [10, +, +5]
3073      .reduce(function (a, b) {
3074        if (a[a.length - 1] === '' && ['+', '-'].indexOf(b) !== -1) {
3075          a[a.length - 1] = b;
3076          mergeWithPrevious = true;
3077          return a;
3078        } else if (mergeWithPrevious) {
3079          a[a.length - 1] += b;
3080          mergeWithPrevious = false;
3081          return a;
3082        } else {
3083          return a.concat(b);
3084        }
3085      }, [])
3086      // Here we convert the string values into number values (in px)
3087      .map(function (str) {
3088        return toValue(str, measurement, popperOffsets, referenceOffsets);
3089      });
3090    });
3091
3092    // Loop trough the offsets arrays and execute the operations
3093    ops.forEach(function (op, index) {
3094      op.forEach(function (frag, index2) {
3095        if (isNumeric(frag)) {
3096          offsets[index] += frag * (op[index2 - 1] === '-' ? -1 : 1);
3097        }
3098      });
3099    });
3100    return offsets;
3101  }
3102
3103  /**
3104   * @function
3105   * @memberof Modifiers
3106   * @argument {Object} data - The data object generated by update method
3107   * @argument {Object} options - Modifiers configuration and options
3108   * @argument {Number|String} options.offset=0
3109   * The offset value as described in the modifier description
3110   * @returns {Object} The data object, properly modified
3111   */
3112  function offset(data, _ref) {
3113    var offset = _ref.offset;
3114    var placement = data.placement,
3115      _data$offsets = data.offsets,
3116      popper = _data$offsets.popper,
3117      reference = _data$offsets.reference;
3118    var basePlacement = placement.split('-')[0];
3119    var offsets = void 0;
3120    if (isNumeric(+offset)) {
3121      offsets = [+offset, 0];
3122    } else {
3123      offsets = parseOffset(offset, popper, reference, basePlacement);
3124    }
3125    if (basePlacement === 'left') {
3126      popper.top += offsets[0];
3127      popper.left -= offsets[1];
3128    } else if (basePlacement === 'right') {
3129      popper.top += offsets[0];
3130      popper.left += offsets[1];
3131    } else if (basePlacement === 'top') {
3132      popper.left += offsets[0];
3133      popper.top -= offsets[1];
3134    } else if (basePlacement === 'bottom') {
3135      popper.left += offsets[0];
3136      popper.top += offsets[1];
3137    }
3138    data.popper = popper;
3139    return data;
3140  }
3141
3142  /**
3143   * @function
3144   * @memberof Modifiers
3145   * @argument {Object} data - The data object generated by `update` method
3146   * @argument {Object} options - Modifiers configuration and options
3147   * @returns {Object} The data object, properly modified
3148   */
3149  function preventOverflow(data, options) {
3150    var boundariesElement = options.boundariesElement || getOffsetParent(data.instance.popper);
3151
3152    // If offsetParent is the reference element, we really want to
3153    // go one step up and use the next offsetParent as reference to
3154    // avoid to make this modifier completely useless and look like broken
3155    if (data.instance.reference === boundariesElement) {
3156      boundariesElement = getOffsetParent(boundariesElement);
3157    }
3158
3159    // NOTE: DOM access here
3160    // resets the popper's position so that the document size can be calculated excluding
3161    // the size of the popper element itself
3162    var transformProp = getSupportedPropertyName('transform');
3163    var popperStyles = data.instance.popper.style; // assignment to help minification
3164    var top = popperStyles.top,
3165      left = popperStyles.left,
3166      transform = popperStyles[transformProp];
3167    popperStyles.top = '';
3168    popperStyles.left = '';
3169    popperStyles[transformProp] = '';
3170    var boundaries = getBoundaries(data.instance.popper, data.instance.reference, options.padding, boundariesElement, data.positionFixed);
3171
3172    // NOTE: DOM access here
3173    // restores the original style properties after the offsets have been computed
3174    popperStyles.top = top;
3175    popperStyles.left = left;
3176    popperStyles[transformProp] = transform;
3177    options.boundaries = boundaries;
3178    var order = options.priority;
3179    var popper = data.offsets.popper;
3180    var check = {
3181      primary: function primary(placement) {
3182        var value = popper[placement];
3183        if (popper[placement] < boundaries[placement] && !options.escapeWithReference) {
3184          value = Math.max(popper[placement], boundaries[placement]);
3185        }
3186        return defineProperty({}, placement, value);
3187      },
3188      secondary: function secondary(placement) {
3189        var mainSide = placement === 'right' ? 'left' : 'top';
3190        var value = popper[mainSide];
3191        if (popper[placement] > boundaries[placement] && !options.escapeWithReference) {
3192          value = Math.min(popper[mainSide], boundaries[placement] - (placement === 'right' ? popper.width : popper.height));
3193        }
3194        return defineProperty({}, mainSide, value);
3195      }
3196    };
3197    order.forEach(function (placement) {
3198      var side = ['left', 'top'].indexOf(placement) !== -1 ? 'primary' : 'secondary';
3199      popper = _extends({}, popper, check[side](placement));
3200    });
3201    data.offsets.popper = popper;
3202    return data;
3203  }
3204
3205  /**
3206   * @function
3207   * @memberof Modifiers
3208   * @argument {Object} data - The data object generated by `update` method
3209   * @argument {Object} options - Modifiers configuration and options
3210   * @returns {Object} The data object, properly modified
3211   */
3212  function shift(data) {
3213    var placement = data.placement;
3214    var basePlacement = placement.split('-')[0];
3215    var shiftvariation = placement.split('-')[1];
3216
3217    // if shift shiftvariation is specified, run the modifier
3218    if (shiftvariation) {
3219      var _data$offsets = data.offsets,
3220        reference = _data$offsets.reference,
3221        popper = _data$offsets.popper;
3222      var isVertical = ['bottom', 'top'].indexOf(basePlacement) !== -1;
3223      var side = isVertical ? 'left' : 'top';
3224      var measurement = isVertical ? 'width' : 'height';
3225      var shiftOffsets = {
3226        start: defineProperty({}, side, reference[side]),
3227        end: defineProperty({}, side, reference[side] + reference[measurement] - popper[measurement])
3228      };
3229      data.offsets.popper = _extends({}, popper, shiftOffsets[shiftvariation]);
3230    }
3231    return data;
3232  }
3233
3234  /**
3235   * @function
3236   * @memberof Modifiers
3237   * @argument {Object} data - The data object generated by update method
3238   * @argument {Object} options - Modifiers configuration and options
3239   * @returns {Object} The data object, properly modified
3240   */
3241  function hide(data) {
3242    if (!isModifierRequired(data.instance.modifiers, 'hide', 'preventOverflow')) {
3243      return data;
3244    }
3245    var refRect = data.offsets.reference;
3246    var bound = find(data.instance.modifiers, function (modifier) {
3247      return modifier.name === 'preventOverflow';
3248    }).boundaries;
3249    if (refRect.bottom < bound.top || refRect.left > bound.right || refRect.top > bound.bottom || refRect.right < bound.left) {
3250      // Avoid unnecessary DOM access if visibility hasn't changed
3251      if (data.hide === true) {
3252        return data;
3253      }
3254      data.hide = true;
3255      data.attributes['x-out-of-boundaries'] = '';
3256    } else {
3257      // Avoid unnecessary DOM access if visibility hasn't changed
3258      if (data.hide === false) {
3259        return data;
3260      }
3261      data.hide = false;
3262      data.attributes['x-out-of-boundaries'] = false;
3263    }
3264    return data;
3265  }
3266
3267  /**
3268   * @function
3269   * @memberof Modifiers
3270   * @argument {Object} data - The data object generated by `update` method
3271   * @argument {Object} options - Modifiers configuration and options
3272   * @returns {Object} The data object, properly modified
3273   */
3274  function inner(data) {
3275    var placement = data.placement;
3276    var basePlacement = placement.split('-')[0];
3277    var _data$offsets = data.offsets,
3278      popper = _data$offsets.popper,
3279      reference = _data$offsets.reference;
3280    var isHoriz = ['left', 'right'].indexOf(basePlacement) !== -1;
3281    var subtractLength = ['top', 'left'].indexOf(basePlacement) === -1;
3282    popper[isHoriz ? 'left' : 'top'] = reference[basePlacement] - (subtractLength ? popper[isHoriz ? 'width' : 'height'] : 0);
3283    data.placement = getOppositePlacement(placement);
3284    data.offsets.popper = getClientRect(popper);
3285    return data;
3286  }
3287
3288  /**
3289   * Modifier function, each modifier can have a function of this type assigned
3290   * to its `fn` property.<br />
3291   * These functions will be called on each update, this means that you must
3292   * make sure they are performant enough to avoid performance bottlenecks.
3293   *
3294   * @function ModifierFn
3295   * @argument {dataObject} data - The data object generated by `update` method
3296   * @argument {Object} options - Modifiers configuration and options
3297   * @returns {dataObject} The data object, properly modified
3298   */
3299
3300  /**
3301   * Modifiers are plugins used to alter the behavior of your poppers.<br />
3302   * Popper.js uses a set of 9 modifiers to provide all the basic functionalities
3303   * needed by the library.
3304   *
3305   * Usually you don't want to override the `order`, `fn` and `onLoad` props.
3306   * All the other properties are configurations that could be tweaked.
3307   * @namespace modifiers
3308   */
3309  var modifiers = {
3310    /**
3311     * Modifier used to shift the popper on the start or end of its reference
3312     * element.<br />
3313     * It will read the variation of the `placement` property.<br />
3314     * It can be one either `-end` or `-start`.
3315     * @memberof modifiers
3316     * @inner
3317     */
3318    shift: {
3319      /** @prop {number} order=100 - Index used to define the order of execution */
3320      order: 100,
3321      /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
3322      enabled: true,
3323      /** @prop {ModifierFn} */
3324      fn: shift
3325    },
3326    /**
3327     * The `offset` modifier can shift your popper on both its axis.
3328     *
3329     * It accepts the following units:
3330     * - `px` or unit-less, interpreted as pixels
3331     * - `%` or `%r`, percentage relative to the length of the reference element
3332     * - `%p`, percentage relative to the length of the popper element
3333     * - `vw`, CSS viewport width unit
3334     * - `vh`, CSS viewport height unit
3335     *
3336     * For length is intended the main axis relative to the placement of the popper.<br />
3337     * This means that if the placement is `top` or `bottom`, the length will be the
3338     * `width`. In case of `left` or `right`, it will be the `height`.
3339     *
3340     * You can provide a single value (as `Number` or `String`), or a pair of values
3341     * as `String` divided by a comma or one (or more) white space