https://www.colibrirealestate.com/wp-content/mu-plugins/wp-common-…/cl2-blocks-view.js?ver=2026-10-01-11-09

1286  return function () {
1287    if (called) {
1288      return;
1289    }
1290    called = true;
1291    window.Promise.resolve().then(function () {
1292      called = false;
1293      fn();
1294    });
1295  };
1296}
1297
1298function taskDebounce(fn) {
1299  var scheduled = false;
1300  return function () {
1301    if (!scheduled) {
1302      scheduled = true;
1303      setTimeout(function () {
1304        scheduled = false;
1305        fn();
1306      }, timeoutDuration);
1307    }
1308  };
1309}
1310
1311var supportsMicroTasks = isBrowser && window.Promise;
1312
1313/**
1314* Create a debounced version of a method, that's asynchronously deferred
1315* but called in the minimum time possible.
1316*
1317* @method
1318* @memberof Popper.Utils
1319* @argument {Function} fn
1320* @returns {Function}
1321*/
1322var debounce = supportsMicroTasks ? microtaskDebounce : taskDebounce;
1323
1324/**
1325 * Check if the given variable is a function
1326 * @method
1327 * @memberof Popper.Utils
1328 * @argument {Any} functionToCheck - variable to check
1329 * @returns {Boolean} answer to: is a function?
1330 */
1331function isFunction(functionToCheck) {
1332  var getType = {};
1333  return functionToCheck && getType.toString.call(functionToCheck) === '[object Function]';
1334}
1335
1336/**
1337 * Get CSS computed property of the given element
1338 * @method
1339 * @memberof Popper.Utils
1340 * @argument {Eement} element
1341 * @argument {String} property
1342 */
1343function getStyleComputedProperty(element, property) {
1344  if (element.nodeType !== 1) {
1345    return [];
1346  }
1347  // NOTE: 1 DOM access here
1348  var window = element.ownerDocument.defaultView;
1349  var css = window.getComputedStyle(element, null);
1350  return property ? css[property] : css;
1351}
1352
1353/**
1354 * Returns the parentNode or the host of the element
1355 * @method
1356 * @memberof Popper.Utils
1357 * @argument {Element} element
1358 * @returns {Element} parent
1359 */
1360function getParentNode(element) {
1361  if (element.nodeName === 'HTML') {
1362    return element;
1363  }
1364  return element.parentNode || element.host;
1365}
1366
1367/**
1368 * Returns the scrolling parent of the given element
1369 * @method
1370 * @memberof Popper.Utils
1371 * @argument {Element} element
1372 * @returns {Element} scroll parent
1373 */
1374function getScrollParent(element) {
1375  // Return body, `getScroll` will take care to get the correct `scrollTop` from it
1376  if (!element) {
1377    return document.body;
1378  }
1379
1380  switch (element.nodeName) {
1381    case 'HTML':
1382    case 'BODY':
1383      return element.ownerDocument.body;
1384    case '#document':
1385      return element.body;
1386  }
1387
1388  // Firefox want us to check `-x` and `-y` variations as well
1389
1390  var _getStyleComputedProp = getStyleComputedProperty(element),
1391      overflow = _getStyleComputedProp.overflow,
1392      overflowX = _getStyleComputedProp.overflowX,
1393      overflowY = _getStyleComputedProp.overflowY;
1394
1395  if (/(auto|scroll|overlay)/.test(overflow + overflowY + overflowX)) {
1396    return element;
1397  }
1398
1399  return getScrollParent(getParentNode(element));
1400}
1401
1402/**
1403 * Returns the reference node of the reference object, or the reference object itself.
1404 * @method
1405 * @memberof Popper.Utils
1406 * @param {Element|Object} reference - the reference element (the popper will be relative to this)
1407 * @returns {Element} parent
1408 */
1409function getReferenceNode(reference) {
1410  return reference && reference.referenceNode ? reference.referenceNode : reference;
1411}

