@opentiny/vue-renderless 3.1.0-alpha.0

package/common/deps/popper.js

@@ -0,0 +1,713 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+import { on, off } from '@opentiny/vue-renderless/common/deps/dom';
+import { typeOf } from '@opentiny/vue-renderless/common/type';
+import { xss } from '@opentiny/vue-renderless/common/xss.js';
+var win = window;
+var positions = ['left', 'right', 'top', 'bottom'];
+var modifiers = ['shift', 'offset', 'preventOverflow', 'keepTogether', 'arrow', 'flip', 'applyStyle'];
+var DEFAULTS = {
+  arrowOffset: 0,
+  arrowElement: '[x-arrow]',
+  boundariesElement: 'viewport',
+  boundariesPadding: 5,
+  flipBehavior: 'flip',
+  forceAbsolute: false,
+  gpuAcceleration: true,
+  offset: 0,
+  placement: 'bottom',
+  preventOverflowOrder: positions,
+  modifiers: modifiers,
+  modifiersIgnored: []
+};
+var getRealElement = function getRealElement(el) {
+  return el.jquery ? el[0] : el;
+};
+var setStyle = function setStyle(el, styles) {
+  var isNumeric = function isNumeric(n) {
+    return n !== '' && !isNaN(parseFloat(n)) && isFinite(n);
+  };
+  Object.keys(styles).forEach(function (prop) {
+    var unit = '';
+    if (~['width', 'height', 'top', 'right', 'bottom', 'left'].indexOf(prop) && isNumeric(styles[prop])) {
+      unit = 'px';
+    }
+    el.style[prop] = styles[prop] + unit;
+  });
+};
+var getSupportedPropertyName = function getSupportedPropertyName(property) {
+  var prefixes = ['', 'ms', 'webkit', 'moz', 'o'];
+  var bodyEl = win.document.body;
+  for (var i = 0; i < prefixes.length; i++) {
+    var toCheck = prefixes[i] ? prefixes[i] + property.charAt(0).toUpperCase() + property.slice(1) : property;
+    if (typeof bodyEl.style[toCheck] !== 'undefined') {
+      return toCheck;
+    }
+  }
+  return null;
+};
+var addClassNames = function addClassNames(el, classNames) {
+  classNames.forEach(function (className) {
+    el.classList.add(className);
+  });
+};
+var addAttributes = function addAttributes(el, attributes) {
+  attributes.forEach(function (attribute) {
+    var attrs = attribute.split(':');
+    el.setAttribute(attrs[0], attrs[1] || '');
+  });
+};
+var getOffsetParent = function getOffsetParent(el) {
+  var offsetParent = el.offsetParent;
+  return offsetParent === win.document.body || !offsetParent ? win.document.documentElement : offsetParent;
+};
+var getStyleComputedProperty = function getStyleComputedProperty(el, property) {
+  if (!el || el.nodeType !== 1) {
+    return;
+  }
+  var css = win.getComputedStyle(el, null);
+  return css[property];
+};
+var isFixed = function isFixed(el) {
+  if (el === win.document.body) {
+    return false;
+  }
+  if (getStyleComputedProperty(el, 'position') === 'fixed') {
+    return true;
+  }
+  return el.parentNode ? isFixed(el.parentNode) : el;
+};
+var getBoundingClientRect = function getBoundingClientRect(el) {
+  var rectObj = el.getBoundingClientRect();
+  var isIE = navigator.userAgent.indexOf('MSIE') != -1;
+  var rectTop = isIE && el.tagName === 'HTML' ? -el.scrollTop : rectObj.top;
+  return {
+    left: rectObj.left,
+    top: rectTop,
+    right: rectObj.right,
+    bottom: rectObj.bottom,
+    width: rectObj.right - rectObj.left,
+    height: rectObj.bottom - rectTop
+  };
+};
+var isScrollElement = function isScrollElement(parent) {
+  var scrollTypes = ['scroll', 'auto'];
+  return ~scrollTypes.indexOf(getStyleComputedProperty(parent, 'overflow')) || ~scrollTypes.indexOf(getStyleComputedProperty(parent, 'overflow-x')) || ~scrollTypes.indexOf(getStyleComputedProperty(parent, 'overflow-y'));
+};
+export var getScrollParent = function getScrollParent(el) {
+  var parent = el.parentNode;
+  if (!parent) {
+    return el;
+  }
+  if (parent === win.document) {
+    if (win.document.body.scrollTop || win.document.body.scrollLeft) {
+      return win.document.body;
+    }
+    return win.document.documentElement;
+  }
+  if (isScrollElement(parent)) {
+    return parent;
+  }
+  return getScrollParent(el.parentNode);
+};
+var getOffsetRectRelativeToCustomParent = function getOffsetRectRelativeToCustomParent(el, parent, fixed) {
+  var _getBoundingClientRec = getBoundingClientRect(el),
+    top = _getBoundingClientRec.top,
+    left = _getBoundingClientRec.left,
+    width = _getBoundingClientRec.width,
+    height = _getBoundingClientRec.height;
+  var parentRect = getBoundingClientRect(parent);
+  if (fixed) {
+    var _getScrollParent = getScrollParent(parent),
+      scrollTop = _getScrollParent.scrollTop,
+      scrollLeft = _getScrollParent.scrollLeft;
+    parentRect.top += scrollTop;
+    parentRect.bottom += scrollTop;
+    parentRect.left += scrollLeft;
+    parentRect.right += scrollLeft;
+  }
+  var rect = {
+    top: top - parentRect.top,
+    left: left - parentRect.left,
+    bottom: top - parentRect.top + height,
+    right: left - parentRect.left + width,
+    width: width,
+    height: height
+  };
+  return rect;
+};
+var getScrollTopValue = function getScrollTopValue(el) {
+  return el == document.body ? Math.max(document.documentElement.scrollTop, document.body.scrollTop) : el.scrollTop;
+};
+var getScrollLeftValue = function getScrollLeftValue(el) {
+  return el == document.body ? Math.max(document.documentElement.scrollLeft, document.body.scrollLeft) : el.scrollLeft;
+};
+var getMaxWH = function getMaxWH(body, html) {
+  var height = Math.max(body.scrollHeight, body.offsetHeight, html.clientHeight, html.scrollHeight, html.offsetHeight);
+  var width = Math.max(body.scrollWidth, body.offsetWidth, html.clientWidth, html.scrollWidth, html.offsetWidth);
+  return {
+    width: width,
+    height: height
+  };
+};
+var adjustArrowStyle = function adjustArrowStyle(arrowStyle, side, arrowRect, popperRect, popperOptions) {
+  var params = popperOptions.placement.split('-');
+  if (popperOptions.adjustArrow && ~['top', 'bottom'].indexOf(params[0]) && side === 'left') {
+    if (params[1] === 'start') {
+      arrowStyle.left = 8;
+    } else if (!params[1]) {
+      arrowStyle.left = (popperRect.width - arrowRect.width) / 2;
+    }
+  }
+  return arrowStyle;
+};
+var getOuterSizes = function getOuterSizes(el) {
+  var _display = el.style.display,
+    _visibility = el.style.visibility;
+  el.style.display = 'block';
+  el.style.visibility = 'hidden';
+  var styles = win.getComputedStyle(el);
+  var x = parseFloat(styles.marginTop) + parseFloat(styles.marginBottom);
+  var y = parseFloat(styles.marginLeft) + parseFloat(styles.marginRight);
+  var result = {
+    width: el.offsetWidth + y,
+    height: el.offsetHeight + x
+  };
+  el.style.display = _display;
+  el.style.visibility = _visibility;
+  return result;
+};
+var getOppositePlacement = function getOppositePlacement(placement) {
+  var hash = {
+    left: 'right',
+    right: 'left',
+    bottom: 'top',
+    top: 'bottom'
+  };
+  return placement.replace(/left|right|bottom|top/g, function (matched) {
+    return hash[matched];
+  });
+};
+var getPopperClientRect = function getPopperClientRect(popperOffsets) {
+  var offsets = _objectSpread({}, popperOffsets);
+  offsets.right = offsets.left + offsets.width;
+  offsets.bottom = offsets.top + offsets.height;
+  return offsets;
+};
+var getArrayKeyIndex = function getArrayKeyIndex(arr, keyToFind) {
+  var i = 0;
+  var _iterator = _createForOfIteratorHelper(arr),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var value = _step.value;
+      if (value === keyToFind) {
+        return i;
+      }
+      i++;
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return null;
+};
+export var getAllScrollParents = function getAllScrollParents(el) {
+  var parents = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  var parent = el.parentNode;
+  if (parent) {
+    isScrollElement(parent) && parents.push(parent);
+    return getAllScrollParents(parent, parents);
+  }
+  return parents;
+};
+var getOffsetRect = function getOffsetRect(el) {
+  var elementRect = {
+    width: el.offsetWidth,
+    height: el.offsetHeight,
+    left: el.offsetLeft,
+    top: el.offsetTop
+  };
+  elementRect.right = elementRect.left + elementRect.width;
+  elementRect.bottom = elementRect.top + elementRect.height;
+  return elementRect;
+};
+function Popper(reference, popper, options) {
+  var _this = this;
+  this._reference = getRealElement(reference);
+  this.state = {};
+  var isNotDefined = typeof popper === 'undefined' || popper === null;
+  var isConfig = popper && Object.prototype.toString.call(popper) === '[object Object]';
+  if (isNotDefined || isConfig) {
+    this._popper = this.parse(isConfig ? popper : {});
+  } else {
+    this._popper = getRealElement(popper);
+  }
+  this._options = _objectSpread(_objectSpread({}, DEFAULTS), options);
+  this._options.modifiers = this._options.modifiers.map(function (modifier) {
+    if (~_this._options.modifiersIgnored.indexOf(modifier)) {
+      return undefined;
+    }
+    if (modifier === 'applyStyle') {
+      _this._popper.setAttribute('x-placement', _this._options.placement);
+    }
+    return _this.modifiers[modifier] || modifier;
+  });
+  this.state.position = this._getPosition(this._popper, this._reference);
+  setStyle(this._popper, {
+    position: this.state.position,
+    top: 0
+  });
+  this.update();
+  this._setupEventListeners();
+  this._oldreference = this._reference;
+  this._oldreference._popper = this._popper.style || {};
+  return this;
+}
+Popper.prototype.destroy = function () {
+  this._popper.removeAttribute('x-placement');
+  var popperStyle = this._reference === this._oldreference && this._oldreference._popper || {};
+  this._popper.style.position = '';
+  this._popper.style.top = popperStyle.top || '';
+  this._popper.style.left = popperStyle.left || '';
+  this._popper.style[getSupportedPropertyName('transform')] = '';
+  this._removeEventListeners();
+  this._options.removeOnDestroy && this._popper.remove();
+  return this;
+};
+Popper.prototype.onCreate = function (callback) {
+  callback(this);
+  return this;
+};
+Popper.prototype.onUpdate = function (callback) {
+  this.state.updateCallback = callback;
+  return this;
+};
+Popper.prototype.update = function () {
+  var data = {
+    instance: this,
+    styles: {}
+  };
+  data.placement = data._originalPlacement = this._options.placement;
+  data.offsets = this._getOffsets(this._popper, this._reference, data.placement);
+  data.boundaries = this._getBoundaries(data, this._options.boundariesPadding, this._options.boundariesElement);
+  data = this.runModifiers(data, this._options.modifiers);
+  typeof this.state.updateCallback === 'function' && this.state.updateCallback(data);
+};
+Popper.prototype.parse = function (config) {
+  var defaultConfig = {
+    attributes: [],
+    arrowTagName: 'div',
+    arrowClassNames: ['popper__arrow'],
+    arrowAttributes: ['x-arrow'],
+    classNames: ['popper'],
+    content: '',
+    contentType: 'text',
+    parent: win.document.body,
+    tagName: 'div'
+  };
+  config = _objectSpread(_objectSpread({}, defaultConfig), config);
+  var _config = config,
+    tagName = _config.tagName,
+    classNames = _config.classNames,
+    attributes = _config.attributes,
+    contentType = _config.contentType,
+    content = _config.content,
+    arrowTagName = _config.arrowTagName;
+  var docEl = win.document;
+  var popper = docEl.createElement(tagName);
+  addClassNames(popper, classNames);
+  addAttributes(popper, attributes);
+  if (contentType === 'node') {
+    popper.appendChild(getRealElement(content));
+  } else if (contentType === 'html') {
+    popper.innerHTML = xss.filterHtml(content);
+  } else {
+    popper.textContent = content;
+  }
+  if (arrowTagName) {
+    var arrow = docEl.createElement(arrowTagName);
+    addClassNames(arrow, config.arrowClassNames);
+    addAttributes(arrow, config.arrowAttributes);
+    popper.appendChild(arrow);
+  }
+  var parent = getRealElement(config.parent);
+  if (typeof parent === 'string') {
+    parent = docEl.querySelectorAll(config.parent);
+    if (parent && parent.length) {
+      parent = parent[0];
+    } else {
+      throw new Error('ERROR: the given `parent` does not exists!');
+    }
+  }
+  if (parent.length > 1 && parent instanceof Element === false) {
+    parent = parent[0];
+  }
+  parent.appendChild(popper);
+  return popper;
+};
+Popper.prototype._getPosition = function (popper, reference) {
+  var container = getOffsetParent(reference);
+  if (this._options.forceAbsolute) {
+    return 'absolute';
+  }
+  var isParentFixed = isFixed(reference, container);
+  return isParentFixed ? 'fixed' : 'absolute';
+};
+Popper.prototype._getOffsets = function (popper, reference, placement) {
+  placement = placement.split('-')[0];
+  var popperOffsets = {};
+  popperOffsets.position = this.state.position;
+  var isParentFixed = popperOffsets.position === 'fixed';
+  var referenceOffsets = getOffsetRectRelativeToCustomParent(reference, getOffsetParent(popper), isParentFixed);
+  var _getOuterSizes = getOuterSizes(popper),
+    width = _getOuterSizes.width,
+    height = _getOuterSizes.height;
+  if (~['right', 'left'].indexOf(placement)) {
+    popperOffsets.top = referenceOffsets.top + referenceOffsets.height / 2 - height / 2;
+    if (placement === 'left') {
+      popperOffsets.left = referenceOffsets.left - width;
+    } else {
+      popperOffsets.left = referenceOffsets.right;
+    }
+  } else {
+    popperOffsets.left = referenceOffsets.left + referenceOffsets.width / 2 - width / 2;
+    if (placement === 'top') {
+      popperOffsets.top = referenceOffsets.top - height;
+    } else {
+      popperOffsets.top = referenceOffsets.bottom;
+    }
+  }
+  popperOffsets.width = width;
+  popperOffsets.height = height;
+  return {
+    popper: popperOffsets,
+    reference: referenceOffsets
+  };
+};
+Popper.prototype._setupEventListeners = function () {
+  var _this2 = this;
+  this.state.updateBound = this.update.bind(this);
+  on(win, 'resize', this.state.updateBound);
+  if (this._options.boundariesElement !== 'window') {
+    var target = getScrollParent(this._reference);
+    if (target === win.document.body || target === win.document.documentElement) {
+      target = win;
+    }
+    if (this._options.bubbling) {
+      var targets = getAllScrollParents(this._reference);
+      this.state.scrollTargets = targets || [];
+      targets.forEach(function (target) {
+        on(target, 'scroll', _this2.state.updateBound);
+      });
+    } else {
+      on(target, 'scroll', this.state.updateBound);
+    }
+    this.state.scrollTarget = target;
+  }
+};
+Popper.prototype._removeEventListeners = function () {
+  var _this3 = this;
+  off(win, 'resize', this.state.updateBound);
+  if (this._options.boundariesElement !== 'window' && this.state.scrollTarget) {
+    off(this.state.scrollTarget, 'scroll', this.state.updateBound);
+    this.state.scrollTarget = null;
+    if (this._options.bubbling) {
+      var targets = this.state.scrollTargets || [];
+      targets.forEach(function (target) {
+        off(target, 'scroll', _this3.state.updateBound);
+      });
+      this.state.scrollTargets = null;
+    }
+  }
+  this.state.updateBound = null;
+};
+Popper.prototype._getBoundaries = function (data, padding, boundariesElement) {
+  var boundaries = {};
+  if (boundariesElement === 'window') {
+    var body = win.document.body;
+    var html = win.document.documentElement;
+    var _getMaxWH = getMaxWH(body, html),
+      width = _getMaxWH.width,
+      height = _getMaxWH.height;
+    boundaries = {
+      top: 0,
+      right: width,
+      bottom: height,
+      left: 0
+    };
+  } else if (boundariesElement === 'viewport') {
+    var offsetParent = getOffsetParent(this._popper);
+    var scrollParent = getScrollParent(this._popper);
+    var offsetParentRect = getOffsetRect(offsetParent);
+    var _isFixed = data.offsets.popper.position === 'fixed';
+    var scrollTop = _isFixed ? 0 : getScrollTopValue(scrollParent);
+    var scrollLeft = _isFixed ? 0 : getScrollLeftValue(scrollParent);
+    boundaries = {
+      top: 0 - (offsetParentRect.top - scrollTop),
+      right: win.document.documentElement.clientWidth - (offsetParentRect.left - scrollLeft),
+      bottom: win.document.documentElement.clientHeight - (offsetParentRect.top - scrollTop),
+      left: 0 - (offsetParentRect.left - scrollLeft)
+    };
+  } else {
+    if (getOffsetParent(this._popper) === boundariesElement) {
+      var clientWidth = boundariesElement.clientWidth,
+        clientHeight = boundariesElement.clientHeight;
+      boundaries = {
+        right: clientWidth,
+        bottom: clientHeight,
+        top: 0,
+        left: 0
+      };
+    } else {
+      boundaries = getOffsetRect(boundariesElement);
+    }
+  }
+  boundaries.right -= padding;
+  boundaries.left += padding;
+  boundaries.bottom = boundaries.bottom - padding;
+  boundaries.top = boundaries.top + padding;
+  return boundaries;
+};
+Popper.prototype.isModifierRequired = function (requesting, requested) {
+  var index = getArrayKeyIndex(this._options.modifiers, requesting);
+  return !!this._options.modifiers.slice(0, index).filter(function (modifier) {
+    return modifier === requested;
+  }).length;
+};
+Popper.prototype.runModifiers = function (data, modifiers, ends) {
+  var _this4 = this;
+  var modifiersToRun = modifiers.slice();
+  var _options = this._options;
+  if (ends !== undefined) {
+    modifiersToRun = _options.modifiers.slice(0, getArrayKeyIndex(_options.modifiers, ends));
+  }
+  modifiersToRun.forEach(function (modifier) {
+    if (typeOf(modifier) === 'function') {
+      data = modifier.call(_this4, data);
+    }
+  });
+  return data;
+};
+Popper.prototype.modifiers = {};
+Popper.prototype.modifiers.applyStyle = function (data) {
+  var styles = {
+    position: data.offsets.popper.position
+  };
+  var left = Math.round(data.offsets.popper.left);
+  var top = Math.round(data.offsets.popper.top);
+  var prefixedProperty;
+  if (this._options.gpuAcceleration && (prefixedProperty = getSupportedPropertyName('transform'))) {
+    styles[prefixedProperty] = "translate3d(".concat(left, "px, ").concat(top, "px, 0)");
+    Object.assign(styles, {
+      top: 0,
+      left: 0
+    });
+  } else {
+    Object.assign(styles, {
+      top: top,
+      left: left
+    });
+  }
+  Object.assign(styles, data.styles);
+  setStyle(this._popper, styles);
+  this._popper.setAttribute('x-placement', data.placement);
+  var modifiers = this.modifiers;
+  if (this.isModifierRequired(modifiers.applyStyle, modifiers.arrow) && data.offsets.arrow) {
+    setStyle(data.arrowElement, data.offsets.arrow);
+  }
+  return data;
+};
+Popper.prototype.modifiers.shift = function (data) {
+  var placement = data.placement;
+  var basePlacement = placement.split('-')[0];
+  var shiftVariation = placement.split('-')[1];
+  if (shiftVariation) {
+    var _data$offsets$referen = data.offsets.reference,
+      top = _data$offsets$referen.top,
+      left = _data$offsets$referen.left,
+      height = _data$offsets$referen.height,
+      width = _data$offsets$referen.width;
+    var popper = getPopperClientRect(data.offsets.popper);
+    var shiftOffsets = {
+      y: {
+        start: {
+          top: top
+        },
+        end: {
+          top: top + height - popper.height
+        }
+      },
+      x: {
+        start: {
+          left: left
+        },
+        end: {
+          left: left + width - popper.width
+        }
+      }
+    };
+    var axis = ~['bottom', 'top'].indexOf(basePlacement) ? 'x' : 'y';
+    data.offsets.popper = Object.assign(popper, shiftOffsets[axis][shiftVariation]);
+  }
+  return data;
+};
+Popper.prototype.modifiers.preventOverflow = function (data) {
+  var order = this._options.preventOverflowOrder;
+  var popper = getPopperClientRect(data.offsets.popper);
+  var check = {
+    top: function top() {
+      var top = popper.top;
+      if (top < data.boundaries.top) {
+        top = Math.max(top, data.boundaries.top);
+      }
+      return {
+        top: top
+      };
+    },
+    right: function right() {
+      var left = popper.left;
+      if (popper.right > data.boundaries.right) {
+        left = Math.min(left, data.boundaries.right - popper.width);
+      }
+      return {
+        left: left
+      };
+    },
+    bottom: function bottom() {
+      var top = popper.top;
+      if (popper.bottom > data.boundaries.bottom) {
+        top = Math.min(top, data.boundaries.bottom - popper.height);
+      }
+      return {
+        top: top
+      };
+    },
+    left: function left() {
+      var left = popper.left;
+      if (popper.left < data.boundaries.left) {
+        left = Math.max(left, data.boundaries.left);
+      }
+      return {
+        left: left
+      };
+    }
+  };
+  order.forEach(function (direction) {
+    data.offsets.popper = Object.assign(popper, check[direction]());
+  });
+  return data;
+};
+Popper.prototype.modifiers.keepTogether = function (data) {
+  var popper = getPopperClientRect(data.offsets.popper);
+  var reference = data.offsets.reference;
+  if (popper.right < Math.floor(reference.left)) {
+    data.offsets.popper.left = Math.floor(reference.left) - popper.width;
+  }
+  if (popper.left > Math.floor(reference.right)) {
+    data.offsets.popper.left = Math.floor(reference.right);
+  }
+  if (popper.bottom < Math.floor(reference.top)) {
+    data.offsets.popper.top = Math.floor(reference.top) - popper.height;
+  }
+  if (popper.top > Math.floor(reference.bottom)) {
+    data.offsets.popper.top = Math.floor(reference.bottom);
+  }
+  return data;
+};
+Popper.prototype.modifiers.flip = function (data) {
+  var _this5 = this;
+  if (!this.isModifierRequired(this.modifiers.flip, this.modifiers.preventOverflow)) {
+    return data;
+  }
+  if (data.flipped && data.placement === data._originalPlacement) {
+    return data;
+  }
+  var placements = data.placement.split('-');
+  var placement = placements[0];
+  var placementOpposite = getOppositePlacement(placement);
+  var variation = placements[1] || '';
+  var flipOrderArr = [];
+  if (this._options.flipBehavior === 'flip') {
+    flipOrderArr = [placement, placementOpposite];
+  } else {
+    flipOrderArr = this._options.flipBehavior;
+  }
+  flipOrderArr.forEach(function (step, index) {
+    if (placement !== step || flipOrderArr.length === index + 1) {
+      return;
+    }
+    placement = data.placement.split('-')[0];
+    placementOpposite = getOppositePlacement(placement);
+    var popperOffsets = getPopperClientRect(data.offsets.popper);
+    var a = ~['right', 'bottom'].indexOf(placement);
+    var p = Math.floor(data.offsets.reference[placement]);
+    var po = Math.floor(popperOffsets[placementOpposite]);
+    if (a && p > po || !a && p < po) {
+      data.flipped = true;
+      data.placement = flipOrderArr[index + 1];
+      if (variation) {
+        data.placement += "-".concat(variation);
+      }
+      data.offsets.popper = _this5._getOffsets(_this5._popper, _this5._reference, data.placement).popper;
+      data = _this5.runModifiers(data, _this5._options.modifiers, _this5._flip);
+    }
+  });
+  return data;
+};
+Popper.prototype.modifiers.offset = function (data) {
+  var offset = this._options.offset;
+  var popper = data.offsets.popper;
+  if (~data.placement.indexOf('left')) {
+    popper.top -= offset;
+  } else if (~data.placement.indexOf('right')) {
+    popper.top += offset;
+  } else if (~data.placement.indexOf('top')) {
+    popper.left -= offset;
+  } else if (~data.placement.indexOf('bottom')) {
+    popper.left += offset;
+  }
+  return data;
+};
+Popper.prototype.modifiers.arrow = function (data) {
+  var arrow = this._options.arrowElement;
+  var arrowOffset = this._options.arrowOffset;
+  if (typeof arrow === 'string') {
+    arrow = this._popper.querySelector(arrow);
+  }
+  if (!arrow || !this._popper.contains(arrow) || !this.isModifierRequired(this.modifiers.arrow, this.modifiers.keepTogether)) {
+    return data;
+  }
+  var arrowStyle = {};
+  var placement = data.placement.split('-')[0];
+  var popper = getPopperClientRect(data.offsets.popper);
+  var reference = data.offsets.reference;
+  var isVertical = ~['left', 'right'].indexOf(placement);
+  var len = isVertical ? 'height' : 'width';
+  var opSide = isVertical ? 'bottom' : 'right';
+  var altSide = isVertical ? 'left' : 'top';
+  var side = isVertical ? 'top' : 'left';
+  var popperRect = getOuterSizes(this._popper);
+  var arrowRect = getOuterSizes(arrow);
+  var arrowSize = arrowRect[len];
+  if (reference[opSide] - arrowSize < popper[side]) {
+    data.offsets.popper[side] -= popper[side] - (reference[opSide] - arrowSize);
+  }
+  if (reference[side] + arrowSize > popper[opSide]) {
+    data.offsets.popper[side] += reference[side] + arrowSize - popper[opSide];
+  }
+  var center = reference[side] + (arrowOffset || reference[len] / 2 - arrowSize / 2);
+  var sideValue = center - popper[side];
+  sideValue = Math.max(Math.min(popper[len] - arrowSize - 8, sideValue), 8);
+  arrowStyle[side] = sideValue;
+  arrowStyle[altSide] = '';
+  data.offsets.arrow = adjustArrowStyle(arrowStyle, side, arrowRect, popperRect, this._options);
+  data.arrowElement = arrow;
+  return data;
+};
+export default Popper;