@serendie/ui 3.2.0 → 3.2.1-dev.202604251106

package/dist/node_modules/@floating-ui/core/dist/floating-ui.core.js

@@ -1,270 +1,273 @@
-import { evaluate as L, getSide as j, getSideAxis as T, getOppositePlacement as ee, getExpandedPlacements as te, getOppositeAxisPlacements as ne, getAlignmentSides as ie, clamp as X, getPaddingObject as J, getAlignmentAxis as K, getAlignment as z, min as $, max as W, rectToClientRect as _, getOppositeAxis as N, getAxisLength as Q, sides as se } from "../../utils/dist/floating-ui.utils.js";
-function I(t, e, d) {
+import { getSideAxis as T, getAlignmentAxis as U, getSide as j, getAlignment as _, evaluate as L, getPaddingObject as q, rectToClientRect as z, getOppositePlacement as Z, getExpandedPlacements as ee, getOppositeAxisPlacements as te, getAlignmentSides as ne, clamp as $, min as Y, max as B, getAxisLength as G, getOppositeAxis as J, sides as ie } from "../../utils/dist/floating-ui.utils.js";
+function X(t, e, d) {
   let {
     reference: a,
-    floating: r
+    floating: m
   } = t;
-  const n = T(e), o = K(e), m = Q(o), u = j(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 (u) {
+  const n = T(e), i = U(e), l = G(i), g = j(e), p = n === "y", r = a.x + a.width / 2 - m.width / 2, o = a.y + a.height / 2 - m.height / 2, f = a[l] / 2 - m[l] / 2;
+  let s;
+  switch (g) {
     case "top":
-      i = {
-        x: c,
-        y: a.y - r.height
+      s = {
+        x: r,
+        y: a.y - m.height
       };
       break;
     case "bottom":
-      i = {
-        x: c,
+      s = {
+        x: r,
         y: a.y + a.height
       };
       break;
     case "right":
-      i = {
+      s = {
         x: a.x + a.width,
-        y: s
+        y: o
       };
       break;
     case "left":
-      i = {
-        x: a.x - r.width,
-        y: s
+      s = {
+        x: a.x - m.width,
+        y: o
       };
       break;
     default:
-      i = {
+      s = {
         x: a.x,
         y: a.y
       };
   }
-  switch (z(e)) {
+  switch (_(e)) {
     case "start":
-      i[o] -= f * (d && h ? -1 : 1);
+      s[i] -= f * (d && p ? -1 : 1);
       break;
     case "end":
-      i[o] += f * (d && h ? -1 : 1);
+      s[i] += f * (d && p ? -1 : 1);
       break;
   }
-  return i;
+  return s;
+}
+async function se(t, e) {
+  var d;
+  e === void 0 && (e = {});
+  const {
+    x: a,
+    y: m,
+    platform: n,
+    rects: i,
+    elements: l,
+    strategy: g
+  } = t, {
+    boundary: p = "clippingAncestors",
+    rootBoundary: r = "viewport",
+    elementContext: o = "floating",
+    altBoundary: f = !1,
+    padding: s = 0
+  } = L(e, t), c = q(s), h = l[f ? o === "floating" ? "reference" : "floating" : o], v = z(await n.getClippingRect({
+    element: (d = await (n.isElement == null ? void 0 : n.isElement(h))) == null || d ? h : h.contextElement || await (n.getDocumentElement == null ? void 0 : n.getDocumentElement(l.floating)),
+    boundary: p,
+    rootBoundary: r,
+    strategy: g
+  })), A = o === "floating" ? {
+    x: a,
+    y: m,
+    width: i.floating.width,
+    height: i.floating.height
+  } : i.reference, u = await (n.getOffsetParent == null ? void 0 : n.getOffsetParent(l.floating)), w = await (n.isElement == null ? void 0 : n.isElement(u)) ? await (n.getScale == null ? void 0 : n.getScale(u)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  }, y = z(n.convertOffsetParentRelativeRectToViewportRelativeRect ? await n.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: l,
+    rect: A,
+    offsetParent: u,
+    strategy: g
+  }) : A);
+  return {
+    top: (v.top - y.top + c.top) / w.y,
+    bottom: (y.bottom - v.bottom + c.bottom) / w.y,
+    left: (v.left - y.left + c.left) / w.x,
+    right: (y.right - v.right + c.right) / w.x
+  };
 }
-const ce = async (t, e, d) => {
+const oe = 50, le = async (t, e, d) => {
   const {
     placement: a = "bottom",
-    strategy: r = "absolute",
+    strategy: m = "absolute",
     middleware: n = [],
-    platform: o
-  } = d, m = n.filter(Boolean), u = await (o.isRTL == null ? void 0 : o.isRTL(e));
-  let h = await o.getElementRects({
+    platform: i
+  } = d, l = i.detectOverflow ? i : {
+    ...i,
+    detectOverflow: se
+  }, g = await (i.isRTL == null ? void 0 : i.isRTL(e));
+  let p = await i.getElementRects({
     reference: t,
     floating: e,
-    strategy: r
+    strategy: m
   }), {
-    x: c,
-    y: s
-  } = I(h, a, u), f = a, i = {}, l = 0;
-  for (let g = 0; g < m.length; g++) {
+    x: r,
+    y: o
+  } = X(p, a, g), f = a, s = 0;
+  const c = {};
+  for (let x = 0; x < n.length; x++) {
+    const h = n[x];
+    if (!h)
+      continue;
     const {
-      name: x,
-      fn: y
-    } = m[g], {
-      x: A,
-      y: p,
-      data: v,
-      reset: w
-    } = await y({
-      x: c,
-      y: s,
+      name: v,
+      fn: A
+    } = h, {
+      x: u,
+      y: w,
+      data: y,
+      reset: b
+    } = await A({
+      x: r,
+      y: o,
       initialPlacement: a,
       placement: f,
-      strategy: r,
-      middlewareData: i,
-      rects: h,
-      platform: o,
+      strategy: m,
+      middlewareData: c,
+      rects: p,
+      platform: l,
       elements: {
         reference: t,
         floating: e
       }
     });
-    c = A ?? c, s = p ?? s, i = {
-      ...i,
-      [x]: {
-        ...i[x],
-        ...v
-      }
-    }, w && l <= 50 && (l++, typeof w == "object" && (w.placement && (f = w.placement), w.rects && (h = w.rects === !0 ? await o.getElementRects({
+    r = u ?? r, o = w ?? o, c[v] = {
+      ...c[v],
+      ...y
+    }, b && s < oe && (s++, typeof b == "object" && (b.placement && (f = b.placement), b.rects && (p = b.rects === !0 ? await i.getElementRects({
       reference: t,
       floating: e,
-      strategy: r
-    }) : w.rects), {
-      x: c,
-      y: s
-    } = I(h, f, u)), g = -1);
+      strategy: m
+    }) : b.rects), {
+      x: r,
+      y: o
+    } = X(p, f, g)), x = -1);
   }
   return {
-    x: c,
-    y: s,
+    x: r,
+    y: o,
     placement: f,
-    strategy: r,
-    middlewareData: i
+    strategy: m,
+    middlewareData: c
   };
-};
-async function Y(t, e) {
-  var d;
-  e === void 0 && (e = {});
-  const {
-    x: a,
-    y: r,
-    platform: n,
-    rects: o,
-    elements: m,
-    strategy: u
-  } = t, {
-    boundary: h = "clippingAncestors",
-    rootBoundary: c = "viewport",
-    elementContext: s = "floating",
-    altBoundary: f = !1,
-    padding: i = 0
-  } = L(e, t), l = J(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: u
-  })), 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: 1,
-    y: 1
-  } : {
-    x: 1,
-    y: 1
-  }, w = _(n.convertOffsetParentRelativeRectToViewportRelativeRect ? await n.convertOffsetParentRelativeRectToViewportRelativeRect({
-    elements: m,
-    rect: A,
-    offsetParent: p,
-    strategy: u
-  }) : A);
-  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
-  };
-}
-const le = (t) => ({
+}, re = (t) => ({
   name: "arrow",
   options: t,
   async fn(e) {
     const {
       x: d,
       y: a,
-      placement: r,
+      placement: m,
       rects: n,
-      platform: o,
-      elements: m,
-      middlewareData: u
+      platform: i,
+      elements: l,
+      middlewareData: g
     } = e, {
-      element: h,
-      padding: c = 0
+      element: p,
+      padding: r = 0
     } = L(t, e) || {};
-    if (h == null)
+    if (p == null)
       return {};
-    const s = J(c), f = {
+    const o = q(r), f = {
       x: d,
       y: a
-    }, i = K(r), l = Q(i), g = 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], P = await (o.getOffsetParent == null ? void 0 : o.getOffsetParent(h));
-    let C = P ? P[p] : 0;
-    (!C || !await (o.isElement == null ? void 0 : o.isElement(P))) && (C = m.floating[p] || n.floating[l]);
-    const M = v / 2 - w / 2, k = C / 2 - g[l] / 2 - 1, O = $(s[y], k), H = $(s[A], k), D = O, F = C - g[l] - H, b = C / 2 - g[l] / 2 + M, B = X(D, b, F), E = !u.arrow && z(r) != null && b !== B && n.reference[l] / 2 - (b < D ? O : H) - g[l] / 2 < 0, S = E ? b < D ? b - D : b - F : 0;
+    }, s = U(m), c = G(s), x = await i.getDimensions(p), h = s === "y", v = h ? "top" : "left", A = h ? "bottom" : "right", u = h ? "clientHeight" : "clientWidth", w = n.reference[c] + n.reference[s] - f[s] - n.floating[c], y = f[s] - n.reference[s], b = await (i.getOffsetParent == null ? void 0 : i.getOffsetParent(p));
+    let C = b ? b[u] : 0;
+    (!C || !await (i.isElement == null ? void 0 : i.isElement(b))) && (C = l.floating[u] || n.floating[c]);
+    const E = w / 2 - y / 2, D = C / 2 - x[c] / 2 - 1, P = Y(o[v], D), H = Y(o[A], D), k = P, F = C - x[c] - H, O = C / 2 - x[c] / 2 + E, W = $(k, O, F), M = !g.arrow && _(m) != null && O !== W && n.reference[c] / 2 - (O < k ? P : H) - x[c] / 2 < 0, S = M ? O < k ? O - k : O - F : 0;
     return {
-      [i]: f[i] + S,
+      [s]: f[s] + S,
       data: {
-        [i]: B,
-        centerOffset: b - B - S,
-        ...E && {
+        [s]: W,
+        centerOffset: O - W - S,
+        ...M && {
           alignmentOffset: S
         }
       },
-      reset: E
+      reset: M
     };
   }
-}), re = function(t) {
+}), fe = function(t) {
   return t === void 0 && (t = {}), {
     name: "flip",
     options: t,
     async fn(e) {
       var d, a;
       const {
-        placement: r,
+        placement: m,
         middlewareData: n,
-        rects: o,
-        initialPlacement: m,
-        platform: u,
-        elements: h
+        rects: i,
+        initialPlacement: l,
+        platform: g,
+        elements: p
       } = e, {
-        mainAxis: c = !0,
-        crossAxis: s = !0,
+        mainAxis: r = !0,
+        crossAxis: o = !0,
         fallbackPlacements: f,
-        fallbackStrategy: i = "bestFit",
-        fallbackAxisSideDirection: l = "none",
-        flipAlignment: g = !0,
-        ...x
+        fallbackStrategy: s = "bestFit",
+        fallbackAxisSideDirection: c = "none",
+        flipAlignment: x = !0,
+        ...h
       } = L(t, e);
       if ((d = n.arrow) != null && d.alignmentOffset)
         return {};
-      const y = j(r), A = T(m), p = j(m) === m, v = await (u.isRTL == null ? void 0 : u.isRTL(h.floating)), w = f || (p || !g ? [ee(m)] : te(m)), P = l !== "none";
-      !f && P && w.push(...ne(m, g, l, v));
-      const C = [m, ...w], M = await Y(e, x), k = [];
-      let O = ((a = n.flip) == null ? void 0 : a.overflows) || [];
-      if (c && k.push(M[y]), s) {
-        const b = ie(r, o, v);
-        k.push(M[b[0]], M[b[1]]);
+      const v = j(m), A = T(l), u = j(l) === l, w = await (g.isRTL == null ? void 0 : g.isRTL(p.floating)), y = f || (u || !x ? [Z(l)] : ee(l)), b = c !== "none";
+      !f && b && y.push(...te(l, x, c, w));
+      const C = [l, ...y], E = await g.detectOverflow(e, h), D = [];
+      let P = ((a = n.flip) == null ? void 0 : a.overflows) || [];
+      if (r && D.push(E[v]), o) {
+        const O = ne(m, i, w);
+        D.push(E[O[0]], E[O[1]]);
       }
-      if (O = [...O, {
-        placement: r,
-        overflows: k
-      }], !k.every((b) => b <= 0)) {
-        var H, D;
-        const b = (((H = n.flip) == null ? void 0 : H.index) || 0) + 1, B = C[b];
-        if (B && (!(s === "alignment" ? A !== T(B) : !1) || // We leave the current main axis only if every placement on that axis
+      if (P = [...P, {
+        placement: m,
+        overflows: D
+      }], !D.every((O) => O <= 0)) {
+        var H, k;
+        const O = (((H = n.flip) == null ? void 0 : H.index) || 0) + 1, W = C[O];
+        if (W && (!(o === "alignment" ? A !== T(W) : !1) || // We leave the current main axis only if every placement on that axis
         // overflows the main axis.
-        O.every((R) => T(R.placement) === A ? R.overflows[0] > 0 : !0)))
+        P.every((R) => T(R.placement) === A ? R.overflows[0] > 0 : !0)))
           return {
             data: {
-              index: b,
-              overflows: O
+              index: O,
+              overflows: P
             },
             reset: {
-              placement: B
+              placement: W
             }
           };
-        let E = (D = O.filter((S) => S.overflows[0] <= 0).sort((S, R) => S.overflows[1] - R.overflows[1])[0]) == null ? void 0 : D.placement;
-        if (!E)
-          switch (i) {
+        let M = (k = P.filter((S) => S.overflows[0] <= 0).sort((S, R) => S.overflows[1] - R.overflows[1])[0]) == null ? void 0 : k.placement;
+        if (!M)
+          switch (s) {
             case "bestFit": {
               var F;
-              const S = (F = O.filter((R) => {
-                if (P) {
+              const S = (F = P.filter((R) => {
+                if (b) {
                   const V = T(R.placement);
                   return V === A || // Create a bias to the `y` side axis due to horizontal
                   // reading directions favoring greater width.
                   V === "y";
                 }
                 return !0;
-              }).map((R) => [R.placement, R.overflows.filter((V) => V > 0).reduce((V, Z) => V + Z, 0)]).sort((R, V) => R[1] - V[1])[0]) == null ? void 0 : F[0];
-              S && (E = S);
+              }).map((R) => [R.placement, R.overflows.filter((V) => V > 0).reduce((V, Q) => V + Q, 0)]).sort((R, V) => R[1] - V[1])[0]) == null ? void 0 : F[0];
+              S && (M = S);
               break;
             }
             case "initialPlacement":
-              E = m;
+              M = l;
               break;
           }
-        if (r !== E)
+        if (m !== M)
           return {
             reset: {
-              placement: E
+              placement: M
             }
           };
       }
@@ -272,7 +275,7 @@ const le = (t) => ({
     }
   };
 };
-function q(t, e) {
+function I(t, e) {
   return {
     top: t.top - e.height,
     right: t.right - e.width,
@@ -280,42 +283,43 @@ function q(t, e) {
     left: t.left - e.width
   };
 }
-function G(t) {
-  return se.some((e) => t[e] >= 0);
+function N(t) {
+  return ie.some((e) => t[e] >= 0);
 }
-const fe = function(t) {
+const me = function(t) {
   return t === void 0 && (t = {}), {
     name: "hide",
     options: t,
     async fn(e) {
       const {
-        rects: d
+        rects: d,
+        platform: a
       } = e, {
-        strategy: a = "referenceHidden",
-        ...r
+        strategy: m = "referenceHidden",
+        ...n
       } = L(t, e);
-      switch (a) {
+      switch (m) {
         case "referenceHidden": {
-          const n = await Y(e, {
-            ...r,
+          const i = await a.detectOverflow(e, {
+            ...n,
             elementContext: "reference"
-          }), o = q(n, d.reference);
+          }), l = I(i, d.reference);
           return {
             data: {
-              referenceHiddenOffsets: o,
-              referenceHidden: G(o)
+              referenceHiddenOffsets: l,
+              referenceHidden: N(l)
             }
           };
         }
         case "escaped": {
-          const n = await Y(e, {
-            ...r,
+          const i = await a.detectOverflow(e, {
+            ...n,
             altBoundary: !0
-          }), o = q(n, d.floating);
+          }), l = I(i, d.floating);
           return {
             data: {
-              escapedOffsets: o,
-              escaped: G(o)
+              escapedOffsets: l,
+              escaped: N(l)
             }
           };
         }
@@ -324,57 +328,57 @@ const fe = function(t) {
       }
     }
   };
-}, U = /* @__PURE__ */ new Set(["left", "top"]);
-async function oe(t, e) {
+}, K = /* @__PURE__ */ new Set(["left", "top"]);
+async function ce(t, e) {
   const {
     placement: d,
     platform: a,
-    elements: r
-  } = t, n = await (a.isRTL == null ? void 0 : a.isRTL(r.floating)), o = j(d), m = z(d), u = T(d) === "y", h = U.has(o) ? -1 : 1, c = n && u ? -1 : 1, s = L(e, t);
+    elements: m
+  } = t, n = await (a.isRTL == null ? void 0 : a.isRTL(m.floating)), i = j(d), l = _(d), g = T(d) === "y", p = K.has(i) ? -1 : 1, r = n && g ? -1 : 1, o = L(e, t);
   let {
     mainAxis: f,
-    crossAxis: i,
-    alignmentAxis: l
-  } = typeof s == "number" ? {
-    mainAxis: s,
+    crossAxis: s,
+    alignmentAxis: c
+  } = typeof o == "number" ? {
+    mainAxis: o,
     crossAxis: 0,
     alignmentAxis: null
   } : {
-    mainAxis: s.mainAxis || 0,
-    crossAxis: s.crossAxis || 0,
-    alignmentAxis: s.alignmentAxis
+    mainAxis: o.mainAxis || 0,
+    crossAxis: o.crossAxis || 0,
+    alignmentAxis: o.alignmentAxis
   };
-  return m && typeof l == "number" && (i = m === "end" ? l * -1 : l), u ? {
-    x: i * c,
-    y: f * h
+  return l && typeof c == "number" && (s = l === "end" ? c * -1 : c), g ? {
+    x: s * r,
+    y: f * p
   } : {
-    x: f * h,
-    y: i * c
+    x: f * p,
+    y: s * r
   };
 }
-const me = function(t) {
+const de = function(t) {
   return t === void 0 && (t = 0), {
     name: "offset",
     options: t,
     async fn(e) {
       var d, a;
       const {
-        x: r,
+        x: m,
         y: n,
-        placement: o,
-        middlewareData: m
-      } = e, u = await oe(e, t);
-      return o === ((d = m.offset) == null ? void 0 : d.placement) && (a = m.arrow) != null && a.alignmentOffset ? {} : {
-        x: r + u.x,
-        y: n + u.y,
+        placement: i,
+        middlewareData: l
+      } = e, g = await ce(e, t);
+      return i === ((d = l.offset) == null ? void 0 : d.placement) && (a = l.arrow) != null && a.alignmentOffset ? {} : {
+        x: m + g.x,
+        y: n + g.y,
         data: {
-          ...u,
-          placement: o
+          ...g,
+          placement: i
         }
       };
     }
   };
-}, de = function(t) {
+}, xe = function(t) {
   return t === void 0 && (t = {}), {
     name: "shift",
     options: t,
@@ -382,130 +386,131 @@ const me = function(t) {
       const {
         x: d,
         y: a,
-        placement: r
+        placement: m,
+        platform: n
       } = e, {
-        mainAxis: n = !0,
-        crossAxis: o = !1,
-        limiter: m = {
-          fn: (x) => {
+        mainAxis: i = !0,
+        crossAxis: l = !1,
+        limiter: g = {
+          fn: (v) => {
             let {
-              x: y,
-              y: A
-            } = x;
+              x: A,
+              y: u
+            } = v;
             return {
-              x: y,
-              y: A
+              x: A,
+              y: u
             };
           }
         },
-        ...u
-      } = L(t, e), h = {
+        ...p
+      } = L(t, e), r = {
         x: d,
         y: a
-      }, c = await Y(e, u), s = T(j(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);
+      }, o = await n.detectOverflow(e, p), f = T(j(m)), s = J(f);
+      let c = r[s], x = r[f];
+      if (i) {
+        const v = s === "y" ? "top" : "left", A = s === "y" ? "bottom" : "right", u = c + o[v], w = c - o[A];
+        c = $(u, c, w);
       }
-      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 (l) {
+        const v = f === "y" ? "top" : "left", A = f === "y" ? "bottom" : "right", u = x + o[v], w = x - o[A];
+        x = $(u, x, w);
       }
-      const g = m.fn({
+      const h = g.fn({
         ...e,
-        [f]: i,
-        [s]: l
+        [s]: c,
+        [f]: x
       });
       return {
-        ...g,
+        ...h,
         data: {
-          x: g.x - d,
-          y: g.y - a,
+          x: h.x - d,
+          y: h.y - a,
           enabled: {
-            [f]: n,
-            [s]: o
+            [s]: i,
+            [f]: l
           }
         }
       };
     }
   };
-}, xe = function(t) {
+}, ge = function(t) {
   return t === void 0 && (t = {}), {
     options: t,
     fn(e) {
       const {
         x: d,
         y: a,
-        placement: r,
+        placement: m,
         rects: n,
-        middlewareData: o
+        middlewareData: i
       } = e, {
-        offset: m = 0,
-        mainAxis: u = !0,
-        crossAxis: h = !0
-      } = L(t, e), c = {
+        offset: l = 0,
+        mainAxis: g = !0,
+        crossAxis: p = !0
+      } = L(t, e), r = {
         x: d,
         y: a
-      }, s = T(r), f = N(s);
-      let i = c[f], l = c[s];
-      const g = L(m, e), x = typeof g == "number" ? {
-        mainAxis: g,
+      }, o = T(m), f = J(o);
+      let s = r[f], c = r[o];
+      const x = L(l, e), h = typeof x == "number" ? {
+        mainAxis: x,
         crossAxis: 0
       } : {
         mainAxis: 0,
         crossAxis: 0,
-        ...g
+        ...x
       };
-      if (u) {
-        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 (g) {
+        const u = f === "y" ? "height" : "width", w = n.reference[f] - n.floating[u] + h.mainAxis, y = n.reference[f] + n.reference[u] - h.mainAxis;
+        s < w ? s = w : s > y && (s = y);
       }
-      if (h) {
-        var y, A;
-        const p = f === "y" ? "width" : "height", v = U.has(j(r)), w = n.reference[s] - n.floating[p] + (v && ((y = o.offset) == null ? void 0 : y[s]) || 0) + (v ? 0 : x.crossAxis), P = 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 > P && (l = P);
+      if (p) {
+        var v, A;
+        const u = f === "y" ? "width" : "height", w = K.has(j(m)), y = n.reference[o] - n.floating[u] + (w && ((v = i.offset) == null ? void 0 : v[o]) || 0) + (w ? 0 : h.crossAxis), b = n.reference[o] + n.reference[u] + (w ? 0 : ((A = i.offset) == null ? void 0 : A[o]) || 0) - (w ? h.crossAxis : 0);
+        c < y ? c = y : c > b && (c = b);
       }
       return {
-        [f]: i,
-        [s]: l
+        [f]: s,
+        [o]: c
       };
     }
   };
-}, ge = function(t) {
+}, ue = function(t) {
   return t === void 0 && (t = {}), {
     name: "size",
     options: t,
     async fn(e) {
       var d, a;
       const {
-        placement: r,
+        placement: m,
         rects: n,
-        platform: o,
-        elements: m
+        platform: i,
+        elements: l
       } = e, {
-        apply: u = () => {
+        apply: g = () => {
         },
-        ...h
-      } = L(t, e), c = await Y(e, h), s = j(r), f = z(r), i = T(r) === "y", {
-        width: l,
-        height: g
+        ...p
+      } = L(t, e), r = await i.detectOverflow(e, p), o = j(m), f = _(m), s = T(m) === "y", {
+        width: c,
+        height: x
       } = 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 = g - c.top - c.bottom, p = l - c.left - c.right, v = $(g - c[x], A), w = $(l - c[y], p), P = !e.middlewareData.shift;
-      let C = v, M = w;
-      if ((d = e.middlewareData.shift) != null && d.enabled.x && (M = p), (a = e.middlewareData.shift) != null && a.enabled.y && (C = A), P && !f) {
-        const O = W(c.left, 0), H = W(c.right, 0), D = W(c.top, 0), F = W(c.bottom, 0);
-        i ? M = l - 2 * (O !== 0 || H !== 0 ? O + H : W(c.left, c.right)) : C = g - 2 * (D !== 0 || F !== 0 ? D + F : W(c.top, c.bottom));
+      let h, v;
+      o === "top" || o === "bottom" ? (h = o, v = f === (await (i.isRTL == null ? void 0 : i.isRTL(l.floating)) ? "start" : "end") ? "left" : "right") : (v = o, h = f === "end" ? "top" : "bottom");
+      const A = x - r.top - r.bottom, u = c - r.left - r.right, w = Y(x - r[h], A), y = Y(c - r[v], u), b = !e.middlewareData.shift;
+      let C = w, E = y;
+      if ((d = e.middlewareData.shift) != null && d.enabled.x && (E = u), (a = e.middlewareData.shift) != null && a.enabled.y && (C = A), b && !f) {
+        const P = B(r.left, 0), H = B(r.right, 0), k = B(r.top, 0), F = B(r.bottom, 0);
+        s ? E = c - 2 * (P !== 0 || H !== 0 ? P + H : B(r.left, r.right)) : C = x - 2 * (k !== 0 || F !== 0 ? k + F : B(r.top, r.bottom));
       }
-      await u({
+      await g({
         ...e,
-        availableWidth: M,
+        availableWidth: E,
         availableHeight: C
       });
-      const k = await o.getDimensions(m.floating);
-      return l !== k.width || g !== k.height ? {
+      const D = await i.getDimensions(l.floating);
+      return c !== D.width || x !== D.height ? {
         reset: {
           rects: !0
         }
@@ -514,14 +519,14 @@ const me = function(t) {
   };
 };
 export {
-  le as arrow,
-  ce as computePosition,
-  Y as detectOverflow,
-  re as flip,
-  fe as hide,
-  xe as limitShift,
-  me as offset,
-  _ as rectToClientRect,
-  de as shift,
-  ge as size
+  re as arrow,
+  le as computePosition,
+  se as detectOverflow,
+  fe as flip,
+  me as hide,
+  ge as limitShift,
+  de as offset,
+  z as rectToClientRect,
+  xe as shift,
+  ue as size
 };