@koide-labs/ui 0.0.0 → 0.0.2

package/dist/getDisabledMountTransitionStyles-YfHPge6T.js

@@ -0,0 +1,1510 @@
+import * as O from "react";
+import { useLayoutEffect as qt } from "react";
+import { e as q, g as z, a as Y, b as Ut, c as Jt, d as Kt, h as Gt, i as re, m as ue, j as _, k as bt, l as be, s as Qt, n as At, o as Ot, p as He, q as St, t as j, f as ye, r as Ae } from "./floating-ui.utils-C7pRWMZ_.js";
+import { o as Et } from "./owner-rKN292Q9.js";
+import { u as oe } from "./useIsoLayoutEffect-CIDbvm3Q.js";
+import { u as ke } from "./useValueAsRef-HURLzret.js";
+import { u as Zt } from "./useStableCallback-CkTrVkNX.js";
+import { u as en } from "./DirectionContext-C2o_MF_i.js";
+import { h as We, a as k, j as J, d as K, k as ut, g as U, i as G, l as Ct, m as Ve, n as de, o as Oe, p as tn, q as Pt, r as nn, f as Ie, e as _e, s as Ee } from "./floating-ui.utils.dom-C7FS5id0.js";
+import * as on from "react-dom";
+import { u as sn, F as rn, P as cn, a as ln } from "./transitions.module-CWX8e5cx.js";
+import { u as an } from "./useId-C5kyn6tA.js";
+import { a as fn, E as un } from "./useRenderElement-DwToLA61.js";
+import { D as dn } from "./FloatingPortal-tWyuKRSN.js";
+function dt(e, t, i) {
+  let {
+    reference: n,
+    floating: o
+  } = e;
+  const s = Y(t), r = At(t), c = Ot(r), a = z(t), f = s === "y", l = n.x + n.width / 2 - o.width / 2, u = n.y + n.height / 2 - o.height / 2, g = n[c] / 2 - o[c] / 2;
+  let d;
+  switch (a) {
+    case "top":
+      d = {
+        x: l,
+        y: n.y - o.height
+      };
+      break;
+    case "bottom":
+      d = {
+        x: l,
+        y: n.y + n.height
+      };
+      break;
+    case "right":
+      d = {
+        x: n.x + n.width,
+        y: u
+      };
+      break;
+    case "left":
+      d = {
+        x: n.x - o.width,
+        y: u
+      };
+      break;
+    default:
+      d = {
+        x: n.x,
+        y: n.y
+      };
+  }
+  switch (re(t)) {
+    case "start":
+      d[r] -= g * (i && f ? -1 : 1);
+      break;
+    case "end":
+      d[r] += g * (i && f ? -1 : 1);
+      break;
+  }
+  return d;
+}
+const mn = async (e, t, i) => {
+  const {
+    placement: n = "bottom",
+    strategy: o = "absolute",
+    middleware: s = [],
+    platform: r
+  } = i, c = s.filter(Boolean), a = await (r.isRTL == null ? void 0 : r.isRTL(t));
+  let f = await r.getElementRects({
+    reference: e,
+    floating: t,
+    strategy: o
+  }), {
+    x: l,
+    y: u
+  } = dt(f, n, a), g = n, d = {}, m = 0;
+  for (let h = 0; h < c.length; h++) {
+    const {
+      name: x,
+      fn: w
+    } = c[h], {
+      x: y,
+      y: v,
+      data: A,
+      reset: b
+    } = await w({
+      x: l,
+      y: u,
+      initialPlacement: n,
+      placement: g,
+      strategy: o,
+      middlewareData: d,
+      rects: f,
+      platform: r,
+      elements: {
+        reference: e,
+        floating: t
+      }
+    });
+    l = y ?? l, u = v ?? u, d = {
+      ...d,
+      [x]: {
+        ...d[x],
+        ...A
+      }
+    }, b && m <= 50 && (m++, typeof b == "object" && (b.placement && (g = b.placement), b.rects && (f = b.rects === !0 ? await r.getElementRects({
+      reference: e,
+      floating: t,
+      strategy: o
+    }) : b.rects), {
+      x: l,
+      y: u
+    } = dt(f, g, a)), h = -1);
+  }
+  return {
+    x: l,
+    y: u,
+    placement: g,
+    strategy: o,
+    middlewareData: d
+  };
+};
+async function me(e, t) {
+  var i;
+  t === void 0 && (t = {});
+  const {
+    x: n,
+    y: o,
+    platform: s,
+    rects: r,
+    elements: c,
+    strategy: a
+  } = e, {
+    boundary: f = "clippingAncestors",
+    rootBoundary: l = "viewport",
+    elementContext: u = "floating",
+    altBoundary: g = !1,
+    padding: d = 0
+  } = q(t, e), m = bt(d), x = c[g ? u === "floating" ? "reference" : "floating" : u], w = be(await s.getClippingRect({
+    element: (i = await (s.isElement == null ? void 0 : s.isElement(x))) == null || i ? x : x.contextElement || await (s.getDocumentElement == null ? void 0 : s.getDocumentElement(c.floating)),
+    boundary: f,
+    rootBoundary: l,
+    strategy: a
+  })), y = u === "floating" ? {
+    x: n,
+    y: o,
+    width: r.floating.width,
+    height: r.floating.height
+  } : r.reference, v = await (s.getOffsetParent == null ? void 0 : s.getOffsetParent(c.floating)), A = await (s.isElement == null ? void 0 : s.isElement(v)) ? await (s.getScale == null ? void 0 : s.getScale(v)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  }, b = be(s.convertOffsetParentRelativeRectToViewportRelativeRect ? await s.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: c,
+    rect: y,
+    offsetParent: v,
+    strategy: a
+  }) : y);
+  return {
+    top: (w.top - b.top + m.top) / A.y,
+    bottom: (b.bottom - w.bottom + m.bottom) / A.y,
+    left: (w.left - b.left + m.left) / A.x,
+    right: (b.right - w.right + m.right) / A.x
+  };
+}
+const gn = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "flip",
+    options: e,
+    async fn(t) {
+      var i, n;
+      const {
+        placement: o,
+        middlewareData: s,
+        rects: r,
+        initialPlacement: c,
+        platform: a,
+        elements: f
+      } = t, {
+        mainAxis: l = !0,
+        crossAxis: u = !0,
+        fallbackPlacements: g,
+        fallbackStrategy: d = "bestFit",
+        fallbackAxisSideDirection: m = "none",
+        flipAlignment: h = !0,
+        ...x
+      } = q(e, t);
+      if ((i = s.arrow) != null && i.alignmentOffset)
+        return {};
+      const w = z(o), y = Y(c), v = z(c) === c, A = await (a.isRTL == null ? void 0 : a.isRTL(f.floating)), b = g || (v || !h ? [Ut(c)] : Jt(c)), E = m !== "none";
+      !g && E && b.push(...Kt(c, h, m, A));
+      const R = [c, ...b], S = await me(t, x), V = [];
+      let L = ((n = s.flip) == null ? void 0 : n.overflows) || [];
+      if (l && V.push(S[w]), u) {
+        const $ = Gt(o, r, A);
+        V.push(S[$[0]], S[$[1]]);
+      }
+      if (L = [...L, {
+        placement: o,
+        overflows: V
+      }], !V.every(($) => $ <= 0)) {
+        var B, H;
+        const $ = (((B = s.flip) == null ? void 0 : B.index) || 0) + 1, D = R[$];
+        if (D && (!(u === "alignment" ? y !== Y(D) : !1) || // We leave the current main axis only if every placement on that axis
+        // overflows the main axis.
+        L.every((p) => Y(p.placement) === y ? p.overflows[0] > 0 : !0)))
+          return {
+            data: {
+              index: $,
+              overflows: L
+            },
+            reset: {
+              placement: D
+            }
+          };
+        let M = (H = L.filter((F) => F.overflows[0] <= 0).sort((F, p) => F.overflows[1] - p.overflows[1])[0]) == null ? void 0 : H.placement;
+        if (!M)
+          switch (d) {
+            case "bestFit": {
+              var P;
+              const F = (P = L.filter((p) => {
+                if (E) {
+                  const C = Y(p.placement);
+                  return C === y || // Create a bias to the `y` side axis due to horizontal
+                  // reading directions favoring greater width.
+                  C === "y";
+                }
+                return !0;
+              }).map((p) => [p.placement, p.overflows.filter((C) => C > 0).reduce((C, N) => C + N, 0)]).sort((p, C) => p[1] - C[1])[0]) == null ? void 0 : P[0];
+              F && (M = F);
+              break;
+            }
+            case "initialPlacement":
+              M = c;
+              break;
+          }
+        if (o !== M)
+          return {
+            reset: {
+              placement: M
+            }
+          };
+      }
+      return {};
+    }
+  };
+};
+function mt(e, t) {
+  return {
+    top: e.top - t.height,
+    right: e.right - t.width,
+    bottom: e.bottom - t.height,
+    left: e.left - t.width
+  };
+}
+function gt(e) {
+  return Qt.some((t) => e[t] >= 0);
+}
+const hn = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "hide",
+    options: e,
+    async fn(t) {
+      const {
+        rects: i
+      } = t, {
+        strategy: n = "referenceHidden",
+        ...o
+      } = q(e, t);
+      switch (n) {
+        case "referenceHidden": {
+          const s = await me(t, {
+            ...o,
+            elementContext: "reference"
+          }), r = mt(s, i.reference);
+          return {
+            data: {
+              referenceHiddenOffsets: r,
+              referenceHidden: gt(r)
+            }
+          };
+        }
+        case "escaped": {
+          const s = await me(t, {
+            ...o,
+            altBoundary: !0
+          }), r = mt(s, i.floating);
+          return {
+            data: {
+              escapedOffsets: r,
+              escaped: gt(r)
+            }
+          };
+        }
+        default:
+          return {};
+      }
+    }
+  };
+}, Dt = /* @__PURE__ */ new Set(["left", "top"]);
+async function pn(e, t) {
+  const {
+    placement: i,
+    platform: n,
+    elements: o
+  } = e, s = await (n.isRTL == null ? void 0 : n.isRTL(o.floating)), r = z(i), c = re(i), a = Y(i) === "y", f = Dt.has(r) ? -1 : 1, l = s && a ? -1 : 1, u = q(t, e);
+  let {
+    mainAxis: g,
+    crossAxis: d,
+    alignmentAxis: m
+  } = typeof u == "number" ? {
+    mainAxis: u,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: u.mainAxis || 0,
+    crossAxis: u.crossAxis || 0,
+    alignmentAxis: u.alignmentAxis
+  };
+  return c && typeof m == "number" && (d = c === "end" ? m * -1 : m), a ? {
+    x: d * l,
+    y: g * f
+  } : {
+    x: g * f,
+    y: d * l
+  };
+}
+const xn = function(e) {
+  return e === void 0 && (e = 0), {
+    name: "offset",
+    options: e,
+    async fn(t) {
+      var i, n;
+      const {
+        x: o,
+        y: s,
+        placement: r,
+        middlewareData: c
+      } = t, a = await pn(t, e);
+      return r === ((i = c.offset) == null ? void 0 : i.placement) && (n = c.arrow) != null && n.alignmentOffset ? {} : {
+        x: o + a.x,
+        y: s + a.y,
+        data: {
+          ...a,
+          placement: r
+        }
+      };
+    }
+  };
+}, wn = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "shift",
+    options: e,
+    async fn(t) {
+      const {
+        x: i,
+        y: n,
+        placement: o
+      } = t, {
+        mainAxis: s = !0,
+        crossAxis: r = !1,
+        limiter: c = {
+          fn: (x) => {
+            let {
+              x: w,
+              y
+            } = x;
+            return {
+              x: w,
+              y
+            };
+          }
+        },
+        ...a
+      } = q(e, t), f = {
+        x: i,
+        y: n
+      }, l = await me(t, a), u = Y(z(o)), g = St(u);
+      let d = f[g], m = f[u];
+      if (s) {
+        const x = g === "y" ? "top" : "left", w = g === "y" ? "bottom" : "right", y = d + l[x], v = d - l[w];
+        d = He(y, d, v);
+      }
+      if (r) {
+        const x = u === "y" ? "top" : "left", w = u === "y" ? "bottom" : "right", y = m + l[x], v = m - l[w];
+        m = He(y, m, v);
+      }
+      const h = c.fn({
+        ...t,
+        [g]: d,
+        [u]: m
+      });
+      return {
+        ...h,
+        data: {
+          x: h.x - i,
+          y: h.y - n,
+          enabled: {
+            [g]: s,
+            [u]: r
+          }
+        }
+      };
+    }
+  };
+}, yn = function(e) {
+  return e === void 0 && (e = {}), {
+    options: e,
+    fn(t) {
+      const {
+        x: i,
+        y: n,
+        placement: o,
+        rects: s,
+        middlewareData: r
+      } = t, {
+        offset: c = 0,
+        mainAxis: a = !0,
+        crossAxis: f = !0
+      } = q(e, t), l = {
+        x: i,
+        y: n
+      }, u = Y(o), g = St(u);
+      let d = l[g], m = l[u];
+      const h = q(c, t), x = typeof h == "number" ? {
+        mainAxis: h,
+        crossAxis: 0
+      } : {
+        mainAxis: 0,
+        crossAxis: 0,
+        ...h
+      };
+      if (a) {
+        const v = g === "y" ? "height" : "width", A = s.reference[g] - s.floating[v] + x.mainAxis, b = s.reference[g] + s.reference[v] - x.mainAxis;
+        d < A ? d = A : d > b && (d = b);
+      }
+      if (f) {
+        var w, y;
+        const v = g === "y" ? "width" : "height", A = Dt.has(z(o)), b = s.reference[u] - s.floating[v] + (A && ((w = r.offset) == null ? void 0 : w[u]) || 0) + (A ? 0 : x.crossAxis), E = s.reference[u] + s.reference[v] + (A ? 0 : ((y = r.offset) == null ? void 0 : y[u]) || 0) - (A ? x.crossAxis : 0);
+        m < b ? m = b : m > E && (m = E);
+      }
+      return {
+        [g]: d,
+        [u]: m
+      };
+    }
+  };
+}, Rn = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "size",
+    options: e,
+    async fn(t) {
+      var i, n;
+      const {
+        placement: o,
+        rects: s,
+        platform: r,
+        elements: c
+      } = t, {
+        apply: a = () => {
+        },
+        ...f
+      } = q(e, t), l = await me(t, f), u = z(o), g = re(o), d = Y(o) === "y", {
+        width: m,
+        height: h
+      } = s.floating;
+      let x, w;
+      u === "top" || u === "bottom" ? (x = u, w = g === (await (r.isRTL == null ? void 0 : r.isRTL(c.floating)) ? "start" : "end") ? "left" : "right") : (w = u, x = g === "end" ? "top" : "bottom");
+      const y = h - l.top - l.bottom, v = m - l.left - l.right, A = ue(h - l[x], y), b = ue(m - l[w], v), E = !t.middlewareData.shift;
+      let R = A, S = b;
+      if ((i = t.middlewareData.shift) != null && i.enabled.x && (S = v), (n = t.middlewareData.shift) != null && n.enabled.y && (R = y), E && !g) {
+        const L = _(l.left, 0), B = _(l.right, 0), H = _(l.top, 0), P = _(l.bottom, 0);
+        d ? S = m - 2 * (L !== 0 || B !== 0 ? L + B : _(l.left, l.right)) : R = h - 2 * (H !== 0 || P !== 0 ? H + P : _(l.top, l.bottom));
+      }
+      await a({
+        ...t,
+        availableWidth: S,
+        availableHeight: R
+      });
+      const V = await r.getDimensions(c.floating);
+      return m !== V.width || h !== V.height ? {
+        reset: {
+          rects: !0
+        }
+      } : {};
+    }
+  };
+};
+function Mt(e) {
+  const t = U(e);
+  let i = parseFloat(t.width) || 0, n = parseFloat(t.height) || 0;
+  const o = G(e), s = o ? e.offsetWidth : i, r = o ? e.offsetHeight : n, c = Ae(i) !== s || Ae(n) !== r;
+  return c && (i = s, n = r), {
+    width: i,
+    height: n,
+    $: c
+  };
+}
+function ze(e) {
+  return k(e) ? e : e.contextElement;
+}
+function se(e) {
+  const t = ze(e);
+  if (!G(t))
+    return j(1);
+  const i = t.getBoundingClientRect(), {
+    width: n,
+    height: o,
+    $: s
+  } = Mt(t);
+  let r = (s ? Ae(i.width) : i.width) / n, c = (s ? Ae(i.height) : i.height) / o;
+  return (!r || !Number.isFinite(r)) && (r = 1), (!c || !Number.isFinite(c)) && (c = 1), {
+    x: r,
+    y: c
+  };
+}
+const vn = /* @__PURE__ */ j(0);
+function Tt(e) {
+  const t = K(e);
+  return !Ct() || !t.visualViewport ? vn : {
+    x: t.visualViewport.offsetLeft,
+    y: t.visualViewport.offsetTop
+  };
+}
+function bn(e, t, i) {
+  return t === void 0 && (t = !1), !i || t && i !== K(e) ? !1 : t;
+}
+function Q(e, t, i, n) {
+  t === void 0 && (t = !1), i === void 0 && (i = !1);
+  const o = e.getBoundingClientRect(), s = ze(e);
+  let r = j(1);
+  t && (n ? k(n) && (r = se(n)) : r = se(e));
+  const c = bn(s, i, n) ? Tt(s) : j(0);
+  let a = (o.left + c.x) / r.x, f = (o.top + c.y) / r.y, l = o.width / r.x, u = o.height / r.y;
+  if (s) {
+    const g = K(s), d = n && k(n) ? K(n) : n;
+    let m = g, h = ut(m);
+    for (; h && n && d !== m; ) {
+      const x = se(h), w = h.getBoundingClientRect(), y = U(h), v = w.left + (h.clientLeft + parseFloat(y.paddingLeft)) * x.x, A = w.top + (h.clientTop + parseFloat(y.paddingTop)) * x.y;
+      a *= x.x, f *= x.y, l *= x.x, u *= x.y, a += v, f += A, m = K(h), h = ut(m);
+    }
+  }
+  return be({
+    width: l,
+    height: u,
+    x: a,
+    y: f
+  });
+}
+function Ce(e, t) {
+  const i = Ee(e).scrollLeft;
+  return t ? t.left + i : Q(J(e)).left + i;
+}
+function Lt(e, t) {
+  const i = e.getBoundingClientRect(), n = i.left + t.scrollLeft - Ce(e, i), o = i.top + t.scrollTop;
+  return {
+    x: n,
+    y: o
+  };
+}
+function An(e) {
+  let {
+    elements: t,
+    rect: i,
+    offsetParent: n,
+    strategy: o
+  } = e;
+  const s = o === "fixed", r = J(n), c = t ? Ve(t.floating) : !1;
+  if (n === r || c && s)
+    return i;
+  let a = {
+    scrollLeft: 0,
+    scrollTop: 0
+  }, f = j(1);
+  const l = j(0), u = G(n);
+  if ((u || !u && !s) && ((Ie(n) !== "body" || _e(r)) && (a = Ee(n)), G(n))) {
+    const d = Q(n);
+    f = se(n), l.x = d.x + n.clientLeft, l.y = d.y + n.clientTop;
+  }
+  const g = r && !u && !s ? Lt(r, a) : j(0);
+  return {
+    width: i.width * f.x,
+    height: i.height * f.y,
+    x: i.x * f.x - a.scrollLeft * f.x + l.x + g.x,
+    y: i.y * f.y - a.scrollTop * f.y + l.y + g.y
+  };
+}
+function On(e) {
+  return Array.from(e.getClientRects());
+}
+function Sn(e) {
+  const t = J(e), i = Ee(e), n = e.ownerDocument.body, o = _(t.scrollWidth, t.clientWidth, n.scrollWidth, n.clientWidth), s = _(t.scrollHeight, t.clientHeight, n.scrollHeight, n.clientHeight);
+  let r = -i.scrollLeft + Ce(e);
+  const c = -i.scrollTop;
+  return U(n).direction === "rtl" && (r += _(t.clientWidth, n.clientWidth) - o), {
+    width: o,
+    height: s,
+    x: r,
+    y: c
+  };
+}
+const ht = 25;
+function En(e, t) {
+  const i = K(e), n = J(e), o = i.visualViewport;
+  let s = n.clientWidth, r = n.clientHeight, c = 0, a = 0;
+  if (o) {
+    s = o.width, r = o.height;
+    const l = Ct();
+    (!l || l && t === "fixed") && (c = o.offsetLeft, a = o.offsetTop);
+  }
+  const f = Ce(n);
+  if (f <= 0) {
+    const l = n.ownerDocument, u = l.body, g = getComputedStyle(u), d = l.compatMode === "CSS1Compat" && parseFloat(g.marginLeft) + parseFloat(g.marginRight) || 0, m = Math.abs(n.clientWidth - u.clientWidth - d);
+    m <= ht && (s -= m);
+  } else f <= ht && (s += f);
+  return {
+    width: s,
+    height: r,
+    x: c,
+    y: a
+  };
+}
+const Cn = /* @__PURE__ */ new Set(["absolute", "fixed"]);
+function Pn(e, t) {
+  const i = Q(e, !0, t === "fixed"), n = i.top + e.clientTop, o = i.left + e.clientLeft, s = G(e) ? se(e) : j(1), r = e.clientWidth * s.x, c = e.clientHeight * s.y, a = o * s.x, f = n * s.y;
+  return {
+    width: r,
+    height: c,
+    x: a,
+    y: f
+  };
+}
+function pt(e, t, i) {
+  let n;
+  if (t === "viewport")
+    n = En(e, i);
+  else if (t === "document")
+    n = Sn(J(e));
+  else if (k(t))
+    n = Pn(t, i);
+  else {
+    const o = Tt(e);
+    n = {
+      x: t.x - o.x,
+      y: t.y - o.y,
+      width: t.width,
+      height: t.height
+    };
+  }
+  return be(n);
+}
+function Ft(e, t) {
+  const i = de(e);
+  return i === t || !k(i) || Oe(i) ? !1 : U(i).position === "fixed" || Ft(i, t);
+}
+function Dn(e, t) {
+  const i = t.get(e);
+  if (i)
+    return i;
+  let n = We(e, [], !1).filter((c) => k(c) && Ie(c) !== "body"), o = null;
+  const s = U(e).position === "fixed";
+  let r = s ? de(e) : e;
+  for (; k(r) && !Oe(r); ) {
+    const c = U(r), a = Pt(r);
+    !a && c.position === "fixed" && (o = null), (s ? !a && !o : !a && c.position === "static" && !!o && Cn.has(o.position) || _e(r) && !a && Ft(e, r)) ? n = n.filter((l) => l !== r) : o = c, r = de(r);
+  }
+  return t.set(e, n), n;
+}
+function Mn(e) {
+  let {
+    element: t,
+    boundary: i,
+    rootBoundary: n,
+    strategy: o
+  } = e;
+  const r = [...i === "clippingAncestors" ? Ve(t) ? [] : Dn(t, this._c) : [].concat(i), n], c = r[0], a = r.reduce((f, l) => {
+    const u = pt(t, l, o);
+    return f.top = _(u.top, f.top), f.right = ue(u.right, f.right), f.bottom = ue(u.bottom, f.bottom), f.left = _(u.left, f.left), f;
+  }, pt(t, c, o));
+  return {
+    width: a.right - a.left,
+    height: a.bottom - a.top,
+    x: a.left,
+    y: a.top
+  };
+}
+function Tn(e) {
+  const {
+    width: t,
+    height: i
+  } = Mt(e);
+  return {
+    width: t,
+    height: i
+  };
+}
+function Ln(e, t, i) {
+  const n = G(t), o = J(t), s = i === "fixed", r = Q(e, !0, s, t);
+  let c = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const a = j(0);
+  function f() {
+    a.x = Ce(o);
+  }
+  if (n || !n && !s)
+    if ((Ie(t) !== "body" || _e(o)) && (c = Ee(t)), n) {
+      const d = Q(t, !0, s, t);
+      a.x = d.x + t.clientLeft, a.y = d.y + t.clientTop;
+    } else o && f();
+  s && !n && o && f();
+  const l = o && !n && !s ? Lt(o, c) : j(0), u = r.left + c.scrollLeft - a.x - l.x, g = r.top + c.scrollTop - a.y - l.y;
+  return {
+    x: u,
+    y: g,
+    width: r.width,
+    height: r.height
+  };
+}
+function $e(e) {
+  return U(e).position === "static";
+}
+function xt(e, t) {
+  if (!G(e) || U(e).position === "fixed")
+    return null;
+  if (t)
+    return t(e);
+  let i = e.offsetParent;
+  return J(e) === i && (i = i.ownerDocument.body), i;
+}
+function kt(e, t) {
+  const i = K(e);
+  if (Ve(e))
+    return i;
+  if (!G(e)) {
+    let o = de(e);
+    for (; o && !Oe(o); ) {
+      if (k(o) && !$e(o))
+        return o;
+      o = de(o);
+    }
+    return i;
+  }
+  let n = xt(e, t);
+  for (; n && tn(n) && $e(n); )
+    n = xt(n, t);
+  return n && Oe(n) && $e(n) && !Pt(n) ? i : n || nn(e) || i;
+}
+const Fn = async function(e) {
+  const t = this.getOffsetParent || kt, i = this.getDimensions, n = await i(e.floating);
+  return {
+    reference: Ln(e.reference, await t(e.floating), e.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      width: n.width,
+      height: n.height
+    }
+  };
+};
+function kn(e) {
+  return U(e).direction === "rtl";
+}
+const $n = {
+  convertOffsetParentRelativeRectToViewportRelativeRect: An,
+  getDocumentElement: J,
+  getClippingRect: Mn,
+  getOffsetParent: kt,
+  getElementRects: Fn,
+  getClientRects: On,
+  getDimensions: Tn,
+  getScale: se,
+  isElement: k,
+  isRTL: kn
+};
+function $t(e, t) {
+  return e.x === t.x && e.y === t.y && e.width === t.width && e.height === t.height;
+}
+function Bn(e, t) {
+  let i = null, n;
+  const o = J(e);
+  function s() {
+    var c;
+    clearTimeout(n), (c = i) == null || c.disconnect(), i = null;
+  }
+  function r(c, a) {
+    c === void 0 && (c = !1), a === void 0 && (a = 1), s();
+    const f = e.getBoundingClientRect(), {
+      left: l,
+      top: u,
+      width: g,
+      height: d
+    } = f;
+    if (c || t(), !g || !d)
+      return;
+    const m = ye(u), h = ye(o.clientWidth - (l + g)), x = ye(o.clientHeight - (u + d)), w = ye(l), v = {
+      rootMargin: -m + "px " + -h + "px " + -x + "px " + -w + "px",
+      threshold: _(0, ue(1, a)) || 1
+    };
+    let A = !0;
+    function b(E) {
+      const R = E[0].intersectionRatio;
+      if (R !== a) {
+        if (!A)
+          return r();
+        R ? r(!1, R) : n = setTimeout(() => {
+          r(!1, 1e-7);
+        }, 1e3);
+      }
+      R === 1 && !$t(f, e.getBoundingClientRect()) && r(), A = !1;
+    }
+    try {
+      i = new IntersectionObserver(b, {
+        ...v,
+        // Handle <iframe>s
+        root: o.ownerDocument
+      });
+    } catch {
+      i = new IntersectionObserver(b, v);
+    }
+    i.observe(e);
+  }
+  return r(!0), s;
+}
+function wt(e, t, i, n) {
+  n === void 0 && (n = {});
+  const {
+    ancestorScroll: o = !0,
+    ancestorResize: s = !0,
+    elementResize: r = typeof ResizeObserver == "function",
+    layoutShift: c = typeof IntersectionObserver == "function",
+    animationFrame: a = !1
+  } = n, f = ze(e), l = o || s ? [...f ? We(f) : [], ...We(t)] : [];
+  l.forEach((w) => {
+    o && w.addEventListener("scroll", i, {
+      passive: !0
+    }), s && w.addEventListener("resize", i);
+  });
+  const u = f && c ? Bn(f, i) : null;
+  let g = -1, d = null;
+  r && (d = new ResizeObserver((w) => {
+    let [y] = w;
+    y && y.target === f && d && (d.unobserve(t), cancelAnimationFrame(g), g = requestAnimationFrame(() => {
+      var v;
+      (v = d) == null || v.observe(t);
+    })), i();
+  }), f && !a && d.observe(f), d.observe(t));
+  let m, h = a ? Q(e) : null;
+  a && x();
+  function x() {
+    const w = Q(e);
+    h && !$t(h, w) && i(), h = w, m = requestAnimationFrame(x);
+  }
+  return i(), () => {
+    var w;
+    l.forEach((y) => {
+      o && y.removeEventListener("scroll", i), s && y.removeEventListener("resize", i);
+    }), u?.(), (w = d) == null || w.disconnect(), d = null, a && cancelAnimationFrame(m);
+  };
+}
+const Hn = xn, Wn = wn, Vn = gn, In = Rn, _n = hn, zn = yn, Nn = (e, t, i) => {
+  const n = /* @__PURE__ */ new Map(), o = {
+    platform: $n,
+    ...i
+  }, s = {
+    ...o.platform,
+    _c: n
+  };
+  return mn(e, t, {
+    ...o,
+    platform: s
+  });
+};
+var Yn = typeof document < "u", Xn = function() {
+}, Re = Yn ? qt : Xn;
+function Se(e, t) {
+  if (e === t)
+    return !0;
+  if (typeof e != typeof t)
+    return !1;
+  if (typeof e == "function" && e.toString() === t.toString())
+    return !0;
+  let i, n, o;
+  if (e && t && typeof e == "object") {
+    if (Array.isArray(e)) {
+      if (i = e.length, i !== t.length) return !1;
+      for (n = i; n-- !== 0; )
+        if (!Se(e[n], t[n]))
+          return !1;
+      return !0;
+    }
+    if (o = Object.keys(e), i = o.length, i !== Object.keys(t).length)
+      return !1;
+    for (n = i; n-- !== 0; )
+      if (!{}.hasOwnProperty.call(t, o[n]))
+        return !1;
+    for (n = i; n-- !== 0; ) {
+      const s = o[n];
+      if (!(s === "_owner" && e.$$typeof) && !Se(e[s], t[s]))
+        return !1;
+    }
+    return !0;
+  }
+  return e !== e && t !== t;
+}
+function Bt(e) {
+  return typeof window > "u" ? 1 : (e.ownerDocument.defaultView || window).devicePixelRatio || 1;
+}
+function yt(e, t) {
+  const i = Bt(e);
+  return Math.round(t * i) / i;
+}
+function Be(e) {
+  const t = O.useRef(e);
+  return Re(() => {
+    t.current = e;
+  }), t;
+}
+function jn(e) {
+  e === void 0 && (e = {});
+  const {
+    placement: t = "bottom",
+    strategy: i = "absolute",
+    middleware: n = [],
+    platform: o,
+    elements: {
+      reference: s,
+      floating: r
+    } = {},
+    transform: c = !0,
+    whileElementsMounted: a,
+    open: f
+  } = e, [l, u] = O.useState({
+    x: 0,
+    y: 0,
+    strategy: i,
+    placement: t,
+    middlewareData: {},
+    isPositioned: !1
+  }), [g, d] = O.useState(n);
+  Se(g, n) || d(n);
+  const [m, h] = O.useState(null), [x, w] = O.useState(null), y = O.useCallback((p) => {
+    p !== E.current && (E.current = p, h(p));
+  }, []), v = O.useCallback((p) => {
+    p !== R.current && (R.current = p, w(p));
+  }, []), A = s || m, b = r || x, E = O.useRef(null), R = O.useRef(null), S = O.useRef(l), V = a != null, L = Be(a), B = Be(o), H = Be(f), P = O.useCallback(() => {
+    if (!E.current || !R.current)
+      return;
+    const p = {
+      placement: t,
+      strategy: i,
+      middleware: g
+    };
+    B.current && (p.platform = B.current), Nn(E.current, R.current, p).then((C) => {
+      const N = {
+        ...C,
+        // The floating element's position may be recomputed while it's closed
+        // but still mounted (such as when transitioning out). To ensure
+        // `isPositioned` will be `false` initially on the next open, avoid
+        // setting it to `true` when `open === false` (must be specified).
+        isPositioned: H.current !== !1
+      };
+      $.current && !Se(S.current, N) && (S.current = N, on.flushSync(() => {
+        u(N);
+      }));
+    });
+  }, [g, t, i, B, H]);
+  Re(() => {
+    f === !1 && S.current.isPositioned && (S.current.isPositioned = !1, u((p) => ({
+      ...p,
+      isPositioned: !1
+    })));
+  }, [f]);
+  const $ = O.useRef(!1);
+  Re(() => ($.current = !0, () => {
+    $.current = !1;
+  }), []), Re(() => {
+    if (A && (E.current = A), b && (R.current = b), A && b) {
+      if (L.current)
+        return L.current(A, b, P);
+      P();
+    }
+  }, [A, b, P, L, V]);
+  const D = O.useMemo(() => ({
+    reference: E,
+    floating: R,
+    setReference: y,
+    setFloating: v
+  }), [y, v]), M = O.useMemo(() => ({
+    reference: A,
+    floating: b
+  }), [A, b]), F = O.useMemo(() => {
+    const p = {
+      position: i,
+      left: 0,
+      top: 0
+    };
+    if (!M.floating)
+      return p;
+    const C = yt(M.floating, l.x), N = yt(M.floating, l.y);
+    return c ? {
+      ...p,
+      transform: "translate(" + C + "px, " + N + "px)",
+      ...Bt(M.floating) >= 1.5 && {
+        willChange: "transform"
+      }
+    } : {
+      position: i,
+      left: C,
+      top: N
+    };
+  }, [i, c, M.floating, l.x, l.y]);
+  return O.useMemo(() => ({
+    ...l,
+    update: P,
+    refs: D,
+    elements: M,
+    floatingStyles: F
+  }), [l, P, D, M, F]);
+}
+const qn = (e, t) => ({
+  ...Hn(e),
+  options: [e, t]
+}), Un = (e, t) => ({
+  ...Wn(e),
+  options: [e, t]
+}), Jn = (e, t) => ({
+  ...zn(e),
+  options: [e, t]
+}), Kn = (e, t) => ({
+  ...Vn(e),
+  options: [e, t]
+}), Gn = (e, t) => ({
+  ...In(e),
+  options: [e, t]
+}), Qn = (e, t) => ({
+  ..._n(e),
+  options: [e, t]
+});
+function Zn(e) {
+  const {
+    open: t = !1,
+    onOpenChange: i,
+    elements: n = {}
+  } = e, o = an(), s = sn() != null;
+  if (process.env.NODE_ENV !== "production") {
+    const c = n.reference;
+    c && !k(c) && console.error("Cannot pass a virtual element to the `elements.reference` option,", "as it must be a real DOM element. Use `context.setPositionReference()`", "instead.");
+  }
+  const r = fn(() => new rn({
+    open: t,
+    onOpenChange: i,
+    referenceElement: n.reference ?? null,
+    floatingElement: n.floating ?? null,
+    triggerElements: n.triggers ?? new cn(),
+    floatingId: o,
+    nested: s,
+    noEmit: e.noEmit || !1
+  })).current;
+  return oe(() => {
+    const c = {
+      open: t,
+      floatingId: o
+    };
+    n.reference !== void 0 && (c.referenceElement = n.reference, c.domReferenceElement = k(n.reference) ? n.reference : null), n.floating !== void 0 && (c.floatingElement = n.floating), r.update(c);
+  }, [t, o, n.reference, n.floating, r]), r.context.onOpenChange = i, r.context.nested = s, r.context.noEmit = e.noEmit || !1, r;
+}
+function ei(e = {}) {
+  const {
+    nodeId: t,
+    externalTree: i
+  } = e, n = Zn(e), o = e.rootContext || n, s = {
+    reference: o.useState("referenceElement"),
+    floating: o.useState("floatingElement"),
+    domReference: o.useState("domReferenceElement")
+  }, [r, c] = O.useState(null), a = O.useRef(null), f = ln(i);
+  oe(() => {
+    s.domReference && (a.current = s.domReference);
+  }, [s.domReference]);
+  const l = jn({
+    ...e,
+    elements: {
+      ...s,
+      ...r && {
+        reference: r
+      }
+    }
+  }), u = O.useCallback((R) => {
+    const S = k(R) ? {
+      getBoundingClientRect: () => R.getBoundingClientRect(),
+      getClientRects: () => R.getClientRects(),
+      contextElement: R
+    } : R;
+    c(S), l.refs.setReference(S);
+  }, [l.refs]), [g, d] = O.useState(null), [m, h] = O.useState(null);
+  o.useSyncedValue("referenceElement", g), o.useSyncedValue("domReferenceElement", k(g) ? g : null), o.useSyncedValue("floatingElement", m);
+  const x = O.useCallback((R) => {
+    (k(R) || R === null) && (a.current = R, d(R)), (k(l.refs.reference.current) || l.refs.reference.current === null || // Don't allow setting virtual elements using the old technique back to
+    // `null` to support `positionReference` + an unstable `reference`
+    // callback ref.
+    R !== null && !k(R)) && l.refs.setReference(R);
+  }, [l.refs, d]), w = O.useCallback((R) => {
+    h(R), l.refs.setFloating(R);
+  }, [l.refs]), y = O.useMemo(() => ({
+    ...l.refs,
+    setReference: x,
+    setFloating: w,
+    setPositionReference: u,
+    domReference: a
+  }), [l.refs, x, w, u]), v = O.useMemo(() => ({
+    ...l.elements,
+    domReference: s.domReference
+  }), [l.elements, s.domReference]), A = o.useState("open"), b = o.useState("floatingId"), E = O.useMemo(() => ({
+    ...l,
+    dataRef: o.context.dataRef,
+    open: A,
+    onOpenChange: o.setOpen,
+    events: o.context.events,
+    floatingId: b,
+    refs: y,
+    elements: v,
+    nodeId: t,
+    rootStore: o
+  }), [l, y, v, t, o, A, b]);
+  return oe(() => {
+    o.context.dataRef.current.floatingContext = E;
+    const R = f?.nodesRef.current.find((S) => S.id === t);
+    R && (R.context = E);
+  }), O.useMemo(() => ({
+    ...l,
+    context: E,
+    refs: y,
+    elements: v,
+    rootStore: o
+  }), [l, y, v, E, o]);
+}
+const ti = (e) => ({
+  name: "arrow",
+  options: e,
+  async fn(t) {
+    const {
+      x: i,
+      y: n,
+      placement: o,
+      rects: s,
+      platform: r,
+      elements: c,
+      middlewareData: a
+    } = t, {
+      element: f,
+      padding: l = 0,
+      offsetParent: u = "real"
+    } = q(e, t) || {};
+    if (f == null)
+      return {};
+    const g = bt(l), d = {
+      x: i,
+      y: n
+    }, m = At(o), h = Ot(m), x = await r.getDimensions(f), w = m === "y", y = w ? "top" : "left", v = w ? "bottom" : "right", A = w ? "clientHeight" : "clientWidth", b = s.reference[h] + s.reference[m] - d[m] - s.floating[h], E = d[m] - s.reference[m], R = u === "real" ? await r.getOffsetParent?.(f) : c.floating;
+    let S = c.floating[A] || s.floating[h];
+    (!S || !await r.isElement?.(R)) && (S = c.floating[A] || s.floating[h]);
+    const V = b / 2 - E / 2, L = S / 2 - x[h] / 2 - 1, B = Math.min(g[y], L), H = Math.min(g[v], L), P = B, $ = S - x[h] - H, D = S / 2 - x[h] / 2 + V, M = He(P, D, $), F = !a.arrow && re(o) != null && D !== M && s.reference[h] / 2 - (D < P ? B : H) - x[h] / 2 < 0, p = F ? D < P ? D - P : D - $ : 0;
+    return {
+      [m]: d[m] + p,
+      data: {
+        [m]: M,
+        centerOffset: D - M - p,
+        ...F && {
+          alignmentOffset: p
+        }
+      },
+      reset: F
+    };
+  }
+}), ni = (e, t) => ({
+  ...ti(e),
+  options: [e, t]
+}), ii = {
+  name: "hide",
+  async fn(e) {
+    const {
+      width: t,
+      height: i,
+      x: n,
+      y: o
+    } = e.rects.reference, s = t === 0 && i === 0 && n === 0 && o === 0;
+    return {
+      data: {
+        referenceHidden: (await Qn().fn(e)).data?.referenceHidden || s
+      }
+    };
+  }
+}, ve = {
+  sideX: "left",
+  sideY: "top"
+}, wi = {
+  name: "adaptiveOrigin",
+  async fn(e) {
+    const {
+      x: t,
+      y: i,
+      rects: {
+        floating: n
+      },
+      elements: {
+        floating: o
+      },
+      platform: s,
+      strategy: r,
+      placement: c
+    } = e, a = K(o), f = a.getComputedStyle(o);
+    if (!(f.transitionDuration !== "0s" && f.transitionDuration !== ""))
+      return {
+        x: t,
+        y: i,
+        data: ve
+      };
+    const u = await s.getOffsetParent?.(o);
+    let g = {
+      width: 0,
+      height: 0
+    };
+    if (r === "fixed" && a?.visualViewport)
+      g = {
+        width: a.visualViewport.width,
+        height: a.visualViewport.height
+      };
+    else if (u === a) {
+      const y = Et(o);
+      g = {
+        width: y.documentElement.clientWidth,
+        height: y.documentElement.clientHeight
+      };
+    } else await s.isElement?.(u) && (g = await s.getDimensions(u));
+    const d = z(c);
+    let m = t, h = i;
+    d === "left" && (m = g.width - (t + n.width)), d === "top" && (h = g.height - (i + n.height));
+    const x = d === "left" ? "right" : ve.sideX, w = d === "top" ? "bottom" : ve.sideY;
+    return {
+      x: m,
+      y: h,
+      data: {
+        sideX: x,
+        sideY: w
+      }
+    };
+  }
+};
+function Ht(e, t, i) {
+  const n = e === "inline-start" || e === "inline-end";
+  return {
+    top: "top",
+    right: n ? i ? "inline-start" : "inline-end" : "right",
+    bottom: "bottom",
+    left: n ? i ? "inline-end" : "inline-start" : "left"
+  }[t];
+}
+function Rt(e, t, i) {
+  const {
+    rects: n,
+    placement: o
+  } = e;
+  return {
+    side: Ht(t, z(o), i),
+    align: re(o) || "center",
+    anchor: {
+      width: n.reference.width,
+      height: n.reference.height
+    },
+    positioner: {
+      width: n.floating.width,
+      height: n.floating.height
+    }
+  };
+}
+function yi(e) {
+  const {
+    // Public parameters
+    anchor: t,
+    positionMethod: i = "absolute",
+    side: n = "bottom",
+    sideOffset: o = 0,
+    align: s = "center",
+    alignOffset: r = 0,
+    collisionBoundary: c,
+    collisionPadding: a = 5,
+    sticky: f = !1,
+    arrowPadding: l = 5,
+    disableAnchorTracking: u = !1,
+    // Private parameters
+    keepMounted: g = !1,
+    floatingRootContext: d,
+    mounted: m,
+    collisionAvoidance: h,
+    shiftCrossAxis: x = !1,
+    nodeId: w,
+    adaptiveOrigin: y,
+    lazyFlip: v = !1,
+    externalTree: A
+  } = e, [b, E] = O.useState(null);
+  !m && b !== null && E(null);
+  const R = h.side || "flip", S = h.align || "flip", V = h.fallbackAxisSide || "end", L = typeof t == "function" ? t : void 0, B = Zt(L), H = L ? B : t, P = ke(t), D = en() === "rtl", M = b || {
+    top: "top",
+    right: "right",
+    bottom: "bottom",
+    left: "left",
+    "inline-end": D ? "left" : "right",
+    "inline-start": D ? "right" : "left"
+  }[n], F = s === "center" ? M : `${M}-${s}`;
+  let p = a;
+  const C = 1, N = n === "bottom" ? C : 0, Ne = n === "top" ? C : 0, Ye = n === "right" ? C : 0, Xe = n === "left" ? C : 0;
+  typeof p == "number" ? p = {
+    top: p + N,
+    right: p + Xe,
+    bottom: p + Ne,
+    left: p + Ye
+  } : p && (p = {
+    top: (p.top || 0) + N,
+    right: (p.right || 0) + Xe,
+    bottom: (p.bottom || 0) + Ne,
+    left: (p.left || 0) + Ye
+  });
+  const ge = {
+    boundary: c === "clipping-ancestors" ? "clippingAncestors" : c,
+    padding: p
+  }, Z = O.useRef(null), Pe = ke(o), De = ke(r), he = [qn((T) => {
+    const W = Rt(T, n, D), X = typeof Pe.current == "function" ? Pe.current(W) : Pe.current, I = typeof De.current == "function" ? De.current(W) : De.current;
+    return {
+      mainAxis: X,
+      crossAxis: I,
+      alignmentAxis: I
+    };
+  }, [typeof o != "function" ? o : 0, typeof r != "function" ? r : 0, D, n])], je = S === "none" && R !== "shift", qe = !je && (f || x || R === "shift"), Ue = R === "none" ? null : Kn({
+    ...ge,
+    // Ensure the popup flips if it's been limited by its --available-height and it resizes.
+    // Since the size() padding is smaller than the flip() padding, flip() will take precedence.
+    padding: {
+      top: p.top + C,
+      right: p.right + C,
+      bottom: p.bottom + C,
+      left: p.left + C
+    },
+    mainAxis: !x && R === "flip",
+    crossAxis: S === "flip" ? "alignment" : !1,
+    fallbackAxisSideDirection: V
+  }), Je = je ? null : Un((T) => {
+    const W = Et(T.elements.floating).documentElement;
+    return {
+      ...ge,
+      // Use the Layout Viewport to avoid shifting around when pinch-zooming
+      // for context menus.
+      rootBoundary: x ? {
+        x: 0,
+        y: 0,
+        width: W.clientWidth,
+        height: W.clientHeight
+      } : void 0,
+      mainAxis: S !== "none",
+      crossAxis: qe,
+      limiter: f || x ? void 0 : Jn((X) => {
+        if (!Z.current)
+          return {};
+        const {
+          width: I,
+          height: ne
+        } = Z.current.getBoundingClientRect(), ie = Y(z(X.placement)), we = ie === "y" ? I : ne, Le = ie === "y" ? p.left + p.right : p.top + p.bottom;
+        return {
+          offset: we / 2 + Le / 2
+        };
+      })
+    };
+  }, [ge, f, x, p, S]);
+  R === "shift" || S === "shift" || s === "center" ? he.push(Je, Ue) : he.push(Ue, Je), he.push(Gn({
+    ...ge,
+    apply({
+      elements: {
+        floating: T
+      },
+      rects: {
+        reference: W
+      },
+      availableWidth: X,
+      availableHeight: I
+    }) {
+      Object.entries({
+        "--available-width": `${X}px`,
+        "--available-height": `${I}px`,
+        "--anchor-width": `${W.width}px`,
+        "--anchor-height": `${W.height}px`
+      }).forEach(([ne, ie]) => {
+        T.style.setProperty(ne, ie);
+      });
+    }
+  }), ni(() => ({
+    // `transform-origin` calculations rely on an element existing. If the arrow hasn't been set,
+    // we'll create a fake element.
+    element: Z.current || document.createElement("div"),
+    padding: l,
+    offsetParent: "floating"
+  }), [l]), {
+    name: "transformOrigin",
+    fn(T) {
+      const {
+        elements: W,
+        middlewareData: X,
+        placement: I,
+        rects: ne,
+        y: ie
+      } = T, we = z(I), Le = Y(we), at = Z.current, Wt = X.arrow?.x || 0, Vt = X.arrow?.y || 0, It = at?.clientWidth || 0, _t = at?.clientHeight || 0, Fe = Wt + It / 2, ft = Vt + _t / 2, zt = Math.abs(X.shift?.y || 0), Nt = ne.reference.height / 2, fe = typeof o == "function" ? o(Rt(T, n, D)) : o, Yt = zt > fe, Xt = {
+        top: `${Fe}px calc(100% + ${fe}px)`,
+        bottom: `${Fe}px ${-fe}px`,
+        left: `calc(100% + ${fe}px) ${ft}px`,
+        right: `${-fe}px ${ft}px`
+      }[we], jt = `${Fe}px ${ne.reference.y + Nt - ie}px`;
+      return W.floating.style.setProperty("--transform-origin", qe && Le === "y" && Yt ? jt : Xt), {};
+    }
+  }, ii, y), oe(() => {
+    !m && d && d.update({
+      referenceElement: null,
+      floatingElement: null,
+      domReferenceElement: null
+    });
+  }, [m, d]);
+  const Me = O.useMemo(() => ({
+    elementResize: !u && typeof ResizeObserver < "u",
+    layoutShift: !u && typeof IntersectionObserver < "u"
+  }), [u]), {
+    refs: ee,
+    elements: ce,
+    x: Ke,
+    y: Ge,
+    middlewareData: te,
+    update: pe,
+    placement: Qe,
+    context: Ze,
+    isPositioned: le,
+    floatingStyles: et
+  } = ei({
+    rootContext: d,
+    placement: F,
+    middleware: he,
+    strategy: i,
+    whileElementsMounted: g ? void 0 : (...T) => wt(...T, Me),
+    nodeId: w,
+    externalTree: A
+  }), {
+    sideX: tt,
+    sideY: nt
+  } = te.adaptiveOrigin || ve, Te = le ? i : "fixed", it = O.useMemo(() => y ? {
+    position: Te,
+    [tt]: Ke,
+    [nt]: Ge
+  } : {
+    position: Te,
+    ...et
+  }, [y, Te, tt, Ke, nt, Ge, et]), xe = O.useRef(null);
+  oe(() => {
+    if (!m)
+      return;
+    const T = P.current, W = typeof T == "function" ? T() : T, I = (vt(W) ? W.current : W) || null || null;
+    I !== xe.current && (ee.setPositionReference(I), xe.current = I);
+  }, [m, ee, H, P]), O.useEffect(() => {
+    if (!m)
+      return;
+    const T = P.current;
+    typeof T != "function" && vt(T) && T.current !== xe.current && (ee.setPositionReference(T.current), xe.current = T.current);
+  }, [m, ee, H, P]), O.useEffect(() => {
+    if (g && m && ce.domReference && ce.floating)
+      return wt(ce.domReference, ce.floating, pe, Me);
+  }, [g, m, ce, pe, Me]);
+  const ae = z(Qe), ot = Ht(n, ae, D), st = re(Qe) || "center", rt = !!te.hide?.referenceHidden;
+  oe(() => {
+    v && m && le && E(ae);
+  }, [v, m, le, ae]);
+  const ct = O.useMemo(() => ({
+    position: "absolute",
+    top: te.arrow?.y,
+    left: te.arrow?.x
+  }), [te.arrow]), lt = te.arrow?.centerOffset !== 0;
+  return O.useMemo(() => ({
+    positionerStyles: it,
+    arrowStyles: ct,
+    arrowRef: Z,
+    arrowUncentered: lt,
+    side: ot,
+    align: st,
+    physicalSide: ae,
+    anchorHidden: rt,
+    refs: ee,
+    context: Ze,
+    isPositioned: le,
+    update: pe
+  }), [it, ct, Z, lt, ot, st, ae, rt, ee, Ze, le, pe]);
+}
+function vt(e) {
+  return e != null && "current" in e;
+}
+function Ri(e) {
+  return e === "starting" ? dn : un;
+}
+export {
+  yi as a,
+  wi as b,
+  Ri as g,
+  Zn as u
+};