@nulogy/components 16.1.0 → 17.0.0

package/dist/esm/node_modules/.pnpm/popper.js@1.16.1/node_modules/popper.js/dist/esm/popper.js

@@ -0,0 +1,1517 @@
+var isBrowser = typeof window !== "undefined" && typeof document !== "undefined" && typeof navigator !== "undefined";
+var timeoutDuration = (function() {
+  var longerTimeoutBrowsers = ["Edge", "Trident", "Firefox"];
+  for (var i = 0; i < longerTimeoutBrowsers.length; i += 1) {
+    if (isBrowser && navigator.userAgent.indexOf(longerTimeoutBrowsers[i]) >= 0) {
+      return 1;
+    }
+  }
+  return 0;
+})();
+function microtaskDebounce(fn) {
+  var called = false;
+  return function() {
+    if (called) {
+      return;
+    }
+    called = true;
+    window.Promise.resolve().then(function() {
+      called = false;
+      fn();
+    });
+  };
+}
+function taskDebounce(fn) {
+  var scheduled = false;
+  return function() {
+    if (!scheduled) {
+      scheduled = true;
+      setTimeout(function() {
+        scheduled = false;
+        fn();
+      }, timeoutDuration);
+    }
+  };
+}
+var supportsMicroTasks = isBrowser && window.Promise;
+var debounce = supportsMicroTasks ? microtaskDebounce : taskDebounce;
+function isFunction(functionToCheck) {
+  var getType = {};
+  return functionToCheck && getType.toString.call(functionToCheck) === "[object Function]";
+}
+function getStyleComputedProperty(element, property) {
+  if (element.nodeType !== 1) {
+    return [];
+  }
+  var window2 = element.ownerDocument.defaultView;
+  var css = window2.getComputedStyle(element, null);
+  return property ? css[property] : css;
+}
+function getParentNode(element) {
+  if (element.nodeName === "HTML") {
+    return element;
+  }
+  return element.parentNode || element.host;
+}
+function getScrollParent(element) {
+  if (!element) {
+    return document.body;
+  }
+  switch (element.nodeName) {
+    case "HTML":
+    case "BODY":
+      return element.ownerDocument.body;
+    case "#document":
+      return element.body;
+  }
+  var _getStyleComputedProp = getStyleComputedProperty(element), overflow = _getStyleComputedProp.overflow, overflowX = _getStyleComputedProp.overflowX, overflowY = _getStyleComputedProp.overflowY;
+  if (/(auto|scroll|overlay)/.test(overflow + overflowY + overflowX)) {
+    return element;
+  }
+  return getScrollParent(getParentNode(element));
+}
+function getReferenceNode(reference) {
+  return reference && reference.referenceNode ? reference.referenceNode : reference;
+}
+var isIE11 = isBrowser && !!(window.MSInputMethodContext && document.documentMode);
+var isIE10 = isBrowser && /MSIE 10/.test(navigator.userAgent);
+function isIE(version) {
+  if (version === 11) {
+    return isIE11;
+  }
+  if (version === 10) {
+    return isIE10;
+  }
+  return isIE11 || isIE10;
+}
+function getOffsetParent(element) {
+  if (!element) {
+    return document.documentElement;
+  }
+  var noOffsetParent = isIE(10) ? document.body : null;
+  var offsetParent = element.offsetParent || null;
+  while (offsetParent === noOffsetParent && element.nextElementSibling) {
+    offsetParent = (element = element.nextElementSibling).offsetParent;
+  }
+  var nodeName = offsetParent && offsetParent.nodeName;
+  if (!nodeName || nodeName === "BODY" || nodeName === "HTML") {
+    return element ? element.ownerDocument.documentElement : document.documentElement;
+  }
+  if (["TH", "TD", "TABLE"].indexOf(offsetParent.nodeName) !== -1 && getStyleComputedProperty(offsetParent, "position") === "static") {
+    return getOffsetParent(offsetParent);
+  }
+  return offsetParent;
+}
+function isOffsetContainer(element) {
+  var nodeName = element.nodeName;
+  if (nodeName === "BODY") {
+    return false;
+  }
+  return nodeName === "HTML" || getOffsetParent(element.firstElementChild) === element;
+}
+function getRoot(node) {
+  if (node.parentNode !== null) {
+    return getRoot(node.parentNode);
+  }
+  return node;
+}
+function findCommonOffsetParent(element1, element2) {
+  if (!element1 || !element1.nodeType || !element2 || !element2.nodeType) {
+    return document.documentElement;
+  }
+  var order = element1.compareDocumentPosition(element2) & Node.DOCUMENT_POSITION_FOLLOWING;
+  var start = order ? element1 : element2;
+  var end = order ? element2 : element1;
+  var range = document.createRange();
+  range.setStart(start, 0);
+  range.setEnd(end, 0);
+  var commonAncestorContainer = range.commonAncestorContainer;
+  if (element1 !== commonAncestorContainer && element2 !== commonAncestorContainer || start.contains(end)) {
+    if (isOffsetContainer(commonAncestorContainer)) {
+      return commonAncestorContainer;
+    }
+    return getOffsetParent(commonAncestorContainer);
+  }
+  var element1root = getRoot(element1);
+  if (element1root.host) {
+    return findCommonOffsetParent(element1root.host, element2);
+  } else {
+    return findCommonOffsetParent(element1, getRoot(element2).host);
+  }
+}
+function getScroll(element) {
+  var side = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "top";
+  var upperSide = side === "top" ? "scrollTop" : "scrollLeft";
+  var nodeName = element.nodeName;
+  if (nodeName === "BODY" || nodeName === "HTML") {
+    var html = element.ownerDocument.documentElement;
+    var scrollingElement = element.ownerDocument.scrollingElement || html;
+    return scrollingElement[upperSide];
+  }
+  return element[upperSide];
+}
+function includeScroll(rect, element) {
+  var subtract = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
+  var scrollTop = getScroll(element, "top");
+  var scrollLeft = getScroll(element, "left");
+  var modifier = subtract ? -1 : 1;
+  rect.top += scrollTop * modifier;
+  rect.bottom += scrollTop * modifier;
+  rect.left += scrollLeft * modifier;
+  rect.right += scrollLeft * modifier;
+  return rect;
+}
+function getBordersSize(styles, axis) {
+  var sideA = axis === "x" ? "Left" : "Top";
+  var sideB = sideA === "Left" ? "Right" : "Bottom";
+  return parseFloat(styles["border" + sideA + "Width"]) + parseFloat(styles["border" + sideB + "Width"]);
+}
+function getSize(axis, body, html, computedStyle) {
+  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);
+}
+function getWindowSizes(document2) {
+  var body = document2.body;
+  var html = document2.documentElement;
+  var computedStyle = isIE(10) && getComputedStyle(html);
+  return {
+    height: getSize("Height", body, html, computedStyle),
+    width: getSize("Width", body, html, computedStyle)
+  };
+}
+var classCallCheck = function(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+};
+var createClass = /* @__PURE__ */ (function() {
+  function defineProperties(target, props) {
+    for (var i = 0; i < props.length; i++) {
+      var descriptor = props[i];
+      descriptor.enumerable = descriptor.enumerable || false;
+      descriptor.configurable = true;
+      if ("value" in descriptor) descriptor.writable = true;
+      Object.defineProperty(target, descriptor.key, descriptor);
+    }
+  }
+  return function(Constructor, protoProps, staticProps) {
+    if (protoProps) defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) defineProperties(Constructor, staticProps);
+    return Constructor;
+  };
+})();
+var defineProperty = function(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+};
+var _extends = Object.assign || function(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i];
+    for (var key in source) {
+      if (Object.prototype.hasOwnProperty.call(source, key)) {
+        target[key] = source[key];
+      }
+    }
+  }
+  return target;
+};
+function getClientRect(offsets) {
+  return _extends({}, offsets, {
+    right: offsets.left + offsets.width,
+    bottom: offsets.top + offsets.height
+  });
+}
+function getBoundingClientRect(element) {
+  var rect = {};
+  try {
+    if (isIE(10)) {
+      rect = element.getBoundingClientRect();
+      var scrollTop = getScroll(element, "top");
+      var scrollLeft = getScroll(element, "left");
+      rect.top += scrollTop;
+      rect.left += scrollLeft;
+      rect.bottom += scrollTop;
+      rect.right += scrollLeft;
+    } else {
+      rect = element.getBoundingClientRect();
+    }
+  } catch (e) {
+  }
+  var result = {
+    left: rect.left,
+    top: rect.top,
+    width: rect.right - rect.left,
+    height: rect.bottom - rect.top
+  };
+  var sizes = element.nodeName === "HTML" ? getWindowSizes(element.ownerDocument) : {};
+  var width = sizes.width || element.clientWidth || result.width;
+  var height = sizes.height || element.clientHeight || result.height;
+  var horizScrollbar = element.offsetWidth - width;
+  var vertScrollbar = element.offsetHeight - height;
+  if (horizScrollbar || vertScrollbar) {
+    var styles = getStyleComputedProperty(element);
+    horizScrollbar -= getBordersSize(styles, "x");
+    vertScrollbar -= getBordersSize(styles, "y");
+    result.width -= horizScrollbar;
+    result.height -= vertScrollbar;
+  }
+  return getClientRect(result);
+}
+function getOffsetRectRelativeToArbitraryNode(children, parent) {
+  var fixedPosition = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
+  var isIE102 = isIE(10);
+  var isHTML = parent.nodeName === "HTML";
+  var childrenRect = getBoundingClientRect(children);
+  var parentRect = getBoundingClientRect(parent);
+  var scrollParent = getScrollParent(children);
+  var styles = getStyleComputedProperty(parent);
+  var borderTopWidth = parseFloat(styles.borderTopWidth);
+  var borderLeftWidth = parseFloat(styles.borderLeftWidth);
+  if (fixedPosition && isHTML) {
+    parentRect.top = Math.max(parentRect.top, 0);
+    parentRect.left = Math.max(parentRect.left, 0);
+  }
+  var offsets = getClientRect({
+    top: childrenRect.top - parentRect.top - borderTopWidth,
+    left: childrenRect.left - parentRect.left - borderLeftWidth,
+    width: childrenRect.width,
+    height: childrenRect.height
+  });
+  offsets.marginTop = 0;
+  offsets.marginLeft = 0;
+  if (!isIE102 && isHTML) {
+    var marginTop = parseFloat(styles.marginTop);
+    var marginLeft = parseFloat(styles.marginLeft);
+    offsets.top -= borderTopWidth - marginTop;
+    offsets.bottom -= borderTopWidth - marginTop;
+    offsets.left -= borderLeftWidth - marginLeft;
+    offsets.right -= borderLeftWidth - marginLeft;
+    offsets.marginTop = marginTop;
+    offsets.marginLeft = marginLeft;
+  }
+  if (isIE102 && !fixedPosition ? parent.contains(scrollParent) : parent === scrollParent && scrollParent.nodeName !== "BODY") {
+    offsets = includeScroll(offsets, parent);
+  }
+  return offsets;
+}
+function getViewportOffsetRectRelativeToArtbitraryNode(element) {
+  var excludeScroll = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
+  var html = element.ownerDocument.documentElement;
+  var relativeOffset = getOffsetRectRelativeToArbitraryNode(element, html);
+  var width = Math.max(html.clientWidth, window.innerWidth || 0);
+  var height = Math.max(html.clientHeight, window.innerHeight || 0);
+  var scrollTop = !excludeScroll ? getScroll(html) : 0;
+  var scrollLeft = !excludeScroll ? getScroll(html, "left") : 0;
+  var offset2 = {
+    top: scrollTop - relativeOffset.top + relativeOffset.marginTop,
+    left: scrollLeft - relativeOffset.left + relativeOffset.marginLeft,
+    width,
+    height
+  };
+  return getClientRect(offset2);
+}
+function isFixed(element) {
+  var nodeName = element.nodeName;
+  if (nodeName === "BODY" || nodeName === "HTML") {
+    return false;
+  }
+  if (getStyleComputedProperty(element, "position") === "fixed") {
+    return true;
+  }
+  var parentNode = getParentNode(element);
+  if (!parentNode) {
+    return false;
+  }
+  return isFixed(parentNode);
+}
+function getFixedPositionOffsetParent(element) {
+  if (!element || !element.parentElement || isIE()) {
+    return document.documentElement;
+  }
+  var el = element.parentElement;
+  while (el && getStyleComputedProperty(el, "transform") === "none") {
+    el = el.parentElement;
+  }
+  return el || document.documentElement;
+}
+function getBoundaries(popper, reference, padding, boundariesElement) {
+  var fixedPosition = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : false;
+  var boundaries = { top: 0, left: 0 };
+  var offsetParent = fixedPosition ? getFixedPositionOffsetParent(popper) : findCommonOffsetParent(popper, getReferenceNode(reference));
+  if (boundariesElement === "viewport") {
+    boundaries = getViewportOffsetRectRelativeToArtbitraryNode(offsetParent, fixedPosition);
+  } else {
+    var boundariesNode = void 0;
+    if (boundariesElement === "scrollParent") {
+      boundariesNode = getScrollParent(getParentNode(reference));
+      if (boundariesNode.nodeName === "BODY") {
+        boundariesNode = popper.ownerDocument.documentElement;
+      }
+    } else if (boundariesElement === "window") {
+      boundariesNode = popper.ownerDocument.documentElement;
+    } else {
+      boundariesNode = boundariesElement;
+    }
+    var offsets = getOffsetRectRelativeToArbitraryNode(boundariesNode, offsetParent, fixedPosition);
+    if (boundariesNode.nodeName === "HTML" && !isFixed(offsetParent)) {
+      var _getWindowSizes = getWindowSizes(popper.ownerDocument), height = _getWindowSizes.height, width = _getWindowSizes.width;
+      boundaries.top += offsets.top - offsets.marginTop;
+      boundaries.bottom = height + offsets.top;
+      boundaries.left += offsets.left - offsets.marginLeft;
+      boundaries.right = width + offsets.left;
+    } else {
+      boundaries = offsets;
+    }
+  }
+  padding = padding || 0;
+  var isPaddingNumber = typeof padding === "number";
+  boundaries.left += isPaddingNumber ? padding : padding.left || 0;
+  boundaries.top += isPaddingNumber ? padding : padding.top || 0;
+  boundaries.right -= isPaddingNumber ? padding : padding.right || 0;
+  boundaries.bottom -= isPaddingNumber ? padding : padding.bottom || 0;
+  return boundaries;
+}
+function getArea(_ref) {
+  var width = _ref.width, height = _ref.height;
+  return width * height;
+}
+function computeAutoPlacement(placement, refRect, popper, reference, boundariesElement) {
+  var padding = arguments.length > 5 && arguments[5] !== void 0 ? arguments[5] : 0;
+  if (placement.indexOf("auto") === -1) {
+    return placement;
+  }
+  var boundaries = getBoundaries(popper, reference, padding, boundariesElement);
+  var rects = {
+    top: {
+      width: boundaries.width,
+      height: refRect.top - boundaries.top
+    },
+    right: {
+      width: boundaries.right - refRect.right,
+      height: boundaries.height
+    },
+    bottom: {
+      width: boundaries.width,
+      height: boundaries.bottom - refRect.bottom
+    },
+    left: {
+      width: refRect.left - boundaries.left,
+      height: boundaries.height
+    }
+  };
+  var sortedAreas = Object.keys(rects).map(function(key) {
+    return _extends({
+      key
+    }, rects[key], {
+      area: getArea(rects[key])
+    });
+  }).sort(function(a, b) {
+    return b.area - a.area;
+  });
+  var filteredAreas = sortedAreas.filter(function(_ref2) {
+    var width = _ref2.width, height = _ref2.height;
+    return width >= popper.clientWidth && height >= popper.clientHeight;
+  });
+  var computedPlacement = filteredAreas.length > 0 ? filteredAreas[0].key : sortedAreas[0].key;
+  var variation = placement.split("-")[1];
+  return computedPlacement + (variation ? "-" + variation : "");
+}
+function getReferenceOffsets(state, popper, reference) {
+  var fixedPosition = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : null;
+  var commonOffsetParent = fixedPosition ? getFixedPositionOffsetParent(popper) : findCommonOffsetParent(popper, getReferenceNode(reference));
+  return getOffsetRectRelativeToArbitraryNode(reference, commonOffsetParent, fixedPosition);
+}
+function getOuterSizes(element) {
+  var window2 = element.ownerDocument.defaultView;
+  var styles = window2.getComputedStyle(element);
+  var x = parseFloat(styles.marginTop || 0) + parseFloat(styles.marginBottom || 0);
+  var y = parseFloat(styles.marginLeft || 0) + parseFloat(styles.marginRight || 0);
+  var result = {
+    width: element.offsetWidth + y,
+    height: element.offsetHeight + x
+  };
+  return result;
+}
+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];
+  });
+}
+function getPopperOffsets(popper, referenceOffsets, placement) {
+  placement = placement.split("-")[0];
+  var popperRect = getOuterSizes(popper);
+  var popperOffsets = {
+    width: popperRect.width,
+    height: popperRect.height
+  };
+  var isHoriz = ["right", "left"].indexOf(placement) !== -1;
+  var mainSide = isHoriz ? "top" : "left";
+  var secondarySide = isHoriz ? "left" : "top";
+  var measurement = isHoriz ? "height" : "width";
+  var secondaryMeasurement = !isHoriz ? "height" : "width";
+  popperOffsets[mainSide] = referenceOffsets[mainSide] + referenceOffsets[measurement] / 2 - popperRect[measurement] / 2;
+  if (placement === secondarySide) {
+    popperOffsets[secondarySide] = referenceOffsets[secondarySide] - popperRect[secondaryMeasurement];
+  } else {
+    popperOffsets[secondarySide] = referenceOffsets[getOppositePlacement(secondarySide)];
+  }
+  return popperOffsets;
+}
+function find(arr, check) {
+  if (Array.prototype.find) {
+    return arr.find(check);
+  }
+  return arr.filter(check)[0];
+}
+function findIndex(arr, prop, value) {
+  if (Array.prototype.findIndex) {
+    return arr.findIndex(function(cur) {
+      return cur[prop] === value;
+    });
+  }
+  var match = find(arr, function(obj) {
+    return obj[prop] === value;
+  });
+  return arr.indexOf(match);
+}
+function runModifiers(modifiers2, data, ends) {
+  var modifiersToRun = ends === void 0 ? modifiers2 : modifiers2.slice(0, findIndex(modifiers2, "name", ends));
+  modifiersToRun.forEach(function(modifier) {
+    if (modifier["function"]) {
+      console.warn("`modifier.function` is deprecated, use `modifier.fn`!");
+    }
+    var fn = modifier["function"] || modifier.fn;
+    if (modifier.enabled && isFunction(fn)) {
+      data.offsets.popper = getClientRect(data.offsets.popper);
+      data.offsets.reference = getClientRect(data.offsets.reference);
+      data = fn(data, modifier);
+    }
+  });
+  return data;
+}
+function update() {
+  if (this.state.isDestroyed) {
+    return;
+  }
+  var data = {
+    instance: this,
+    styles: {},
+    arrowStyles: {},
+    attributes: {},
+    flipped: false,
+    offsets: {}
+  };
+  data.offsets.reference = getReferenceOffsets(this.state, this.popper, this.reference, this.options.positionFixed);
+  data.placement = computeAutoPlacement(this.options.placement, data.offsets.reference, this.popper, this.reference, this.options.modifiers.flip.boundariesElement, this.options.modifiers.flip.padding);
+  data.originalPlacement = data.placement;
+  data.positionFixed = this.options.positionFixed;
+  data.offsets.popper = getPopperOffsets(this.popper, data.offsets.reference, data.placement);
+  data.offsets.popper.position = this.options.positionFixed ? "fixed" : "absolute";
+  data = runModifiers(this.modifiers, data);
+  if (!this.state.isCreated) {
+    this.state.isCreated = true;
+    this.options.onCreate(data);
+  } else {
+    this.options.onUpdate(data);
+  }
+}
+function isModifierEnabled(modifiers2, modifierName) {
+  return modifiers2.some(function(_ref) {
+    var name = _ref.name, enabled = _ref.enabled;
+    return enabled && name === modifierName;
+  });
+}
+function getSupportedPropertyName(property) {
+  var prefixes = [false, "ms", "Webkit", "Moz", "O"];
+  var upperProp = property.charAt(0).toUpperCase() + property.slice(1);
+  for (var i = 0; i < prefixes.length; i++) {
+    var prefix = prefixes[i];
+    var toCheck = prefix ? "" + prefix + upperProp : property;
+    if (typeof document.body.style[toCheck] !== "undefined") {
+      return toCheck;
+    }
+  }
+  return null;
+}
+function destroy() {
+  this.state.isDestroyed = true;
+  if (isModifierEnabled(this.modifiers, "applyStyle")) {
+    this.popper.removeAttribute("x-placement");
+    this.popper.style.position = "";
+    this.popper.style.top = "";
+    this.popper.style.left = "";
+    this.popper.style.right = "";
+    this.popper.style.bottom = "";
+    this.popper.style.willChange = "";
+    this.popper.style[getSupportedPropertyName("transform")] = "";
+  }
+  this.disableEventListeners();
+  if (this.options.removeOnDestroy) {
+    this.popper.parentNode.removeChild(this.popper);
+  }
+  return this;
+}
+function getWindow(element) {
+  var ownerDocument = element.ownerDocument;
+  return ownerDocument ? ownerDocument.defaultView : window;
+}
+function attachToScrollParents(scrollParent, event, callback, scrollParents) {
+  var isBody = scrollParent.nodeName === "BODY";
+  var target = isBody ? scrollParent.ownerDocument.defaultView : scrollParent;
+  target.addEventListener(event, callback, { passive: true });
+  if (!isBody) {
+    attachToScrollParents(getScrollParent(target.parentNode), event, callback, scrollParents);
+  }
+  scrollParents.push(target);
+}
+function setupEventListeners(reference, options, state, updateBound) {
+  state.updateBound = updateBound;
+  getWindow(reference).addEventListener("resize", state.updateBound, { passive: true });
+  var scrollElement = getScrollParent(reference);
+  attachToScrollParents(scrollElement, "scroll", state.updateBound, state.scrollParents);
+  state.scrollElement = scrollElement;
+  state.eventsEnabled = true;
+  return state;
+}
+function enableEventListeners() {
+  if (!this.state.eventsEnabled) {
+    this.state = setupEventListeners(this.reference, this.options, this.state, this.scheduleUpdate);
+  }
+}
+function removeEventListeners(reference, state) {
+  getWindow(reference).removeEventListener("resize", state.updateBound);
+  state.scrollParents.forEach(function(target) {
+    target.removeEventListener("scroll", state.updateBound);
+  });
+  state.updateBound = null;
+  state.scrollParents = [];
+  state.scrollElement = null;
+  state.eventsEnabled = false;
+  return state;
+}
+function disableEventListeners() {
+  if (this.state.eventsEnabled) {
+    cancelAnimationFrame(this.scheduleUpdate);
+    this.state = removeEventListeners(this.reference, this.state);
+  }
+}
+function isNumeric(n) {
+  return n !== "" && !isNaN(parseFloat(n)) && isFinite(n);
+}
+function setStyles(element, styles) {
+  Object.keys(styles).forEach(function(prop) {
+    var unit = "";
+    if (["width", "height", "top", "right", "bottom", "left"].indexOf(prop) !== -1 && isNumeric(styles[prop])) {
+      unit = "px";
+    }
+    element.style[prop] = styles[prop] + unit;
+  });
+}
+function setAttributes(element, attributes) {
+  Object.keys(attributes).forEach(function(prop) {
+    var value = attributes[prop];
+    if (value !== false) {
+      element.setAttribute(prop, attributes[prop]);
+    } else {
+      element.removeAttribute(prop);
+    }
+  });
+}
+function applyStyle(data) {
+  setStyles(data.instance.popper, data.styles);
+  setAttributes(data.instance.popper, data.attributes);
+  if (data.arrowElement && Object.keys(data.arrowStyles).length) {
+    setStyles(data.arrowElement, data.arrowStyles);
+  }
+  return data;
+}
+function applyStyleOnLoad(reference, popper, options, modifierOptions, state) {
+  var referenceOffsets = getReferenceOffsets(state, popper, reference, options.positionFixed);
+  var placement = computeAutoPlacement(options.placement, referenceOffsets, popper, reference, options.modifiers.flip.boundariesElement, options.modifiers.flip.padding);
+  popper.setAttribute("x-placement", placement);
+  setStyles(popper, { position: options.positionFixed ? "fixed" : "absolute" });
+  return options;
+}
+function getRoundedOffsets(data, shouldRound) {
+  var _data$offsets = data.offsets, popper = _data$offsets.popper, reference = _data$offsets.reference;
+  var round = Math.round, floor = Math.floor;
+  var noRound = function noRound2(v) {
+    return v;
+  };
+  var referenceWidth = round(reference.width);
+  var popperWidth = round(popper.width);
+  var isVertical = ["left", "right"].indexOf(data.placement) !== -1;
+  var isVariation = data.placement.indexOf("-") !== -1;
+  var sameWidthParity = referenceWidth % 2 === popperWidth % 2;
+  var bothOddWidth = referenceWidth % 2 === 1 && popperWidth % 2 === 1;
+  var horizontalToInteger = !shouldRound ? noRound : isVertical || isVariation || sameWidthParity ? round : floor;
+  var verticalToInteger = !shouldRound ? noRound : round;
+  return {
+    left: horizontalToInteger(bothOddWidth && !isVariation && shouldRound ? popper.left - 1 : popper.left),
+    top: verticalToInteger(popper.top),
+    bottom: verticalToInteger(popper.bottom),
+    right: horizontalToInteger(popper.right)
+  };
+}
+var isFirefox = isBrowser && /Firefox/i.test(navigator.userAgent);
+function computeStyle(data, options) {
+  var x = options.x, y = options.y;
+  var popper = data.offsets.popper;
+  var legacyGpuAccelerationOption = find(data.instance.modifiers, function(modifier) {
+    return modifier.name === "applyStyle";
+  }).gpuAcceleration;
+  if (legacyGpuAccelerationOption !== void 0) {
+    console.warn("WARNING: `gpuAcceleration` option moved to `computeStyle` modifier and will not be supported in future versions of Popper.js!");
+  }
+  var gpuAcceleration = legacyGpuAccelerationOption !== void 0 ? legacyGpuAccelerationOption : options.gpuAcceleration;
+  var offsetParent = getOffsetParent(data.instance.popper);
+  var offsetParentRect = getBoundingClientRect(offsetParent);
+  var styles = {
+    position: popper.position
+  };
+  var offsets = getRoundedOffsets(data, window.devicePixelRatio < 2 || !isFirefox);
+  var sideA = x === "bottom" ? "top" : "bottom";
+  var sideB = y === "right" ? "left" : "right";
+  var prefixedProperty = getSupportedPropertyName("transform");
+  var left = void 0, top = void 0;
+  if (sideA === "bottom") {
+    if (offsetParent.nodeName === "HTML") {
+      top = -offsetParent.clientHeight + offsets.bottom;
+    } else {
+      top = -offsetParentRect.height + offsets.bottom;
+    }
+  } else {
+    top = offsets.top;
+  }
+  if (sideB === "right") {
+    if (offsetParent.nodeName === "HTML") {
+      left = -offsetParent.clientWidth + offsets.right;
+    } else {
+      left = -offsetParentRect.width + offsets.right;
+    }
+  } else {
+    left = offsets.left;
+  }
+  if (gpuAcceleration && prefixedProperty) {
+    styles[prefixedProperty] = "translate3d(" + left + "px, " + top + "px, 0)";
+    styles[sideA] = 0;
+    styles[sideB] = 0;
+    styles.willChange = "transform";
+  } else {
+    var invertTop = sideA === "bottom" ? -1 : 1;
+    var invertLeft = sideB === "right" ? -1 : 1;
+    styles[sideA] = top * invertTop;
+    styles[sideB] = left * invertLeft;
+    styles.willChange = sideA + ", " + sideB;
+  }
+  var attributes = {
+    "x-placement": data.placement
+  };
+  data.attributes = _extends({}, attributes, data.attributes);
+  data.styles = _extends({}, styles, data.styles);
+  data.arrowStyles = _extends({}, data.offsets.arrow, data.arrowStyles);
+  return data;
+}
+function isModifierRequired(modifiers2, requestingName, requestedName) {
+  var requesting = find(modifiers2, function(_ref) {
+    var name = _ref.name;
+    return name === requestingName;
+  });
+  var isRequired = !!requesting && modifiers2.some(function(modifier) {
+    return modifier.name === requestedName && modifier.enabled && modifier.order < requesting.order;
+  });
+  if (!isRequired) {
+    var _requesting = "`" + requestingName + "`";
+    var requested = "`" + requestedName + "`";
+    console.warn(requested + " modifier is required by " + _requesting + " modifier in order to work, be sure to include it before " + _requesting + "!");
+  }
+  return isRequired;
+}
+function arrow(data, options) {
+  var _data$offsets$arrow;
+  if (!isModifierRequired(data.instance.modifiers, "arrow", "keepTogether")) {
+    return data;
+  }
+  var arrowElement = options.element;
+  if (typeof arrowElement === "string") {
+    arrowElement = data.instance.popper.querySelector(arrowElement);
+    if (!arrowElement) {
+      return data;
+    }
+  } else {
+    if (!data.instance.popper.contains(arrowElement)) {
+      console.warn("WARNING: `arrow.element` must be child of its popper element!");
+      return data;
+    }
+  }
+  var placement = data.placement.split("-")[0];
+  var _data$offsets = data.offsets, popper = _data$offsets.popper, reference = _data$offsets.reference;
+  var isVertical = ["left", "right"].indexOf(placement) !== -1;
+  var len = isVertical ? "height" : "width";
+  var sideCapitalized = isVertical ? "Top" : "Left";
+  var side = sideCapitalized.toLowerCase();
+  var altSide = isVertical ? "left" : "top";
+  var opSide = isVertical ? "bottom" : "right";
+  var arrowElementSize = getOuterSizes(arrowElement)[len];
+  if (reference[opSide] - arrowElementSize < popper[side]) {
+    data.offsets.popper[side] -= popper[side] - (reference[opSide] - arrowElementSize);
+  }
+  if (reference[side] + arrowElementSize > popper[opSide]) {
+    data.offsets.popper[side] += reference[side] + arrowElementSize - popper[opSide];
+  }
+  data.offsets.popper = getClientRect(data.offsets.popper);
+  var center = reference[side] + reference[len] / 2 - arrowElementSize / 2;
+  var css = getStyleComputedProperty(data.instance.popper);
+  var popperMarginSide = parseFloat(css["margin" + sideCapitalized]);
+  var popperBorderSide = parseFloat(css["border" + sideCapitalized + "Width"]);
+  var sideValue = center - data.offsets.popper[side] - popperMarginSide - popperBorderSide;
+  sideValue = Math.max(Math.min(popper[len] - arrowElementSize, sideValue), 0);
+  data.arrowElement = arrowElement;
+  data.offsets.arrow = (_data$offsets$arrow = {}, defineProperty(_data$offsets$arrow, side, Math.round(sideValue)), defineProperty(_data$offsets$arrow, altSide, ""), _data$offsets$arrow);
+  return data;
+}
+function getOppositeVariation(variation) {
+  if (variation === "end") {
+    return "start";
+  } else if (variation === "start") {
+    return "end";
+  }
+  return variation;
+}
+var placements = ["auto-start", "auto", "auto-end", "top-start", "top", "top-end", "right-start", "right", "right-end", "bottom-end", "bottom", "bottom-start", "left-end", "left", "left-start"];
+var validPlacements = placements.slice(3);
+function clockwise(placement) {
+  var counter = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
+  var index = validPlacements.indexOf(placement);
+  var arr = validPlacements.slice(index + 1).concat(validPlacements.slice(0, index));
+  return counter ? arr.reverse() : arr;
+}
+var BEHAVIORS = {
+  FLIP: "flip",
+  CLOCKWISE: "clockwise",
+  COUNTERCLOCKWISE: "counterclockwise"
+};
+function flip(data, options) {
+  if (isModifierEnabled(data.instance.modifiers, "inner")) {
+    return data;
+  }
+  if (data.flipped && data.placement === data.originalPlacement) {
+    return data;
+  }
+  var boundaries = getBoundaries(data.instance.popper, data.instance.reference, options.padding, options.boundariesElement, data.positionFixed);
+  var placement = data.placement.split("-")[0];
+  var placementOpposite = getOppositePlacement(placement);
+  var variation = data.placement.split("-")[1] || "";
+  var flipOrder = [];
+  switch (options.behavior) {
+    case BEHAVIORS.FLIP:
+      flipOrder = [placement, placementOpposite];
+      break;
+    case BEHAVIORS.CLOCKWISE:
+      flipOrder = clockwise(placement);
+      break;
+    case BEHAVIORS.COUNTERCLOCKWISE:
+      flipOrder = clockwise(placement, true);
+      break;
+    default:
+      flipOrder = options.behavior;
+  }
+  flipOrder.forEach(function(step, index) {
+    if (placement !== step || flipOrder.length === index + 1) {
+      return data;
+    }
+    placement = data.placement.split("-")[0];
+    placementOpposite = getOppositePlacement(placement);
+    var popperOffsets = data.offsets.popper;
+    var refOffsets = data.offsets.reference;
+    var floor = Math.floor;
+    var overlapsRef = placement === "left" && floor(popperOffsets.right) > floor(refOffsets.left) || placement === "right" && floor(popperOffsets.left) < floor(refOffsets.right) || placement === "top" && floor(popperOffsets.bottom) > floor(refOffsets.top) || placement === "bottom" && floor(popperOffsets.top) < floor(refOffsets.bottom);
+    var overflowsLeft = floor(popperOffsets.left) < floor(boundaries.left);
+    var overflowsRight = floor(popperOffsets.right) > floor(boundaries.right);
+    var overflowsTop = floor(popperOffsets.top) < floor(boundaries.top);
+    var overflowsBottom = floor(popperOffsets.bottom) > floor(boundaries.bottom);
+    var overflowsBoundaries = placement === "left" && overflowsLeft || placement === "right" && overflowsRight || placement === "top" && overflowsTop || placement === "bottom" && overflowsBottom;
+    var isVertical = ["top", "bottom"].indexOf(placement) !== -1;
+    var flippedVariationByRef = !!options.flipVariations && (isVertical && variation === "start" && overflowsLeft || isVertical && variation === "end" && overflowsRight || !isVertical && variation === "start" && overflowsTop || !isVertical && variation === "end" && overflowsBottom);
+    var flippedVariationByContent = !!options.flipVariationsByContent && (isVertical && variation === "start" && overflowsRight || isVertical && variation === "end" && overflowsLeft || !isVertical && variation === "start" && overflowsBottom || !isVertical && variation === "end" && overflowsTop);
+    var flippedVariation = flippedVariationByRef || flippedVariationByContent;
+    if (overlapsRef || overflowsBoundaries || flippedVariation) {
+      data.flipped = true;
+      if (overlapsRef || overflowsBoundaries) {
+        placement = flipOrder[index + 1];
+      }
+      if (flippedVariation) {
+        variation = getOppositeVariation(variation);
+      }
+      data.placement = placement + (variation ? "-" + variation : "");
+      data.offsets.popper = _extends({}, data.offsets.popper, getPopperOffsets(data.instance.popper, data.offsets.reference, data.placement));
+      data = runModifiers(data.instance.modifiers, data, "flip");
+    }
+  });
+  return data;
+}
+function keepTogether(data) {
+  var _data$offsets = data.offsets, popper = _data$offsets.popper, reference = _data$offsets.reference;
+  var placement = data.placement.split("-")[0];
+  var floor = Math.floor;
+  var isVertical = ["top", "bottom"].indexOf(placement) !== -1;
+  var side = isVertical ? "right" : "bottom";
+  var opSide = isVertical ? "left" : "top";
+  var measurement = isVertical ? "width" : "height";
+  if (popper[side] < floor(reference[opSide])) {
+    data.offsets.popper[opSide] = floor(reference[opSide]) - popper[measurement];
+  }
+  if (popper[opSide] > floor(reference[side])) {
+    data.offsets.popper[opSide] = floor(reference[side]);
+  }
+  return data;
+}
+function toValue(str, measurement, popperOffsets, referenceOffsets) {
+  var split = str.match(/((?:\-|\+)?\d*\.?\d*)(.*)/);
+  var value = +split[1];
+  var unit = split[2];
+  if (!value) {
+    return str;
+  }
+  if (unit.indexOf("%") === 0) {
+    var element = void 0;
+    switch (unit) {
+      case "%p":
+        element = popperOffsets;
+        break;
+      case "%":
+      case "%r":
+      default:
+        element = referenceOffsets;
+    }
+    var rect = getClientRect(element);
+    return rect[measurement] / 100 * value;
+  } else if (unit === "vh" || unit === "vw") {
+    var size = void 0;
+    if (unit === "vh") {
+      size = Math.max(document.documentElement.clientHeight, window.innerHeight || 0);
+    } else {
+      size = Math.max(document.documentElement.clientWidth, window.innerWidth || 0);
+    }
+    return size / 100 * value;
+  } else {
+    return value;
+  }
+}
+function parseOffset(offset2, popperOffsets, referenceOffsets, basePlacement) {
+  var offsets = [0, 0];
+  var useHeight = ["right", "left"].indexOf(basePlacement) !== -1;
+  var fragments = offset2.split(/(\+|\-)/).map(function(frag) {
+    return frag.trim();
+  });
+  var divider = fragments.indexOf(find(fragments, function(frag) {
+    return frag.search(/,|\s/) !== -1;
+  }));
+  if (fragments[divider] && fragments[divider].indexOf(",") === -1) {
+    console.warn("Offsets separated by white space(s) are deprecated, use a comma (,) instead.");
+  }
+  var splitRegex = /\s*,\s*|\s+/;
+  var ops = divider !== -1 ? [fragments.slice(0, divider).concat([fragments[divider].split(splitRegex)[0]]), [fragments[divider].split(splitRegex)[1]].concat(fragments.slice(divider + 1))] : [fragments];
+  ops = ops.map(function(op, index) {
+    var measurement = (index === 1 ? !useHeight : useHeight) ? "height" : "width";
+    var mergeWithPrevious = false;
+    return op.reduce(function(a, b) {
+      if (a[a.length - 1] === "" && ["+", "-"].indexOf(b) !== -1) {
+        a[a.length - 1] = b;
+        mergeWithPrevious = true;
+        return a;
+      } else if (mergeWithPrevious) {
+        a[a.length - 1] += b;
+        mergeWithPrevious = false;
+        return a;
+      } else {
+        return a.concat(b);
+      }
+    }, []).map(function(str) {
+      return toValue(str, measurement, popperOffsets, referenceOffsets);
+    });
+  });
+  ops.forEach(function(op, index) {
+    op.forEach(function(frag, index2) {
+      if (isNumeric(frag)) {
+        offsets[index] += frag * (op[index2 - 1] === "-" ? -1 : 1);
+      }
+    });
+  });
+  return offsets;
+}
+function offset(data, _ref) {
+  var offset2 = _ref.offset;
+  var placement = data.placement, _data$offsets = data.offsets, popper = _data$offsets.popper, reference = _data$offsets.reference;
+  var basePlacement = placement.split("-")[0];
+  var offsets = void 0;
+  if (isNumeric(+offset2)) {
+    offsets = [+offset2, 0];
+  } else {
+    offsets = parseOffset(offset2, popper, reference, basePlacement);
+  }
+  if (basePlacement === "left") {
+    popper.top += offsets[0];
+    popper.left -= offsets[1];
+  } else if (basePlacement === "right") {
+    popper.top += offsets[0];
+    popper.left += offsets[1];
+  } else if (basePlacement === "top") {
+    popper.left += offsets[0];
+    popper.top -= offsets[1];
+  } else if (basePlacement === "bottom") {
+    popper.left += offsets[0];
+    popper.top += offsets[1];
+  }
+  data.popper = popper;
+  return data;
+}
+function preventOverflow(data, options) {
+  var boundariesElement = options.boundariesElement || getOffsetParent(data.instance.popper);
+  if (data.instance.reference === boundariesElement) {
+    boundariesElement = getOffsetParent(boundariesElement);
+  }
+  var transformProp = getSupportedPropertyName("transform");
+  var popperStyles = data.instance.popper.style;
+  var top = popperStyles.top, left = popperStyles.left, transform = popperStyles[transformProp];
+  popperStyles.top = "";
+  popperStyles.left = "";
+  popperStyles[transformProp] = "";
+  var boundaries = getBoundaries(data.instance.popper, data.instance.reference, options.padding, boundariesElement, data.positionFixed);
+  popperStyles.top = top;
+  popperStyles.left = left;
+  popperStyles[transformProp] = transform;
+  options.boundaries = boundaries;
+  var order = options.priority;
+  var popper = data.offsets.popper;
+  var check = {
+    primary: function primary(placement) {
+      var value = popper[placement];
+      if (popper[placement] < boundaries[placement] && !options.escapeWithReference) {
+        value = Math.max(popper[placement], boundaries[placement]);
+      }
+      return defineProperty({}, placement, value);
+    },
+    secondary: function secondary(placement) {
+      var mainSide = placement === "right" ? "left" : "top";
+      var value = popper[mainSide];
+      if (popper[placement] > boundaries[placement] && !options.escapeWithReference) {
+        value = Math.min(popper[mainSide], boundaries[placement] - (placement === "right" ? popper.width : popper.height));
+      }
+      return defineProperty({}, mainSide, value);
+    }
+  };
+  order.forEach(function(placement) {
+    var side = ["left", "top"].indexOf(placement) !== -1 ? "primary" : "secondary";
+    popper = _extends({}, popper, check[side](placement));
+  });
+  data.offsets.popper = popper;
+  return data;
+}
+function shift(data) {
+  var placement = data.placement;
+  var basePlacement = placement.split("-")[0];
+  var shiftvariation = placement.split("-")[1];
+  if (shiftvariation) {
+    var _data$offsets = data.offsets, reference = _data$offsets.reference, popper = _data$offsets.popper;
+    var isVertical = ["bottom", "top"].indexOf(basePlacement) !== -1;
+    var side = isVertical ? "left" : "top";
+    var measurement = isVertical ? "width" : "height";
+    var shiftOffsets = {
+      start: defineProperty({}, side, reference[side]),
+      end: defineProperty({}, side, reference[side] + reference[measurement] - popper[measurement])
+    };
+    data.offsets.popper = _extends({}, popper, shiftOffsets[shiftvariation]);
+  }
+  return data;
+}
+function hide(data) {
+  if (!isModifierRequired(data.instance.modifiers, "hide", "preventOverflow")) {
+    return data;
+  }
+  var refRect = data.offsets.reference;
+  var bound = find(data.instance.modifiers, function(modifier) {
+    return modifier.name === "preventOverflow";
+  }).boundaries;
+  if (refRect.bottom < bound.top || refRect.left > bound.right || refRect.top > bound.bottom || refRect.right < bound.left) {
+    if (data.hide === true) {
+      return data;
+    }
+    data.hide = true;
+    data.attributes["x-out-of-boundaries"] = "";
+  } else {
+    if (data.hide === false) {
+      return data;
+    }
+    data.hide = false;
+    data.attributes["x-out-of-boundaries"] = false;
+  }
+  return data;
+}
+function inner(data) {
+  var placement = data.placement;
+  var basePlacement = placement.split("-")[0];
+  var _data$offsets = data.offsets, popper = _data$offsets.popper, reference = _data$offsets.reference;
+  var isHoriz = ["left", "right"].indexOf(basePlacement) !== -1;
+  var subtractLength = ["top", "left"].indexOf(basePlacement) === -1;
+  popper[isHoriz ? "left" : "top"] = reference[basePlacement] - (subtractLength ? popper[isHoriz ? "width" : "height"] : 0);
+  data.placement = getOppositePlacement(placement);
+  data.offsets.popper = getClientRect(popper);
+  return data;
+}
+var modifiers = {
+  /**
+   * Modifier used to shift the popper on the start or end of its reference
+   * element.<br />
+   * It will read the variation of the `placement` property.<br />
+   * It can be one either `-end` or `-start`.
+   * @memberof modifiers
+   * @inner
+   */
+  shift: {
+    /** @prop {number} order=100 - Index used to define the order of execution */
+    order: 100,
+    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
+    enabled: true,
+    /** @prop {ModifierFn} */
+    fn: shift
+  },
+  /**
+   * The `offset` modifier can shift your popper on both its axis.
+   *
+   * It accepts the following units:
+   * - `px` or unit-less, interpreted as pixels
+   * - `%` or `%r`, percentage relative to the length of the reference element
+   * - `%p`, percentage relative to the length of the popper element
+   * - `vw`, CSS viewport width unit
+   * - `vh`, CSS viewport height unit
+   *
+   * For length is intended the main axis relative to the placement of the popper.<br />
+   * This means that if the placement is `top` or `bottom`, the length will be the
+   * `width`. In case of `left` or `right`, it will be the `height`.
+   *
+   * You can provide a single value (as `Number` or `String`), or a pair of values
+   * as `String` divided by a comma or one (or more) white spaces.<br />
+   * The latter is a deprecated method because it leads to confusion and will be
+   * removed in v2.<br />
+   * Additionally, it accepts additions and subtractions between different units.
+   * Note that multiplications and divisions aren't supported.
+   *
+   * Valid examples are:
+   * ```
+   * 10
+   * '10%'
+   * '10, 10'
+   * '10%, 10'
+   * '10 + 10%'
+   * '10 - 5vh + 3%'
+   * '-10px + 5vh, 5px - 6%'
+   * ```
+   * > **NB**: If you desire to apply offsets to your poppers in a way that may make them overlap
+   * > with their reference element, unfortunately, you will have to disable the `flip` modifier.
+   * > You can read more on this at this [issue](https://github.com/FezVrasta/popper.js/issues/373).
+   *
+   * @memberof modifiers
+   * @inner
+   */
+  offset: {
+    /** @prop {number} order=200 - Index used to define the order of execution */
+    order: 200,
+    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
+    enabled: true,
+    /** @prop {ModifierFn} */
+    fn: offset,
+    /** @prop {Number|String} offset=0
+     * The offset value as described in the modifier description
+     */
+    offset: 0
+  },
+  /**
+   * Modifier used to prevent the popper from being positioned outside the boundary.
+   *
+   * A scenario exists where the reference itself is not within the boundaries.<br />
+   * We can say it has "escaped the boundaries" — or just "escaped".<br />
+   * In this case we need to decide whether the popper should either:
+   *
+   * - detach from the reference and remain "trapped" in the boundaries, or
+   * - if it should ignore the boundary and "escape with its reference"
+   *
+   * When `escapeWithReference` is set to`true` and reference is completely
+   * outside its boundaries, the popper will overflow (or completely leave)
+   * the boundaries in order to remain attached to the edge of the reference.
+   *
+   * @memberof modifiers
+   * @inner
+   */
+  preventOverflow: {
+    /** @prop {number} order=300 - Index used to define the order of execution */
+    order: 300,
+    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
+    enabled: true,
+    /** @prop {ModifierFn} */
+    fn: preventOverflow,
+    /**
+     * @prop {Array} [priority=['left','right','top','bottom']]
+     * Popper will try to prevent overflow following these priorities by default,
+     * then, it could overflow on the left and on top of the `boundariesElement`
+     */
+    priority: ["left", "right", "top", "bottom"],
+    /**
+     * @prop {number} padding=5
+     * Amount of pixel used to define a minimum distance between the boundaries
+     * and the popper. This makes sure the popper always has a little padding
+     * between the edges of its container
+     */
+    padding: 5,
+    /**
+     * @prop {String|HTMLElement} boundariesElement='scrollParent'
+     * Boundaries used by the modifier. Can be `scrollParent`, `window`,
+     * `viewport` or any DOM element.
+     */
+    boundariesElement: "scrollParent"
+  },
+  /**
+   * Modifier used to make sure the reference and its popper stay near each other
+   * without leaving any gap between the two. Especially useful when the arrow is
+   * enabled and you want to ensure that it points to its reference element.
+   * It cares only about the first axis. You can still have poppers with margin
+   * between the popper and its reference element.
+   * @memberof modifiers
+   * @inner
+   */
+  keepTogether: {
+    /** @prop {number} order=400 - Index used to define the order of execution */
+    order: 400,
+    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
+    enabled: true,
+    /** @prop {ModifierFn} */
+    fn: keepTogether
+  },
+  /**
+   * This modifier is used to move the `arrowElement` of the popper to make
+   * sure it is positioned between the reference element and its popper element.
+   * It will read the outer size of the `arrowElement` node to detect how many
+   * pixels of conjunction are needed.
+   *
+   * It has no effect if no `arrowElement` is provided.
+   * @memberof modifiers
+   * @inner
+   */
+  arrow: {
+    /** @prop {number} order=500 - Index used to define the order of execution */
+    order: 500,
+    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
+    enabled: true,
+    /** @prop {ModifierFn} */
+    fn: arrow,
+    /** @prop {String|HTMLElement} element='[x-arrow]' - Selector or node used as arrow */
+    element: "[x-arrow]"
+  },
+  /**
+   * Modifier used to flip the popper's placement when it starts to overlap its
+   * reference element.
+   *
+   * Requires the `preventOverflow` modifier before it in order to work.
+   *
+   * **NOTE:** this modifier will interrupt the current update cycle and will
+   * restart it if it detects the need to flip the placement.
+   * @memberof modifiers
+   * @inner
+   */
+  flip: {
+    /** @prop {number} order=600 - Index used to define the order of execution */
+    order: 600,
+    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
+    enabled: true,
+    /** @prop {ModifierFn} */
+    fn: flip,
+    /**
+     * @prop {String|Array} behavior='flip'
+     * The behavior used to change the popper's placement. It can be one of
+     * `flip`, `clockwise`, `counterclockwise` or an array with a list of valid
+     * placements (with optional variations)
+     */
+    behavior: "flip",
+    /**
+     * @prop {number} padding=5
+     * The popper will flip if it hits the edges of the `boundariesElement`
+     */
+    padding: 5,
+    /**
+     * @prop {String|HTMLElement} boundariesElement='viewport'
+     * The element which will define the boundaries of the popper position.
+     * The popper will never be placed outside of the defined boundaries
+     * (except if `keepTogether` is enabled)
+     */
+    boundariesElement: "viewport",
+    /**
+     * @prop {Boolean} flipVariations=false
+     * The popper will switch placement variation between `-start` and `-end` when
+     * the reference element overlaps its boundaries.
+     *
+     * The original placement should have a set variation.
+     */
+    flipVariations: false,
+    /**
+     * @prop {Boolean} flipVariationsByContent=false
+     * The popper will switch placement variation between `-start` and `-end` when
+     * the popper element overlaps its reference boundaries.
+     *
+     * The original placement should have a set variation.
+     */
+    flipVariationsByContent: false
+  },
+  /**
+   * Modifier used to make the popper flow toward the inner of the reference element.
+   * By default, when this modifier is disabled, the popper will be placed outside
+   * the reference element.
+   * @memberof modifiers
+   * @inner
+   */
+  inner: {
+    /** @prop {number} order=700 - Index used to define the order of execution */
+    order: 700,
+    /** @prop {Boolean} enabled=false - Whether the modifier is enabled or not */
+    enabled: false,
+    /** @prop {ModifierFn} */
+    fn: inner
+  },
+  /**
+   * Modifier used to hide the popper when its reference element is outside of the
+   * popper boundaries. It will set a `x-out-of-boundaries` attribute which can
+   * be used to hide with a CSS selector the popper when its reference is
+   * out of boundaries.
+   *
+   * Requires the `preventOverflow` modifier before it in order to work.
+   * @memberof modifiers
+   * @inner
+   */
+  hide: {
+    /** @prop {number} order=800 - Index used to define the order of execution */
+    order: 800,
+    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
+    enabled: true,
+    /** @prop {ModifierFn} */
+    fn: hide
+  },
+  /**
+   * Computes the style that will be applied to the popper element to gets
+   * properly positioned.
+   *
+   * Note that this modifier will not touch the DOM, it just prepares the styles
+   * so that `applyStyle` modifier can apply it. This separation is useful
+   * in case you need to replace `applyStyle` with a custom implementation.
+   *
+   * This modifier has `850` as `order` value to maintain backward compatibility
+   * with previous versions of Popper.js. Expect the modifiers ordering method
+   * to change in future major versions of the library.
+   *
+   * @memberof modifiers
+   * @inner
+   */
+  computeStyle: {
+    /** @prop {number} order=850 - Index used to define the order of execution */
+    order: 850,
+    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
+    enabled: true,
+    /** @prop {ModifierFn} */
+    fn: computeStyle,
+    /**
+     * @prop {Boolean} gpuAcceleration=true
+     * If true, it uses the CSS 3D transformation to position the popper.
+     * Otherwise, it will use the `top` and `left` properties
+     */
+    gpuAcceleration: true,
+    /**
+     * @prop {string} [x='bottom']
+     * Where to anchor the X axis (`bottom` or `top`). AKA X offset origin.
+     * Change this if your popper should grow in a direction different from `bottom`
+     */
+    x: "bottom",
+    /**
+     * @prop {string} [x='left']
+     * Where to anchor the Y axis (`left` or `right`). AKA Y offset origin.
+     * Change this if your popper should grow in a direction different from `right`
+     */
+    y: "right"
+  },
+  /**
+   * Applies the computed styles to the popper element.
+   *
+   * All the DOM manipulations are limited to this modifier. This is useful in case
+   * you want to integrate Popper.js inside a framework or view library and you
+   * want to delegate all the DOM manipulations to it.
+   *
+   * Note that if you disable this modifier, you must make sure the popper element
+   * has its position set to `absolute` before Popper.js can do its work!
+   *
+   * Just disable this modifier and define your own to achieve the desired effect.
+   *
+   * @memberof modifiers
+   * @inner
+   */
+  applyStyle: {
+    /** @prop {number} order=900 - Index used to define the order of execution */
+    order: 900,
+    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
+    enabled: true,
+    /** @prop {ModifierFn} */
+    fn: applyStyle,
+    /** @prop {Function} */
+    onLoad: applyStyleOnLoad,
+    /**
+     * @deprecated since version 1.10.0, the property moved to `computeStyle` modifier
+     * @prop {Boolean} gpuAcceleration=true
+     * If true, it uses the CSS 3D transformation to position the popper.
+     * Otherwise, it will use the `top` and `left` properties
+     */
+    gpuAcceleration: void 0
+  }
+};
+var Defaults = {
+  /**
+   * Popper's placement.
+   * @prop {Popper.placements} placement='bottom'
+   */
+  placement: "bottom",
+  /**
+   * Set this to true if you want popper to position it self in 'fixed' mode
+   * @prop {Boolean} positionFixed=false
+   */
+  positionFixed: false,
+  /**
+   * Whether events (resize, scroll) are initially enabled.
+   * @prop {Boolean} eventsEnabled=true
+   */
+  eventsEnabled: true,
+  /**
+   * Set to true if you want to automatically remove the popper when
+   * you call the `destroy` method.
+   * @prop {Boolean} removeOnDestroy=false
+   */
+  removeOnDestroy: false,
+  /**
+   * Callback called when the popper is created.<br />
+   * By default, it is set to no-op.<br />
+   * Access Popper.js instance with `data.instance`.
+   * @prop {onCreate}
+   */
+  onCreate: function onCreate() {
+  },
+  /**
+   * Callback called when the popper is updated. This callback is not called
+   * on the initialization/creation of the popper, but only on subsequent
+   * updates.<br />
+   * By default, it is set to no-op.<br />
+   * Access Popper.js instance with `data.instance`.
+   * @prop {onUpdate}
+   */
+  onUpdate: function onUpdate() {
+  },
+  /**
+   * List of modifiers used to modify the offsets before they are applied to the popper.
+   * They provide most of the functionalities of Popper.js.
+   * @prop {modifiers}
+   */
+  modifiers
+};
+var Popper = (function() {
+  function Popper2(reference, popper) {
+    var _this = this;
+    var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+    classCallCheck(this, Popper2);
+    this.scheduleUpdate = function() {
+      return requestAnimationFrame(_this.update);
+    };
+    this.update = debounce(this.update.bind(this));
+    this.options = _extends({}, Popper2.Defaults, options);
+    this.state = {
+      isDestroyed: false,
+      isCreated: false,
+      scrollParents: []
+    };
+    this.reference = reference && reference.jquery ? reference[0] : reference;
+    this.popper = popper && popper.jquery ? popper[0] : popper;
+    this.options.modifiers = {};
+    Object.keys(_extends({}, Popper2.Defaults.modifiers, options.modifiers)).forEach(function(name) {
+      _this.options.modifiers[name] = _extends({}, Popper2.Defaults.modifiers[name] || {}, options.modifiers ? options.modifiers[name] : {});
+    });
+    this.modifiers = Object.keys(this.options.modifiers).map(function(name) {
+      return _extends({
+        name
+      }, _this.options.modifiers[name]);
+    }).sort(function(a, b) {
+      return a.order - b.order;
+    });
+    this.modifiers.forEach(function(modifierOptions) {
+      if (modifierOptions.enabled && isFunction(modifierOptions.onLoad)) {
+        modifierOptions.onLoad(_this.reference, _this.popper, _this.options, modifierOptions, _this.state);
+      }
+    });
+    this.update();
+    var eventsEnabled = this.options.eventsEnabled;
+    if (eventsEnabled) {
+      this.enableEventListeners();
+    }
+    this.state.eventsEnabled = eventsEnabled;
+  }
+  createClass(Popper2, [{
+    key: "update",
+    value: function update$$1() {
+      return update.call(this);
+    }
+  }, {
+    key: "destroy",
+    value: function destroy$$1() {
+      return destroy.call(this);
+    }
+  }, {
+    key: "enableEventListeners",
+    value: function enableEventListeners$$1() {
+      return enableEventListeners.call(this);
+    }
+  }, {
+    key: "disableEventListeners",
+    value: function disableEventListeners$$1() {
+      return disableEventListeners.call(this);
+    }
+    /**
+     * Schedules an update. It will run on the next UI update available.
+     * @method scheduleUpdate
+     * @memberof Popper
+     */
+    /**
+     * Collection of utilities useful when writing custom modifiers.
+     * Starting from version 1.7, this method is available only if you
+     * include `popper-utils.js` before `popper.js`.
+     *
+     * **DEPRECATION**: This way to access PopperUtils is deprecated
+     * and will be removed in v2! Use the PopperUtils module directly instead.
+     * Due to the high instability of the methods contained in Utils, we can't
+     * guarantee them to follow semver. Use them at your own risk!
+     * @static
+     * @private
+     * @type {Object}
+     * @deprecated since version 1.8
+     * @member Utils
+     * @memberof Popper
+     */
+  }]);
+  return Popper2;
+})();
+Popper.Utils = (typeof window !== "undefined" ? window : global).PopperUtils;
+Popper.placements = placements;
+Popper.Defaults = Defaults;
+export {
+  Popper as default
+};
+//# sourceMappingURL=popper.js.map