@worldcoin/mini-apps-ui-kit-react 1.0.0-canary.2 → 1.0.0-canary.21

package/dist/node_modules/.pnpm/@floating-ui_core@1.6.8/node_modules/@floating-ui/core/dist/floating-ui.core.js

@@ -1,525 +1,715 @@
-import { evaluate as E, getSide as V, getSideAxis as B, getOppositePlacement as Z, getExpandedPlacements as ee, getOppositeAxisPlacements as te, getAlignmentSides as ne, clamp as X, getAlignment as z, min as $, max as W, getAlignmentAxis as J, getPaddingObject as K, rectToClientRect as _, sides as ie, getOppositeAxis as N, getAxisLength as Q } from "../../../../../@floating-ui_utils@0.2.8/node_modules/@floating-ui/utils/dist/floating-ui.utils.js";
-function I(t, e, d) {
+import { evaluate, getSide, getSideAxis, getOppositePlacement, getExpandedPlacements, getOppositeAxisPlacements, getAlignmentSides, clamp, getAlignment, min, max, getAlignmentAxis, getPaddingObject, rectToClientRect, sides, getOppositeAxis, getAxisLength } from "../../../../../@floating-ui_utils@0.2.8/node_modules/@floating-ui/utils/dist/floating-ui.utils.js";
+function computeCoordsFromPlacement(_ref, placement, rtl) {
   let {
-    reference: a,
-    floating: r
-  } = t;
-  const n = B(e), o = J(e), m = Q(o), g = V(e), h = n === "y", c = a.x + a.width / 2 - r.width / 2, s = a.y + a.height / 2 - r.height / 2, f = a[m] / 2 - r[m] / 2;
-  let i;
-  switch (g) {
+    reference,
+    floating
+  } = _ref;
+  const sideAxis = getSideAxis(placement);
+  const alignmentAxis = getAlignmentAxis(placement);
+  const alignLength = getAxisLength(alignmentAxis);
+  const side = getSide(placement);
+  const isVertical = sideAxis === "y";
+  const commonX = reference.x + reference.width / 2 - floating.width / 2;
+  const commonY = reference.y + reference.height / 2 - floating.height / 2;
+  const commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2;
+  let coords;
+  switch (side) {
     case "top":
-      i = {
-        x: c,
-        y: a.y - r.height
+      coords = {
+        x: commonX,
+        y: reference.y - floating.height
       };
       break;
     case "bottom":
-      i = {
-        x: c,
-        y: a.y + a.height
+      coords = {
+        x: commonX,
+        y: reference.y + reference.height
       };
       break;
     case "right":
-      i = {
-        x: a.x + a.width,
-        y: s
+      coords = {
+        x: reference.x + reference.width,
+        y: commonY
       };
       break;
     case "left":
-      i = {
-        x: a.x - r.width,
-        y: s
+      coords = {
+        x: reference.x - floating.width,
+        y: commonY
       };
       break;
     default:
-      i = {
-        x: a.x,
-        y: a.y
+      coords = {
+        x: reference.x,
+        y: reference.y
       };
   }
-  switch (z(e)) {
+  switch (getAlignment(placement)) {
     case "start":
-      i[o] -= f * (d && h ? -1 : 1);
+      coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);
       break;
     case "end":
-      i[o] += f * (d && h ? -1 : 1);
+      coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);
       break;
   }
-  return i;
+  return coords;
 }
-const ae = async (t, e, d) => {
+const computePosition = async (reference, floating, config) => {
   const {
-    placement: a = "bottom",
-    strategy: r = "absolute",
-    middleware: n = [],
-    platform: o
-  } = d, m = n.filter(Boolean), g = await (o.isRTL == null ? void 0 : o.isRTL(e));
-  let h = await o.getElementRects({
-    reference: t,
-    floating: e,
-    strategy: r
-  }), {
-    x: c,
-    y: s
-  } = I(h, a, g), f = a, i = {}, l = 0;
-  for (let u = 0; u < m.length; u++) {
+    placement = "bottom",
+    strategy = "absolute",
+    middleware = [],
+    platform
+  } = config;
+  const validMiddleware = middleware.filter(Boolean);
+  const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(floating));
+  let rects = await platform.getElementRects({
+    reference,
+    floating,
+    strategy
+  });
+  let {
+    x,
+    y
+  } = computeCoordsFromPlacement(rects, placement, rtl);
+  let statefulPlacement = placement;
+  let middlewareData = {};
+  let resetCount = 0;
+  for (let i = 0; i < validMiddleware.length; i++) {
+    const {
+      name,
+      fn
+    } = validMiddleware[i];
     const {
-      name: x,
-      fn: y
-    } = m[u], {
-      x: A,
-      y: p,
-      data: v,
-      reset: w
-    } = await y({
-      x: c,
-      y: s,
-      initialPlacement: a,
-      placement: f,
-      strategy: r,
-      middlewareData: i,
-      rects: h,
-      platform: o,
+      x: nextX,
+      y: nextY,
+      data,
+      reset
+    } = await fn({
+      x,
+      y,
+      initialPlacement: placement,
+      placement: statefulPlacement,
+      strategy,
+      middlewareData,
+      rects,
+      platform,
       elements: {
-        reference: t,
-        floating: e
+        reference,
+        floating
       }
     });
-    c = A ?? c, s = p ?? s, i = {
-      ...i,
-      [x]: {
-        ...i[x],
-        ...v
+    x = nextX != null ? nextX : x;
+    y = nextY != null ? nextY : y;
+    middlewareData = {
+      ...middlewareData,
+      [name]: {
+        ...middlewareData[name],
+        ...data
+      }
+    };
+    if (reset && resetCount <= 50) {
+      resetCount++;
+      if (typeof reset === "object") {
+        if (reset.placement) {
+          statefulPlacement = reset.placement;
+        }
+        if (reset.rects) {
+          rects = reset.rects === true ? await platform.getElementRects({
+            reference,
+            floating,
+            strategy
+          }) : reset.rects;
+        }
+        ({
+          x,
+          y
+        } = computeCoordsFromPlacement(rects, statefulPlacement, rtl));
       }
-    }, w && l <= 50 && (l++, typeof w == "object" && (w.placement && (f = w.placement), w.rects && (h = w.rects === !0 ? await o.getElementRects({
-      reference: t,
-      floating: e,
-      strategy: r
-    }) : w.rects), {
-      x: c,
-      y: s
-    } = I(h, f, g)), u = -1);
+      i = -1;
+    }
   }
   return {
-    x: c,
-    y: s,
-    placement: f,
-    strategy: r,
-    middlewareData: i
+    x,
+    y,
+    placement: statefulPlacement,
+    strategy,
+    middlewareData
   };
 };
-async function Y(t, e) {
-  var d;
-  e === void 0 && (e = {});
+async function detectOverflow(state, options) {
+  var _await$platform$isEle;
+  if (options === void 0) {
+    options = {};
+  }
   const {
-    x: a,
-    y: r,
-    platform: n,
-    rects: o,
-    elements: m,
-    strategy: g
-  } = t, {
-    boundary: h = "clippingAncestors",
-    rootBoundary: c = "viewport",
-    elementContext: s = "floating",
-    altBoundary: f = !1,
-    padding: i = 0
-  } = E(e, t), l = K(i), x = m[f ? s === "floating" ? "reference" : "floating" : s], y = _(await n.getClippingRect({
-    element: (d = await (n.isElement == null ? void 0 : n.isElement(x))) == null || d ? x : x.contextElement || await (n.getDocumentElement == null ? void 0 : n.getDocumentElement(m.floating)),
-    boundary: h,
-    rootBoundary: c,
-    strategy: g
-  })), A = s === "floating" ? {
-    x: a,
-    y: r,
-    width: o.floating.width,
-    height: o.floating.height
-  } : o.reference, p = await (n.getOffsetParent == null ? void 0 : n.getOffsetParent(m.floating)), v = await (n.isElement == null ? void 0 : n.isElement(p)) ? await (n.getScale == null ? void 0 : n.getScale(p)) || {
+    x,
+    y,
+    platform,
+    rects,
+    elements,
+    strategy
+  } = state;
+  const {
+    boundary = "clippingAncestors",
+    rootBoundary = "viewport",
+    elementContext = "floating",
+    altBoundary = false,
+    padding = 0
+  } = evaluate(options, state);
+  const paddingObject = getPaddingObject(padding);
+  const altContext = elementContext === "floating" ? "reference" : "floating";
+  const element = elements[altBoundary ? altContext : elementContext];
+  const clippingClientRect = rectToClientRect(await platform.getClippingRect({
+    element: ((_await$platform$isEle = await (platform.isElement == null ? void 0 : platform.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || await (platform.getDocumentElement == null ? void 0 : platform.getDocumentElement(elements.floating)),
+    boundary,
+    rootBoundary,
+    strategy
+  }));
+  const rect = elementContext === "floating" ? {
+    x,
+    y,
+    width: rects.floating.width,
+    height: rects.floating.height
+  } : rects.reference;
+  const offsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(elements.floating));
+  const offsetScale = await (platform.isElement == null ? void 0 : platform.isElement(offsetParent)) ? await (platform.getScale == null ? void 0 : platform.getScale(offsetParent)) || {
     x: 1,
     y: 1
   } : {
     x: 1,
     y: 1
-  }, w = _(n.convertOffsetParentRelativeRectToViewportRelativeRect ? await n.convertOffsetParentRelativeRectToViewportRelativeRect({
-    elements: m,
-    rect: A,
-    offsetParent: p,
-    strategy: g
-  }) : A);
+  };
+  const elementClientRect = rectToClientRect(platform.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements,
+    rect,
+    offsetParent,
+    strategy
+  }) : rect);
   return {
-    top: (y.top - w.top + l.top) / v.y,
-    bottom: (w.bottom - y.bottom + l.bottom) / v.y,
-    left: (y.left - w.left + l.left) / v.x,
-    right: (w.right - y.right + l.right) / v.x
+    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
   };
 }
-const ce = (t) => ({
+const arrow = (options) => ({
   name: "arrow",
-  options: t,
-  async fn(e) {
+  options,
+  async fn(state) {
     const {
-      x: d,
-      y: a,
-      placement: r,
-      rects: n,
-      platform: o,
-      elements: m,
-      middlewareData: g
-    } = e, {
-      element: h,
-      padding: c = 0
-    } = E(t, e) || {};
-    if (h == null)
+      x,
+      y,
+      placement,
+      rects,
+      platform,
+      elements,
+      middlewareData
+    } = state;
+    const {
+      element,
+      padding = 0
+    } = evaluate(options, state) || {};
+    if (element == null) {
       return {};
-    const s = K(c), f = {
-      x: d,
-      y: a
-    }, i = J(r), l = Q(i), u = await o.getDimensions(h), x = i === "y", y = x ? "top" : "left", A = x ? "bottom" : "right", p = x ? "clientHeight" : "clientWidth", v = n.reference[l] + n.reference[i] - f[i] - n.floating[l], w = f[i] - n.reference[i], O = await (o.getOffsetParent == null ? void 0 : o.getOffsetParent(h));
-    let P = O ? O[p] : 0;
-    (!P || !await (o.isElement == null ? void 0 : o.isElement(O))) && (P = m.floating[p] || n.floating[l]);
-    const D = v / 2 - w / 2, R = P / 2 - u[l] / 2 - 1, C = $(s[y], R), T = $(s[A], R), S = C, L = P - u[l] - T, b = P / 2 - u[l] / 2 + D, j = X(S, b, L), M = !g.arrow && z(r) != null && b !== j && n.reference[l] / 2 - (b < S ? C : T) - u[l] / 2 < 0, k = M ? b < S ? b - S : b - L : 0;
+    }
+    const paddingObject = getPaddingObject(padding);
+    const coords = {
+      x,
+      y
+    };
+    const axis = getAlignmentAxis(placement);
+    const length = getAxisLength(axis);
+    const arrowDimensions = await platform.getDimensions(element);
+    const isYAxis = axis === "y";
+    const minProp = isYAxis ? "top" : "left";
+    const maxProp = isYAxis ? "bottom" : "right";
+    const clientProp = isYAxis ? "clientHeight" : "clientWidth";
+    const endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length];
+    const startDiff = coords[axis] - rects.reference[axis];
+    const arrowOffsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(element));
+    let clientSize = arrowOffsetParent ? arrowOffsetParent[clientProp] : 0;
+    if (!clientSize || !await (platform.isElement == null ? void 0 : platform.isElement(arrowOffsetParent))) {
+      clientSize = elements.floating[clientProp] || rects.floating[length];
+    }
+    const centerToReference = endDiff / 2 - startDiff / 2;
+    const largestPossiblePadding = clientSize / 2 - arrowDimensions[length] / 2 - 1;
+    const minPadding = min(paddingObject[minProp], largestPossiblePadding);
+    const maxPadding = min(paddingObject[maxProp], largestPossiblePadding);
+    const min$1 = minPadding;
+    const max2 = clientSize - arrowDimensions[length] - maxPadding;
+    const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;
+    const offset2 = clamp(min$1, center, max2);
+    const shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center !== offset2 && rects.reference[length] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;
+    const alignmentOffset = shouldAddOffset ? center < min$1 ? center - min$1 : center - max2 : 0;
     return {
-      [i]: f[i] + k,
+      [axis]: coords[axis] + alignmentOffset,
       data: {
-        [i]: j,
-        centerOffset: b - j - k,
-        ...M && {
-          alignmentOffset: k
+        [axis]: offset2,
+        centerOffset: center - offset2 - alignmentOffset,
+        ...shouldAddOffset && {
+          alignmentOffset
         }
       },
-      reset: M
+      reset: shouldAddOffset
     };
   }
-}), le = function(t) {
-  return t === void 0 && (t = {}), {
+});
+const flip = function(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
     name: "flip",
-    options: t,
-    async fn(e) {
-      var d, a;
+    options,
+    async fn(state) {
+      var _middlewareData$arrow, _middlewareData$flip;
+      const {
+        placement,
+        middlewareData,
+        rects,
+        initialPlacement,
+        platform,
+        elements
+      } = state;
       const {
-        placement: r,
-        middlewareData: n,
-        rects: o,
-        initialPlacement: m,
-        platform: g,
-        elements: h
-      } = e, {
-        mainAxis: c = !0,
-        crossAxis: s = !0,
-        fallbackPlacements: f,
-        fallbackStrategy: i = "bestFit",
-        fallbackAxisSideDirection: l = "none",
-        flipAlignment: u = !0,
-        ...x
-      } = E(t, e);
-      if ((d = n.arrow) != null && d.alignmentOffset)
+        mainAxis: checkMainAxis = true,
+        crossAxis: checkCrossAxis = true,
+        fallbackPlacements: specifiedFallbackPlacements,
+        fallbackStrategy = "bestFit",
+        fallbackAxisSideDirection = "none",
+        flipAlignment = true,
+        ...detectOverflowOptions
+      } = evaluate(options, state);
+      if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
         return {};
-      const y = V(r), A = B(m), p = V(m) === m, v = await (g.isRTL == null ? void 0 : g.isRTL(h.floating)), w = f || (p || !u ? [Z(m)] : ee(m)), O = l !== "none";
-      !f && O && w.push(...te(m, u, l, v));
-      const P = [m, ...w], D = await Y(e, x), R = [];
-      let C = ((a = n.flip) == null ? void 0 : a.overflows) || [];
-      if (c && R.push(D[y]), s) {
-        const b = ne(r, o, v);
-        R.push(D[b[0]], D[b[1]]);
       }
-      if (C = [...C, {
-        placement: r,
-        overflows: R
-      }], !R.every((b) => b <= 0)) {
-        var T, S;
-        const b = (((T = n.flip) == null ? void 0 : T.index) || 0) + 1, j = P[b];
-        if (j)
+      const side = getSide(placement);
+      const initialSideAxis = getSideAxis(initialPlacement);
+      const isBasePlacement = getSide(initialPlacement) === initialPlacement;
+      const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));
+      const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));
+      const hasFallbackAxisSideDirection = fallbackAxisSideDirection !== "none";
+      if (!specifiedFallbackPlacements && hasFallbackAxisSideDirection) {
+        fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
+      }
+      const placements = [initialPlacement, ...fallbackPlacements];
+      const overflow = await detectOverflow(state, detectOverflowOptions);
+      const overflows = [];
+      let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];
+      if (checkMainAxis) {
+        overflows.push(overflow[side]);
+      }
+      if (checkCrossAxis) {
+        const sides2 = getAlignmentSides(placement, rects, rtl);
+        overflows.push(overflow[sides2[0]], overflow[sides2[1]]);
+      }
+      overflowsData = [...overflowsData, {
+        placement,
+        overflows
+      }];
+      if (!overflows.every((side2) => side2 <= 0)) {
+        var _middlewareData$flip2, _overflowsData$filter;
+        const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;
+        const nextPlacement = placements[nextIndex];
+        if (nextPlacement) {
           return {
             data: {
-              index: b,
-              overflows: C
+              index: nextIndex,
+              overflows: overflowsData
             },
             reset: {
-              placement: j
+              placement: nextPlacement
             }
           };
-        let M = (S = C.filter((k) => k.overflows[0] <= 0).sort((k, H) => k.overflows[1] - H.overflows[1])[0]) == null ? void 0 : S.placement;
-        if (!M)
-          switch (i) {
+        }
+        let resetPlacement = (_overflowsData$filter = overflowsData.filter((d) => d.overflows[0] <= 0).sort((a, b) => a.overflows[1] - b.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement;
+        if (!resetPlacement) {
+          switch (fallbackStrategy) {
             case "bestFit": {
-              var L;
-              const k = (L = C.filter((H) => {
-                if (O) {
-                  const F = B(H.placement);
-                  return F === A || // Create a bias to the `y` side axis due to horizontal
+              var _overflowsData$filter2;
+              const placement2 = (_overflowsData$filter2 = overflowsData.filter((d) => {
+                if (hasFallbackAxisSideDirection) {
+                  const currentSideAxis = getSideAxis(d.placement);
+                  return currentSideAxis === initialSideAxis || // Create a bias to the `y` side axis due to horizontal
                   // reading directions favoring greater width.
-                  F === "y";
+                  currentSideAxis === "y";
                 }
-                return !0;
-              }).map((H) => [H.placement, H.overflows.filter((F) => F > 0).reduce((F, U) => F + U, 0)]).sort((H, F) => H[1] - F[1])[0]) == null ? void 0 : L[0];
-              k && (M = k);
+                return true;
+              }).map((d) => [d.placement, d.overflows.filter((overflow2) => overflow2 > 0).reduce((acc, overflow2) => acc + overflow2, 0)]).sort((a, b) => a[1] - b[1])[0]) == null ? void 0 : _overflowsData$filter2[0];
+              if (placement2) {
+                resetPlacement = placement2;
+              }
               break;
             }
             case "initialPlacement":
-              M = m;
+              resetPlacement = initialPlacement;
               break;
           }
-        if (r !== M)
+        }
+        if (placement !== resetPlacement) {
           return {
             reset: {
-              placement: M
+              placement: resetPlacement
             }
           };
+        }
       }
       return {};
     }
   };
 };
-function q(t, e) {
+function getSideOffsets(overflow, rect) {
   return {
-    top: t.top - e.height,
-    right: t.right - e.width,
-    bottom: t.bottom - e.height,
-    left: t.left - e.width
+    top: overflow.top - rect.height,
+    right: overflow.right - rect.width,
+    bottom: overflow.bottom - rect.height,
+    left: overflow.left - rect.width
   };
 }
-function G(t) {
-  return ie.some((e) => t[e] >= 0);
+function isAnySideFullyClipped(overflow) {
+  return sides.some((side) => overflow[side] >= 0);
 }
-const re = function(t) {
-  return t === void 0 && (t = {}), {
+const hide = function(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
     name: "hide",
-    options: t,
-    async fn(e) {
+    options,
+    async fn(state) {
+      const {
+        rects
+      } = state;
       const {
-        rects: d
-      } = e, {
-        strategy: a = "referenceHidden",
-        ...r
-      } = E(t, e);
-      switch (a) {
+        strategy = "referenceHidden",
+        ...detectOverflowOptions
+      } = evaluate(options, state);
+      switch (strategy) {
         case "referenceHidden": {
-          const n = await Y(e, {
-            ...r,
+          const overflow = await detectOverflow(state, {
+            ...detectOverflowOptions,
             elementContext: "reference"
-          }), o = q(n, d.reference);
+          });
+          const offsets = getSideOffsets(overflow, rects.reference);
           return {
             data: {
-              referenceHiddenOffsets: o,
-              referenceHidden: G(o)
+              referenceHiddenOffsets: offsets,
+              referenceHidden: isAnySideFullyClipped(offsets)
             }
           };
         }
         case "escaped": {
-          const n = await Y(e, {
-            ...r,
-            altBoundary: !0
-          }), o = q(n, d.floating);
+          const overflow = await detectOverflow(state, {
+            ...detectOverflowOptions,
+            altBoundary: true
+          });
+          const offsets = getSideOffsets(overflow, rects.floating);
           return {
             data: {
-              escapedOffsets: o,
-              escaped: G(o)
+              escapedOffsets: offsets,
+              escaped: isAnySideFullyClipped(offsets)
             }
           };
         }
-        default:
+        default: {
           return {};
+        }
       }
     }
   };
 };
-async function se(t, e) {
+async function convertValueToCoords(state, options) {
   const {
-    placement: d,
-    platform: a,
-    elements: r
-  } = t, n = await (a.isRTL == null ? void 0 : a.isRTL(r.floating)), o = V(d), m = z(d), g = B(d) === "y", h = ["left", "top"].includes(o) ? -1 : 1, c = n && g ? -1 : 1, s = E(e, t);
+    placement,
+    platform,
+    elements
+  } = state;
+  const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));
+  const side = getSide(placement);
+  const alignment = getAlignment(placement);
+  const isVertical = getSideAxis(placement) === "y";
+  const mainAxisMulti = ["left", "top"].includes(side) ? -1 : 1;
+  const crossAxisMulti = rtl && isVertical ? -1 : 1;
+  const rawValue = evaluate(options, state);
   let {
-    mainAxis: f,
-    crossAxis: i,
-    alignmentAxis: l
-  } = typeof s == "number" ? {
-    mainAxis: s,
+    mainAxis,
+    crossAxis,
+    alignmentAxis
+  } = typeof rawValue === "number" ? {
+    mainAxis: rawValue,
     crossAxis: 0,
     alignmentAxis: null
   } : {
-    mainAxis: s.mainAxis || 0,
-    crossAxis: s.crossAxis || 0,
-    alignmentAxis: s.alignmentAxis
+    mainAxis: rawValue.mainAxis || 0,
+    crossAxis: rawValue.crossAxis || 0,
+    alignmentAxis: rawValue.alignmentAxis
   };
-  return m && typeof l == "number" && (i = m === "end" ? l * -1 : l), g ? {
-    x: i * c,
-    y: f * h
+  if (alignment && typeof alignmentAxis === "number") {
+    crossAxis = alignment === "end" ? alignmentAxis * -1 : alignmentAxis;
+  }
+  return isVertical ? {
+    x: crossAxis * crossAxisMulti,
+    y: mainAxis * mainAxisMulti
   } : {
-    x: f * h,
-    y: i * c
+    x: mainAxis * mainAxisMulti,
+    y: crossAxis * crossAxisMulti
   };
 }
-const fe = function(t) {
-  return t === void 0 && (t = 0), {
+const offset = function(options) {
+  if (options === void 0) {
+    options = 0;
+  }
+  return {
     name: "offset",
-    options: t,
-    async fn(e) {
-      var d, a;
+    options,
+    async fn(state) {
+      var _middlewareData$offse, _middlewareData$arrow;
       const {
-        x: r,
-        y: n,
-        placement: o,
-        middlewareData: m
-      } = e, g = await se(e, t);
-      return o === ((d = m.offset) == null ? void 0 : d.placement) && (a = m.arrow) != null && a.alignmentOffset ? {} : {
-        x: r + g.x,
-        y: n + g.y,
+        x,
+        y,
+        placement,
+        middlewareData
+      } = state;
+      const diffCoords = await convertValueToCoords(state, options);
+      if (placement === ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse.placement) && (_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
+        return {};
+      }
+      return {
+        x: x + diffCoords.x,
+        y: y + diffCoords.y,
         data: {
-          ...g,
-          placement: o
+          ...diffCoords,
+          placement
         }
       };
     }
   };
-}, me = function(t) {
-  return t === void 0 && (t = {}), {
+};
+const shift = function(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
     name: "shift",
-    options: t,
-    async fn(e) {
+    options,
+    async fn(state) {
+      const {
+        x,
+        y,
+        placement
+      } = state;
       const {
-        x: d,
-        y: a,
-        placement: r
-      } = e, {
-        mainAxis: n = !0,
-        crossAxis: o = !1,
-        limiter: m = {
-          fn: (x) => {
+        mainAxis: checkMainAxis = true,
+        crossAxis: checkCrossAxis = false,
+        limiter = {
+          fn: (_ref) => {
             let {
-              x: y,
-              y: A
-            } = x;
+              x: x2,
+              y: y2
+            } = _ref;
             return {
-              x: y,
-              y: A
+              x: x2,
+              y: y2
             };
           }
         },
-        ...g
-      } = E(t, e), h = {
-        x: d,
-        y: a
-      }, c = await Y(e, g), s = B(V(r)), f = N(s);
-      let i = h[f], l = h[s];
-      if (n) {
-        const x = f === "y" ? "top" : "left", y = f === "y" ? "bottom" : "right", A = i + c[x], p = i - c[y];
-        i = X(A, i, p);
+        ...detectOverflowOptions
+      } = evaluate(options, state);
+      const coords = {
+        x,
+        y
+      };
+      const overflow = await detectOverflow(state, detectOverflowOptions);
+      const crossAxis = getSideAxis(getSide(placement));
+      const mainAxis = getOppositeAxis(crossAxis);
+      let mainAxisCoord = coords[mainAxis];
+      let crossAxisCoord = coords[crossAxis];
+      if (checkMainAxis) {
+        const minSide = mainAxis === "y" ? "top" : "left";
+        const maxSide = mainAxis === "y" ? "bottom" : "right";
+        const min2 = mainAxisCoord + overflow[minSide];
+        const max2 = mainAxisCoord - overflow[maxSide];
+        mainAxisCoord = clamp(min2, mainAxisCoord, max2);
       }
-      if (o) {
-        const x = s === "y" ? "top" : "left", y = s === "y" ? "bottom" : "right", A = l + c[x], p = l - c[y];
-        l = X(A, l, p);
+      if (checkCrossAxis) {
+        const minSide = crossAxis === "y" ? "top" : "left";
+        const maxSide = crossAxis === "y" ? "bottom" : "right";
+        const min2 = crossAxisCoord + overflow[minSide];
+        const max2 = crossAxisCoord - overflow[maxSide];
+        crossAxisCoord = clamp(min2, crossAxisCoord, max2);
       }
-      const u = m.fn({
-        ...e,
-        [f]: i,
-        [s]: l
+      const limitedCoords = limiter.fn({
+        ...state,
+        [mainAxis]: mainAxisCoord,
+        [crossAxis]: crossAxisCoord
       });
       return {
-        ...u,
+        ...limitedCoords,
         data: {
-          x: u.x - d,
-          y: u.y - a,
+          x: limitedCoords.x - x,
+          y: limitedCoords.y - y,
           enabled: {
-            [f]: n,
-            [s]: o
+            [mainAxis]: checkMainAxis,
+            [crossAxis]: checkCrossAxis
           }
         }
       };
     }
   };
-}, de = function(t) {
-  return t === void 0 && (t = {}), {
-    options: t,
-    fn(e) {
+};
+const limitShift = function(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
+    options,
+    fn(state) {
       const {
-        x: d,
-        y: a,
-        placement: r,
-        rects: n,
-        middlewareData: o
-      } = e, {
-        offset: m = 0,
-        mainAxis: g = !0,
-        crossAxis: h = !0
-      } = E(t, e), c = {
-        x: d,
-        y: a
-      }, s = B(r), f = N(s);
-      let i = c[f], l = c[s];
-      const u = E(m, e), x = typeof u == "number" ? {
-        mainAxis: u,
+        x,
+        y,
+        placement,
+        rects,
+        middlewareData
+      } = state;
+      const {
+        offset: offset2 = 0,
+        mainAxis: checkMainAxis = true,
+        crossAxis: checkCrossAxis = true
+      } = evaluate(options, state);
+      const coords = {
+        x,
+        y
+      };
+      const crossAxis = getSideAxis(placement);
+      const mainAxis = getOppositeAxis(crossAxis);
+      let mainAxisCoord = coords[mainAxis];
+      let crossAxisCoord = coords[crossAxis];
+      const rawOffset = evaluate(offset2, state);
+      const computedOffset = typeof rawOffset === "number" ? {
+        mainAxis: rawOffset,
         crossAxis: 0
       } : {
         mainAxis: 0,
         crossAxis: 0,
-        ...u
+        ...rawOffset
       };
-      if (g) {
-        const p = f === "y" ? "height" : "width", v = n.reference[f] - n.floating[p] + x.mainAxis, w = n.reference[f] + n.reference[p] - x.mainAxis;
-        i < v ? i = v : i > w && (i = w);
+      if (checkMainAxis) {
+        const len = mainAxis === "y" ? "height" : "width";
+        const limitMin = rects.reference[mainAxis] - rects.floating[len] + computedOffset.mainAxis;
+        const limitMax = rects.reference[mainAxis] + rects.reference[len] - computedOffset.mainAxis;
+        if (mainAxisCoord < limitMin) {
+          mainAxisCoord = limitMin;
+        } else if (mainAxisCoord > limitMax) {
+          mainAxisCoord = limitMax;
+        }
       }
-      if (h) {
-        var y, A;
-        const p = f === "y" ? "width" : "height", v = ["top", "left"].includes(V(r)), w = n.reference[s] - n.floating[p] + (v && ((y = o.offset) == null ? void 0 : y[s]) || 0) + (v ? 0 : x.crossAxis), O = n.reference[s] + n.reference[p] + (v ? 0 : ((A = o.offset) == null ? void 0 : A[s]) || 0) - (v ? x.crossAxis : 0);
-        l < w ? l = w : l > O && (l = O);
+      if (checkCrossAxis) {
+        var _middlewareData$offse, _middlewareData$offse2;
+        const len = mainAxis === "y" ? "width" : "height";
+        const isOriginSide = ["top", "left"].includes(getSide(placement));
+        const limitMin = rects.reference[crossAxis] - rects.floating[len] + (isOriginSide ? ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse[crossAxis]) || 0 : 0) + (isOriginSide ? 0 : computedOffset.crossAxis);
+        const 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 {
-        [f]: i,
-        [s]: l
+        [mainAxis]: mainAxisCoord,
+        [crossAxis]: crossAxisCoord
       };
     }
   };
-}, xe = function(t) {
-  return t === void 0 && (t = {}), {
+};
+const size = function(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
     name: "size",
-    options: t,
-    async fn(e) {
-      var d, a;
+    options,
+    async fn(state) {
+      var _state$middlewareData, _state$middlewareData2;
       const {
-        placement: r,
-        rects: n,
-        platform: o,
-        elements: m
-      } = e, {
-        apply: g = () => {
+        placement,
+        rects,
+        platform,
+        elements
+      } = state;
+      const {
+        apply = () => {
         },
-        ...h
-      } = E(t, e), c = await Y(e, h), s = V(r), f = z(r), i = B(r) === "y", {
-        width: l,
-        height: u
-      } = n.floating;
-      let x, y;
-      s === "top" || s === "bottom" ? (x = s, y = f === (await (o.isRTL == null ? void 0 : o.isRTL(m.floating)) ? "start" : "end") ? "left" : "right") : (y = s, x = f === "end" ? "top" : "bottom");
-      const A = u - c.top - c.bottom, p = l - c.left - c.right, v = $(u - c[x], A), w = $(l - c[y], p), O = !e.middlewareData.shift;
-      let P = v, D = w;
-      if ((d = e.middlewareData.shift) != null && d.enabled.x && (D = p), (a = e.middlewareData.shift) != null && a.enabled.y && (P = A), O && !f) {
-        const C = W(c.left, 0), T = W(c.right, 0), S = W(c.top, 0), L = W(c.bottom, 0);
-        i ? D = l - 2 * (C !== 0 || T !== 0 ? C + T : W(c.left, c.right)) : P = u - 2 * (S !== 0 || L !== 0 ? S + L : W(c.top, c.bottom));
+        ...detectOverflowOptions
+      } = evaluate(options, state);
+      const overflow = await detectOverflow(state, detectOverflowOptions);
+      const side = getSide(placement);
+      const alignment = getAlignment(placement);
+      const isYAxis = getSideAxis(placement) === "y";
+      const {
+        width,
+        height
+      } = rects.floating;
+      let heightSide;
+      let widthSide;
+      if (side === "top" || side === "bottom") {
+        heightSide = side;
+        widthSide = alignment === (await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating)) ? "start" : "end") ? "left" : "right";
+      } else {
+        widthSide = side;
+        heightSide = alignment === "end" ? "top" : "bottom";
       }
-      await g({
-        ...e,
-        availableWidth: D,
-        availableHeight: P
-      });
-      const R = await o.getDimensions(m.floating);
-      return l !== R.width || u !== R.height ? {
-        reset: {
-          rects: !0
+      const maximumClippingHeight = height - overflow.top - overflow.bottom;
+      const maximumClippingWidth = width - overflow.left - overflow.right;
+      const overflowAvailableHeight = min(height - overflow[heightSide], maximumClippingHeight);
+      const overflowAvailableWidth = min(width - overflow[widthSide], maximumClippingWidth);
+      const noShift = !state.middlewareData.shift;
+      let availableHeight = overflowAvailableHeight;
+      let availableWidth = overflowAvailableWidth;
+      if ((_state$middlewareData = state.middlewareData.shift) != null && _state$middlewareData.enabled.x) {
+        availableWidth = maximumClippingWidth;
+      }
+      if ((_state$middlewareData2 = state.middlewareData.shift) != null && _state$middlewareData2.enabled.y) {
+        availableHeight = maximumClippingHeight;
+      }
+      if (noShift && !alignment) {
+        const xMin = max(overflow.left, 0);
+        const xMax = max(overflow.right, 0);
+        const yMin = max(overflow.top, 0);
+        const yMax = max(overflow.bottom, 0);
+        if (isYAxis) {
+          availableWidth = width - 2 * (xMin !== 0 || xMax !== 0 ? xMin + xMax : max(overflow.left, overflow.right));
+        } else {
+          availableHeight = height - 2 * (yMin !== 0 || yMax !== 0 ? yMin + yMax : max(overflow.top, overflow.bottom));
         }
-      } : {};
+      }
+      await apply({
+        ...state,
+        availableWidth,
+        availableHeight
+      });
+      const nextDimensions = await platform.getDimensions(elements.floating);
+      if (width !== nextDimensions.width || height !== nextDimensions.height) {
+        return {
+          reset: {
+            rects: true
+          }
+        };
+      }
+      return {};
     }
   };
 };
 export {
-  ce as arrow,
-  ae as computePosition,
-  Y as detectOverflow,
-  le as flip,
-  re as hide,
-  de as limitShift,
-  fe as offset,
-  _ as rectToClientRect,
-  me as shift,
-  xe as size
+  arrow,
+  computePosition,
+  detectOverflow,
+  flip,
+  hide,
+  limitShift,
+  offset,
+  rectToClientRect,
+  shift,
+  size
 };