https://www.skysouq.com/assets/js/bootstrap.bundle.js?v=1790902553

419    _proto.toggle = function toggle() {
420      var triggerChangeEvent = true;
421      var addAriaPressed = true;
422      var rootElement = $$$1(this._element).closest(Selector.DATA_TOGGLE)[0];
423
424      if (rootElement) {
425        var input = $$$1(this._element).find(Selector.INPUT)[0];
426
427        if (input) {
428          if (input.type === 'radio') {
429            if (input.checked && $$$1(this._element).hasClass(ClassName.ACTIVE)) {
430              triggerChangeEvent = false;
431            } else {
432              var activeElement = $$$1(rootElement).find(Selector.ACTIVE)[0];
433
434              if (activeElement) {
435                $$$1(activeElement).removeClass(ClassName.ACTIVE);
436              }
437            }
438          }
439
440          if (triggerChangeEvent) {
441            if (input.hasAttribute('disabled') || rootElement.hasAttribute('disabled') || input.classList.contains('disabled') || rootElement.classList.contains('disabled')) {
442              return;
443            }
444
445            input.checked = !$$$1(this._element).hasClass(ClassName.ACTIVE);
446            $$$1(input).trigger('change');
447          }
448
449          input.focus();
450          addAriaPressed = false;
451        }
452      }
453
454      if (addAriaPressed) {
455        this._element.setAttribute('aria-pressed', !$$$1(this._element).hasClass(ClassName.ACTIVE));
456      }
457
458      if (triggerChangeEvent) {
459        $$$1(this._element).toggleClass(ClassName.ACTIVE);
460      }
461    };
462
463    _proto.dispose = function dispose() {
464      $$$1.removeData(this._element, DATA_KEY);
465      this._element = null;
466    }; // Static
467
468
469    Button._jQueryInterface = function _jQueryInterface(config) {
470      return this.each(function () {
471        var data = $$$1(this).data(DATA_KEY);
472
473        if (!data) {
474          data = new Button(this);
475          $$$1(this).data(DATA_KEY, data);
476        }
477
478        if (config === 'toggle') {
479          data[config]();
480        }
481      });
482    };
483
484    _createClass(Button, null, [{
485      key: "VERSION",
486      get: function get() {
487        return VERSION;
488      }
489    }]);
490    return Button;
491  }();
492  /**
493   * ------------------------------------------------------------------------
494   * Data Api implementation
495   * ------------------------------------------------------------------------
496   */
497
498
499  $$$1(document).on(Event.CLICK_DATA_API, Selector.DATA_TOGGLE_CARROT, function (event) {
500    event.preventDefault();
501    var button = event.target;
502
503    if (!$$$1(button).hasClass(ClassName.BUTTON)) {
504      button = $$$1(button).closest(Selector.BUTTON);
505    }
506
507    Button._jQueryInterface.call($$$1(button), 'toggle');
508  }).on(Event.FOCUS_BLUR_DATA_API, Selector.DATA_TOGGLE_CARROT, function (event) {
509    var button = $$$1(event.target).closest(Selector.BUTTON)[0];
510    $$$1(button).toggleClass(ClassName.FOCUS, /^focus(in)?$/.test(event.type));
511  });
512  /**
513   * ------------------------------------------------------------------------
514   * jQuery
515   * ------------------------------------------------------------------------
516   */
517
518  $$$1.fn[NAME] = Button._jQueryInterface;
519  $$$1.fn[NAME].Constructor = Button;
520
521  $$$1.fn[NAME].noConflict = function () {
522    $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
523    return Button._jQueryInterface;
524  };
525
526  return Button;
527}($);
528
529/**
530 * --------------------------------------------------------------------------
531 * Bootstrap (v4.0.0): carousel.js
532 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
533 * --------------------------------------------------------------------------
534 */
535
536var Carousel = function ($$$1) {
537  /**
538   * ------------------------------------------------------------------------
539   * Constants
540   * ------------------------------------------------------------------------
541   */
542  var NAME = 'carousel';
543  var VERSION = '4.0.0';
544  var DATA_KEY = 'bs.carousel';
545  var EVENT_KEY = "." + DATA_KEY;
546  var DATA_API_KEY = '.data-api';
547  var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
548  var TRANSITION_DURATION = 600;
549  var ARROW_LEFT_KEYCODE = 37; // KeyboardEvent.which value for left arrow key
550
551  var ARROW_RIGHT_KEYCODE = 39; // KeyboardEvent.which value for right arrow key
552
553  var TOUCHEVENT_COMPAT_WAIT = 500; // Time for mouse compat events to fire after touch
554
555  var Default = {
556    interval: 5000,
557    keyboard: true,
558    slide: false,
559    pause: 'hover',
560    wrap: true
561  };
562  var DefaultType = {
563    interval: '(number|boolean)',
564    keyboard: 'boolean',
565    slide: '(boolean|string)',
566    pause: '(string|boolean)',
567    wrap: 'boolean'
568  };
569  var Direction = {
570    NEXT: 'next',
571    PREV: 'prev',
572    LEFT: 'left',
573    RIGHT: 'right'
574  };
575  var Event = {
576    SLIDE: "slide" + EVENT_KEY,
577    SLID: "slid" + EVENT_KEY,
578    KEYDOWN: "keydown" + EVENT_KEY,
579    MOUSEENTER: "mouseenter" + EVENT_KEY,
580    MOUSELEAVE: "mouseleave" + EVENT_KEY,
581    TOUCHEND: "touchend" + EVENT_KEY,
582    LOAD_DATA_API: "load" + EVENT_KEY + DATA_API_KEY,
583    CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY
584  };
585  var ClassName = {
586    CAROUSEL: 'carousel',
587    ACTIVE: 'active',
588    SLIDE: 'slide',
589    RIGHT: 'carousel-item-right',
590    LEFT: 'carousel-item-left',
591    NEXT: 'carousel-item-next',
592    PREV: 'carousel-item-prev',
593    ITEM: 'carousel-item'
594  };
595  var Selector = {
596    ACTIVE: '.active',
597    ACTIVE_ITEM: '.active.carousel-item',
598    ITEM: '.carousel-item',
599    NEXT_PREV: '.carousel-item-next, .carousel-item-prev',
600    INDICATORS: '.carousel-indicators',

943            throw new TypeError("No method named \"" + action + "\"");
944          }
945
946          data[action]();
947        } else if (_config.interval) {
948          data.pause();
949          data.cycle();
950        }
951      });
952    };
953
954    Carousel._dataApiClickHandler = function _dataApiClickHandler(event) {
955      var selector = Util.getSelectorFromElement(this);
956
957      if (!selector) {
958        return;
959      }
960
961      var target = $$$1(selector)[0];
962
963      if (!target || !$$$1(target).hasClass(ClassName.CAROUSEL)) {
964        return;
965      }
966
967      var config = _extends({}, $$$1(target).data(), $$$1(this).data());
968      var slideIndex = this.getAttribute('data-slide-to');
969
970      if (slideIndex) {
971        config.interval = false;
972      }
973
974      Carousel._jQueryInterface.call($$$1(target), config);
975
976      if (slideIndex) {
977        $$$1(target).data(DATA_KEY).to(slideIndex);
978      }
979
980      event.preventDefault();
981    };
982
983    _createClass(Carousel, null, [{
984      key: "VERSION",
985      get: function get() {
986        return VERSION;
987      }
988    }, {
989      key: "Default",
990      get: function get() {
991        return Default;
992      }
993    }]);
994    return Carousel;
995  }();
996  /**
997   * ------------------------------------------------------------------------
998   * Data Api implementation
999   * ------------------------------------------------------------------------
1000   */
1001
1002
1003  $$$1(document).on(Event.CLICK_DATA_API, Selector.DATA_SLIDE, Carousel._dataApiClickHandler);
1004  $$$1(window).on(Event.LOAD_DATA_API, function () {
1005    $$$1(Selector.DATA_RIDE).each(function () {
1006      var $carousel = $$$1(this);
1007
1008      Carousel._jQueryInterface.call($carousel, $carousel.data());
1009    });
1010  });
1011  /**
1012   * ------------------------------------------------------------------------
1013   * jQuery
1014   * ------------------------------------------------------------------------
1015   */
1016
1017  $$$1.fn[NAME] = Carousel._jQueryInterface;
1018  $$$1.fn[NAME].Constructor = Carousel;
1019
1020  $$$1.fn[NAME].noConflict = function () {
1021    $$$1.fn[NAME] = JQUERY_NO_CONFLICT;
1022    return Carousel._jQueryInterface;
1023  };
1024
1025  return Carousel;
1026}($);
1027
1028/**
1029 * --------------------------------------------------------------------------
1030 * Bootstrap (v4.0.0): collapse.js
1031 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
1032 * --------------------------------------------------------------------------
1033 */
1034
1035var Collapse = function ($$$1) {
1036  /**
1037   * ------------------------------------------------------------------------
1038   * Constants
1039   * ------------------------------------------------------------------------
1040   */
1041  var NAME = 'collapse';
1042  var VERSION = '4.0.0';
1043  var DATA_KEY = 'bs.collapse';
1044  var EVENT_KEY = "." + DATA_KEY;
1045  var DATA_API_KEY = '.data-api';
1046  var JQUERY_NO_CONFLICT = $$$1.fn[NAME];
1047  var TRANSITION_DURATION = 600;
1048  var Default = {
1049    toggle: true,
1050    parent: ''
1051  };
1052  var DefaultType = {
1053    toggle: 'boolean',
1054    parent: '(string|element)'
1055  };
1056  var Event = {
1057    SHOW: "show" + EVENT_KEY,
1058    SHOWN: "shown" + EVENT_KEY,
1059    HIDE: "hide" + EVENT_KEY,
1060    HIDDEN: "hidden" + EVENT_KEY,
1061    CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY
1062  };
1063  var ClassName = {
1064    SHOW: 'show',
1065    COLLAPSE: 'collapse',
1066    COLLAPSING: 'collapsing',
1067    COLLAPSED: 'collapsed'
1068  };
1069  var Dimension = {
1070    WIDTH: 'width',
1071    HEIGHT: 'height'
1072  };
1073  var Selector = {
1074    ACTIVES: '.show, .collapsing',
1075    DATA_TOGGLE: '[data-toggle="collapse"]'
1076    /**
1077     * ------------------------------------------------------------------------
1078     * Class Definition
1079     * ------------------------------------------------------------------------
1080     */
1081
1082  };
1083
1084  var Collapse =
1085  /*#__PURE__*/
1086  function () {
1087    function Collapse(element, config) {
1088      this._isTransitioning = false;
1089      this._element = element;
1090      this._config = this._getConfig(config);
1091      this._triggerArray = $$$1.makeArray($$$1("[data-toggle=\"collapse\"][href=\"#" + element.i

1442  };
1443}
1444
1445function taskDebounce(fn) {
1446  var scheduled = false;
1447  return function () {
1448    if (!scheduled) {
1449      scheduled = true;
1450      setTimeout(function () {
1451        scheduled = false;
1452        fn();
1453      }, timeoutDuration);
1454    }
1455  };
1456}
1457
1458var supportsMicroTasks = isBrowser && window.Promise;
1459
1460/**
1461* Create a debounced version of a method, that's asynchronously deferred
1462* but called in the minimum time possible.
1463*
1464* @method
1465* @memberof Popper.Utils
1466* @argument {Function} fn
1467* @returns {Function}
1468*/
1469var debounce = supportsMicroTasks ? microtaskDebounce : taskDebounce;
1470
1471/**
1472 * Check if the given variable is a function
1473 * @method
1474 * @memberof Popper.Utils
1475 * @argument {Any} functionToCheck - variable to check
1476 * @returns {Boolean} answer to: is a function?
1477 */
1478function isFunction(functionToCheck) {
1479  var getType = {};
1480  return functionToCheck && getType.toString.call(functionToCheck) === '[object Function]';
1481}
1482
1483/**
1484 * Get CSS computed property of the given element
1485 * @method
1486 * @memberof Popper.Utils
1487 * @argument {Eement} element
1488 * @argument {String} property
1489 */
1490function getStyleComputedProperty(element, property) {
1491  if (element.nodeType !== 1) {
1492    return [];
1493  }
1494  // NOTE: 1 DOM access here
1495  var css = getComputedStyle(element, null);
1496  return property ? css[property] : css;
1497}
1498
1499/**
1500 * Returns the parentNode or the host of the element
1501 * @method
1502 * @memberof Popper.Utils
1503 * @argument {Element} element
1504 * @returns {Element} parent
1505 */
1506function getParentNode(element) {
1507  if (element.nodeName === 'HTML') {
1508    return element;
1509  }
1510  return element.parentNode || element.host;
1511}
1512
1513/**
1514 * Returns the scrolling parent of the given element
1515 * @method
1516 * @memberof Popper.Utils
1517 * @argument {Element} element
1518 * @returns {Element} scroll parent
1519 */
1520function getScrollParent(element) {
1521  // Return body, `getScroll` will take care to get the correct `scrollTop` from it
1522  if (!element) {
1523    return document.body;
1524  }
1525
1526  switch (element.nodeName) {
1527    case 'HTML':
1528    case 'BODY':
1529      return element.ownerDocument.body;
1530    case '#document':
1531      return element.body;
1532  }
1533
1534  // Firefox want us to check `-x` and `-y` variations as well
1535
1536  var _getStyleComputedProp = getStyleComputedProperty(element),
1537      overflow = _getStyleComputedProp.overflow,
1538      overflowX = _getStyleComputedProp.overflowX,
1539      overflowY = _getStyleComputedProp.overflowY;
1540
1541  if (/(auto|scroll)/.test(overflow + overflowY + overflowX)) {
1542    return element;
1543  }
1544
1545  return getScrollParent(getParentNode(element));
1546}
1547
1548/**
1549 * Returns the offset parent of the given element
1550 * @method
1551 * @memberof Popper.Utils
1552 * @argument {Element} element
1553 * @returns {Element} offset parent
1554 */
1555function getOffsetParent(element) {
1556  // NOTE: 1 DOM access here
1557  var offsetParent = element && element.offsetParent;
1558  var nodeName = offsetParent && offsetParent.nodeName;
1559
1560  if (!nodeName || nodeName === 'BODY' || nodeName === 'HTML') {
1561    if (element) {
1562      return element.ownerDocument.documentElement;
1563    }
1564
1565    return document.documentElement;
1566  }
1567
1568  // .offsetParent will return the closest TD or TABLE in case
1569  // no offsetParent is present, I hate this job...
1570  if (['TD', 'TABLE'].indexOf(offsetParent.nodeName) !== -1 && getStyleComputedProperty(offsetParent, 'position') === 'static') {
1571    return getOffsetParent(offsetParent);
1572  }
1573
1574  return offsetParent;
1575}
1576
1577function isOffsetContainer(element) {
1578  var nodeName = element.nodeName;
1579
1580  if (nodeName === 'BODY') {
1581    return false;
1582  }
1583  return nodeName === 'HTML' || getOffsetParent(element.firstElementChild) === element;
1584}
1585
1586/**
1587 * Finds the root node (document, shadowDOM root) of the given element
1588 * @method
1589 * @memberof Popper.Utils
1590 * @argument {Element} node
1591 * @returns {Element} root node
1592 */
1593function getRoot(node) {
1594  if (node.parentNode !== null) {
1595    return getRoot(node.parentNode);
1596  }
1597
1598  return node;
1599}
1600
1601/**
1602 * Finds the offset parent common to the two provided nodes
1603 * @method
1604 * @memberof Popper.Utils
1605 * @argument {Element} element1
1606 * @argument {Element} element2
1607 * @returns {Element} common offset parent
1608 */
1609function findCommonOffsetParent(element1, element2) {
1610  // This check is needed to avoid errors in case one of the elements isn't defined for any reason
1611  if (!element1 || !element1.nodeType || !element2 || !element2.nodeType) {
1612    return document.documentElement;
1613  }
1614
1615  // Here we make sure to give as "start" the element that comes first in the DOM
1616  var order = element1.compareDocumentPosition(element2) & Node.DOCUMENT_POSITION_FOLLOWING;
1617  var start = order ? element1 : element2;
1618  var end = order ? element2 : element1;
1619
1620  // Get common ancestor container
1621  var range = document.createRange();
1622  range.setStart(start, 0);
1623  range.setEnd(end, 0);
1624  var commonAncestorContainer = range.commonAncestorContainer;
1625

1626  // Both nodes are inside #document
1627
1628  if (element1 !== commonAncestorContainer && element2 !== commonAncestorContainer || start.contains(end)) {
1629    if (isOffsetContainer(commonAncestorContainer)) {
1630      return commonAncestorContainer;
1631    }
1632
1633    return getOffsetParent(commonAncestorContainer);
1634  }
1635
1636  // one of the nodes is inside shadowDOM, find which one
1637  var element1root = getRoot(element1);
1638  if (element1root.host) {
1639    return findCommonOffsetParent(element1root.host, element2);
1640  } else {
1641    return findCommonOffsetParent(element1, getRoot(element2).host);
1642  }
1643}
1644
1645/**
1646 * Gets the scroll value of the given element in the given side (top and left)
1647 * @method
1648 * @memberof Popper.Utils
1649 * @argument {Element} element
1650 * @argument {String} side `top` or `left`
1651 * @returns {number} amount of scrolled pixels
1652 */
1653function getScroll(element) {
1654  var side = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'top';
1655
1656  var upperSide = side === 'top' ? 'scrollTop' : 'scrollLeft';
1657  var nodeName = element.nodeName;
1658
1659  if (nodeName === 'BODY' || nodeName === 'HTML') {
1660    var html = element.ownerDocument.documentElement;
1661    var scrollingElement = element.ownerDocument.scrollingElement || html;
1662    return scrollingElement[upperSide];
1663  }
1664
1665  return element[upperSide];
1666}
1667
1668/*
1669 * Sum or subtract the element scroll values (left and top) from a given rect object
1670 * @method
1671 * @memberof Popper.Utils
1672 * @param {Object} rect - Rect object you want to change
1673 * @param {HTMLElement} element - The element from the function reads the scroll values
1674 * @param {Boolean} subtract - set to true if you want to subtract the scroll values
1675 * @return {Object} rect - The modifier rect object
1676 */
1677function includeScroll(rect, element) {
1678  var subtract = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
1679
1680  var scrollTop = getScroll(element, 'top');
1681  var scrollLeft = getScroll(element, 'left');
1682  var modifier = subtract ? -1 : 1;
1683  rect.top += scrollTop * modifier;
1684  rect.bottom += scrollTop * modifier;
1685  rect.left += scrollLeft * modifier;
1686  rect.right += scrollLeft * modifier;
1687  return rect;
1688}
1689
1690/*
1691 * Helper to detect borders of a given element
1692 * @method
1693 * @memberof Popper.Utils
1694 * @param {CSSStyleDeclaration} styles
1695 * Result of `getStyleComputedProperty` on the given element
1696 * @param {String} axis - `x` or `y`
1697 * @return {number} borders - The borders size of the given axis
1698 */
1699
1700function getBordersSize(styles, axis) {
1701  var sideA = axis === 'x' ? 'Left' : 'Top';
1702  var sideB = sideA === 'Left' ? 'Right' : 'Bottom';
1703
1704  return parseFloat(styles['border' + sideA + 'Width'], 10) + parseFloat(styles['border' + sideB + 'Width'], 10);
1705}
1706
1707/**
1708 * Tells if you are running Internet Explorer 10
1709 * @method
1710 * @memberof Popper.Utils
1711 * @returns {Boolean} isIE10
1712 */
1713var isIE10 = undefined;
1714
1715var isIE10$1 = function () {
1716  if (isIE10 === undefined) {
1717    isIE10 = navigator.appVersion.indexOf('MSIE 10') !== -1;
1718  }
1719  return isIE10;
1720};
1721
1722function getSize(axis, body, html, computedStyle) {
1723  return Math.max(body['offset' + axis], body['scroll' + axis], html['client' + axis], html['offset' + axis], html['scroll' + axis], isIE10$1() ? html['offset' + axis] + computedStyle['margin' + (axis === 'Height' ? 'Top' : 'Left')] + computedStyle['margin' + (axis === 'Height' ? 'Bottom' : 'Right')] : 0);
1724}
1725
1726function getWindowSizes() {
1727  var body = document.body;
1728  var html = document.documentElement;
1729  var computedStyle = isIE10$1() && getComputedStyle(html);
1730
1731  return {
1732    height: getSize('Height', body, html, computedStyle),
1733    width: getSize('Width', body, html, computedStyle)
1734  };
1735}
1736
1737var classCallCheck = function (instance, Constructor) {
1738  if (!(instance instanceof Constructor)) {
1739    throw new TypeError("Cannot call a class as a function");
1740  }
1741};
1742
1743var createClass = function () {
1744  function defineProperties(target, props) {
1745    for (var i = 0; i < props.length; i++) {
1746      var descriptor = props[i];
1747      descriptor.enumerable = descriptor.enumerable || false;
1748      descriptor.configurable = true;
1749      if ("value" in descriptor) descriptor.writable = true;
1750      Object.defineProperty(target, descriptor.key, descriptor);
1751    }
1752  }
1753
1754  return function (Constructor, protoProps, staticProps) {
1755    if (protoProps) defineProperties(Constructor.prototype, protoProps);
1756    if (staticProps) defineProperties(Constructor, staticProps);
1757    return Constructor;
1758  };
1759}();
1760
1761
1762
1763
1764
1765var defineProperty = function (obj, key, value) {
1766  if (key in obj) {
1767    Object.defineProperty(obj, key, {
1768      value: value,
1769      enumerable: true,
1770      configurable: true,
1771      writable: true
1772    });
1773  } else {
1774    obj[key] = value;
1775  }
1776
1777  return obj;
1778};
1779
1780var _extends$1 = Object.assign || function (target) {
1781  for (var i = 1; i < arguments.length; i++) {
1782    var source = arguments[i];
1783
1784    for (var key in source) {
1785      if (Object.prototype.hasOwnProperty.call(source, key)) {
1786        target[key] = source[key];
1787      }
1788    }
1789  }
1790
1791  return target;
1792};
1793
1794/**
1795 * Given element offsets, generate an output similar to getBoundingClientRect
1796 * @method
1797 * @memberof Popper.Utils
1798 * @argument {Object} offsets
1799 * @returns {Object} ClientRect like output
1800 */
1801function getClientRect(offsets) {
1802  return _extends$1({}, offsets, {
1803    right: offsets.left + offsets.width,
1804    bottom: offsets.top + offsets.height
1805  });
1806}
1807
1808/**
1809 * Get bounding client rect of given element
1810 * @method
1811 * @memberof Popper.Utils
1812 * @param {HTMLElement} element
1813 * @return {Object} client rect
1814 */
1815function getBoundingClientRect(element) {
1816  var rect = {};
1817
1818  // IE10 10 FIX: Please, don't ask, the element isn't
1819  // considered in DOM in some circumstances...
1820  // This isn't reproducible in IE10 compatibility mode of IE11
1821  if (isIE10$1()) {
1822    try {
1823      rect = element.getBoundingClientRect();
1824      var scrollTop = getScroll(element, 'top');
1825      var scrollLeft = getScroll(element, 'left');
1826      rect.top += scrollTop;
1827      rect.left += scrollLeft;
1828      rect.bottom += scrollTop;
1829      rect.right += scrollLeft;
1830    } catch (err) {}
1831  } else {
1832    rect = element.getBoundingClientRect();
1833  }
1834
1835  var result = {
1836    left: rect.left,
1837    top: rect.top,
1838    width: rect.right - rect.left,
1839    height: rect.bottom - rect.top
1840  };
1841
1842  // subtract scrollbar size from sizes
1843  var sizes = element.nodeName === 'HTML' ? getWindowSizes() : {};
1844  var width = sizes.width || element.clientWidth || result.right - result.left;
1845  var height = sizes.height || element.clientHeight || result.bottom - result.top;
1846
1847  var horizScrollbar = element.offsetWidth - width;
1848  var vertScrollbar = element.offsetHeight - height;
1849
1850  // if an hypothetical scrollbar is detected, we must be sure it's not a `border`
1851  // we make this check conditional for performance reasons
1852  if (horizScrollbar || vertScrollbar) {
1853    var styles = getStyleComputedProperty(element);
1854    horizScrollbar -= getBordersSize(styles, 'x');
1855    vertScrollbar -= getBordersSize(styles, 'y');
1856
1857    result.width -= horizScrollbar;
1858    result.height -= vertScrollbar;
1859  }
1860
1861  return getClientRect(result);
1862}
1863
1864function getOffsetRectRelativeToArbitraryNode(children, parent) {
1865  var isIE10 = isIE10$1();
1866  var isHTML = parent.nodeName === 'HTML';
1867  var childrenRect = getBoundingClientRect(children);
1868  var parentRect = getBoundingClientRect(parent);
1869  var scrollParent = getScrollParent(children);
1870
1871  var styles = getStyleComputedProperty(parent);
1872  var borderTopWidth = parseFloat(styles.borderTopWidth, 10);
1873  var borderLeftWidth = parseFloat(styles.borderLeftWidth, 10);
1874
1875  var offsets = getClientRect({
1876    top: childrenRect.top - parentRect.top - borderTopWidth,
1877    left: childrenRect.left - parentRect.left - borderLeftWidth,
1878    width: childrenRect.width,
1879    height: childrenRect.height
1880  });
1881  offsets.marginTop = 0;
1882  offsets.marginLeft = 0;
1883
1884  // Subtract margins of documentElement in case it's being used as parent
1885  // we do this only on HTML because it's the only element that behaves
1886  // differently when margins are applied to it. The margins are included in
1887  // the box of the documentElement, in the other cases not.
1888  if (!isIE10 && isHTML) {
1889    var marginTop = parseFloat(styles.marginTop, 10);
1890    var marginLeft = parseFloat(styles.marginLeft, 10);
1891
1892    offsets.top -= borderTopWidth - marginTop;
1893    offsets.bottom -= borderTopWidth - marginTop;
1894    offsets.left -= borderLeftWidth - marginLeft;
1895    offsets.right -= borderLeftWidth - marginLeft;
1896
1897    // Attach marginTop and marginLeft because in some circumstances we may need them
1898    offsets.marginTop = marginTop;
1899    offsets.marginLeft = marginLeft;
1900  }
1901
1902  if (isIE10 ? parent.contains(scrollParent) : parent === scrollParent && scrollParent.nodeName !== 'BODY') {
1903    offsets = includeScroll(offsets, parent);
1904  }
1905
1906  return offsets;
1907}
1908
1909function getViewportOffsetRectRelativeToArtbitraryNode(element) {
1910  var html = element.ownerDocument.documentElement;
1911  var relativeOffset = getOffsetRectRelativeToArbitraryNode(element, html);
1912  var width = Math.max(html.clientWidth, window.innerWidth || 0);
1913  var height = Math.max(html.clientHeight, window.innerHeight || 0

1913);
1914
1915  var scrollTop = getScroll(html);
1916  var scrollLeft = getScroll(html, 'left');
1917
1918  var offset = {
1919    top: scrollTop - relativeOffset.top + relativeOffset.marginTop,
1920    left: scrollLeft - relativeOffset.left + relativeOffset.marginLeft,
1921    width: width,
1922    height: height
1923  };
1924
1925  return getClientRect(offset);
1926}
1927
1928/**
1929 * Check if the given element is fixed or is inside a fixed parent
1930 * @method
1931 * @memberof Popper.Utils
1932 * @argument {Element} element
1933 * @argument {Element} customContainer
1934 * @returns {Boolean} answer to "isFixed?"
1935 */
1936function isFixed(element) {
1937  var nodeName = element.nodeName;
1938  if (nodeName === 'BODY' || nodeName === 'HTML') {
1939    return false;
1940  }
1941  if (getStyleComputedProperty(element, 'position') === 'fixed') {
1942    return true;
1943  }
1944  return isFixed(getParentNode(element));
1945}
1946
1947/**
1948 * Computed the boundaries limits and return them
1949 * @method
1950 * @memberof Popper.Utils
1951 * @param {HTMLElement} popper
1952 * @param {HTMLElement} reference
1953 * @param {number} padding
1954 * @param {HTMLElement} boundariesElement - Element used to define the boundaries
1955 * @returns {Object} Coordinates of the boundaries
1956 */
1957function getBoundaries(popper, reference, padding, boundariesElement) {
1958  // NOTE: 1 DOM access here
1959  var boundaries = { top: 0, left: 0 };
1960  var offsetParent = findCommonOffsetParent(popper, reference);
1961
1962  // Handle viewport case
1963  if (boundariesElement === 'viewport') {
1964    boundaries = getViewportOffsetRectRelativeToArtbitraryNode(offsetParent);
1965  } else {
1966    // Handle other cases based on DOM element used as boundaries
1967    var boundariesNode = void 0;
1968    if (boundariesElement === 'scrollParent') {
1969      boundariesNode = getScrollParent(getParentNode(reference));
1970      if (boundariesNode.nodeName === 'BODY') {
1971        boundariesNode = popper.ownerDocument.documentElement;
1972      }
1973    } else if (boundariesElement === 'window') {
1974      boundariesNode = popper.ownerDocument.documentElement;
1975    } else {
1976      boundariesNode = boundariesElement;
1977    }
1978
1979    var offsets = getOffsetRectRelativeToArbitraryNode(boundariesNode, offsetParent);
1980
1981    // In case of HTML, we need a different computation
1982    if (boundariesNode.nodeName === 'HTML' && !isFixed(offsetParent)) {
1983      var _getWindowSizes = getWindowSizes(),
1984          height = _getWindowSizes.height,
1985          width = _getWindowSizes.width;
1986
1987      boundaries.top += offsets.top - offsets.marginTop;
1988      boundaries.bottom = height + offsets.top;
1989      boundaries.left += offsets.left - offsets.marginLeft;
1990      boundaries.right = width + offsets.left;
1991    } else {
1992      // for all the other DOM elements, this one is good
1993      boundaries = offsets;
1994    }
1995  }
1996
1997  // Add paddings
1998  boundaries.left += padding;
1999  boundaries.top += padding;
2000  boundaries.right -= padding;
2001  boundaries.bottom -= padding;
2002
2003  return boundaries;
2004}
2005
2006function getArea(_ref) {
2007  var width = _ref.width,
2008      height = _ref.height;
2009
2010  return width * height;
2011}
2012
2013/**
2014 * Utility used to transform the `auto` placement to the placement with more
2015 * available space.
2016 * @method
2017 * @memberof Popper.Utils
2018 * @argument {Object} data - The data object generated by update method
2019 * @argument {Object} options - Modifiers configuration and options
2020 * @returns {Object} The data object, properly modified
2021 */
2022function computeAutoPlacement(placement, refRect, popper, reference, boundariesElement) {
2023  var padding = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 0;
2024
2025  if (placement.indexOf('auto') === -1) {
2026    return placement;
2027  }
2028
2029  var boundaries = getBoundaries(popper, reference, padding, boundariesElement);
2030
2031  var rects = {
2032    top: {
2033      width: boundaries.width,
2034      height: refRect.top - boundaries.top
2035    },
2036    right: {
2037      width: boundaries.right - refRect.right,
2038      height: boundaries.height
2039    },
2040    bottom: {
2041      width: boundaries.width,
2042      height: boundaries.bottom - refRect.bottom
2043    },
2044    left: {
2045      width: refRect.left - boundaries.left,
2046      height: boundaries.height
2047    }
2048  };
2049
2050  var sortedAreas = Object.keys(rects).map(function (key) {
2051    return _extends$1({
2052      key: key
2053    }, rects[key], {
2054      area: getArea(rects[key])
2055    });

2092 object containing width and height properties
2093 */
2094function getOuterSizes(element) {
2095  var styles = getComputedStyle(element);
2096  var x = parseFloat(styles.marginTop) + parseFloat(styles.marginBottom);
2097  var y = parseFloat(styles.marginLeft) + parseFloat(styles.marginRight);
2098  var result = {
2099    width: element.offsetWidth + y,
2100    height: element.offsetHeight + x
2101  };
2102  return result;
2103}
2104
2105/**
2106 * Get the opposite placement of the given one
2107 * @method
2108 * @memberof Popper.Utils
2109 * @argument {String} placement
2110 * @returns {String} flipped placement
2111 */
2112function getOppositePlacement(placement) {
2113  var hash = { left: 'right', right: 'left', bottom: 'top', top: 'bottom' };
2114  return placement.replace(/left|right|bottom|top/g, function (matched) {
2115    return hash[matched];
2116  });
2117}
2118
2119/**
2120 * Get offsets to the popper
2121 * @method
2122 * @memberof Popper.Utils
2123 * @param {Object} position - CSS position the Popper will get applied
2124 * @param {HTMLElement} popper - the popper element
2125 * @param {Object} referenceOffsets - the reference offsets (the popper will be relative to this)
2126 * @param {String} placement - one of the valid placement options
2127 * @returns {Object} popperOffsets - An object containing the offsets which will be applied to the popper
2128 */
2129function getPopperOffsets(popper, referenceOffsets, placement) {
2130  placement = placement.split('-')[0];
2131
2132  // Get popper node sizes
2133  var popperRect = getOuterSizes(popper);
2134
2135  // Add position, width and height to our offsets object
2136  var popperOffsets = {
2137    width: popperRect.width,
2138    height: popperRect.height
2139  };
2140
2141  // depending by the popper placement we have to compute its offsets slightly differently
2142  var isHoriz = ['right', 'left'].indexOf(placement) !== -1;
2143  var mainSide = isHoriz ? 'top' : 'left';
2144  var secondarySide = isHoriz ? 'left' : 'top';
2145  var measurement = isHoriz ? 'height' : 'width';
2146  var secondaryMeasurement = !isHoriz ? 'height' : 'width';
2147
2148  popperOffsets[mainSide] = referenceOffsets[mainSide] + referenceOffsets[measurement] / 2 - popperRect[measurement] / 2;
2149  if (placement === secondarySide) {
2150    popperOffsets[secondarySide] = referenceOffsets[secondarySide] - popperRect[secondaryMeasurement];
2151  } else {
2152    popperOffsets[secondarySide] = referenceOffsets[getOppositePlacement(secondarySide)];
2153  }
2154
2155  return popperOffsets;
2156}
2157
2158/**
2159 * Mimics the `find` method of Array
2160 * @method
2161 * @memberof Popper.Utils
2162 * @argument {Array} arr
2163 * @argument prop
2164 * @argument value
2165 * @returns index or -1
2166 */
2167function find(arr, check) {
2168  // use native find if supported
2169  if (Array.prototype.find) {
2170    return arr.find(check);
2171  }
2172
2173  // use `filter` to obtain the same behavior of `find`
2174  return arr.filter(check)[0];
2175}
2176
2177/**
2178 * Return the index of the matching object
2179 * @method
2180 * @memberof Popper.Utils
2181 * @argument {Array} arr
2182 * @argument prop
2183 * @argument value
2184 * @returns index or -1
2185 */
2186function findIndex(arr, prop, value) {
2187  // use native findIndex if supported
2188  if (Array.prototype.findIndex) {
2189    return arr.findIndex(function (cur) {
2190      return cur[prop] === value;
2191    });
2192  }
2193
2194  // use `find` + `indexOf` if `findIndex` isn't supported
2195  var match = find(arr, function (obj) {
2196    return obj[prop] === value;
2197  });
2198  return arr.indexOf(match);
2199}
2200
2201/**
2202 * Loop trough the list of modifiers and run them in order,
2203 * each of them will then edit the data object.
2204 * @method
2205 * @memberof Popper.Utils
2206 * @param {dataObject} data
2207 * @param {Array} modifiers
2208 * @param {String} ends - Optional modifier name used as stopper
2209 * @returns {dataObject}
2210 */
2211function runModifiers(modifiers, data, ends) {
2212  var modifiersToRun = ends === undefined ? modifiers : modifiers.slice(0, findIndex(modifiers, 'name', ends));
2213
2214  modifiersToRun.forEach(function (modifier) {
2215    if (modifier['function']) {
2216      // eslint-disable-line dot-notation
2217      console.warn('`modifier.function` is deprecated, use `modifier.fn`!');
2218    }
2219    var fn = modifier['function'] || modifier.fn; // eslint-disable-line dot-notation
2220    if (modifier.enabled && isFunction(fn)) {
2221      // Add properties to offsets to make them a complete clientRect object
2222      // we do this before each modifier to make sure the previous one doesn't
2223      // mess with these values
2224      data.offsets.popper = getClientRect(data.offsets.popper);
2225      data.offsets.reference = getClientRect(data.offsets.reference);
2226
2227      data = fn(data, modifier);
2228    }
2229  });
2230
2231  return data;
2232}
2233
2234/**
2235 * Updates the position of the popper, computing the new offsets and applying
2236 * the new style.<br />
2237 * Prefer `scheduleUpdate` over `update` because of performance reasons.
2238 * @method
2239 * @memberof Popper
2240 */

2241function update() {
2242  // if popper is destroyed, don't perform any further update
2243  if (this.state.isDestroyed) {
2244    return;
2245  }
2246
2247  var data = {
2248    instance: this,
2249    styles: {},
2250    arrowStyles: {},
2251    attributes: {},
2252    flipped: false,
2253    offsets: {}
2254  };
2255
2256  // compute reference element offsets
2257  data.offsets.reference = getReferenceOffsets(this.state, this.popper, this.reference);
2258
2259  // compute auto placement, store placement inside the data object,
2260  // modifiers will be able to edit `placement` if needed
2261  // and refer to originalPlacement to know the original value
2262  data.placement = computeAutoPlacement(this.options.placement, data.offsets.reference, this.popper, this.reference, this.options.modifiers.flip.boundariesElement, this.options.modifiers.flip.padding);
2263
2264  // store the computed placement inside `originalPlacement`
2265  data.originalPlacement = data.placement;
2266
2267  // compute the popper offsets
2268  data.offsets.popper = getPopperOffsets(this.popper, data.offsets.reference, data.placement);
2269  data.offsets.popper.position = 'absolute';
2270
2271  // run the modifiers
2272  data = runModifiers(this.modifiers, data);
2273
2274  // the first `update` will call `onCreate` callback
2275  // the other ones will call `onUpdate` callback
2276  if (!this.state.isCreated) {
2277    this.state.isCreated = true;
2278    this.options.onCreate(data);
2279  } else {
2280    this.options.onUpdate(data);
2281  }
2282}
2283
2284/**
2285 * Helper used to know if the given modifier is enabled.
2286 * @method
2287 * @memberof Popper.Utils
2288 * @returns {Boolean}
2289 */
2290function isModifierEnabled(modifiers, modifierName) {
2291  return modifiers.some(function (_ref) {
2292    var name = _ref.name,
2293        enabled = _ref.enabled;
2294    return enabled && name === modifierName;
2295  });
2296}
2297
2298/**
2299 * Get the prefixed supported property name
2300 * @method
2301 * @memberof Popper.Utils
2302 * @argument {String} property (camelCase)
2303 * @returns {String} prefixed property (camelCase or PascalCase, depending on the vendor prefix)
2304 */
2305function getSupportedPropertyName(property) {
2306  var prefixes = [false, 'ms', 'Webkit', 'Moz', 'O'];
2307  var upperProp = property.charAt(0).toUpperCase() + property.slice(1);
2308
2309  for (var i = 0; i < prefixes.length - 1; i++) {
2310    var prefix = prefixes[i];
2311    var toCheck = prefix ? '' + prefix + upperProp : property;
2312    if (typeof document.body.style[toCheck] !== 'undefined') {
2313      return toCheck;
2314    }
2315  }
2316  return null;
2317}
2318
2319/**
2320 * Destroy the popper
2321 * @method
2322 * @memberof Popper
2323 */
2324function destroy() {
2325  this.state.isDestroyed = true;
2326
2327  // touch DOM only if `applyStyle` modifier is enabled
2328  if (isModifierEnabled(this.modifiers, 'applyStyle')) {
2329    this.popper.removeAttribute('x-placement');
2330    this.popper.style.left = '';
2331    this.popper.style.position = '';
2332    this.popper.style.top = '';
2333    this.popper.style[getSupportedPropertyName('transform')] = '';
2334  }
2335
2336  this.disableEventListeners();
2337
2338  // remove the popper if user explicity asked for the deletion on destroy
2339  // do not use `remove` because IE11 doesn't support it
2340  if (this.options.removeOnDestroy) {
2341    this.popper.parentNode.removeChild(this.popper);
2342  }
2343  return this;
2344}
2345
2346/**
2347 * Get the window associated with the element
2348 * @argument {Element} element
2349 * @returns {Window}
2350 */
2351function getWindow(element) {
2352  var ownerDocument = element.ownerDocument;
2353  return ownerDocument ? ownerDocument.defaultView : window;
2354}
2355
2356function attachToScrollParents(scrollParent, event, callback, scrollParents) {
2357  var isBody = scrollParent.nodeName === 'BODY';
2358  var target = isBody ? scrollParent.ownerDocument.defaultView : scrollParent;
2359  target.addEventListener(event, callback, { passive: true });
2360
2361  if (!isBody) {
2362    attachToScrollParents(getScrollParent(target.parentNode), event, callback, scrollParents);
2363  }
2364  scrollParents.push(target);
2365}
2366
2367/**
2368 * Setup needed event listeners used to update the popper position
2369 * @method
2370 * @memberof Popper.Utils
2371 * @private
2372 */
2373function setupEventListeners(reference, options, state, updateBound) {
2374  // Resize event listener on window
2375  state.updateBound = updateBound;
2376  getWindow(reference).addEventListener('resize', state.updateBound, { passive: true });
2377
2378  // Scroll event listener on scroll parents
2379  var scrollElement = getScrollParent(reference);
2380  attachToScrollParents(scrollElement, 'scroll', state.updateBound, state.scrollParents);
2381  state.scrollElement = scrollElement;
2382  state.eventsEnabled = true;
2383
2384  return state;
2385}
2386
2387/**
2388 * It will add resize/scroll events and start recalculating
2389 * position of the popper element when they are triggered.
2390 * @method
2391 * @memberof Popper
2392 */
2393function enableEventListeners() {
2394  if (!this.state.eventsEnabled) {
2395    this.state = setupEventListeners(this.reference, this.options, this.state, this.scheduleUpdate);
2396  }
2397}
2398
2399/**
2400 * Remove event listeners used to update the popper position
2401 * @method
2402 * @memberof Popper.Utils
2403 * @private
2404 */
2405function removeEventListeners(reference, state) {
2406  // Remove resize event listener on window
2407  getWindow(reference).removeEventListener('resize', state.updateBound);
2408
2409  // Remove scroll event listener on scroll parents
2410  state.scrollParents.forEach(function (target) {
2411    target.removeEventListener('scroll', state.updateBound);
2412  });
2413
2414  // Reset state
2415  state.updateBound = null;
2416  state.scrollParents = [];
2417  state.scrollElement = null;
2418  state.eventsEnabled = false;
2419  return state;
2420}
2421
2422/**
2423 * It will remove resize/scroll events and won't recalculate popper position
2424 * when they are triggered. It also won't trigger onUpdate callback anymore,
2425 * unless you call `update` method manually.
2426 * @method
2427 * @memberof Popper
2428 */
2429function disableEventListeners() {
2430  if (this.state.eventsEnabled) {
2431    cancelAnimationFrame(this.scheduleUpdate);
2432    this.state = removeEventListeners(this.reference, this.state);
2433  }
2434}
2435
2436/**
2437 * Tells if a given input is a number
2438 * @method
2439 * @memberof Popper.Utils
2440 * @param {*} input to check
2441 * @return {Boolean}
2442 */
2443function isNumeric(n) {
2444  return n !== '' && !isNaN(parseFloat(n)) && isFinite(n);
2445}
2446
2447/**
2448 * Set the style to the given popper
2449 * @method
2450 * @memberof Popper.Utils
2451 * @argument {Element} element - Element to apply the style to
2452 * @argument {Object} styles
2453 * Object with a list of properties and values which will be applied to the element
2454 */
2455function setStyles(element, styles) {
2456  Object.keys(styles).forEach(function (prop) {
2457    var unit = '';
2458    // add unit if the value is numeric and is one of the following
2459    if (['width', 'height', 'top', 'right', 'bottom', 'left'].indexOf(prop) !== -1 && isNumeric(styles[prop])) {
2460      unit = 'px';
2461    }
2462    element.style[prop] = styles[prop] + unit;
2463  });
2464}
2465
2466/**
2467 * Set the attributes to the given popper
2468 * @method
2469 * @memberof Popper.Utils
2470 * @argument {Element} element - Element to apply the attributes to
2471 * @argument {Object} styles
2472 * Object with a list of properties and values which will be applied to the element
2473 */
2474function setAttributes(element, attributes) {
2475  Object.keys(attributes).forEach(function (prop) {
2476    var value = attributes[prop];
2477    if (value !== false) {
2478      element.setAttribute(prop, attributes[prop]);
2479    } else {
2480      element.removeAttribute(prop);
2481    }
2482  });
2483}
2484
2485/**
2486 * @function
2487 * @memberof Modifiers
2488 * @argument {Object} data - The data object generated by `update` method
2489 * @argument {Object} data.styles - List of style properties - values to apply to popper element
2490 * @argument {Object} data.attributes - List of attribute properties - values to apply to popper element
2491 * @argument {Object} options - Modifiers configuration and options
2492 * @returns {Object} The same data object
2493 */
2494function applyStyle(data) {
2495  // any property present in `data.styles` will be applied to the popper,
2496  // in this way we can make the 3rd party modifiers add custom styles to it
2497  // Be aware, modifiers could override the properties defined in the previous
2498  // lines of this modifier!
2499  setStyles(data.instance.popper, data.styles);
2500
2501  // any property present in `data.attributes` will be applied to the popper,
2502  // they will be set as HTML attributes of the element
2503  setAttributes(data.instance.popper, data.attributes);
2504
2505  // if arrowElement is defined and arrowStyles has some properties

2551  var popper = data.offsets.popper;
2552
2553  // Remove this legacy support in Popper.js v2
2554
2555  var legacyGpuAccelerationOption = find(data.instance.modifiers, function (modifier) {
2556    return modifier.name === 'applyStyle';
2557  }).gpuAcceleration;
2558  if (legacyGpuAccelerationOption !== undefined) {
2559    console.warn('WARNING: `gpuAcceleration` option moved to `computeStyle` modifier and will not be supported in future versions of Popper.js!');
2560  }
2561  var gpuAcceleration = legacyGpuAccelerationOption !== undefined ? legacyGpuAccelerationOption : options.gpuAcceleration;
2562
2563  var offsetParent = getOffsetParent(data.instance.popper);
2564  var offsetParentRect = getBoundingClientRect(offsetParent);
2565
2566  // Styles
2567  var styles = {
2568    position: popper.position
2569  };
2570
2571  // floor sides to avoid blurry text
2572  var offsets = {
2573    left: Math.floor(popper.left),
2574    top: Math.floor(popper.top),
2575    bottom: Math.floor(popper.bottom),
2576    right: Math.floor(popper.right)
2577  };
2578
2579  var sideA = x === 'bottom' ? 'top' : 'bottom';
2580  var sideB = y === 'right' ? 'left' : 'right';
2581
2582  // if gpuAcceleration is set to `true` and transform is supported,
2583  //  we use `translate3d` to apply the position to the popper we
2584  // automatically use the supported prefixed version if needed
2585  var prefixedProperty = getSupportedPropertyName('transform');
2586
2587  // now, let's make a step back and look at this code closely (wtf?)
2588  // If the content of the popper grows once it's been positioned, it
2589  // may happen that the popper gets misplaced because of the new content
2590  // overflowing its reference element
2591  // To avoid this problem, we provide two options (x and y), which allow
2592  // the consumer to define the offset origin.
2593  // If we position a popper on top of a reference element, we can set
2594  // `x` to `top` to make the popper grow towards its top instead of
2595  // its bottom.
2596  var left = void 0,
2597      top = void 0;
2598  if (sideA === 'bottom') {
2599    top = -offsetParentRect.height + offsets.bottom;
2600  } else {
2601    top = offsets.top;
2602  }
2603  if (sideB === 'right') {
2604    left = -offsetParentRect.width + offsets.right;
2605  } else {
2606    left = offsets.left;
2607  }
2608  if (gpuAcceleration && prefixedProperty) {
2609    styles[prefixedProperty] = 'translate3d(' + left + 'px, ' + top + 'px, 0)';
2610    styles[sideA] = 0;
2611    styles[sideB] = 0;
2612    styles.willChange = 'transform';
2613  } else {
2614    // othwerise, we use the standard `top`, `left`, `bottom` and `right` properties
2615    var invertTop = sideA === 'bottom' ? -1 : 1;
2616    var invertLeft = sideB === 'right' ? -1 : 1;
2617    styles[sideA] = top * invertTop;
2618    styles[sideB] = left * invertLeft;
2619    styles.willChange = sideA + ', ' + sideB;
2620  }
2621
2622  // Attributes
2623  var attributes = {
2624    'x-placement': data.placement
2625  };
2626
2627  // Update `data` attributes, styles and arrowStyles
2628  data.attributes = _extends$1({}, attributes, data.attributes);
2629  data.styles = _extends$1({}, styles, data.styles);
2630  data.arrowStyles = _extends$1({}, data.offsets.arrow, data.arrowStyles);
2631
2632  return data;
2633}
2634
2635/**
2636 * Helper used to know if the given modifier depends from another one.<br />
2637 * It checks if the needed modifier is listed and enabled.
2638 * @method
2639 * @memberof Popper.Utils
2640 * @param {Array} modifiers - list of modifiers
2641 * @param {String} requestingName - name of requesting modifier
2642 * @param {String} requestedName - name of requested modifier
2643 * @returns {Boolean}
2644 */
2645function isModifierRequired(modifiers, requestingName, requestedName) {
2646  var requesting = find(modifiers, function (_ref) {
2647    var name = _ref.name;
2648    return name === requestingName;
2649  });
2650
2651  var isRequired = !!requesting && modifiers.some(function (modifier) {
2652    return modifier.name === requestedName && modifier.enabled && modifier.order < requesting.order;
2653  });
2654
2655  if (!isRequired) {
2656    var _requesting = '`' + requestingName + '`';
2657    var requested = '`' + requestedName + '`';
2658    console.warn(requested + ' modifier is required by ' + _requesting + ' modifier in order to work, be sure to include it before ' + _requesting + '!');
2659  }
2660  return isRequired;
2661}
2662
2663/**
2664 * @function
2665 * @memberof Modifiers
2666 * @argument {Object} data - The data object generated by update method
2667 * @argument {Object} options - Modifiers configuration and options
2668 * @returns {Object} The data object, properly modified
2669 */
2670function arrow(data, options) {
2671  var _data$offsets$arrow;
2672
2673  // arrow depends on keepTogether in order to work
2674  if (!isModifierRequired(data.instance.modifiers, 'arrow', 'keepTogether')) {
2675    return data;
2676  }
2677
2678  var arrowElement = options.element;
2679