1411
1412
1413var isIE11 = isBrowser && !!(window.MSInputMethodContext && document.documentMode);
1414var isIE10 = isBrowser && /MSIE 10/.test(navigator.userAgent);
1415
1416/**
1417 * Determines if the browser is Internet Explorer
1418 * @method
1419 * @memberof Popper.Utils
1420 * @param {Number} version to check
1421 * @returns {Boolean} isIE
1422 */
1423function isIE(version) {
1424  if (version === 11) {
1425    return isIE11;
1426  }
1427  if (version === 10) {
1428    return isIE10;
1429  }
1430  return isIE11 || isIE10;
1431}
1432
1433/**
1434 * Returns the offset parent of the given element
1435 * @method
1436 * @memberof Popper.Utils
1437 * @argument {Element} element
1438 * @returns {Element} offset parent
1439 */
1440function getOffsetParent(element) {
1441  if (!element) {
1442    return document.documentElement;
1443  }
1444
1445  var noOffsetParent = isIE(10) ? document.body : null;
1446
1447  // NOTE: 1 DOM access here
1448  var offsetParent = element.offsetParent || null;
1449  // Skip hidden elements which don't have an offsetParent
1450  while (offsetParent === noOffsetParent && element.nextElementSibling) {
1451    offsetParent = (element = element.nextElementSibling).offsetParent;
1452  }
1453
1454  var nodeName = offsetParent && offsetParent.nodeName;
1455
1456  if (!nodeName || nodeName === 'BODY' || nodeName === 'HTML') {
1457    return element ? element.ownerDocument.documentElement : document.documentElement;
1458  }
1459
1460  // .offsetParent will return the closest TH, TD or TABLE in case
1461  // no offsetParent is present, I hate this job...
1462  if (['TH', 'TD', 'TABLE'].indexOf(offsetParent.nodeName) !== -1 && getStyleComputedProperty(offsetParent, 'position') === 'static') {
1463    return getOffsetParent(offsetParent);
1464  }
1465
1466  return offsetParent;
1467}
1468
1469function isOffsetContainer(element) {
1470  var nodeName = element.nodeName;
1471
1472  if (nodeName === 'BODY') {
1473    return false;
1474  }
1475  return nodeName === 'HTML' || getOffsetParent(element.firstElementChild) === element;
1476}
1477
1478/**
1479 * Finds the root node (document, shadowDOM root) of the given element
1480 * @method
1481 * @memberof Popper.Utils
1482 * @argument {Element} node
1483 * @returns {Element} root node
1484 */
1485function getRoot(node) {
1486  if (node.parentNode !== null) {
1487    return getRoot(node.parentNode);
1488  }
1489
1490  return node;
1491}
1492
1493/**
1494 * Finds the offset parent common to the two provided nodes
1495 * @method
1496 * @memberof Popper.Utils
1497 * @argument {Element} element1
1498 * @argument {Element} element2
1499 * @returns {Element} common offset parent
1500 */
1501function findCommonOffsetParent(element1, element2) {
1502  // This check is needed to avoid errors in case one of the elements isn't defined for any reason
1503  if (!element1 || !element1.nodeType || !element2 || !element2.nodeType) {
1504    return document.documentElement;
1505  }
1506
1507  // Here we make sure to give as "start" the element that comes first in the DOM
1508  var order = element1.compareDocumentPosition(element2) & Node.DOCUMENT_POSITION_FOLLOWING;
1509  var start = order ? element1 : element2;
1510  var end = order ? element2 : element1;
1511
1512  // Get common ancestor container
1513  var range = document.createRange();
1514  range.setStart(start, 0);
1515  range.setEnd(end, 0);
1516  var commonAncestorContainer = range.commonAncestorContainer;
1517

1518  // Both nodes are inside #document
1519
1520  if (element1 !== commonAncestorContainer && element2 !== commonAncestorContainer || start.contains(end)) {
1521    if (isOffsetContainer(commonAncestorContainer)) {
1522      return commonAncestorContainer;
1523    }
1524
1525    return getOffsetParent(commonAncestorContainer);
1526  }
1527
1528  // one of the nodes is inside shadowDOM, find which one
1529  var element1root = getRoot(element1);
1530  if (element1root.host) {
1531    return findCommonOffsetParent(element1root.host, element2);
1532  } else {
1533    return findCommonOffsetParent(element1, getRoot(element2).host);
1534  }
1535}
1536
1537/**
1538 * Gets the scroll value of the given element in the given side (top and left)
1539 * @method
1540 * @memberof Popper.Utils
1541 * @argument {Element} element
1542 * @argument {String} side `top` or `left`
1543 * @returns {number} amount of scrolled pixels
1544 */
1545function getScroll(element) {
1546  var side = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'top';
1547
1548  var upperSide = side === 'top' ? 'scrollTop' : 'scrollLeft';
1549  var nodeName = element.nodeName;
1550
1551  if (nodeName === 'BODY' || nodeName === 'HTML') {
1552    var html = element.ownerDocument.documentElement;
1553    var scrollingElement = element.ownerDocument.scrollingElement || html;
1554    return scrollingElement[upperSide];
1555  }
1556
1557  return element[upperSide];
1558}
1559
1560/*
1561 * Sum or subtract the element scroll values (left and top) from a given rect object
1562 * @method
1563 * @memberof Popper.Utils
1564 * @param {Object} rect - Rect object you want to change
1565 * @param {HTMLElement} element - The element from the function reads the scroll values
1566 * @param {Boolean} subtract - set to true if you want to subtract the scroll values
1567 * @return {Object} rect - The modifier rect object
1568 */
1569function includeScroll(rect, element) {
1570  var subtract = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
1571
1572  var scrollTop = getScroll(element, 'top');
1573  var scrollLeft = getScroll(element, 'left');
1574  var modifier = subtract ? -1 : 1;
1575  rect.top += scrollTop * modifier;
1576  rect.bottom += scrollTop * modifier;
1577  rect.left += scrollLeft * modifier;
1578  rect.right += scrollLeft * modifier;
1579  return rect;
1580}
1581
1582/*
1583 * Helper to detect borders of a given element
1584 * @method
1585 * @memberof Popper.Utils
1586 * @param {CSSStyleDeclaration} styles
1587 * Result of `getStyleComputedProperty` on the given element
1588 * @param {String} axis - `x` or `y`
1589 * @return {number} borders - The borders size of the given axis
1590 */
1591
1592function getBordersSize(styles, axis) {
1593  var sideA = axis === 'x' ? 'Left' : 'Top';
1594  var sideB = sideA === 'Left' ? 'Right' : 'Bottom';
1595
1596  return parseFloat(styles['border' + sideA + 'Width']) + parseFloat(styles['border' + sideB + 'Width']);
1597}
1598
1599function getSize(axis, body, html, computedStyle) {
1600  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);
1601}
1602
1603function getWindowSizes(document) {
1604  var body = document.body;
1605  var html = document.documentElement;
1606  var computedStyle = isIE(10) && getComputedStyle(html);
1607
1608  return {
1609    height: getSize('Height', body, html, computedStyle),
1610    width: getSize('Width', body, html, computedStyle)
1611  };
1612}
1613
1614var classCallCheck = function (instance, Constructor) {
1615  if (!(instance instanceof Constructor)) {
1616    throw new TypeError("Cannot call a class as a function");
1617  }
1618};
1619
1620var createClass = function () {
1621  function defineProperties(target, props) {
1622    for (var i = 0; i < props.length; i++) {
1623      var descriptor = props[i];
1624      descriptor.enumerable = descriptor.enumerable || false;
1625      descriptor.configurable = true;
1626      if ("value" in descriptor) descriptor.writable = true;
1627      Object.defineProperty(target, descriptor.key, descriptor);
1628    }
1629  }
1630
1631  return function (Constructor, protoProps, staticProps) {
1632    if (protoProps) defineProperties(Constructor.prototype, protoProps);
1633    if (staticProps) defineProperties(Constructor, staticProps);
1634    return Constructor;
1635  };
1636}();
1637
1638
1639
1640
1641
1642var defineProperty = function (obj, key, value) {
1643  if (key in obj) {
1644    Object.defineProperty(obj, key, {
1645      value: value,
1646      enumerable: true,
1647      configurable: true,
1648      writable: true
1649    });
1650  } else {
1651    obj[key] = value;
1652  }
1653
1654  return obj;
1655};
1656
1657var _extends = Object.assign || function (target) {
1658  for (var i = 1; i < arguments.length; i++) {
1659    var source = arguments[i];
1660
1661    for (var key in source) {
1662      if (Object.prototype.hasOwnProperty.call(source, key)) {
1663        target[key] = source[key];
1664      }
1665    }
1666  }
1667
1668  return target;
1669};
1670
1671/**
1672 * Given element offsets, generate an output similar to getBoundingClientRect
1673 * @method
1674 * @memberof Popper.Utils
1675 * @argument {Object} offsets
1676 * @returns {Object} ClientRect like output
1677 */
1678function getClientRect(offsets) {
1679  return _extends({}, offsets, {
1680    right: offsets.left + offsets.width,
1681    bottom: offsets.top + offsets.height
1682  });
1683}
1684
1685/**
1686 * Get bounding client rect of given element
1687 * @method
1688 * @memberof Popper.Utils
1689 * @param {HTMLElement} element
1690 * @return {Object} client rect
1691 */
1692function getBoundingClientRect(element) {
1693  var rect = {};
1694
1695  // IE10 10 FIX: Please, don't ask, the element isn't

1696  // considered in DOM in some circumstances...
1697  // This isn't reproducible in IE10 compatibility mode of IE11
1698  try {
1699    if (isIE(10)) {
1700      rect = element.getBoundingClientRect();
1701      var scrollTop = getScroll(element, 'top');
1702      var scrollLeft = getScroll(element, 'left');
1703      rect.top += scrollTop;
1704      rect.left += scrollLeft;
1705      rect.bottom += scrollTop;
1706      rect.right += scrollLeft;
1707    } else {
1708      rect = element.getBoundingClientRect();
1709    }
1710  } catch (e) {}
1711
1712  var result = {
1713    left: rect.left,
1714    top: rect.top,
1715    width: rect.right - rect.left,
1716    height: rect.bottom - rect.top
1717  };
1718
1719  // subtract scrollbar size from sizes
1720  var sizes = element.nodeName === 'HTML' ? getWindowSizes(element.ownerDocument) : {};
1721  var width = sizes.width || element.clientWidth || result.width;
1722  var height = sizes.height || element.clientHeight || result.height;
1723
1724  var horizScrollbar = element.offsetWidth - width;
1725  var vertScrollbar = element.offsetHeight - height;
1726
1727  // if an hypothetical scrollbar is detected, we must be sure it's not a `border`
1728  // we make this check conditional for performance reasons
1729  if (horizScrollbar || vertScrollbar) {
1730    var styles = getStyleComputedProperty(element);
1731    horizScrollbar -= getBordersSize(styles, 'x');
1732    vertScrollbar -= getBordersSize(styles, 'y');
1733
1734    result.width -= horizScrollbar;
1735    result.height -= vertScrollbar;
1736  }
1737
1738  return getClientRect(result);
1739}
1740
1741function getOffsetRectRelativeToArbitraryNode(children, parent) {
1742  var fixedPosition = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
1743
1744  var isIE10 = isIE(10);
1745  var isHTML = parent.nodeName === 'HTML';
1746  var childrenRect = getBoundingClientRect(children);
1747  var parentRect = getBoundingClientRect(parent);
1748  var scrollParent = getScrollParent(children);
1749
1750  var styles = getStyleComputedProperty(parent);
1751  var borderTopWidth = parseFloat(styles.borderTopWidth);
1752  var borderLeftWidth = parseFloat(styles.borderLeftWidth);
1753
1754  // In cases where the parent is fixed, we must ignore negative scroll in offset calc
1755  if (fixedPosition && isHTML) {
1756    parentRect.top = Math.max(parentRect.top, 0);
1757    parentRect.left = Math.max(parentRect.left, 0);
1758  }
1759  var offsets = getClientRect({
1760    top: childrenRect.top - parentRect.top - borderTopWidth,
1761    left: childrenRect.left - parentRect.left - borderLeftWidth,
1762    width: childrenRect.width,
1763    height: childrenRect.height
1764  });
1765  offsets.marginTop = 0;
1766  offsets.marginLeft = 0;
1767
1768  // Subtract margins of documentElement in case it's being used as parent
1769  // we do this only on HTML because it's the only element that behaves
1770  // differently when margins are applied to it. The margins are included in
1771  // the box of the documentElement, in the other cases not.
1772  if (!isIE10 && isHTML) {
1773    var marginTop = parseFloat(styles.marginTop);
1774    var marginLeft = parseFloat(styles.marginLeft);
1775
1776    offsets.top -= borderTopWidth - marginTop;
1777    offsets.bottom -= borderTopWidth - marginTop;
1778    offsets.left -= borderLeftWidth - marginLeft;
1779    offsets.right -= borderLeftWidth - marginLeft;
1780
1781    // Attach marginTop and marginLeft because in some circumstances we may need them
1782    offsets.marginTop = marginTop;
1783    offsets.marginLeft = marginLeft;
1784  }
1785
1786  if (isIE10 && !fixedPosition ? parent.contains(scrollParent) : parent === scrollParent && scrollParent.nodeName !== 'BODY') {
1787    offsets = includeScroll(offsets, parent);
1788  }
1789
1790  return offsets;
1791}
1792
1793function getViewportOffsetRectRelativeToArtbitraryNode(element) {
1794  var excludeScroll = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
1795
1796  var html = element.ownerDocument.documentElement;
1797  var relativeOffset = getOffsetRectRelativeToArbitraryNode(element, html);
1798  var width = Math.max(html.clientWidth, window.innerWidth || 0);
1799  var height = Math.max(html.clientHeight, window.innerHeight || 0);
1800
1801  var scrollTop = !excludeScroll ? getScroll(html) : 0;
1802  var scrollLeft = !excludeScroll ? getScroll(html, 'left') : 0;
1803
1804  var offset = {
1805    top: scrollTop - relativeOffset.top + relativeOffset.marginTop,
1806    left: scrollLeft - relativeOffset.left + relativeOffset.marginLeft,
1807    width: width,
1808    height: height
1809  };
1810
1811  return getClientRect(offset);
1812}
1813
1814/**
1815 * Check if the given element is fixed or is inside a fixed parent
1816 * @method
1817 * @memberof Popper.Utils
1818 * @argument {Element} element
1819 * @argument {Element} customContainer
1820 * @returns {Boolean} answer to "isFixed?"
1821 */
1822function isFixed(element) {
1823  var nodeName = element.nodeName;
1824  if (nodeName === 'BODY' || nodeName === 'HTML') {
1825    return false;

1826  }
1827  if (getStyleComputedProperty(element, 'position') === 'fixed') {
1828    return true;
1829  }
1830  var parentNode = getParentNode(element);
1831  if (!parentNode) {
1832    return false;
1833  }
1834  return isFixed(parentNode);
1835}
1836
1837/**
1838 * Finds the first parent of an element that has a transformed property defined
1839 * @method
1840 * @memberof Popper.Utils
1841 * @argument {Element} element
1842 * @returns {Element} first transformed parent or documentElement
1843 */
1844
1845function getFixedPositionOffsetParent(element) {
1846  // This check is needed to avoid errors in case one of the elements isn't defined for any reason
1847  if (!element || !element.parentElement || isIE()) {
1848    return document.documentElement;
1849  }
1850  var el = element.parentElement;
1851  while (el && getStyleComputedProperty(el, 'transform') === 'none') {
1852    el = el.parentElement;
1853  }
1854  return el || document.documentElement;
1855}
1856
1857/**
1858 * Computed the boundaries limits and return them
1859 * @method
1860 * @memberof Popper.Utils
1861 * @param {HTMLElement} popper
1862 * @param {HTMLElement} reference
1863 * @param {number} padding
1864 * @param {HTMLElement} boundariesElement - Element used to define the boundaries
1865 * @param {Boolean} fixedPosition - Is in fixed position mode
1866 * @returns {Object} Coordinates of the boundaries
1867 */
1868function getBoundaries(popper, reference, padding, boundariesElement) {
1869  var fixedPosition = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
1870
1871  // NOTE: 1 DOM access here
1872
1873  var boundaries = { top: 0, left: 0 };
1874  var offsetParent = fixedPosition ? getFixedPositionOffsetParent(popper) : findCommonOffsetParent(popper, getReferenceNode(reference));
1875
1876  // Handle viewport case
1877  if (boundariesElement === 'viewport') {
1878    boundaries = getViewportOffsetRectRelativeToArtbitraryNode(offsetParent, fixedPosition);
1879  } else {
1880    // Handle other cases based on DOM element used as boundaries
1881    var boundariesNode = void 0;
1882    if (boundariesElement === 'scrollParent') {
1883      boundariesNode = getScrollParent(getParentNode(reference));
1884      if (boundariesNode.nodeName === 'BODY') {
1885        boundariesNode = popper.ownerDocument.documentElement;
1886      }
1887    } else if (boundariesElement === 'window') {
1888      boundariesNode = popper.ownerDocument.documentElement;
1889    } else {
1890      boundariesNode = boundariesElement;
1891    }
1892
1893    var offsets = getOffsetRectRelativeToArbitraryNode(boundariesNode, offsetParent, fixedPosition);
1894
1895    // In case of HTML, we need a different computation
1896    if (boundariesNode.nodeName === 'HTML' && !isFixed(offsetParent)) {
1897      var _getWindowSizes = getWindowSizes(popper.ownerDocument),
1898          height = _getWindowSizes.height,
1899          width = _getWindowSizes.width;
1900
1901      boundaries.top += offsets.top - offsets.marginTop;
1902      boundaries.bottom = height + offsets.top;
1903      boundaries.left += offsets.left - offsets.marginLeft;
1904      boundaries.right = width + offsets.left;
1905    } else {
1906      // for all the other DOM elements, this one is good
1907      boundaries = offsets;
1908    }
1909  }
1910
1911  // Add paddings
1912  padding = padding || 0;
1913  var isPaddingNumber = typeof padding === 'number';
1914  boundaries.left += isPaddingNumber ? padding : padding.left || 0;
1915  boundaries.top += isPaddingNumber ? padding : padding.top || 0;
1916  boundaries.right -= isPaddingNumber ? padding : padding.right || 0;
1917  boundaries.bottom -= isPaddingNumber ? padding : padding.bottom || 0;
1918
1919  return boundaries;
1920}
1921
1922function getArea(_ref) {
1923  var width = _ref.width,
1924      height = _ref.height;
1925
1926  return width * height;
1927}
1928
1929/**
1930 * Utility used to transform the `auto` placement to the placement with more
1931 * available space.
1932 * @method
1933 * @memberof Popper.Utils
1934 * @argument {Object} data - The data object generated by update method
1935 * @argument {Object} options - Modifiers configuration and options
1936 * @returns {Object} The data object, properly modified
1937 */
1938function computeAutoPlacement(placement, refRect, popper, reference, boundariesElement) {
1939  var padding = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 0;
1940
1941  if (placement.indexOf('auto') === -1) {
1942    return placement;
1943  }
1944
1945  var boundaries = getBoundaries(popper, reference, padding, boundariesElement);
1946
1947  var rects = {
1948    top: {
1949      width: boundaries.width,
1950      height: refRect.top - boundaries.top
1951    },
1952    right: {
1953      width: boundaries.right - refRect.right,
1954      height: boundaries.height
1955    },
1956    bottom: {
1957      width: boundaries.width,
1958      height: boundaries.bottom - refRect.bottom
1959    },
1960    left: {
1961      width: refRect.left - boundaries.left,
1962      height: boundaries.height
1963    }
1964  };
1965
1966  var sortedAreas = Object.keys(rects).map(function (key) {
1967    return _extends({
1968      key: key
1969    }, rects[key], {
1970      area: getArea(rects[key])
1971    });
1972  }).sort(function (a, b) {
1973    return b.area - a.area;
1974  });
1975
1976  var filteredAreas = sortedAreas.filter(function (_ref2) {
1977    var width = _ref2.width,
1978        height = _ref2.height;
1979    return width >= popper.clientWidth && height >= popper.clientHeight;
1980  });
1981
1982  var computedPlacement = filteredAreas.length > 0 ? filteredAreas[0].key : sortedAreas[0].key;
1983
1984  var variation = placement.split('-')[1];
1985
1986  return computedPlacement + (variation ? '-' + variation : '');
1987}
1988
1989/**
1990 * Get offsets to the reference element
1991 * @method
1992 * @memberof Popper.Utils
1993 * @param {Object} state
1994 * @param {Element} popper - the popper element
1995 * @param {Element} reference - the reference element (the popper will be relative to this)
1996 * @param {Element} fixedPosition - is in fixed position mode
1997 * @returns {Object} An object containing the offsets which will be applied to the popper
1998 */
1999function getReferenceOffsets(state, popper, reference) {
2000  var fixedPosition = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
2001
2002  var commonOffsetParent = fixedPosition ? getFixedPositionOffsetParent(popper) : findCommonOffsetParent(popper, getReferenceNode(reference));
2003  return getOffsetRectRelativeToArbitraryNode(reference, commonOffsetParent, fixedPosition);
2004}
2005
2006/**
2007 * Get the outer sizes of the given element (offset size + margins)
2008 * @method
2009 * @memberof Popper.Utils
2010 * @argument {Element} element
2011 * @returns {Object} object containing width and height properties
2012 */
2013function getOuterSizes(element) {
2014  var window = element.ownerDocument.defaultView;
2015  var styles = window.getComputedStyle(element);
2016  var x = parseFloat(styles.marginTop || 0) + parseFloat(styles.marginBottom || 0);
2017  var y = parseFloat(styles.marginLeft || 0) + parseFloat(styles.marginRight || 0);
2018  var result = {
2019    width: element.offsetWidth + y,
2020    height: element.offsetHeight + x
2021  };
2022  return result;
2023}
2024
2025/**
2026 * Get the opposite placement of the given one
2027 * @method
2028 * @memberof Popper.Utils
2029 * @argument {String} placement
2030 * @returns {String} flipped placement
2031 */
2032function getOppositePlacement(placement) {
2033  var hash = { left: 'right', right: 'left', bottom: 'top', top: 'bottom' };
2034  return placement.replace(/left|right|bottom|top/g, function (matched) {
2035    return hash[matched];
2036  });
2037}
2038
2039/**
2040 * Get offsets to the popper
2041 * @method
2042 * @memberof Popper.Utils
2043 * @param {Object} position - CSS position the Popper will get applied
2044 * @param {HTMLElement} popper - the popper element
2045 * @param {Object} referenceOffsets - the reference offsets (the popper will be relative to this)
2046 * @param {String} placement - one of the valid placement options
2047 * @returns {Object} popperOffsets - An object containing the offsets which will be applied to the popper
2048 */
2049function getPopperOffsets(popper, referenceOffsets, placement) {
2050  placement = placement.split('-')[0];
2051
2052  // Get popper node sizes
2053  var popperRect = getOuterSizes(popper);
2054
2055  // Add position, width and height to our offsets object
2056  var popperOffsets = {
2057    width: popperRect.width,
2058    height: popperRect.height
2059  };
2060
2061  // depending by the popper placement we have to compute its offsets slightly differently
2062  var isHoriz = ['right', 'left'].indexOf(placement) !== -1;
2063  var mainSide = isHoriz ? 'top' : 'left';
2064  var secondarySide = isHoriz ? 'left' : 'top';
2065  var measurement = isHoriz ? 'height' : 'width';
2066  var secondaryMeasurement = !isHoriz ? 'height' : 'width';
2067
2068  popperOffsets[mainSide] = referenceOffsets[mainSide] + referenceOffsets[measurement] / 2 - popperRect[measurement] / 2;
2069  if (placement === secondarySide) {
2070    popperOffsets[secondarySide] = referenceOffsets[secondarySide] - popperRect[secondaryMeasurement];
2071  } else {
2072    popperOffsets[secondarySide] = referenceOffsets[getOppositePlacement(secondarySide)];
2073  }
2074
2075  return popperOffsets;
2076}
2077
2078/**
2079 * Mimics the `find` method of Array
2080 * @method
2081 * @memberof Popper.Utils
2082 * @argument {Array} arr
2083 * @argument prop
2084 * @argument value
2085 * @returns index or -1
2086 */
2087function find(arr, check) {
2088  // use native find if supported
2089  if (Array.prototype.find) {
2090    return arr.find(check);
2091  }
2092
2093  // use `filter` to obtain the same behavior of `find`
2094  return arr.filter(check)[0];
2095}
2096
2097/**
2098 * Return the index of the matching object
2099 * @method
2100 * @memberof Popper.Utils
2101 * @argument {Array} arr
2102 * @argument prop
2103 * @argument value
2104 * @returns index or -1
2105 */
2106function findIndex(arr, prop, value) {
2107  // use native findIndex if supported
2108  if (Array.prototype.findIndex) {
2109    return arr.findIndex(function (cur) {
2110      return cur[prop] === value;
2111    });
2112  }
2113
2114  // use `find` + `indexOf` if `findIndex` isn't supported
2115  var match = find(arr, function (obj) {
2116    return obj[prop] === value;
2117  });
2118  return arr.indexOf(match);
2119}
2120
2121/**
2122 * Loop trough the list of modifiers and run them in order,
2123 * each of them will then edit the data object.
2124 * @method
2125 * @memberof Popper.Utils
2126 * @param {dataObject} data
2127 * @param {Array} modifiers
2128 * @param {String} ends - Optional modifier name used as stopper
2129 * @returns {dataObject}
2130 */
2131function runModifiers(modifiers, data, ends) {
2132  var modifiersToRun = ends === undefined ? modifiers : modifiers.slice(0, findIndex(modifiers, 'name', ends));
2133
2134  modifiersToRun.forEach(function (modifier) {
2135    if (modifier['function']) {
2136      // eslint-disable-line dot-notation
2137      console.warn('`modifier.function` is deprecated, use `modifier.fn`!');
2138    }
2139    var fn = modifier['function'] || modifier.fn; // eslint-disable-line dot-notation
2140    if (modifier.enabled && isFunction(fn)) {
2141      // Add properties to offsets to make them a complete clientRect object
2142      // we do this before each modifier to make sure the previous one doesn't
2143      // mess with these values
2144      data.offsets.popper = getClientRect(data.offsets.popper);
2145      data.offsets.reference = getClientRect(data.offsets.reference);
2146
2147      data = fn(data, modifier);
2148    }
2149  });
2150
2151  return data;
2152}
2153
2154/**
2155 * Updates the position of the popper, computing the new offsets and applying
2156 * the new style.<br />
2157 * Prefer `scheduleUpdate` over `update` because of performance reasons.
2158 * @method
2159 * @memberof Popper
2160 */
2161function update() {
2162  // if popper is destroyed, don't perform any further update
2163  if (this.state.isDestroyed) {
2164    return;
2165  }
2166
2167  var data = {
2168    instance: this,
2169    styles: {},
2170    arrowStyles: {},
2171    attributes: {},
2172    flipped: false,
2173    offsets: {}
2174  };
2175
2176  // compute reference element offsets
2177  data.offsets.reference = getReferenceOffsets(this.state, this.popper, this.reference, this.options.positionFixed);
2178
2179  // compute auto placement, store placement inside the data object,
2180  // modifiers will be able to edit `placement` if needed
2181  // and refer to originalPlacement to know the original value
2182  data.placement = computeAutoPlacement(this.options.placement, data.offsets.reference, this.popper, this.reference, this.options.modifiers.flip.boundariesElement, this.options.modifiers.flip.padding);
2183
2184  // store the computed placement inside `originalPlacement`
2185  data.originalPlacement = data.placement;
2186
2187  data.positionFixed = this.options.positionFixed;
2188
2189  // compute the popper offsets
2190  data.offsets.popper = getPopperOffsets(this.popper, data.offsets.reference, data.placement);
2191
2192  data.offsets.popper.position = this.options.positionFixed ? 'fixed' : 'absolute';
2193
2194  // run the modifiers
2195  data = runModifiers(this.modifiers, data);
2196
2197  // the first `update` will call `onCreate` callback
2198  // the other ones will call `onUpdate` callback
2199  if (!this.state.isCreated) {
2200    this.state.isCreated = true;
2201    this.options.onCreate(data);
2202  } else {
2203    this.options.onUpdate(data);
2204  }
2205}
2206
2207/**
2208 * Helper used to know if the given modifier is enabled.
2209 * @method
2210 * @memberof Popper.Utils
2211 * @returns {Boolean}
2212 */
2213function isModifierEnabled(modifiers, modifierName) {
2214  return modifiers.some(function (_ref) {
2215    var name = _ref.name,
2216        enabled = _ref.enabled;
2217    return enabled && name === modifierName;
2218  });
2219}
2220
2221/**
2222 * Get the prefixed supported property name
2223 * @method
2224 * @memberof Popper.Utils
2225 * @argument {String} property (camelCase)
2226 * @returns {String} prefixed property (camelCase or PascalCase, depending on the vendor prefix)
2227 */
2228function getSupportedPropertyName(property) {
2229  var prefixes = [false, 'ms', 'Webkit', 'Moz', 'O'];
2230  var upperProp = property.charAt(0).toUpperCase() + property.slice(1);
2231
2232  for (var i = 0; i < prefixes.length; i++) {
2233    var prefix = prefixes[i];
2234    var toCheck = prefix ? '' + prefix + upperProp : property;
2235    if (typeof document.body.style[toCheck] !== 'undefined') {
2236      return toCheck;
2237    }
2238  }
2239  return null;
2240}
2241
2242/**
2243 * Destroys the popper.
2244 * @method
2245 * @memberof Popper
2246 */
2247function destroy() {
2248  this.state.isDestroyed = true;
2249
2250  // touch DOM only if `applyStyle` modifier is enabled
2251  if (isModifierEnabled(this.modifiers, 'applyStyle')) {
2252    this.popper.removeAttribute('x-placement');
2253    this.popper.style.position = '';
2254    this.popper.style.top = '';
2255    this.popper.style.left = '';
2256    this.popper.style.right = '';
2257    this.popper.style.bottom = '';
2258    this.popper.style.willChange = '';
2259    this.popper.style[getSupportedPropertyName('transform')] = '';
2260  }
2261
2262  this.disableEventListeners();
2263
2264  // remove the popper if user explicitly asked for the deletion on destroy
2265  // do not use `remove` because IE11 doesn't support it
2266  if (this.options.removeOnDestroy) {
2267    this.popper.parentNode.removeChild(this.popper);
2268  }
2269  return this;
2270}
2271
2272/**
2273 * Get the window associated with the element
2274 * @argument {Element} element
2275 * @returns {Window}
2276 */
2277function getWindow(element) {
2278  var ownerDocument = element.ownerDocument;
2279  return ownerDocument ? ownerDocument.defaultView : window;
2280}
2281
2282function attachToScrollParents(scrollParent, event, callback, scrollParents) {
2283  var isBody = scrollParent.nodeName === 'BODY';
2284  var target = isBody ? scrollParent.ownerDocument.defaultView : scrollParent;
2285  target.addEventListener(event, callback, { passive: true });
2286
2287  if (!isBody) {
2288    attachToScrollParents(getScrollParent(target.parentNode), event, callback, scrollParents);
2289  }
2290  scrollParents.push(target);
2291}
2292
2293/**
2294 * Setup needed event listeners used to update the popper position
2295 * @method
2296 * @memberof Popper.Utils
2297 * @private
2298 */
2299function setupEventListeners(reference, options, state, updateBound) {
2300  // Resize event listener on window
2301  state.updateBound = updateBound;
2302  getWindow(reference).addEventListener('resize', state.updateBound, { passive: true });
2303
2304  // Scroll event listener on scroll parents
2305  var scrollElement = getScrollParent(reference);
2306  attachToScrollParents(scrollElement, 'scroll', state.updateBound, state.scrollParents);
2307  state.scrollElement = scrollElement;
2308  state.eventsEnabled = true;
2309
2310  return state;
2311}
2312
2313/**
2314 * It will add resize/scroll events and start recalculating
2315 * position of the popper element when they are triggered.
2316 * @method
2317 * @memberof Popper
2318 */
2319function enableEventListeners() {
2320  if (!this.state.eventsEnabled) {
2321    this.state = setupEventListeners(this.reference, this.options, this.state, this.scheduleUpdate);
2322  }
2323}
2324
2325/**
2326 * Remove event listeners used to update the popper position
2327 * @method
2328 * @memberof Popper.Utils
2329 * @private
2330 */
2331function removeEventListeners(reference, state) {
2332  // Remove resize event listener on window
2333  getWindow(reference).removeEventListener('resize', state.updateBound);
2334
2335  // Remove scroll event listener on scroll parents

2336  state.scrollParents.forEach(function (target) {
2337    target.removeEventListener('scroll', state.updateBound);
2338  });
2339
2340  // Reset state
2341  state.updateBound = null;
2342  state.scrollParents = [];
2343  state.scrollElement = null;
2344  state.eventsEnabled = false;
2345  return state;
2346}
2347
2348/**
2349 * It will remove resize/scroll events and won't recalculate popper position
2350 * when they are triggered. It also won't trigger `onUpdate` callback anymore,
2351 * unless you call `update` method manually.
2352 * @method
2353 * @memberof Popper
2354 */
2355function disableEventListeners() {
2356  if (this.state.eventsEnabled) {
2357    cancelAnimationFrame(this.scheduleUpdate);
2358    this.state = removeEventListeners(this.reference, this.state);
2359  }
2360}
2361
2362/**
2363 * Tells if a given input is a number
2364 * @method
2365 * @memberof Popper.Utils
2366 * @param {*} input to check
2367 * @return {Boolean}
2368 */
2369function isNumeric(n) {
2370  return n !== '' && !isNaN(parseFloat(n)) && isFinite(n);
2371}
2372
2373/**
2374 * Set the style to the given popper
2375 * @method
2376 * @memberof Popper.Utils
2377 * @argument {Element} element - Element to apply the style to
2378 * @argument {Object} styles
2379 * Object with a list of properties and values which will be applied to the element
2380 */
2381function setStyles(element, styles) {
2382  Object.keys(styles).forEach(function (prop) {
2383    var unit = '';
2384    // add unit if the value is numeric and is one of the following
2385    if (['width', 'height', 'top', 'right', 'bottom', 'left'].indexOf(prop) !== -1 && isNumeric(styles[prop])) {
2386      unit = 'px';
2387    }
2388    element.style[prop] = styles[prop] + unit;
2389  });
2390}
2391
2392/**
2393 * Set the attributes to the given popper
2394 * @method
2395 * @memberof Popper.Utils
2396 * @argument {Element} element - Element to apply the attributes to
2397 * @argument {Object} styles
2398 * Object with a list of properties and values which will be applied to the element
2399 */
2400function setAttributes(element, attributes) {
2401  Object.keys(attributes).forEach(function (prop) {
2402    var value = attributes[prop];
2403    if (value !== false) {
2404      element.setAttribute(prop, attributes[prop]);
2405    } else {
2406      element.removeAttribute(prop);
2407    }
2408  });
2409}
2410
2411/**
2412 * @function
2413 * @memberof Modifiers
2414 * @argument {Object} data - The data object generated by `update` method
2415 * @argument {Object} data.styles - List of style properties - values to apply to popper element
2416 * @argument {Object} data.attributes - List of attribute properties - values to apply to popper element
2417 * @argument {Object} options - Modifiers configuration and options
2418 * @returns {Object} The same data object
2419 */
2420function applyStyle(data) {
2421  // any property present in `data.styles` will be applied to the popper,
2422  // in this way we can make the 3rd party modifiers add custom styles to it
2423  // Be aware, modifiers could override the properties defined in the previous
2424  // lines of this modifier!
2425  setStyles(data.instance.popper, data.styles);
2426
2427  // any property present in `data.attributes` will be applied to the popper,
2428  // they will be set as HTML attributes of the element
2429  setAttributes(data.instance.popper, data.attributes);
2430
2431  // if arrowElement is defined and arrowStyles has some properties
2432  if (data.arrowElement && Object.keys(data.arrowStyles).length) {
2433    setStyles(data.arrowElement, data.arrowStyles);
2434  }
2435
2436  return data;
2437}
2438
2439/**
2440 * Set the x-placement attribute before everything else because it could be used
2441 * to add margins to the popper margins needs to be calculated to get the
2442 * correct popper offsets.
2443 * @method
2444 * @memberof Popper.modifiers
2445 * @param {HTMLElement} reference - The reference element used to position the popper
2446 * @param {HTMLElement} popper - The HTML element used as popper
2447 * @param {Object} options - Popper.js options
2448 */
2449function applyStyleOnLoad(reference, popper, options, modifierOptions, state) {
2450  // compute reference element offsets
2451  var referenceOffsets = getReferenceOffsets(state, popper, reference, options.positionFixed);
2452
2453  // compute auto placement, store placement inside the data object,
2454  // modifiers will be able to edit `placement` if needed
2455  // and refer to originalPlacement to know the original value
2456  var placement = computeAutoPlacement(options.placement, referenceOffsets, popper, reference, options.modifiers.flip.boundariesElement, options.modifiers.flip.padding);
2457
2458  popper.setAttribute('x-placement', placement);
2459
2460  // Apply `position` to popper before anything else because
2461  // without the position applied we can't guarantee correct computations
2462  setStyles(popper, { position: options.positionFixed ? 'fixed' : 'absolute' });
2463
2464  return options;
2465}
2466
2467/**
2468 * @function
2469 * @memberof Popper.Utils
2470 * @argument {Object} data - The data object generated by `update` method
2471 * @argument {Boolean} shouldRound - If the offsets should be rounded at all
2472 * @returns {Object} The popper's position offsets rounded
2473 *
2474 * The tale of pixel-perfect positioning. It's still not 100% perfect, but as
2475 * good as it can be within reason.
2476 * Discussion here: https://github.com/FezVrasta/popper.js/pull/715
2477 *
2478 * Low DPI screens cause a popper to be blurry if not using full pixels (Safari
2479 * as well on High DPI screens).
2480 *
2481 * Firefox prefers no rounding for positioning and does not have blurriness on
2482 * high DPI screens.
2483 *
2484 * Only horizontal placement and left/right values need to be considered.
2485 */
2486function getRoundedOffsets(data, shouldRound) {
2487  var _data$offsets = data.offsets,
2488      popper = _data$offsets.popper,
2489      reference = _data$offsets.reference;
2490  var round = Math.round,
2491      floor = Math.floor;
2492
2493  var noRound = function noRound(v) {
2494    return v;
2495  };
2496
2497  var referenceWidth = round(reference.width);
2498  var popperWidth = round(popper.width);
2499
2500  var isVertical = ['left', 'right'].indexOf(data.placement) !== -1;
2501  var isVariation = data.placement.indexOf('-') !== -1;
2502  var sameWidthParity = referenceWidth % 2 === popperWidth % 2;
2503  var bothOddWidth = referenceWidth % 2 === 1 && popperWidth % 2 === 1;
2504
2505  var horizontalToInteger = !shouldRound ? noRound : isVertical || isVariation || sameWidthParity ? round : floor;
2506  var verticalToInteger = !shouldRound ? noRound : round;
2507
2508  return {
2509    left: horizontalToInteger(bothOddWidth && !isVariation && shouldRound ? popper.left - 1 : popper.left),
2510    top: verticalToInteger(popper.top),
2511    bottom: verticalToInteger(popper.bottom),
2512    right: horizontalToInteger(popper.right)
2513  };
2514}
2515
2516var isFirefox = isBrowser && /Firefox/i.test(navigator.userAgent);
2517
2518/**
2519 * @function
2520 * @memberof Modifiers
2521 * @argument {Object} data - The data object generated by `update` method
2522 * @argument {Object} options - Modifiers configuration and options
2523 * @returns {Object} The data object, properly modified
2524 */
2525function computeStyle(data, options) {
2526  var x = options.x,
2527      y = options.y;
2528  var popper = data.offsets.popper;
2529
2530  // Remove this legacy support in Popper.js v2
2531
2532  var legacyGpuAccelerationOption = find(data.instance.modifiers, function (modifier) {
2533    return modifier.name === 'applyStyle';
2534  }).gpuAcceleration;
2535  if (legacyGpuAccelerationOption !== undefined) {
2536    console.warn('WARNING: `gpuAcceleration` option moved to `computeStyle` modifier and will not be supported in future versions of Popper.js!');
2537  }
2538  var gpuAcceleration = legacyGpuAccelerationOption !== undefined ? legacyGpuAccelerationOption : options.gpuAcceleration;
2539
2540  var offsetParent = getOffsetParent(data.instance.popper);
2541  var offsetParentRect = getBoundingClientRect(offsetParent);
2542
2543  // Styles
2544  var styles = {
2545    position: popper.position
2546  };
2547
2548  var offsets = getRoundedOffsets(data, window.devicePixelRatio < 2 || !isFirefox);
2549
2550  var sideA = x === 'bottom' ? 'top' : 'bottom';
2551  var sideB = y === 'right' ? 'left' : 'right';
2552
2553  // if gpuAcceleration is set to `true` and transform is supported,
2554  //  we use `translate3d` to apply the position to the popper we
2555  // automatically use the supported prefixed version if needed
2556  var prefixedProperty = getSupportedPropertyName('transform');
2557
2558  // now, let's make a step back and look at this code closely (wtf?)
2559  // If the content of the popper grows once it's been positioned, it
2560  // may happen that the popper gets misplaced because of the new content
2561  // overflowing its reference element
2562  // To avoid this problem, we provide two options (x and y), which allow
2563  // the consumer to define the offset origin.
2564  // If we position a popper on top of a reference element, we can set
2565  // `x` to `top` to make the popper grow towards its top instead of
2566  // its bottom.
2567  var left = void 0,
2568      top = void 0;
2569  if (sideA === 'bottom') {
2570    // when offsetParent is <html> the positioning is relative to the bottom of the screen (excluding the scrollbar)
2571    // and not the bottom of the html element
2572    if (offsetParent.nodeName === 'HTML') {
2573      top = -offsetParent.clientHeight + offsets.bottom;
2574    } else {
2575      top = -offsetParentRect.height + offsets.bottom;
2576    }
2577  } else {
2578    top = offsets.top;
2579  }
2580  if (sideB === 'right') {
2581    if (offsetParent.nodeName === 'HTML') {
2582      left = -offsetParent.clientWidth + offsets.right;
2583    } else {
2584      left = -offsetParentRect.width + offsets.right;
2585    }
2586  } else {
2587    left = offsets.left;
2588  }
2589  if (gpuAcceleration && prefixedProperty) {
2590    styles[prefixedProperty] = 'translate3d(' + left + 'px, ' + top + 'px, 0)';
2591    styles[sideA] = 0;
2592    styles[sideB] = 0;
2593    styles.willChange = 'transform';
2594  } else {
2595    // othwerise, we use the standard `top`, `left`, `bottom` and `right` properties
2596    var invertTop = sideA === 'bottom' ? -1 : 1;
2597    var invertLeft = sideB === 'right' ? -1 : 1;
2598    styles[sideA] = top * invertTop;
2599    styles[sideB] = left * invertLeft;
2600    styles.willChange = sideA + ', ' + sideB;
2601  }
2602
2603  // Attributes
2604  var attributes = {
2605    'x-placement': data.placement
2606  };
2607
2608  // Update `data` attributes, styles and arrowStyles
2609  data.attributes = _extends({}, attributes, data.attributes);
2610  data.styles = _extends({}, styles, data.styles);
2611  data.arrowStyles = _extends({}, data.offsets.arrow, data.arrowStyles);
2612
2613  return data;
2614}
2615
2616/**
2617 * Helper used to know if the given modifier depends from another one.<br />
2618 * It checks if the needed modifier is listed and enabled.
2619 * @method
2620 * @memberof Popper.Utils
2621 * @param {Array} modifiers - list of modifiers
2622 * @param {String} requestingName - name of requesting modifier
2623 * @param {String} requestedName - name of requested modifier
2624 * @returns {Boolean}
2625 */
2626function isModifierRequired(modifiers, requestingName, requestedName) {
2627  var requesting = find(modifiers, function (_ref) {
2628    var name = _ref.name;
2629    return name === requestingName;
2630  });
2631
2632  var isRequired = !!requesting && modifiers.some(function (modifier) {
2633    return modifier.name === requestedName && modifier.enabled && modifier.order < requesting.order;
2634  });
2635
2636  if (!isRequired) {
2637    var _requesting = '`' + requestingName + '`';
2638    var requested = '`' + requestedName + '`';
2639    console.warn(requested + ' modifier is required by ' + _requesting + ' modifier in order to work, be sure to include it before ' + _requesting + '!');
2640  }
2641  return isRequired;
2642}
2643
2644/**
2645 * @function
2646 * @memberof Modifiers
2647 * @argument {Object} data - The data object generated by update method
2648 * @argument {Object} options - Modifiers configuration and options
2649 * @returns {Object} The data object, properly modified
2650 */
2651function arrow(data, options) {
2652  var _data$offsets$arrow;
2653
2654  // arrow depends on keepTogether in order to work
2655  if (!isModifierRequired(data.instance.modifiers, 'arrow', 'keepTogether')) {
2656    return data;
2657  }
2658
2659  var arrowElement = options.element;
2660
2661  // if arrowElement is a string, suppose it's a CSS selector
2662  if (typeof arrowElement === 'string') {
2663    arrowElement = data.instance.popper.querySelector(arrowElement);
2664
2665    // if arrowElement is not found, don't run the modifier
2666    if (!arrowElement) {
2667      return data;
2668    }
2669  } else {
2670    // if the arrowElement isn't a query selector we must check that the
2671    // provided DOM node is child of its popper node
2672    if (!data.instance.popper.contains(arrowElement)) {
2673      console.warn('WARNING: `arrow.element` must be child of its popper element!');
2674      return data;
2675    }
2676  }
2677
2678  var placement = data.placement.split('-')[0];
2679  var _data$offsets = data.offsets,
2680      popper = _data$offsets.popper,
2681      reference = _data$offsets.reference;
2682
2683  var isVertical = ['left', 'right'].indexOf(placement) !== -1;
2684
2685  var len = isVertical ? 'height' : 'width';
2686  var sideCapitalized = isVertical ? 'Top' : 'Left';
2687  var side = sideCapitalized.toLowerCase();
2688  var altSide = isVertical ? 'left' : 'top';
2689  var opSide = isVertical ? 'bottom' : 'right';
2690  var arrowElementSize = getOuterSizes(arrowElement)[len];
2691
2692  //
2693  // extends keepTogether behavior making sure the popper and its
2694  // reference have enough pixels in conjunction
2695  //
2696
2697  // top/left side