@quoreadmin/ui 1.11.0 → 1.11.1

package/dist/index403.js

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