@xhsreds/reds-rn-next 0.0.1-beta-3

package/esm/components/Popover/rn/hook.js

@@ -0,0 +1,1394 @@
+import { a as _objectSpread2, b as _asyncToGenerator, c as _defineProperty, d as _regeneratorRuntime, e as _typeof, f as _toConsumableArray, g as _objectWithoutProperties, _ as _slicedToArray } from '../../../_chunks/BdytNqoo.js';
+import * as React from 'react';
+import { useState, useRef, useEffect } from 'react';
+import { Dimensions } from 'react-native';
+
+var min = Math.min;
+var max = Math.max;
+var oppositeSideMap = {
+  left: 'right',
+  right: 'left',
+  bottom: 'top',
+  top: 'bottom'
+};
+var oppositeAlignmentMap = {
+  start: 'end',
+  end: 'start'
+};
+function clamp(start, value, end) {
+  return max(start, min(value, end));
+}
+function evaluate(value, param) {
+  return typeof value === 'function' ? value(param) : value;
+}
+function getSide(placement) {
+  return placement.split('-')[0];
+}
+function getAlignment(placement) {
+  return placement.split('-')[1];
+}
+function getOppositeAxis(axis) {
+  return axis === 'x' ? 'y' : 'x';
+}
+function getAxisLength(axis) {
+  return axis === 'y' ? 'height' : 'width';
+}
+function getSideAxis(placement) {
+  return ['top', 'bottom'].includes(getSide(placement)) ? 'y' : 'x';
+}
+function getAlignmentAxis(placement) {
+  return getOppositeAxis(getSideAxis(placement));
+}
+function getAlignmentSides(placement, rects, rtl) {
+  if (rtl === void 0) {
+    rtl = false;
+  }
+  var alignment = getAlignment(placement);
+  var alignmentAxis = getAlignmentAxis(placement);
+  var length = getAxisLength(alignmentAxis);
+  var mainAlignmentSide = alignmentAxis === 'x' ? alignment === (rtl ? 'end' : 'start') ? 'right' : 'left' : alignment === 'start' ? 'bottom' : 'top';
+  if (rects.reference[length] > rects.floating[length]) {
+    mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
+  }
+  return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
+}
+function getExpandedPlacements(placement) {
+  var oppositePlacement = getOppositePlacement(placement);
+  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
+}
+function getOppositeAlignmentPlacement(placement) {
+  return placement.replace(/start|end/g, function (alignment) {
+    return oppositeAlignmentMap[alignment];
+  });
+}
+function getSideList(side, isStart, rtl) {
+  var lr = ['left', 'right'];
+  var rl = ['right', 'left'];
+  var tb = ['top', 'bottom'];
+  var bt = ['bottom', 'top'];
+  switch (side) {
+    case 'top':
+    case 'bottom':
+      if (rtl) return isStart ? rl : lr;
+      return isStart ? lr : rl;
+    case 'left':
+    case 'right':
+      return isStart ? tb : bt;
+    default:
+      return [];
+  }
+}
+function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
+  var alignment = getAlignment(placement);
+  var list = getSideList(getSide(placement), direction === 'start', rtl);
+  if (alignment) {
+    list = list.map(function (side) {
+      return side + "-" + alignment;
+    });
+    if (flipAlignment) {
+      list = list.concat(list.map(getOppositeAlignmentPlacement));
+    }
+  }
+  return list;
+}
+function getOppositePlacement(placement) {
+  return placement.replace(/left|right|bottom|top/g, function (side) {
+    return oppositeSideMap[side];
+  });
+}
+function expandPaddingObject(padding) {
+  return _objectSpread2({
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0
+  }, padding);
+}
+function getPaddingObject(padding) {
+  return typeof padding !== 'number' ? expandPaddingObject(padding) : {
+    top: padding,
+    right: padding,
+    bottom: padding,
+    left: padding
+  };
+}
+function rectToClientRect(rect) {
+  var x = rect.x,
+    y = rect.y,
+    width = rect.width,
+    height = rect.height;
+  return {
+    width: width,
+    height: height,
+    top: y,
+    left: x,
+    right: x + width,
+    bottom: y + height,
+    x: x,
+    y: y
+  };
+}
+
+var _excluded2 = ["mainAxis", "crossAxis", "fallbackPlacements", "fallbackStrategy", "fallbackAxisSideDirection", "flipAlignment"],
+  _excluded4 = ["mainAxis", "crossAxis", "limiter"];
+function computeCoordsFromPlacement(_ref, placement, rtl) {
+  var reference = _ref.reference,
+    floating = _ref.floating;
+  var sideAxis = getSideAxis(placement);
+  var alignmentAxis = getAlignmentAxis(placement);
+  var alignLength = getAxisLength(alignmentAxis);
+  var side = getSide(placement);
+  var isVertical = sideAxis === 'y';
+  var commonX = reference.x + reference.width / 2 - floating.width / 2;
+  var commonY = reference.y + reference.height / 2 - floating.height / 2;
+  var commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2;
+  var coords;
+  switch (side) {
+    case 'top':
+      coords = {
+        x: commonX,
+        y: reference.y - floating.height
+      };
+      break;
+    case 'bottom':
+      coords = {
+        x: commonX,
+        y: reference.y + reference.height
+      };
+      break;
+    case 'right':
+      coords = {
+        x: reference.x + reference.width,
+        y: commonY
+      };
+      break;
+    case 'left':
+      coords = {
+        x: reference.x - floating.width,
+        y: commonY
+      };
+      break;
+    default:
+      coords = {
+        x: reference.x,
+        y: reference.y
+      };
+  }
+  switch (getAlignment(placement)) {
+    case 'start':
+      coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);
+      break;
+    case 'end':
+      coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);
+      break;
+  }
+  return coords;
+}
+
+/**
+ * Computes the `x` and `y` coordinates that will place the floating element
+ * next to a given reference element.
+ *
+ * This export does not have any `platform` interface logic. You will need to
+ * write one for the platform you are using Floating UI with.
+ */
+var computePosition = /*#__PURE__*/function () {
+  var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(reference, floating, config) {
+    var _config$placement, placement, _config$strategy, strategy, _config$middleware, middleware, platform, validMiddleware, rtl, rects, _computeCoordsFromPla, x, y, statefulPlacement, middlewareData, resetCount, i, _validMiddleware$i, name, fn, _yield$fn, nextX, nextY, data, reset, _computeCoordsFromPla2;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _config$placement = config.placement, placement = _config$placement === void 0 ? 'bottom' : _config$placement, _config$strategy = config.strategy, strategy = _config$strategy === void 0 ? 'absolute' : _config$strategy, _config$middleware = config.middleware, middleware = _config$middleware === void 0 ? [] : _config$middleware, platform = config.platform;
+          validMiddleware = middleware.filter(Boolean);
+          _context.next = 4;
+          return platform.isRTL == null ? void 0 : platform.isRTL(floating);
+        case 4:
+          rtl = _context.sent;
+          _context.next = 7;
+          return platform.getElementRects({
+            reference: reference,
+            floating: floating,
+            strategy: strategy
+          });
+        case 7:
+          rects = _context.sent;
+          _computeCoordsFromPla = computeCoordsFromPlacement(rects, placement, rtl), x = _computeCoordsFromPla.x, y = _computeCoordsFromPla.y;
+          statefulPlacement = placement;
+          middlewareData = {};
+          resetCount = 0;
+          i = 0;
+        case 13:
+          if (!(i < validMiddleware.length)) {
+            _context.next = 45;
+            break;
+          }
+          _validMiddleware$i = validMiddleware[i], name = _validMiddleware$i.name, fn = _validMiddleware$i.fn;
+          _context.next = 17;
+          return fn({
+            x: x,
+            y: y,
+            initialPlacement: placement,
+            placement: statefulPlacement,
+            strategy: strategy,
+            middlewareData: middlewareData,
+            rects: rects,
+            platform: platform,
+            elements: {
+              reference: reference,
+              floating: floating
+            }
+          });
+        case 17:
+          _yield$fn = _context.sent;
+          nextX = _yield$fn.x;
+          nextY = _yield$fn.y;
+          data = _yield$fn.data;
+          reset = _yield$fn.reset;
+          x = nextX != null ? nextX : x;
+          y = nextY != null ? nextY : y;
+          middlewareData = _objectSpread2(_objectSpread2({}, middlewareData), {}, _defineProperty({}, name, _objectSpread2(_objectSpread2({}, middlewareData[name]), data)));
+          if (!(reset && resetCount <= 50)) {
+            _context.next = 42;
+            break;
+          }
+          resetCount++;
+          if (!(_typeof(reset) === 'object')) {
+            _context.next = 41;
+            break;
+          }
+          if (reset.placement) {
+            statefulPlacement = reset.placement;
+          }
+          if (!reset.rects) {
+            _context.next = 38;
+            break;
+          }
+          if (!(reset.rects === true)) {
+            _context.next = 36;
+            break;
+          }
+          _context.next = 33;
+          return platform.getElementRects({
+            reference: reference,
+            floating: floating,
+            strategy: strategy
+          });
+        case 33:
+          _context.t0 = _context.sent;
+          _context.next = 37;
+          break;
+        case 36:
+          _context.t0 = reset.rects;
+        case 37:
+          rects = _context.t0;
+        case 38:
+          _computeCoordsFromPla2 = computeCoordsFromPlacement(rects, statefulPlacement, rtl);
+          x = _computeCoordsFromPla2.x;
+          y = _computeCoordsFromPla2.y;
+        case 41:
+          i = -1;
+        case 42:
+          i++;
+          _context.next = 13;
+          break;
+        case 45:
+          return _context.abrupt("return", {
+            x: x,
+            y: y,
+            placement: statefulPlacement,
+            strategy: strategy,
+            middlewareData: middlewareData
+          });
+        case 46:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return function computePosition(_x, _x2, _x3) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+
+/**
+ * Resolves with an object of overflow side offsets that determine how much the
+ * element is overflowing a given clipping boundary on each side.
+ * - positive = overflowing the boundary by that number of pixels
+ * - negative = how many pixels left before it will overflow
+ * - 0 = lies flush with the boundary
+ * @see https://floating-ui.com/docs/detectOverflow
+ */
+function detectOverflow(_x4, _x5) {
+  return _detectOverflow.apply(this, arguments);
+}
+/**
+ * Provides data to position an inner element of the floating element so that it
+ * appears centered to the reference element.
+ * @see https://floating-ui.com/docs/arrow
+ */
+function _detectOverflow() {
+  _detectOverflow = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee10(state, options) {
+    var _await$platform$isEle, x, y, platform, rects, elements, strategy, _evaluate8, _evaluate8$boundary, boundary, _evaluate8$rootBounda, rootBoundary, _evaluate8$elementCon, elementContext, _evaluate8$altBoundar, altBoundary, _evaluate8$padding, padding, paddingObject, altContext, element, clippingClientRect, rect, offsetParent, offsetScale, elementClientRect;
+    return _regeneratorRuntime().wrap(function _callee10$(_context10) {
+      while (1) switch (_context10.prev = _context10.next) {
+        case 0:
+          if (options === void 0) {
+            options = {};
+          }
+          x = state.x, y = state.y, platform = state.platform, rects = state.rects, elements = state.elements, strategy = state.strategy;
+          _evaluate8 = evaluate(options, state), _evaluate8$boundary = _evaluate8.boundary, boundary = _evaluate8$boundary === void 0 ? 'clippingAncestors' : _evaluate8$boundary, _evaluate8$rootBounda = _evaluate8.rootBoundary, rootBoundary = _evaluate8$rootBounda === void 0 ? 'viewport' : _evaluate8$rootBounda, _evaluate8$elementCon = _evaluate8.elementContext, elementContext = _evaluate8$elementCon === void 0 ? 'floating' : _evaluate8$elementCon, _evaluate8$altBoundar = _evaluate8.altBoundary, altBoundary = _evaluate8$altBoundar === void 0 ? false : _evaluate8$altBoundar, _evaluate8$padding = _evaluate8.padding, padding = _evaluate8$padding === void 0 ? 0 : _evaluate8$padding;
+          paddingObject = getPaddingObject(padding);
+          altContext = elementContext === 'floating' ? 'reference' : 'floating';
+          element = elements[altBoundary ? altContext : elementContext];
+          _context10.t0 = rectToClientRect;
+          _context10.t1 = platform;
+          _context10.next = 10;
+          return platform.isElement == null ? void 0 : platform.isElement(element);
+        case 10:
+          _context10.t2 = _await$platform$isEle = _context10.sent;
+          if (!(_context10.t2 != null)) {
+            _context10.next = 15;
+            break;
+          }
+          _context10.t3 = _await$platform$isEle;
+          _context10.next = 16;
+          break;
+        case 15:
+          _context10.t3 = true;
+        case 16:
+          if (!_context10.t3) {
+            _context10.next = 20;
+            break;
+          }
+          _context10.t4 = element;
+          _context10.next = 26;
+          break;
+        case 20:
+          _context10.t5 = element.contextElement;
+          if (_context10.t5) {
+            _context10.next = 25;
+            break;
+          }
+          _context10.next = 24;
+          return platform.getDocumentElement == null ? void 0 : platform.getDocumentElement(elements.floating);
+        case 24:
+          _context10.t5 = _context10.sent;
+        case 25:
+          _context10.t4 = _context10.t5;
+        case 26:
+          _context10.t6 = _context10.t4;
+          _context10.t7 = boundary;
+          _context10.t8 = rootBoundary;
+          _context10.t9 = strategy;
+          _context10.t10 = {
+            element: _context10.t6,
+            boundary: _context10.t7,
+            rootBoundary: _context10.t8,
+            strategy: _context10.t9
+          };
+          _context10.next = 33;
+          return _context10.t1.getClippingRect.call(_context10.t1, _context10.t10);
+        case 33:
+          _context10.t11 = _context10.sent;
+          clippingClientRect = (0, _context10.t0)(_context10.t11);
+          rect = elementContext === 'floating' ? {
+            x: x,
+            y: y,
+            width: rects.floating.width,
+            height: rects.floating.height
+          } : rects.reference;
+          _context10.next = 38;
+          return platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(elements.floating);
+        case 38:
+          offsetParent = _context10.sent;
+          _context10.next = 41;
+          return platform.isElement == null ? void 0 : platform.isElement(offsetParent);
+        case 41:
+          if (!_context10.sent) {
+            _context10.next = 50;
+            break;
+          }
+          _context10.next = 44;
+          return platform.getScale == null ? void 0 : platform.getScale(offsetParent);
+        case 44:
+          _context10.t13 = _context10.sent;
+          if (_context10.t13) {
+            _context10.next = 47;
+            break;
+          }
+          _context10.t13 = {
+            x: 1,
+            y: 1
+          };
+        case 47:
+          _context10.t12 = _context10.t13;
+          _context10.next = 51;
+          break;
+        case 50:
+          _context10.t12 = {
+            x: 1,
+            y: 1
+          };
+        case 51:
+          offsetScale = _context10.t12;
+          _context10.t14 = rectToClientRect;
+          if (!platform.convertOffsetParentRelativeRectToViewportRelativeRect) {
+            _context10.next = 59;
+            break;
+          }
+          _context10.next = 56;
+          return platform.convertOffsetParentRelativeRectToViewportRelativeRect({
+            elements: elements,
+            rect: rect,
+            offsetParent: offsetParent,
+            strategy: strategy
+          });
+        case 56:
+          _context10.t15 = _context10.sent;
+          _context10.next = 60;
+          break;
+        case 59:
+          _context10.t15 = rect;
+        case 60:
+          _context10.t16 = _context10.t15;
+          elementClientRect = (0, _context10.t14)(_context10.t16);
+          return _context10.abrupt("return", {
+            top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y,
+            bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y,
+            left: (clippingClientRect.left - elementClientRect.left + paddingObject.left) / offsetScale.x,
+            right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x
+          });
+        case 63:
+        case "end":
+          return _context10.stop();
+      }
+    }, _callee10);
+  }));
+  return _detectOverflow.apply(this, arguments);
+}
+var arrow$2 = function arrow(options) {
+  return {
+    name: 'arrow',
+    options: options,
+    fn: function fn(state) {
+      return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
+        var x, y, placement, rects, platform, elements, middlewareData, _ref3, element, _ref3$padding, padding, paddingObject, coords, axis, length, arrowDimensions, isYAxis, minProp, maxProp, clientProp, endDiff, startDiff, arrowOffsetParent, clientSize, centerToReference, largestPossiblePadding, minPadding, maxPadding, min$1, max, center, offset, shouldAddOffset, alignmentOffset;
+        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              x = state.x, y = state.y, placement = state.placement, rects = state.rects, platform = state.platform, elements = state.elements, middlewareData = state.middlewareData; // Since `element` is required, we don't Partial<> the type.
+              _ref3 = evaluate(options, state) || {}, element = _ref3.element, _ref3$padding = _ref3.padding, padding = _ref3$padding === void 0 ? 0 : _ref3$padding;
+              if (!(element == null)) {
+                _context2.next = 4;
+                break;
+              }
+              return _context2.abrupt("return", {});
+            case 4:
+              paddingObject = getPaddingObject(padding);
+              coords = {
+                x: x,
+                y: y
+              };
+              axis = getAlignmentAxis(placement);
+              length = getAxisLength(axis);
+              _context2.next = 10;
+              return platform.getDimensions(element);
+            case 10:
+              arrowDimensions = _context2.sent;
+              isYAxis = axis === 'y';
+              minProp = isYAxis ? 'top' : 'left';
+              maxProp = isYAxis ? 'bottom' : 'right';
+              clientProp = isYAxis ? 'clientHeight' : 'clientWidth';
+              endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length];
+              startDiff = coords[axis] - rects.reference[axis];
+              _context2.next = 19;
+              return platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(element);
+            case 19:
+              arrowOffsetParent = _context2.sent;
+              clientSize = arrowOffsetParent ? arrowOffsetParent[clientProp] : 0; // DOM platform can return `window` as the `offsetParent`.
+              _context2.t0 = !clientSize;
+              if (_context2.t0) {
+                _context2.next = 26;
+                break;
+              }
+              _context2.next = 25;
+              return platform.isElement == null ? void 0 : platform.isElement(arrowOffsetParent);
+            case 25:
+              _context2.t0 = !_context2.sent;
+            case 26:
+              if (!_context2.t0) {
+                _context2.next = 28;
+                break;
+              }
+              clientSize = elements.floating[clientProp] || rects.floating[length];
+            case 28:
+              centerToReference = endDiff / 2 - startDiff / 2; // If the padding is large enough that it causes the arrow to no longer be
+              // centered, modify the padding so that it is centered.
+              largestPossiblePadding = clientSize / 2 - arrowDimensions[length] / 2 - 1;
+              minPadding = min(paddingObject[minProp], largestPossiblePadding);
+              maxPadding = min(paddingObject[maxProp], largestPossiblePadding); // Make sure the arrow doesn't overflow the floating element if the center
+              // point is outside the floating element's bounds.
+              min$1 = minPadding;
+              max = clientSize - arrowDimensions[length] - maxPadding;
+              center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;
+              offset = clamp(min$1, center, max); // If the reference is small enough that the arrow's padding causes it to
+              // to point to nothing for an aligned placement, adjust the offset of the
+              // floating element itself. To ensure `shift()` continues to take action,
+              // a single reset is performed when this is true.
+              shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center !== offset && rects.reference[length] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;
+              alignmentOffset = shouldAddOffset ? center < min$1 ? center - min$1 : center - max : 0;
+              return _context2.abrupt("return", _defineProperty(_defineProperty(_defineProperty({}, axis, coords[axis] + alignmentOffset), "data", _objectSpread2(_defineProperty(_defineProperty({}, axis, offset), "centerOffset", center - offset - alignmentOffset), shouldAddOffset && {
+                alignmentOffset: alignmentOffset
+              })), "reset", shouldAddOffset));
+            case 39:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2);
+      }))();
+    }
+  };
+};
+
+/**
+ * Optimizes the visibility of the floating element by flipping the `placement`
+ * in order to keep it in view when the preferred placement(s) will overflow the
+ * clipping boundary. Alternative to `autoPlacement`.
+ * @see https://floating-ui.com/docs/flip
+ */
+var flip$1 = function flip(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
+    name: 'flip',
+    options: options,
+    fn: function fn(state) {
+      return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4() {
+        var _middlewareData$arrow, _middlewareData$flip, placement, middlewareData, rects, initialPlacement, platform, elements, _evaluate2, _evaluate2$mainAxis, checkMainAxis, _evaluate2$crossAxis, checkCrossAxis, specifiedFallbackPlacements, _evaluate2$fallbackSt, fallbackStrategy, _evaluate2$fallbackAx, fallbackAxisSideDirection, _evaluate2$flipAlignm, flipAlignment, detectOverflowOptions, side, isBasePlacement, rtl, fallbackPlacements, placements, overflow, overflows, overflowsData, _sides, _middlewareData$flip2, _overflowsData$filter, nextIndex, nextPlacement, resetPlacement, _overflowsData$map$so, _placement;
+        return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              placement = state.placement, middlewareData = state.middlewareData, rects = state.rects, initialPlacement = state.initialPlacement, platform = state.platform, elements = state.elements;
+              _evaluate2 = evaluate(options, state), _evaluate2$mainAxis = _evaluate2.mainAxis, checkMainAxis = _evaluate2$mainAxis === void 0 ? true : _evaluate2$mainAxis, _evaluate2$crossAxis = _evaluate2.crossAxis, checkCrossAxis = _evaluate2$crossAxis === void 0 ? true : _evaluate2$crossAxis, specifiedFallbackPlacements = _evaluate2.fallbackPlacements, _evaluate2$fallbackSt = _evaluate2.fallbackStrategy, fallbackStrategy = _evaluate2$fallbackSt === void 0 ? 'bestFit' : _evaluate2$fallbackSt, _evaluate2$fallbackAx = _evaluate2.fallbackAxisSideDirection, fallbackAxisSideDirection = _evaluate2$fallbackAx === void 0 ? 'none' : _evaluate2$fallbackAx, _evaluate2$flipAlignm = _evaluate2.flipAlignment, flipAlignment = _evaluate2$flipAlignm === void 0 ? true : _evaluate2$flipAlignm, detectOverflowOptions = _objectWithoutProperties(_evaluate2, _excluded2); // If a reset by the arrow was caused due to an alignment offset being
+              // added, we should skip any logic now since `flip()` has already done its
+              // work.
+              // https://github.com/floating-ui/floating-ui/issues/2549#issuecomment-1719601643
+              if (!((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset)) {
+                _context4.next = 4;
+                break;
+              }
+              return _context4.abrupt("return", {});
+            case 4:
+              side = getSide(placement);
+              isBasePlacement = getSide(initialPlacement) === initialPlacement;
+              _context4.next = 8;
+              return platform.isRTL == null ? void 0 : platform.isRTL(elements.floating);
+            case 8:
+              rtl = _context4.sent;
+              fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));
+              if (!specifiedFallbackPlacements && fallbackAxisSideDirection !== 'none') {
+                fallbackPlacements.push.apply(fallbackPlacements, _toConsumableArray(getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl)));
+              }
+              placements = [initialPlacement].concat(_toConsumableArray(fallbackPlacements));
+              _context4.next = 14;
+              return detectOverflow(state, detectOverflowOptions);
+            case 14:
+              overflow = _context4.sent;
+              overflows = [];
+              overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];
+              if (checkMainAxis) {
+                overflows.push(overflow[side]);
+              }
+              if (checkCrossAxis) {
+                _sides = getAlignmentSides(placement, rects, rtl);
+                overflows.push(overflow[_sides[0]], overflow[_sides[1]]);
+              }
+              overflowsData = [].concat(_toConsumableArray(overflowsData), [{
+                placement: placement,
+                overflows: overflows
+              }]);
+
+              // One or more sides is overflowing.
+              if (overflows.every(function (side) {
+                return side <= 0;
+              })) {
+                _context4.next = 37;
+                break;
+              }
+              nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;
+              nextPlacement = placements[nextIndex];
+              if (!nextPlacement) {
+                _context4.next = 25;
+                break;
+              }
+              return _context4.abrupt("return", {
+                data: {
+                  index: nextIndex,
+                  overflows: overflowsData
+                },
+                reset: {
+                  placement: nextPlacement
+                }
+              });
+            case 25:
+              // First, find the candidates that fit on the mainAxis side of overflow,
+              // then find the placement that fits the best on the main crossAxis side.
+              resetPlacement = (_overflowsData$filter = overflowsData.filter(function (d) {
+                return d.overflows[0] <= 0;
+              }).sort(function (a, b) {
+                return a.overflows[1] - b.overflows[1];
+              })[0]) == null ? void 0 : _overflowsData$filter.placement; // Otherwise fallback.
+              if (resetPlacement) {
+                _context4.next = 35;
+                break;
+              }
+              _context4.t0 = fallbackStrategy;
+              _context4.next = _context4.t0 === 'bestFit' ? 30 : _context4.t0 === 'initialPlacement' ? 33 : 35;
+              break;
+            case 30:
+              _placement = (_overflowsData$map$so = overflowsData.map(function (d) {
+                return [d.placement, d.overflows.filter(function (overflow) {
+                  return overflow > 0;
+                }).reduce(function (acc, overflow) {
+                  return acc + overflow;
+                }, 0)];
+              }).sort(function (a, b) {
+                return a[1] - b[1];
+              })[0]) == null ? void 0 : _overflowsData$map$so[0];
+              if (_placement) {
+                resetPlacement = _placement;
+              }
+              return _context4.abrupt("break", 35);
+            case 33:
+              resetPlacement = initialPlacement;
+              return _context4.abrupt("break", 35);
+            case 35:
+              if (!(placement !== resetPlacement)) {
+                _context4.next = 37;
+                break;
+              }
+              return _context4.abrupt("return", {
+                reset: {
+                  placement: resetPlacement
+                }
+              });
+            case 37:
+              return _context4.abrupt("return", {});
+            case 38:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4);
+      }))();
+    }
+  };
+};
+
+// For type backwards-compatibility, the `OffsetOptions` type was also
+// Derivable.
+function convertValueToCoords(_x6, _x7) {
+  return _convertValueToCoords.apply(this, arguments);
+}
+/**
+ * Modifies the placement by translating the floating element along the
+ * specified axes.
+ * A number (shorthand for `mainAxis` or distance), or an axes configuration
+ * object may be passed.
+ * @see https://floating-ui.com/docs/offset
+ */
+function _convertValueToCoords() {
+  _convertValueToCoords = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee11(state, options) {
+    var placement, platform, elements, rtl, side, alignment, isVertical, mainAxisMulti, crossAxisMulti, rawValue, _ref6, mainAxis, crossAxis, alignmentAxis;
+    return _regeneratorRuntime().wrap(function _callee11$(_context11) {
+      while (1) switch (_context11.prev = _context11.next) {
+        case 0:
+          placement = state.placement, platform = state.platform, elements = state.elements;
+          _context11.next = 3;
+          return platform.isRTL == null ? void 0 : platform.isRTL(elements.floating);
+        case 3:
+          rtl = _context11.sent;
+          side = getSide(placement);
+          alignment = getAlignment(placement);
+          isVertical = getSideAxis(placement) === 'y';
+          mainAxisMulti = ['left', 'top'].includes(side) ? -1 : 1;
+          crossAxisMulti = rtl && isVertical ? -1 : 1;
+          rawValue = evaluate(options, state); // eslint-disable-next-line prefer-const
+          _ref6 = typeof rawValue === 'number' ? {
+            mainAxis: rawValue,
+            crossAxis: 0,
+            alignmentAxis: null
+          } : _objectSpread2({
+            mainAxis: 0,
+            crossAxis: 0,
+            alignmentAxis: null
+          }, rawValue), mainAxis = _ref6.mainAxis, crossAxis = _ref6.crossAxis, alignmentAxis = _ref6.alignmentAxis;
+          if (alignment && typeof alignmentAxis === 'number') {
+            crossAxis = alignment === 'end' ? alignmentAxis * -1 : alignmentAxis;
+          }
+          return _context11.abrupt("return", isVertical ? {
+            x: crossAxis * crossAxisMulti,
+            y: mainAxis * mainAxisMulti
+          } : {
+            x: mainAxis * mainAxisMulti,
+            y: crossAxis * crossAxisMulti
+          });
+        case 13:
+        case "end":
+          return _context11.stop();
+      }
+    }, _callee11);
+  }));
+  return _convertValueToCoords.apply(this, arguments);
+}
+var offset$1 = function offset(options) {
+  return {
+    name: 'offset',
+    options: options,
+    fn: function fn(state) {
+      return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee7() {
+        var _middlewareData$offse, _middlewareData$arrow, x, y, placement, middlewareData, diffCoords;
+        return _regeneratorRuntime().wrap(function _callee7$(_context7) {
+          while (1) switch (_context7.prev = _context7.next) {
+            case 0:
+              x = state.x, y = state.y, placement = state.placement, middlewareData = state.middlewareData;
+              _context7.next = 3;
+              return convertValueToCoords(state, options);
+            case 3:
+              diffCoords = _context7.sent;
+              if (!(placement === ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse.placement) && (_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset)) {
+                _context7.next = 6;
+                break;
+              }
+              return _context7.abrupt("return", {});
+            case 6:
+              return _context7.abrupt("return", {
+                x: x + diffCoords.x,
+                y: y + diffCoords.y,
+                data: _objectSpread2(_objectSpread2({}, diffCoords), {}, {
+                  placement: placement
+                })
+              });
+            case 7:
+            case "end":
+              return _context7.stop();
+          }
+        }, _callee7);
+      }))();
+    }
+  };
+};
+
+/**
+ * Optimizes the visibility of the floating element by shifting it in order to
+ * keep it in view when it will overflow the clipping boundary.
+ * @see https://floating-ui.com/docs/shift
+ */
+var shift$1 = function shift(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
+    name: 'shift',
+    options: options,
+    fn: function fn(state) {
+      return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee8() {
+        var x, y, placement, _evaluate5, _evaluate5$mainAxis, checkMainAxis, _evaluate5$crossAxis, checkCrossAxis, _evaluate5$limiter, limiter, detectOverflowOptions, coords, overflow, crossAxis, mainAxis, mainAxisCoord, crossAxisCoord, minSide, maxSide, _min, _max, _minSide, _maxSide, _min2, _max2, limitedCoords;
+        return _regeneratorRuntime().wrap(function _callee8$(_context8) {
+          while (1) switch (_context8.prev = _context8.next) {
+            case 0:
+              x = state.x, y = state.y, placement = state.placement;
+              _evaluate5 = evaluate(options, state), _evaluate5$mainAxis = _evaluate5.mainAxis, checkMainAxis = _evaluate5$mainAxis === void 0 ? true : _evaluate5$mainAxis, _evaluate5$crossAxis = _evaluate5.crossAxis, checkCrossAxis = _evaluate5$crossAxis === void 0 ? false : _evaluate5$crossAxis, _evaluate5$limiter = _evaluate5.limiter, limiter = _evaluate5$limiter === void 0 ? {
+                fn: function fn(_ref) {
+                  var x = _ref.x,
+                    y = _ref.y;
+                  return {
+                    x: x,
+                    y: y
+                  };
+                }
+              } : _evaluate5$limiter, detectOverflowOptions = _objectWithoutProperties(_evaluate5, _excluded4);
+              coords = {
+                x: x,
+                y: y
+              };
+              _context8.next = 5;
+              return detectOverflow(state, detectOverflowOptions);
+            case 5:
+              overflow = _context8.sent;
+              crossAxis = getSideAxis(getSide(placement));
+              mainAxis = getOppositeAxis(crossAxis);
+              mainAxisCoord = coords[mainAxis];
+              crossAxisCoord = coords[crossAxis];
+              if (checkMainAxis) {
+                minSide = mainAxis === 'y' ? 'top' : 'left';
+                maxSide = mainAxis === 'y' ? 'bottom' : 'right';
+                _min = mainAxisCoord + overflow[minSide];
+                _max = mainAxisCoord - overflow[maxSide];
+                mainAxisCoord = clamp(_min, mainAxisCoord, _max);
+              }
+              if (checkCrossAxis) {
+                _minSide = crossAxis === 'y' ? 'top' : 'left';
+                _maxSide = crossAxis === 'y' ? 'bottom' : 'right';
+                _min2 = crossAxisCoord + overflow[_minSide];
+                _max2 = crossAxisCoord - overflow[_maxSide];
+                crossAxisCoord = clamp(_min2, crossAxisCoord, _max2);
+              }
+              limitedCoords = limiter.fn(_objectSpread2(_objectSpread2({}, state), {}, _defineProperty(_defineProperty({}, mainAxis, mainAxisCoord), crossAxis, crossAxisCoord)));
+              return _context8.abrupt("return", _objectSpread2(_objectSpread2({}, limitedCoords), {}, {
+                data: {
+                  x: limitedCoords.x - x,
+                  y: limitedCoords.y - y
+                }
+              }));
+            case 14:
+            case "end":
+              return _context8.stop();
+          }
+        }, _callee8);
+      }))();
+    }
+  };
+};
+/**
+ * Built-in `limiter` that will stop `shift()` at a certain point.
+ */
+var limitShift$1 = function limitShift(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
+    options: options,
+    fn: function fn(state) {
+      var x = state.x,
+        y = state.y,
+        placement = state.placement,
+        rects = state.rects,
+        middlewareData = state.middlewareData;
+      var _evaluate6 = evaluate(options, state),
+        _evaluate6$offset = _evaluate6.offset,
+        offset = _evaluate6$offset === void 0 ? 0 : _evaluate6$offset,
+        _evaluate6$mainAxis = _evaluate6.mainAxis,
+        checkMainAxis = _evaluate6$mainAxis === void 0 ? true : _evaluate6$mainAxis,
+        _evaluate6$crossAxis = _evaluate6.crossAxis,
+        checkCrossAxis = _evaluate6$crossAxis === void 0 ? true : _evaluate6$crossAxis;
+      var coords = {
+        x: x,
+        y: y
+      };
+      var crossAxis = getSideAxis(placement);
+      var mainAxis = getOppositeAxis(crossAxis);
+      var mainAxisCoord = coords[mainAxis];
+      var crossAxisCoord = coords[crossAxis];
+      var rawOffset = evaluate(offset, state);
+      var computedOffset = typeof rawOffset === 'number' ? {
+        mainAxis: rawOffset,
+        crossAxis: 0
+      } : _objectSpread2({
+        mainAxis: 0,
+        crossAxis: 0
+      }, rawOffset);
+      if (checkMainAxis) {
+        var len = mainAxis === 'y' ? 'height' : 'width';
+        var limitMin = rects.reference[mainAxis] - rects.floating[len] + computedOffset.mainAxis;
+        var limitMax = rects.reference[mainAxis] + rects.reference[len] - computedOffset.mainAxis;
+        if (mainAxisCoord < limitMin) {
+          mainAxisCoord = limitMin;
+        } else if (mainAxisCoord > limitMax) {
+          mainAxisCoord = limitMax;
+        }
+      }
+      if (checkCrossAxis) {
+        var _middlewareData$offse, _middlewareData$offse2;
+        var _len = mainAxis === 'y' ? 'width' : 'height';
+        var isOriginSide = ['top', 'left'].includes(getSide(placement));
+        var _limitMin = rects.reference[crossAxis] - rects.floating[_len] + (isOriginSide ? ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse[crossAxis]) || 0 : 0) + (isOriginSide ? 0 : computedOffset.crossAxis);
+        var _limitMax = rects.reference[crossAxis] + rects.reference[_len] + (isOriginSide ? 0 : ((_middlewareData$offse2 = middlewareData.offset) == null ? void 0 : _middlewareData$offse2[crossAxis]) || 0) - (isOriginSide ? computedOffset.crossAxis : 0);
+        if (crossAxisCoord < _limitMin) {
+          crossAxisCoord = _limitMin;
+        } else if (crossAxisCoord > _limitMax) {
+          crossAxisCoord = _limitMax;
+        }
+      }
+      return _defineProperty(_defineProperty({}, mainAxis, mainAxisCoord), crossAxis, crossAxisCoord);
+    }
+  };
+};
+
+var ORIGIN$1 = {
+  x: 0,
+  y: 0
+};
+function isView(reference) {
+  return 'measure' in reference;
+}
+var createPlatform = function createPlatform(_ref) {
+  var offsetParent = _ref.offsetParent,
+    _ref$sameScrollView = _ref.sameScrollView,
+    sameScrollView = _ref$sameScrollView === void 0 ? true : _ref$sameScrollView,
+    _ref$scrollOffsets = _ref.scrollOffsets,
+    scrollOffsets = _ref$scrollOffsets === void 0 ? ORIGIN$1 : _ref$scrollOffsets;
+  return {
+    getElementRects: function getElementRects(_ref2) {
+      var reference = _ref2.reference,
+        floating = _ref2.floating;
+      return new Promise(function (resolve) {
+        var onMeasure = function onMeasure(offsetX, offsetY) {
+          if (offsetX === void 0) {
+            offsetX = 0;
+          }
+          if (offsetY === void 0) {
+            offsetY = 0;
+          }
+          floating.measure(function (x, y, width, height) {
+            var floatingRect = _objectSpread2({
+              width: width,
+              height: height
+            }, ORIGIN$1);
+            var method = sameScrollView ? 'measure' : 'measureInWindow';
+            if (isView(reference)) {
+              reference[method](function (x, y, width, height) {
+                var referenceRect = {
+                  width: width,
+                  height: height,
+                  x: x - offsetX,
+                  y: y - offsetY
+                };
+                resolve({
+                  reference: referenceRect,
+                  floating: floatingRect
+                });
+              });
+            } else {
+              var boundingRect = reference.getBoundingClientRect();
+              var referenceRect = {
+                width: boundingRect.width,
+                height: boundingRect.height,
+                x: boundingRect.x - offsetX,
+                y: boundingRect.y - offsetY
+              };
+              resolve({
+                reference: referenceRect,
+                floating: floatingRect
+              });
+            }
+          });
+        };
+        if (offsetParent) {
+          offsetParent.measure(onMeasure);
+        } else {
+          onMeasure();
+        }
+      });
+    },
+    getClippingRect: function getClippingRect() {
+      var _Dimensions$get = Dimensions.get('window'),
+        width = _Dimensions$get.width,
+        height = _Dimensions$get.height;
+      return Promise.resolve(_objectSpread2({
+        width: width,
+        height: height
+      }, sameScrollView ? scrollOffsets : ORIGIN$1));
+    },
+    convertOffsetParentRelativeRectToViewportRelativeRect: function convertOffsetParentRelativeRectToViewportRelativeRect(_ref3) {
+      var rect = _ref3.rect;
+      return new Promise(function (resolve) {
+        var onMeasure = function onMeasure(offsetX, offsetY) {
+          if (offsetX === void 0) {
+            offsetX = 0;
+          }
+          if (offsetY === void 0) {
+            offsetY = 0;
+          }
+          resolve(_objectSpread2(_objectSpread2({}, rect), {}, {
+            x: rect.x + offsetX,
+            y: rect.y + offsetY
+          }));
+        };
+        if (offsetParent) {
+          offsetParent.measure(onMeasure);
+        } else {
+          onMeasure();
+        }
+      });
+    },
+    getDimensions: function getDimensions(element) {
+      return new Promise(function (resolve) {
+        return element.measure(function (x, y, width, height) {
+          return resolve({
+            width: width,
+            height: height
+          });
+        });
+      });
+    }
+  };
+};
+
+// Fork of `fast-deep-equal` that only does the comparisons we need and compares
+// functions
+function deepEqual(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (_typeof(a) !== _typeof(b)) {
+    return false;
+  }
+  if (typeof a === 'function' && a.toString() === b.toString()) {
+    return true;
+  }
+  var length;
+  var i;
+  var keys;
+  if (a && b && _typeof(a) === 'object') {
+    if (Array.isArray(a)) {
+      length = a.length;
+      if (length !== b.length) return false;
+      for (i = length; i-- !== 0;) {
+        if (!deepEqual(a[i], b[i])) {
+          return false;
+        }
+      }
+      return true;
+    }
+    keys = Object.keys(a);
+    length = keys.length;
+    if (length !== Object.keys(b).length) {
+      return false;
+    }
+    for (i = length; i-- !== 0;) {
+      if (!{}.hasOwnProperty.call(b, keys[i])) {
+        return false;
+      }
+    }
+    for (i = length; i-- !== 0;) {
+      var key = keys[i];
+      if (key === '_owner' && a.$$typeof) {
+        continue;
+      }
+      if (!deepEqual(a[key], b[key])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return a !== a && b !== b;
+}
+var ORIGIN = {
+  x: 0,
+  y: 0
+};
+function useFloating$1(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  var _options = options,
+    _options$placement = _options.placement,
+    placement = _options$placement === void 0 ? 'bottom' : _options$placement,
+    _options$middleware = _options.middleware,
+    middleware = _options$middleware === void 0 ? [] : _options$middleware,
+    _options$sameScrollVi = _options.sameScrollView,
+    sameScrollView = _options$sameScrollVi === void 0 ? true : _options$sameScrollVi,
+    _options$elements = _options.elements,
+    _options$elements2 = _options$elements === void 0 ? {} : _options$elements,
+    externalReference = _options$elements2.reference,
+    externalFloating = _options$elements2.floating,
+    externalOffsetParent = _options$elements2.offsetParent;
+  var _React$useState = React.useState(null),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    _reference = _React$useState2[0],
+    _setReference = _React$useState2[1];
+  var _React$useState3 = React.useState(null),
+    _React$useState4 = _slicedToArray(_React$useState3, 2),
+    _floating = _React$useState4[0],
+    _setFloating = _React$useState4[1];
+  var _React$useState5 = React.useState(null),
+    _React$useState6 = _slicedToArray(_React$useState5, 2),
+    _offsetParent = _React$useState6[0],
+    _setOffsetParent = _React$useState6[1];
+  var referenceEl = externalReference || _reference;
+  var floatingEl = externalFloating || _floating;
+  var offsetParentEl = externalOffsetParent || _offsetParent;
+  var setReference = React.useCallback(function (node) {
+    if (node !== referenceRef.current) {
+      referenceRef.current = node;
+      _setReference(node);
+    }
+  }, []);
+  var setFloating = React.useCallback(function (node) {
+    if (node !== floatingRef.current) {
+      floatingRef.current = node;
+      _setFloating(node);
+    }
+  }, []);
+  var setOffsetParent = React.useCallback(function (node) {
+    if (node !== offsetParentRef.current) {
+      offsetParentRef.current = node;
+      _setOffsetParent(node);
+    }
+  }, []);
+  var referenceRef = React.useRef(null);
+  var floatingRef = React.useRef(null);
+  var offsetParentRef = React.useRef(null);
+  var _React$useState7 = React.useState({
+      x: 0,
+      y: 0,
+      placement: placement,
+      strategy: 'absolute',
+      middlewareData: {}
+    }),
+    _React$useState8 = _slicedToArray(_React$useState7, 2),
+    data = _React$useState8[0],
+    setData = _React$useState8[1];
+  var _React$useState9 = React.useState(ORIGIN),
+    _React$useState10 = _slicedToArray(_React$useState9, 2),
+    scrollOffsets = _React$useState10[0],
+    setScrollOffsets = _React$useState10[1];
+  var _React$useState11 = React.useState(middleware),
+    _React$useState12 = _slicedToArray(_React$useState11, 2),
+    latestMiddleware = _React$useState12[0],
+    setLatestMiddleware = _React$useState12[1];
+  if (!deepEqual(latestMiddleware, middleware)) {
+    setLatestMiddleware(middleware);
+  }
+  var platform = React.useMemo(function () {
+    return createPlatform({
+      offsetParent: offsetParentEl,
+      scrollOffsets: scrollOffsets,
+      sameScrollView: sameScrollView
+    });
+  }, [offsetParentEl, scrollOffsets, sameScrollView]);
+  var update = React.useCallback(function () {
+    if (!referenceRef.current || !floatingRef.current) {
+      return;
+    }
+    computePosition(referenceRef.current, floatingRef.current, {
+      middleware: latestMiddleware,
+      platform: platform,
+      placement: placement
+    }).then(function (data) {
+      if (isMountedRef.current) {
+        setData(data);
+      }
+    });
+  }, [latestMiddleware, platform, placement]);
+  React.useLayoutEffect(function () {
+    if (referenceEl) referenceRef.current = referenceEl;
+    if (floatingEl) floatingRef.current = floatingEl;
+    if (offsetParentEl) offsetParentRef.current = offsetParentEl;
+    var frame = requestAnimationFrame(update);
+    return function () {
+      cancelAnimationFrame(frame);
+    };
+  }, [referenceEl, floatingEl, offsetParentEl, update]);
+  var isMountedRef = React.useRef(true);
+  React.useLayoutEffect(function () {
+    isMountedRef.current = true;
+    return function () {
+      isMountedRef.current = false;
+    };
+  }, []);
+  var refs = React.useMemo(function () {
+    return {
+      reference: referenceRef,
+      floating: floatingRef,
+      offsetParent: offsetParentRef,
+      setReference: setReference,
+      setFloating: setFloating,
+      setOffsetParent: setOffsetParent
+    };
+  }, [setReference, setFloating, setOffsetParent]);
+  var elements = React.useMemo(function () {
+    return {
+      reference: referenceEl,
+      floating: floatingEl,
+      offsetParent: offsetParentEl
+    };
+  }, [referenceEl, floatingEl, offsetParentEl]);
+  var floatingStyles = React.useMemo(function () {
+    if (!elements.floating) {
+      return {
+        position: 'absolute',
+        left: 0,
+        top: 0
+      };
+    }
+    return {
+      position: 'absolute',
+      left: data.x,
+      top: data.y
+    };
+  }, [elements.floating, data.x, data.y]);
+  return React.useMemo(function () {
+    return _objectSpread2(_objectSpread2({}, data), {}, {
+      update: update,
+      refs: refs,
+      elements: elements,
+      floatingStyles: floatingStyles,
+      offsetParent: setOffsetParent,
+      reference: setReference,
+      floating: setFloating,
+      scrollProps: {
+        onScroll: function onScroll(event) {
+          return setScrollOffsets(event.nativeEvent.contentOffset);
+        },
+        scrollEventThrottle: 16
+      }
+    });
+  }, [data, refs, elements, floatingStyles, setReference, setFloating, setOffsetParent, update]);
+}
+
+/**
+ * A data provider that provides data to position an inner element of the
+ * floating element (usually a triangle or caret) so that it is centered to the
+ * reference element.
+ * This wraps the core `arrow` middleware to allow React refs as the element.
+ * @see https://floating-ui.com/docs/arrow
+ */
+var arrow$1 = function arrow$1(options) {
+  function isRef(value) {
+    return {}.hasOwnProperty.call(value, 'current');
+  }
+  return {
+    name: 'arrow',
+    options: options,
+    fn: function fn(state) {
+      var _ref4 = typeof options === 'function' ? options(state) : options,
+        element = _ref4.element,
+        padding = _ref4.padding;
+      if (element && isRef(element)) {
+        if (element.current != null) {
+          return arrow$2({
+            element: element.current,
+            padding: padding
+          }).fn(state);
+        }
+        return {};
+      }
+      if (element) {
+        return arrow$2({
+          element: element,
+          padding: padding
+        }).fn(state);
+      }
+      return {};
+    }
+  };
+};
+
+/**
+ * Modifies the placement by translating the floating element along the
+ * specified axes.
+ * A number (shorthand for `mainAxis` or distance), or an axes configuration
+ * object may be passed.
+ * @see https://floating-ui.com/docs/offset
+ */
+var offset = function offset(options, deps) {
+  return _objectSpread2(_objectSpread2({}, offset$1(options)), {}, {
+    options: [options, deps]
+  });
+};
+
+/**
+ * Optimizes the visibility of the floating element by shifting it in order to
+ * keep it in view when it will overflow the clipping boundary.
+ * @see https://floating-ui.com/docs/shift
+ */
+var shift = function shift(options, deps) {
+  return _objectSpread2(_objectSpread2({}, shift$1(options)), {}, {
+    options: [options, deps]
+  });
+};
+
+/**
+ * Built-in `limiter` that will stop `shift()` at a certain point.
+ */
+var limitShift = function limitShift(options, deps) {
+  return _objectSpread2(_objectSpread2({}, limitShift$1(options)), {}, {
+    options: [options, deps]
+  });
+};
+
+/**
+ * Optimizes the visibility of the floating element by flipping the `placement`
+ * in order to keep it in view when the preferred placement(s) will overflow the
+ * clipping boundary. Alternative to `autoPlacement`.
+ * @see https://floating-ui.com/docs/flip
+ */
+var flip = function flip(options, deps) {
+  return _objectSpread2(_objectSpread2({}, flip$1(options)), {}, {
+    options: [options, deps]
+  });
+};
+
+/**
+ * Provides data to position an inner element of the floating element so that it
+ * appears centered to the reference element.
+ * This wraps the core `arrow` middleware to allow React refs as the element.
+ * @see https://floating-ui.com/docs/arrow
+ */
+var arrow = function arrow(options, deps) {
+  return _objectSpread2(_objectSpread2({}, arrow$1(options)), {}, {
+    options: [options, deps]
+  });
+};
+
+var _excluded = ["refs", "floatingStyles", "middlewareData", "elements"];
+var useFloating = function useFloating(_ref) {
+  var _middlewareData$arrow, _middlewareData$offse, _middlewareData$offse2;
+  var placement = _ref.placement,
+    needModal = _ref.needModal;
+  var _useState = useState(0),
+    _useState2 = _slicedToArray(_useState, 2),
+    floatingHeight = _useState2[0],
+    setfloatingHeight = _useState2[1];
+  var arrowRef = useRef(null);
+  var _useFloatingUI = useFloating$1({
+      placement: placement,
+      sameScrollView: !needModal,
+      // offset 9,箭头加空隙的宽度
+      middleware: [shift({
+        limiter: limitShift({
+          offset: 9
+        }),
+        padding: 8
+      }), flip(), offset(9), arrow({
+        element: arrowRef,
+        padding: 8
+      })]
+    }),
+    refs = _useFloatingUI.refs,
+    floatingStyles = _useFloatingUI.floatingStyles,
+    middlewareData = _useFloatingUI.middlewareData,
+    elements = _useFloatingUI.elements,
+    other = _objectWithoutProperties(_useFloatingUI, _excluded);
+  useEffect(function () {
+    var _elements$floating;
+    (_elements$floating = elements.floating) === null || _elements$floating === void 0 || _elements$floating.measure(function (x, y, width, height, pageX, pageY) {
+      setfloatingHeight(height);
+    });
+  });
+  return _objectSpread2({
+    setFloatingRef: function setFloatingRef(ref) {
+      return refs.setFloating(ref);
+    },
+    setReferenceRef: function setReferenceRef(ref) {
+      return refs.setReference(ref);
+    },
+    setOffsetParentRef: refs.offsetParent,
+    setArrowRef: arrowRef,
+    refs: refs,
+    elements: elements,
+    middlewareData: middlewareData,
+    floatingStyles: floatingStyles,
+    arrowStyles: {
+      position: "absolute",
+      left: ((_middlewareData$arrow = middlewareData.arrow) === null || _middlewareData$arrow === void 0 ? void 0 : _middlewareData$arrow.x) != null ? middlewareData.arrow.x : null,
+      top: (_middlewareData$offse = middlewareData.offset) !== null && _middlewareData$offse !== void 0 && _middlewareData$offse.placement.includes("top") ? floatingHeight : -12,
+      transform: (_middlewareData$offse2 = middlewareData.offset) !== null && _middlewareData$offse2 !== void 0 && _middlewareData$offse2.placement.includes("top") ? "rotate(180deg)" : "rotate(0deg)"
+    }
+  }, other);
+};
+
+export { useFloating };
+//# sourceMappingURL=hook.js.map