@component-labs/ui 0.0.1

package/dist/X6LNAU2F-DroCIVyL.js

@@ -0,0 +1,1692 @@
+import { i as Le, g as ge, j as Fe, s as ke, k as he, l as $e, m as Ne, n as Ve, C as Be, a as He } from "./IQYAUKXT-CoP_Jrsi.js";
+import { c as at, l as pe, _ as We, m as Pt, C as _t, f as ft, a as ut, Q as ze, d as tt, $ as _e, a0 as kt, U as $t, H as je, k as yt, g as Xe, a1 as Ke, w as Nt, y as Ue, a2 as Ye, e as qe, x as ve, E as xe, i as jt, K as Ge, h as oe, F as xt, j as Je, L as Qe, P as Ze, q as tn, O as en, a3 as nn } from "./U6HHPQDW-BkT6kvCd.js";
+import { useRef as bt, useEffect as on, useContext as rn, useCallback as we, useMemo as sn, createContext as Xt, useState as cn } from "react";
+import { u as ln } from "./PZ3OL7I2-h7WHitqi.js";
+import { u as an, m as fn, o as un, t as dn, c as mn, f as gn } from "./Q5W46E73-DjlVG3LH.js";
+import { jsx as Vt } from "react/jsx-runtime";
+import { g as hn, h as pn, j as vn, c as xn, k as wn, l as yn } from "./Z32PU2LQ-CPSDShGU.js";
+var bn = "div", ye = at(
+  function({
+    store: t,
+    shouldRegisterItem: n = !0,
+    getItem: o = We,
+    // @ts-expect-error This prop may come from a collection renderer.
+    element: i,
+    ...r
+  }) {
+    const s = Le();
+    t = t || s;
+    const c = pe(r.id), a = bt(i);
+    return on(() => {
+      const l = a.current;
+      if (!c || !l || !n) return;
+      const d = o({ id: c, element: l });
+      return t == null ? void 0 : t.renderItem(d);
+    }, [c, n, o, t]), r = {
+      ...r,
+      ref: Pt(a, r.ref)
+    }, _t(r);
+  }
+);
+ft(function(t) {
+  const n = ye(t);
+  return ut(bn, n);
+});
+var Cn = "button";
+function Sn(e) {
+  return kt(e) ? !0 : e.tagName === "INPUT" && !Ye(e);
+}
+function An(e, t = !1) {
+  const n = e.clientHeight, { top: o } = e.getBoundingClientRect(), i = Math.max(n * 0.875, n - 40) * 1.5, r = t ? n - i + o : i + o;
+  return e.tagName === "HTML" ? r + e.scrollTop : r;
+}
+function Pn(e, t = !1) {
+  const { top: n } = e.getBoundingClientRect();
+  return t ? n + e.clientHeight : n;
+}
+function ie(e, t, n, o = !1) {
+  var i;
+  if (!t || !n) return;
+  const { renderedItems: r } = t.getState(), s = qe(e);
+  if (!s) return;
+  const c = An(s, o);
+  let a, l;
+  for (let d = 0; d < r.length; d += 1) {
+    const f = a;
+    if (a = n(d), !a) break;
+    if (a === f) continue;
+    const h = (i = Ve(t, a)) == null ? void 0 : i.element;
+    if (!h) continue;
+    const m = Pn(h, o) - c, p = Math.abs(m);
+    if (o && m <= 0 || !o && m >= 0) {
+      l !== void 0 && l < p && (a = f);
+      break;
+    }
+    l = p;
+  }
+  return a;
+}
+function En(e, t) {
+  return $t(e) ? !1 : he(t, e.target);
+}
+var On = at(
+  function({
+    store: t,
+    rowId: n,
+    preventScrollOnKeyDown: o = !1,
+    moveOnKeyPress: i = !0,
+    tabbable: r = !1,
+    getItem: s,
+    "aria-setsize": c,
+    "aria-posinset": a,
+    ...l
+  }) {
+    const d = ge();
+    t = t || d;
+    const f = pe(l.id), h = bt(null), u = rn(Fe), p = ze(l) && !l.accessibleWhenDisabled, {
+      rowId: v,
+      baseElement: w,
+      isActiveItem: y,
+      ariaSetSize: x,
+      ariaPosInSet: S,
+      isTabbable: C
+    } = an(t, {
+      rowId(g) {
+        if (n) return n;
+        if (g && u != null && u.baseElement && u.baseElement === g.baseElement)
+          return u.id;
+      },
+      baseElement(g) {
+        return (g == null ? void 0 : g.baseElement) || void 0;
+      },
+      isActiveItem(g) {
+        return !!g && g.activeId === f;
+      },
+      ariaSetSize(g) {
+        if (c != null) return c;
+        if (g && u != null && u.ariaSetSize && u.baseElement === g.baseElement)
+          return u.ariaSetSize;
+      },
+      ariaPosInSet(g) {
+        if (a != null) return a;
+        if (!g || !(u != null && u.ariaPosInSet) || u.baseElement !== g.baseElement) return;
+        const b = g.renderedItems.filter(
+          (A) => A.rowId === v
+        );
+        return u.ariaPosInSet + b.findIndex((A) => A.id === f);
+      },
+      isTabbable(g) {
+        if (!(g != null && g.renderedItems.length)) return !0;
+        if (g.virtualFocus) return !1;
+        if (r) return !0;
+        if (g.activeId === null) return !1;
+        const b = t == null ? void 0 : t.item(g.activeId);
+        return b != null && b.disabled || !(b != null && b.element) ? !0 : g.activeId === f;
+      }
+    }), O = we(
+      (g) => {
+        var b;
+        const A = {
+          ...g,
+          id: f || g.id,
+          rowId: v,
+          disabled: !!p,
+          children: (b = g.element) == null ? void 0 : b.textContent
+        };
+        return s ? s(A) : A;
+      },
+      [f, v, p, s]
+    ), E = l.onFocus, P = bt(!1), D = tt((g) => {
+      if (E == null || E(g), g.defaultPrevented || _e(g) || !f || !t || En(g, t)) return;
+      const { virtualFocus: b, baseElement: A } = t.getState();
+      if (t.setActiveId(f), kt(g.currentTarget) && ke(g.currentTarget), !b || !$t(g) || Sn(g.currentTarget) || !(A != null && A.isConnected)) return;
+      je() && g.currentTarget.hasAttribute("data-autofocus") && g.currentTarget.scrollIntoView({
+        block: "nearest",
+        inline: "nearest"
+      }), P.current = !0, g.relatedTarget === A || he(t, g.relatedTarget) ? $e(A) : A.focus();
+    }), T = l.onBlurCapture, M = tt((g) => {
+      if (T == null || T(g), g.defaultPrevented) return;
+      const b = t == null ? void 0 : t.getState();
+      b != null && b.virtualFocus && P.current && (P.current = !1, g.preventDefault(), g.stopPropagation());
+    }), I = l.onKeyDown, L = yt(o), R = yt(i), $ = tt((g) => {
+      if (I == null || I(g), g.defaultPrevented || !$t(g) || !t) return;
+      const { currentTarget: b } = g, A = t.getState(), G = t.item(f), z = !!(G != null && G.rowId), k = A.orientation !== "horizontal", B = A.orientation !== "vertical", Mt = () => !!(z || B || !A.baseElement || !Ue(A.baseElement)), U = {
+        ArrowUp: (z || k) && t.up,
+        ArrowRight: (z || B) && t.next,
+        ArrowDown: (z || k) && t.down,
+        ArrowLeft: (z || B) && t.previous,
+        Home: () => {
+          if (Mt())
+            return !z || g.ctrlKey ? t == null ? void 0 : t.first() : t == null ? void 0 : t.previous(-1);
+        },
+        End: () => {
+          if (Mt())
+            return !z || g.ctrlKey ? t == null ? void 0 : t.last() : t == null ? void 0 : t.next(-1);
+        },
+        PageUp: () => ie(b, t, t == null ? void 0 : t.up, !0),
+        PageDown: () => ie(b, t, t == null ? void 0 : t.down)
+      }[g.key];
+      if (U) {
+        if (kt(b)) {
+          const Y = Xe(b), It = B && g.key === "ArrowLeft", Lt = B && g.key === "ArrowRight", nt = k && g.key === "ArrowUp", ot = k && g.key === "ArrowDown";
+          if (Lt || ot) {
+            const { length: ht } = Ke(b);
+            if (Y.end !== ht) return;
+          } else if ((It || nt) && Y.start !== 0) return;
+        }
+        const gt = U();
+        if (L(g) || gt !== void 0) {
+          if (!R(g)) return;
+          g.preventDefault(), t.move(gt);
+        }
+      }
+    }), F = sn(
+      () => ({ id: f, baseElement: w }),
+      [f, w]
+    );
+    return l = Nt(
+      l,
+      (g) => /* @__PURE__ */ Vt(Ne.Provider, { value: F, children: g }),
+      [F]
+    ), l = {
+      id: f,
+      "data-active-item": y || void 0,
+      ...l,
+      ref: Pt(h, l.ref),
+      tabIndex: C ? l.tabIndex : -1,
+      onFocus: D,
+      onBlurCapture: M,
+      onKeyDown: $
+    }, l = ln(l), l = ye({
+      store: t,
+      ...l,
+      getItem: O,
+      shouldRegisterItem: f ? l.shouldRegisterItem : !1
+    }), _t({
+      ...l,
+      "aria-setsize": x,
+      "aria-posinset": S
+    });
+  }
+);
+ve(
+  ft(function(t) {
+    const n = On(t);
+    return ut(Cn, n);
+  })
+);
+var Et = xe(
+  [pn],
+  [hn]
+), Go = Et.useContext, Kt = Et.useProviderContext, Rn = Et.ContextProvider, be = Et.ScopedContextProvider, Jo = Xt(
+  void 0
+), dt = xe(
+  [Rn, He],
+  [be, Be]
+), Qo = dt.useContext, Zo = dt.useScopedContext, ti = dt.useProviderContext, ei = dt.ContextProvider, ni = dt.ScopedContextProvider, oi = Xt(
+  void 0
+), ii = Xt(!1);
+const J = Math.min, N = Math.max, Ct = Math.round, wt = Math.floor, j = (e) => ({
+  x: e,
+  y: e
+}), Tn = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+}, Dn = {
+  start: "end",
+  end: "start"
+};
+function Bt(e, t, n) {
+  return N(e, J(t, n));
+}
+function Q(e, t) {
+  return typeof e == "function" ? e(t) : e;
+}
+function q(e) {
+  return e.split("-")[0];
+}
+function st(e) {
+  return e.split("-")[1];
+}
+function Ut(e) {
+  return e === "x" ? "y" : "x";
+}
+function Yt(e) {
+  return e === "y" ? "height" : "width";
+}
+const Mn = /* @__PURE__ */ new Set(["top", "bottom"]);
+function _(e) {
+  return Mn.has(q(e)) ? "y" : "x";
+}
+function qt(e) {
+  return Ut(_(e));
+}
+function In(e, t, n) {
+  n === void 0 && (n = !1);
+  const o = st(e), i = qt(e), r = Yt(i);
+  let s = i === "x" ? o === (n ? "end" : "start") ? "right" : "left" : o === "start" ? "bottom" : "top";
+  return t.reference[r] > t.floating[r] && (s = St(s)), [s, St(s)];
+}
+function Ln(e) {
+  const t = St(e);
+  return [Ht(e), t, Ht(t)];
+}
+function Ht(e) {
+  return e.replace(/start|end/g, (t) => Dn[t]);
+}
+const re = ["left", "right"], se = ["right", "left"], Fn = ["top", "bottom"], kn = ["bottom", "top"];
+function $n(e, t, n) {
+  switch (e) {
+    case "top":
+    case "bottom":
+      return n ? t ? se : re : t ? re : se;
+    case "left":
+    case "right":
+      return t ? Fn : kn;
+    default:
+      return [];
+  }
+}
+function Nn(e, t, n, o) {
+  const i = st(e);
+  let r = $n(q(e), n === "start", o);
+  return i && (r = r.map((s) => s + "-" + i), t && (r = r.concat(r.map(Ht)))), r;
+}
+function St(e) {
+  return e.replace(/left|right|bottom|top/g, (t) => Tn[t]);
+}
+function Vn(e) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...e
+  };
+}
+function Ce(e) {
+  return typeof e != "number" ? Vn(e) : {
+    top: e,
+    right: e,
+    bottom: e,
+    left: e
+  };
+}
+function At(e) {
+  const {
+    x: t,
+    y: n,
+    width: o,
+    height: i
+  } = e;
+  return {
+    width: o,
+    height: i,
+    top: n,
+    left: t,
+    right: t + o,
+    bottom: n + i,
+    x: t,
+    y: n
+  };
+}
+function ce(e, t, n) {
+  let {
+    reference: o,
+    floating: i
+  } = e;
+  const r = _(t), s = qt(t), c = Yt(s), a = q(t), l = r === "y", d = o.x + o.width / 2 - i.width / 2, f = o.y + o.height / 2 - i.height / 2, h = o[c] / 2 - i[c] / 2;
+  let u;
+  switch (a) {
+    case "top":
+      u = {
+        x: d,
+        y: o.y - i.height
+      };
+      break;
+    case "bottom":
+      u = {
+        x: d,
+        y: o.y + o.height
+      };
+      break;
+    case "right":
+      u = {
+        x: o.x + o.width,
+        y: f
+      };
+      break;
+    case "left":
+      u = {
+        x: o.x - i.width,
+        y: f
+      };
+      break;
+    default:
+      u = {
+        x: o.x,
+        y: o.y
+      };
+  }
+  switch (st(t)) {
+    case "start":
+      u[s] -= h * (n && l ? -1 : 1);
+      break;
+    case "end":
+      u[s] += h * (n && l ? -1 : 1);
+      break;
+  }
+  return u;
+}
+const Bn = async (e, t, n) => {
+  const {
+    placement: o = "bottom",
+    strategy: i = "absolute",
+    middleware: r = [],
+    platform: s
+  } = n, c = r.filter(Boolean), a = await (s.isRTL == null ? void 0 : s.isRTL(t));
+  let l = await s.getElementRects({
+    reference: e,
+    floating: t,
+    strategy: i
+  }), {
+    x: d,
+    y: f
+  } = ce(l, o, a), h = o, u = {}, m = 0;
+  for (let p = 0; p < c.length; p++) {
+    const {
+      name: v,
+      fn: w
+    } = c[p], {
+      x: y,
+      y: x,
+      data: S,
+      reset: C
+    } = await w({
+      x: d,
+      y: f,
+      initialPlacement: o,
+      placement: h,
+      strategy: i,
+      middlewareData: u,
+      rects: l,
+      platform: s,
+      elements: {
+        reference: e,
+        floating: t
+      }
+    });
+    d = y ?? d, f = x ?? f, u = {
+      ...u,
+      [v]: {
+        ...u[v],
+        ...S
+      }
+    }, C && m <= 50 && (m++, typeof C == "object" && (C.placement && (h = C.placement), C.rects && (l = C.rects === !0 ? await s.getElementRects({
+      reference: e,
+      floating: t,
+      strategy: i
+    }) : C.rects), {
+      x: d,
+      y: f
+    } = ce(l, h, a)), p = -1);
+  }
+  return {
+    x: d,
+    y: f,
+    placement: h,
+    strategy: i,
+    middlewareData: u
+  };
+};
+async function Gt(e, t) {
+  var n;
+  t === void 0 && (t = {});
+  const {
+    x: o,
+    y: i,
+    platform: r,
+    rects: s,
+    elements: c,
+    strategy: a
+  } = e, {
+    boundary: l = "clippingAncestors",
+    rootBoundary: d = "viewport",
+    elementContext: f = "floating",
+    altBoundary: h = !1,
+    padding: u = 0
+  } = Q(t, e), m = Ce(u), v = c[h ? f === "floating" ? "reference" : "floating" : f], w = At(await r.getClippingRect({
+    element: (n = await (r.isElement == null ? void 0 : r.isElement(v))) == null || n ? v : v.contextElement || await (r.getDocumentElement == null ? void 0 : r.getDocumentElement(c.floating)),
+    boundary: l,
+    rootBoundary: d,
+    strategy: a
+  })), y = f === "floating" ? {
+    x: o,
+    y: i,
+    width: s.floating.width,
+    height: s.floating.height
+  } : s.reference, x = await (r.getOffsetParent == null ? void 0 : r.getOffsetParent(c.floating)), S = await (r.isElement == null ? void 0 : r.isElement(x)) ? await (r.getScale == null ? void 0 : r.getScale(x)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  }, C = At(r.convertOffsetParentRelativeRectToViewportRelativeRect ? await r.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: c,
+    rect: y,
+    offsetParent: x,
+    strategy: a
+  }) : y);
+  return {
+    top: (w.top - C.top + m.top) / S.y,
+    bottom: (C.bottom - w.bottom + m.bottom) / S.y,
+    left: (w.left - C.left + m.left) / S.x,
+    right: (C.right - w.right + m.right) / S.x
+  };
+}
+const Hn = (e) => ({
+  name: "arrow",
+  options: e,
+  async fn(t) {
+    const {
+      x: n,
+      y: o,
+      placement: i,
+      rects: r,
+      platform: s,
+      elements: c,
+      middlewareData: a
+    } = t, {
+      element: l,
+      padding: d = 0
+    } = Q(e, t) || {};
+    if (l == null)
+      return {};
+    const f = Ce(d), h = {
+      x: n,
+      y: o
+    }, u = qt(i), m = Yt(u), p = await s.getDimensions(l), v = u === "y", w = v ? "top" : "left", y = v ? "bottom" : "right", x = v ? "clientHeight" : "clientWidth", S = r.reference[m] + r.reference[u] - h[u] - r.floating[m], C = h[u] - r.reference[u], O = await (s.getOffsetParent == null ? void 0 : s.getOffsetParent(l));
+    let E = O ? O[x] : 0;
+    (!E || !await (s.isElement == null ? void 0 : s.isElement(O))) && (E = c.floating[x] || r.floating[m]);
+    const P = S / 2 - C / 2, D = E / 2 - p[m] / 2 - 1, T = J(f[w], D), M = J(f[y], D), I = T, L = E - p[m] - M, R = E / 2 - p[m] / 2 + P, $ = Bt(I, R, L), F = !a.arrow && st(i) != null && R !== $ && r.reference[m] / 2 - (R < I ? T : M) - p[m] / 2 < 0, g = F ? R < I ? R - I : R - L : 0;
+    return {
+      [u]: h[u] + g,
+      data: {
+        [u]: $,
+        centerOffset: R - $ - g,
+        ...F && {
+          alignmentOffset: g
+        }
+      },
+      reset: F
+    };
+  }
+}), Wn = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "flip",
+    options: e,
+    async fn(t) {
+      var n, o;
+      const {
+        placement: i,
+        middlewareData: r,
+        rects: s,
+        initialPlacement: c,
+        platform: a,
+        elements: l
+      } = t, {
+        mainAxis: d = !0,
+        crossAxis: f = !0,
+        fallbackPlacements: h,
+        fallbackStrategy: u = "bestFit",
+        fallbackAxisSideDirection: m = "none",
+        flipAlignment: p = !0,
+        ...v
+      } = Q(e, t);
+      if ((n = r.arrow) != null && n.alignmentOffset)
+        return {};
+      const w = q(i), y = _(c), x = q(c) === c, S = await (a.isRTL == null ? void 0 : a.isRTL(l.floating)), C = h || (x || !p ? [St(c)] : Ln(c)), O = m !== "none";
+      !h && O && C.push(...Nn(c, p, m, S));
+      const E = [c, ...C], P = await Gt(t, v), D = [];
+      let T = ((o = r.flip) == null ? void 0 : o.overflows) || [];
+      if (d && D.push(P[w]), f) {
+        const R = In(i, s, S);
+        D.push(P[R[0]], P[R[1]]);
+      }
+      if (T = [...T, {
+        placement: i,
+        overflows: D
+      }], !D.every((R) => R <= 0)) {
+        var M, I;
+        const R = (((M = r.flip) == null ? void 0 : M.index) || 0) + 1, $ = E[R];
+        if ($ && (!(f === "alignment" ? y !== _($) : !1) || // We leave the current main axis only if every placement on that axis
+        // overflows the main axis.
+        T.every((b) => _(b.placement) === y ? b.overflows[0] > 0 : !0)))
+          return {
+            data: {
+              index: R,
+              overflows: T
+            },
+            reset: {
+              placement: $
+            }
+          };
+        let F = (I = T.filter((g) => g.overflows[0] <= 0).sort((g, b) => g.overflows[1] - b.overflows[1])[0]) == null ? void 0 : I.placement;
+        if (!F)
+          switch (u) {
+            case "bestFit": {
+              var L;
+              const g = (L = T.filter((b) => {
+                if (O) {
+                  const A = _(b.placement);
+                  return A === y || // Create a bias to the `y` side axis due to horizontal
+                  // reading directions favoring greater width.
+                  A === "y";
+                }
+                return !0;
+              }).map((b) => [b.placement, b.overflows.filter((A) => A > 0).reduce((A, G) => A + G, 0)]).sort((b, A) => b[1] - A[1])[0]) == null ? void 0 : L[0];
+              g && (F = g);
+              break;
+            }
+            case "initialPlacement":
+              F = c;
+              break;
+          }
+        if (i !== F)
+          return {
+            reset: {
+              placement: F
+            }
+          };
+      }
+      return {};
+    }
+  };
+}, Se = /* @__PURE__ */ new Set(["left", "top"]);
+async function zn(e, t) {
+  const {
+    placement: n,
+    platform: o,
+    elements: i
+  } = e, r = await (o.isRTL == null ? void 0 : o.isRTL(i.floating)), s = q(n), c = st(n), a = _(n) === "y", l = Se.has(s) ? -1 : 1, d = r && a ? -1 : 1, f = Q(t, e);
+  let {
+    mainAxis: h,
+    crossAxis: u,
+    alignmentAxis: m
+  } = typeof f == "number" ? {
+    mainAxis: f,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: f.mainAxis || 0,
+    crossAxis: f.crossAxis || 0,
+    alignmentAxis: f.alignmentAxis
+  };
+  return c && typeof m == "number" && (u = c === "end" ? m * -1 : m), a ? {
+    x: u * d,
+    y: h * l
+  } : {
+    x: h * l,
+    y: u * d
+  };
+}
+const _n = function(e) {
+  return e === void 0 && (e = 0), {
+    name: "offset",
+    options: e,
+    async fn(t) {
+      var n, o;
+      const {
+        x: i,
+        y: r,
+        placement: s,
+        middlewareData: c
+      } = t, a = await zn(t, e);
+      return s === ((n = c.offset) == null ? void 0 : n.placement) && (o = c.arrow) != null && o.alignmentOffset ? {} : {
+        x: i + a.x,
+        y: r + a.y,
+        data: {
+          ...a,
+          placement: s
+        }
+      };
+    }
+  };
+}, jn = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "shift",
+    options: e,
+    async fn(t) {
+      const {
+        x: n,
+        y: o,
+        placement: i
+      } = t, {
+        mainAxis: r = !0,
+        crossAxis: s = !1,
+        limiter: c = {
+          fn: (v) => {
+            let {
+              x: w,
+              y
+            } = v;
+            return {
+              x: w,
+              y
+            };
+          }
+        },
+        ...a
+      } = Q(e, t), l = {
+        x: n,
+        y: o
+      }, d = await Gt(t, a), f = _(q(i)), h = Ut(f);
+      let u = l[h], m = l[f];
+      if (r) {
+        const v = h === "y" ? "top" : "left", w = h === "y" ? "bottom" : "right", y = u + d[v], x = u - d[w];
+        u = Bt(y, u, x);
+      }
+      if (s) {
+        const v = f === "y" ? "top" : "left", w = f === "y" ? "bottom" : "right", y = m + d[v], x = m - d[w];
+        m = Bt(y, m, x);
+      }
+      const p = c.fn({
+        ...t,
+        [h]: u,
+        [f]: m
+      });
+      return {
+        ...p,
+        data: {
+          x: p.x - n,
+          y: p.y - o,
+          enabled: {
+            [h]: r,
+            [f]: s
+          }
+        }
+      };
+    }
+  };
+}, Xn = function(e) {
+  return e === void 0 && (e = {}), {
+    options: e,
+    fn(t) {
+      const {
+        x: n,
+        y: o,
+        placement: i,
+        rects: r,
+        middlewareData: s
+      } = t, {
+        offset: c = 0,
+        mainAxis: a = !0,
+        crossAxis: l = !0
+      } = Q(e, t), d = {
+        x: n,
+        y: o
+      }, f = _(i), h = Ut(f);
+      let u = d[h], m = d[f];
+      const p = Q(c, t), v = typeof p == "number" ? {
+        mainAxis: p,
+        crossAxis: 0
+      } : {
+        mainAxis: 0,
+        crossAxis: 0,
+        ...p
+      };
+      if (a) {
+        const x = h === "y" ? "height" : "width", S = r.reference[h] - r.floating[x] + v.mainAxis, C = r.reference[h] + r.reference[x] - v.mainAxis;
+        u < S ? u = S : u > C && (u = C);
+      }
+      if (l) {
+        var w, y;
+        const x = h === "y" ? "width" : "height", S = Se.has(q(i)), C = r.reference[f] - r.floating[x] + (S && ((w = s.offset) == null ? void 0 : w[f]) || 0) + (S ? 0 : v.crossAxis), O = r.reference[f] + r.reference[x] + (S ? 0 : ((y = s.offset) == null ? void 0 : y[f]) || 0) - (S ? v.crossAxis : 0);
+        m < C ? m = C : m > O && (m = O);
+      }
+      return {
+        [h]: u,
+        [f]: m
+      };
+    }
+  };
+}, Kn = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "size",
+    options: e,
+    async fn(t) {
+      var n, o;
+      const {
+        placement: i,
+        rects: r,
+        platform: s,
+        elements: c
+      } = t, {
+        apply: a = () => {
+        },
+        ...l
+      } = Q(e, t), d = await Gt(t, l), f = q(i), h = st(i), u = _(i) === "y", {
+        width: m,
+        height: p
+      } = r.floating;
+      let v, w;
+      f === "top" || f === "bottom" ? (v = f, w = h === (await (s.isRTL == null ? void 0 : s.isRTL(c.floating)) ? "start" : "end") ? "left" : "right") : (w = f, v = h === "end" ? "top" : "bottom");
+      const y = p - d.top - d.bottom, x = m - d.left - d.right, S = J(p - d[v], y), C = J(m - d[w], x), O = !t.middlewareData.shift;
+      let E = S, P = C;
+      if ((n = t.middlewareData.shift) != null && n.enabled.x && (P = x), (o = t.middlewareData.shift) != null && o.enabled.y && (E = y), O && !h) {
+        const T = N(d.left, 0), M = N(d.right, 0), I = N(d.top, 0), L = N(d.bottom, 0);
+        u ? P = m - 2 * (T !== 0 || M !== 0 ? T + M : N(d.left, d.right)) : E = p - 2 * (I !== 0 || L !== 0 ? I + L : N(d.top, d.bottom));
+      }
+      await a({
+        ...t,
+        availableWidth: P,
+        availableHeight: E
+      });
+      const D = await s.getDimensions(c.floating);
+      return m !== D.width || p !== D.height ? {
+        reset: {
+          rects: !0
+        }
+      } : {};
+    }
+  };
+};
+function Ot() {
+  return typeof window < "u";
+}
+function ct(e) {
+  return Ae(e) ? (e.nodeName || "").toLowerCase() : "#document";
+}
+function V(e) {
+  var t;
+  return (e == null || (t = e.ownerDocument) == null ? void 0 : t.defaultView) || window;
+}
+function K(e) {
+  var t;
+  return (t = (Ae(e) ? e.ownerDocument : e.document) || window.document) == null ? void 0 : t.documentElement;
+}
+function Ae(e) {
+  return Ot() ? e instanceof Node || e instanceof V(e).Node : !1;
+}
+function H(e) {
+  return Ot() ? e instanceof Element || e instanceof V(e).Element : !1;
+}
+function X(e) {
+  return Ot() ? e instanceof HTMLElement || e instanceof V(e).HTMLElement : !1;
+}
+function le(e) {
+  return !Ot() || typeof ShadowRoot > "u" ? !1 : e instanceof ShadowRoot || e instanceof V(e).ShadowRoot;
+}
+const Un = /* @__PURE__ */ new Set(["inline", "contents"]);
+function mt(e) {
+  const {
+    overflow: t,
+    overflowX: n,
+    overflowY: o,
+    display: i
+  } = W(e);
+  return /auto|scroll|overlay|hidden|clip/.test(t + o + n) && !Un.has(i);
+}
+const Yn = /* @__PURE__ */ new Set(["table", "td", "th"]);
+function qn(e) {
+  return Yn.has(ct(e));
+}
+const Gn = [":popover-open", ":modal"];
+function Rt(e) {
+  return Gn.some((t) => {
+    try {
+      return e.matches(t);
+    } catch {
+      return !1;
+    }
+  });
+}
+const Jn = ["transform", "translate", "scale", "rotate", "perspective"], Qn = ["transform", "translate", "scale", "rotate", "perspective", "filter"], Zn = ["paint", "layout", "strict", "content"];
+function Jt(e) {
+  const t = Qt(), n = H(e) ? W(e) : e;
+  return Jn.some((o) => n[o] ? n[o] !== "none" : !1) || (n.containerType ? n.containerType !== "normal" : !1) || !t && (n.backdropFilter ? n.backdropFilter !== "none" : !1) || !t && (n.filter ? n.filter !== "none" : !1) || Qn.some((o) => (n.willChange || "").includes(o)) || Zn.some((o) => (n.contain || "").includes(o));
+}
+function to(e) {
+  let t = Z(e);
+  for (; X(t) && !rt(t); ) {
+    if (Jt(t))
+      return t;
+    if (Rt(t))
+      return null;
+    t = Z(t);
+  }
+  return null;
+}
+function Qt() {
+  return typeof CSS > "u" || !CSS.supports ? !1 : CSS.supports("-webkit-backdrop-filter", "none");
+}
+const eo = /* @__PURE__ */ new Set(["html", "body", "#document"]);
+function rt(e) {
+  return eo.has(ct(e));
+}
+function W(e) {
+  return V(e).getComputedStyle(e);
+}
+function Tt(e) {
+  return H(e) ? {
+    scrollLeft: e.scrollLeft,
+    scrollTop: e.scrollTop
+  } : {
+    scrollLeft: e.scrollX,
+    scrollTop: e.scrollY
+  };
+}
+function Z(e) {
+  if (ct(e) === "html")
+    return e;
+  const t = (
+    // Step into the shadow DOM of the parent of a slotted node.
+    e.assignedSlot || // DOM Element detected.
+    e.parentNode || // ShadowRoot detected.
+    le(e) && e.host || // Fallback.
+    K(e)
+  );
+  return le(t) ? t.host : t;
+}
+function Pe(e) {
+  const t = Z(e);
+  return rt(t) ? e.ownerDocument ? e.ownerDocument.body : e.body : X(t) && mt(t) ? t : Pe(t);
+}
+function lt(e, t, n) {
+  var o;
+  t === void 0 && (t = []), n === void 0 && (n = !0);
+  const i = Pe(e), r = i === ((o = e.ownerDocument) == null ? void 0 : o.body), s = V(i);
+  if (r) {
+    const c = Wt(s);
+    return t.concat(s, s.visualViewport || [], mt(i) ? i : [], c && n ? lt(c) : []);
+  }
+  return t.concat(i, lt(i, [], n));
+}
+function Wt(e) {
+  return e.parent && Object.getPrototypeOf(e.parent) ? e.frameElement : null;
+}
+function Ee(e) {
+  const t = W(e);
+  let n = parseFloat(t.width) || 0, o = parseFloat(t.height) || 0;
+  const i = X(e), r = i ? e.offsetWidth : n, s = i ? e.offsetHeight : o, c = Ct(n) !== r || Ct(o) !== s;
+  return c && (n = r, o = s), {
+    width: n,
+    height: o,
+    $: c
+  };
+}
+function Zt(e) {
+  return H(e) ? e : e.contextElement;
+}
+function it(e) {
+  const t = Zt(e);
+  if (!X(t))
+    return j(1);
+  const n = t.getBoundingClientRect(), {
+    width: o,
+    height: i,
+    $: r
+  } = Ee(t);
+  let s = (r ? Ct(n.width) : n.width) / o, c = (r ? Ct(n.height) : n.height) / i;
+  return (!s || !Number.isFinite(s)) && (s = 1), (!c || !Number.isFinite(c)) && (c = 1), {
+    x: s,
+    y: c
+  };
+}
+const no = /* @__PURE__ */ j(0);
+function Oe(e) {
+  const t = V(e);
+  return !Qt() || !t.visualViewport ? no : {
+    x: t.visualViewport.offsetLeft,
+    y: t.visualViewport.offsetTop
+  };
+}
+function oo(e, t, n) {
+  return t === void 0 && (t = !1), !n || t && n !== V(e) ? !1 : t;
+}
+function et(e, t, n, o) {
+  t === void 0 && (t = !1), n === void 0 && (n = !1);
+  const i = e.getBoundingClientRect(), r = Zt(e);
+  let s = j(1);
+  t && (o ? H(o) && (s = it(o)) : s = it(e));
+  const c = oo(r, n, o) ? Oe(r) : j(0);
+  let a = (i.left + c.x) / s.x, l = (i.top + c.y) / s.y, d = i.width / s.x, f = i.height / s.y;
+  if (r) {
+    const h = V(r), u = o && H(o) ? V(o) : o;
+    let m = h, p = Wt(m);
+    for (; p && o && u !== m; ) {
+      const v = it(p), w = p.getBoundingClientRect(), y = W(p), x = w.left + (p.clientLeft + parseFloat(y.paddingLeft)) * v.x, S = w.top + (p.clientTop + parseFloat(y.paddingTop)) * v.y;
+      a *= v.x, l *= v.y, d *= v.x, f *= v.y, a += x, l += S, m = V(p), p = Wt(m);
+    }
+  }
+  return At({
+    width: d,
+    height: f,
+    x: a,
+    y: l
+  });
+}
+function Dt(e, t) {
+  const n = Tt(e).scrollLeft;
+  return t ? t.left + n : et(K(e)).left + n;
+}
+function Re(e, t) {
+  const n = e.getBoundingClientRect(), o = n.left + t.scrollLeft - Dt(e, n), i = n.top + t.scrollTop;
+  return {
+    x: o,
+    y: i
+  };
+}
+function io(e) {
+  let {
+    elements: t,
+    rect: n,
+    offsetParent: o,
+    strategy: i
+  } = e;
+  const r = i === "fixed", s = K(o), c = t ? Rt(t.floating) : !1;
+  if (o === s || c && r)
+    return n;
+  let a = {
+    scrollLeft: 0,
+    scrollTop: 0
+  }, l = j(1);
+  const d = j(0), f = X(o);
+  if ((f || !f && !r) && ((ct(o) !== "body" || mt(s)) && (a = Tt(o)), X(o))) {
+    const u = et(o);
+    l = it(o), d.x = u.x + o.clientLeft, d.y = u.y + o.clientTop;
+  }
+  const h = s && !f && !r ? Re(s, a) : j(0);
+  return {
+    width: n.width * l.x,
+    height: n.height * l.y,
+    x: n.x * l.x - a.scrollLeft * l.x + d.x + h.x,
+    y: n.y * l.y - a.scrollTop * l.y + d.y + h.y
+  };
+}
+function ro(e) {
+  return Array.from(e.getClientRects());
+}
+function so(e) {
+  const t = K(e), n = Tt(e), o = e.ownerDocument.body, i = N(t.scrollWidth, t.clientWidth, o.scrollWidth, o.clientWidth), r = N(t.scrollHeight, t.clientHeight, o.scrollHeight, o.clientHeight);
+  let s = -n.scrollLeft + Dt(e);
+  const c = -n.scrollTop;
+  return W(o).direction === "rtl" && (s += N(t.clientWidth, o.clientWidth) - i), {
+    width: i,
+    height: r,
+    x: s,
+    y: c
+  };
+}
+const ae = 25;
+function co(e, t) {
+  const n = V(e), o = K(e), i = n.visualViewport;
+  let r = o.clientWidth, s = o.clientHeight, c = 0, a = 0;
+  if (i) {
+    r = i.width, s = i.height;
+    const d = Qt();
+    (!d || d && t === "fixed") && (c = i.offsetLeft, a = i.offsetTop);
+  }
+  const l = Dt(o);
+  if (l <= 0) {
+    const d = o.ownerDocument, f = d.body, h = getComputedStyle(f), u = d.compatMode === "CSS1Compat" && parseFloat(h.marginLeft) + parseFloat(h.marginRight) || 0, m = Math.abs(o.clientWidth - f.clientWidth - u);
+    m <= ae && (r -= m);
+  } else l <= ae && (r += l);
+  return {
+    width: r,
+    height: s,
+    x: c,
+    y: a
+  };
+}
+const lo = /* @__PURE__ */ new Set(["absolute", "fixed"]);
+function ao(e, t) {
+  const n = et(e, !0, t === "fixed"), o = n.top + e.clientTop, i = n.left + e.clientLeft, r = X(e) ? it(e) : j(1), s = e.clientWidth * r.x, c = e.clientHeight * r.y, a = i * r.x, l = o * r.y;
+  return {
+    width: s,
+    height: c,
+    x: a,
+    y: l
+  };
+}
+function fe(e, t, n) {
+  let o;
+  if (t === "viewport")
+    o = co(e, n);
+  else if (t === "document")
+    o = so(K(e));
+  else if (H(t))
+    o = ao(t, n);
+  else {
+    const i = Oe(e);
+    o = {
+      x: t.x - i.x,
+      y: t.y - i.y,
+      width: t.width,
+      height: t.height
+    };
+  }
+  return At(o);
+}
+function Te(e, t) {
+  const n = Z(e);
+  return n === t || !H(n) || rt(n) ? !1 : W(n).position === "fixed" || Te(n, t);
+}
+function fo(e, t) {
+  const n = t.get(e);
+  if (n)
+    return n;
+  let o = lt(e, [], !1).filter((c) => H(c) && ct(c) !== "body"), i = null;
+  const r = W(e).position === "fixed";
+  let s = r ? Z(e) : e;
+  for (; H(s) && !rt(s); ) {
+    const c = W(s), a = Jt(s);
+    !a && c.position === "fixed" && (i = null), (r ? !a && !i : !a && c.position === "static" && !!i && lo.has(i.position) || mt(s) && !a && Te(e, s)) ? o = o.filter((d) => d !== s) : i = c, s = Z(s);
+  }
+  return t.set(e, o), o;
+}
+function uo(e) {
+  let {
+    element: t,
+    boundary: n,
+    rootBoundary: o,
+    strategy: i
+  } = e;
+  const s = [...n === "clippingAncestors" ? Rt(t) ? [] : fo(t, this._c) : [].concat(n), o], c = s[0], a = s.reduce((l, d) => {
+    const f = fe(t, d, i);
+    return l.top = N(f.top, l.top), l.right = J(f.right, l.right), l.bottom = J(f.bottom, l.bottom), l.left = N(f.left, l.left), l;
+  }, fe(t, c, i));
+  return {
+    width: a.right - a.left,
+    height: a.bottom - a.top,
+    x: a.left,
+    y: a.top
+  };
+}
+function mo(e) {
+  const {
+    width: t,
+    height: n
+  } = Ee(e);
+  return {
+    width: t,
+    height: n
+  };
+}
+function go(e, t, n) {
+  const o = X(t), i = K(t), r = n === "fixed", s = et(e, !0, r, t);
+  let c = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const a = j(0);
+  function l() {
+    a.x = Dt(i);
+  }
+  if (o || !o && !r)
+    if ((ct(t) !== "body" || mt(i)) && (c = Tt(t)), o) {
+      const u = et(t, !0, r, t);
+      a.x = u.x + t.clientLeft, a.y = u.y + t.clientTop;
+    } else i && l();
+  r && !o && i && l();
+  const d = i && !o && !r ? Re(i, c) : j(0), f = s.left + c.scrollLeft - a.x - d.x, h = s.top + c.scrollTop - a.y - d.y;
+  return {
+    x: f,
+    y: h,
+    width: s.width,
+    height: s.height
+  };
+}
+function Ft(e) {
+  return W(e).position === "static";
+}
+function ue(e, t) {
+  if (!X(e) || W(e).position === "fixed")
+    return null;
+  if (t)
+    return t(e);
+  let n = e.offsetParent;
+  return K(e) === n && (n = n.ownerDocument.body), n;
+}
+function De(e, t) {
+  const n = V(e);
+  if (Rt(e))
+    return n;
+  if (!X(e)) {
+    let i = Z(e);
+    for (; i && !rt(i); ) {
+      if (H(i) && !Ft(i))
+        return i;
+      i = Z(i);
+    }
+    return n;
+  }
+  let o = ue(e, t);
+  for (; o && qn(o) && Ft(o); )
+    o = ue(o, t);
+  return o && rt(o) && Ft(o) && !Jt(o) ? n : o || to(e) || n;
+}
+const ho = async function(e) {
+  const t = this.getOffsetParent || De, n = this.getDimensions, o = await n(e.floating);
+  return {
+    reference: go(e.reference, await t(e.floating), e.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      width: o.width,
+      height: o.height
+    }
+  };
+};
+function po(e) {
+  return W(e).direction === "rtl";
+}
+const vo = {
+  convertOffsetParentRelativeRectToViewportRelativeRect: io,
+  getDocumentElement: K,
+  getClippingRect: uo,
+  getOffsetParent: De,
+  getElementRects: ho,
+  getClientRects: ro,
+  getDimensions: mo,
+  getScale: it,
+  isElement: H,
+  isRTL: po
+};
+function Me(e, t) {
+  return e.x === t.x && e.y === t.y && e.width === t.width && e.height === t.height;
+}
+function xo(e, t) {
+  let n = null, o;
+  const i = K(e);
+  function r() {
+    var c;
+    clearTimeout(o), (c = n) == null || c.disconnect(), n = null;
+  }
+  function s(c, a) {
+    c === void 0 && (c = !1), a === void 0 && (a = 1), r();
+    const l = e.getBoundingClientRect(), {
+      left: d,
+      top: f,
+      width: h,
+      height: u
+    } = l;
+    if (c || t(), !h || !u)
+      return;
+    const m = wt(f), p = wt(i.clientWidth - (d + h)), v = wt(i.clientHeight - (f + u)), w = wt(d), x = {
+      rootMargin: -m + "px " + -p + "px " + -v + "px " + -w + "px",
+      threshold: N(0, J(1, a)) || 1
+    };
+    let S = !0;
+    function C(O) {
+      const E = O[0].intersectionRatio;
+      if (E !== a) {
+        if (!S)
+          return s();
+        E ? s(!1, E) : o = setTimeout(() => {
+          s(!1, 1e-7);
+        }, 1e3);
+      }
+      E === 1 && !Me(l, e.getBoundingClientRect()) && s(), S = !1;
+    }
+    try {
+      n = new IntersectionObserver(C, {
+        ...x,
+        // Handle <iframe>s
+        root: i.ownerDocument
+      });
+    } catch {
+      n = new IntersectionObserver(C, x);
+    }
+    n.observe(e);
+  }
+  return s(!0), r;
+}
+function wo(e, t, n, o) {
+  o === void 0 && (o = {});
+  const {
+    ancestorScroll: i = !0,
+    ancestorResize: r = !0,
+    elementResize: s = typeof ResizeObserver == "function",
+    layoutShift: c = typeof IntersectionObserver == "function",
+    animationFrame: a = !1
+  } = o, l = Zt(e), d = i || r ? [...l ? lt(l) : [], ...lt(t)] : [];
+  d.forEach((w) => {
+    i && w.addEventListener("scroll", n, {
+      passive: !0
+    }), r && w.addEventListener("resize", n);
+  });
+  const f = l && c ? xo(l, n) : null;
+  let h = -1, u = null;
+  s && (u = new ResizeObserver((w) => {
+    let [y] = w;
+    y && y.target === l && u && (u.unobserve(t), cancelAnimationFrame(h), h = requestAnimationFrame(() => {
+      var x;
+      (x = u) == null || x.observe(t);
+    })), n();
+  }), l && !a && u.observe(l), u.observe(t));
+  let m, p = a ? et(e) : null;
+  a && v();
+  function v() {
+    const w = et(e);
+    p && !Me(p, w) && n(), p = w, m = requestAnimationFrame(v);
+  }
+  return n(), () => {
+    var w;
+    d.forEach((y) => {
+      i && y.removeEventListener("scroll", n), r && y.removeEventListener("resize", n);
+    }), f == null || f(), (w = u) == null || w.disconnect(), u = null, a && cancelAnimationFrame(m);
+  };
+}
+const yo = _n, bo = jn, Co = Wn, So = Kn, Ao = Hn, Po = Xn, Eo = (e, t, n) => {
+  const o = /* @__PURE__ */ new Map(), i = {
+    platform: vo,
+    ...n
+  }, r = {
+    ...i.platform,
+    _c: o
+  };
+  return Bn(e, t, {
+    ...i,
+    platform: r
+  });
+};
+var Oo = "div";
+function de(e = 0, t = 0, n = 0, o = 0) {
+  if (typeof DOMRect == "function")
+    return new DOMRect(e, t, n, o);
+  const i = {
+    x: e,
+    y: t,
+    width: n,
+    height: o,
+    top: t,
+    right: e + n,
+    bottom: t + o,
+    left: e
+  };
+  return { ...i, toJSON: () => i };
+}
+function Ro(e) {
+  if (!e) return de();
+  const { x: t, y: n, width: o, height: i } = e;
+  return de(t, n, o, i);
+}
+function To(e, t) {
+  return {
+    contextElement: e || void 0,
+    getBoundingClientRect: () => {
+      const o = e, i = t == null ? void 0 : t(o);
+      return i || !o ? Ro(i) : o.getBoundingClientRect();
+    }
+  };
+}
+function Do(e) {
+  return /^(?:top|bottom|left|right)(?:-(?:start|end))?$/.test(e);
+}
+function me(e) {
+  const t = window.devicePixelRatio || 1;
+  return Math.round(e * t) / t;
+}
+function Mo(e, t) {
+  return yo(({ placement: n }) => {
+    var o;
+    const i = ((e == null ? void 0 : e.clientHeight) || 0) / 2, r = typeof t.gutter == "number" ? t.gutter + i : (o = t.gutter) != null ? o : i;
+    return {
+      crossAxis: !!n.split("-")[1] ? void 0 : t.shift,
+      mainAxis: r,
+      alignmentAxis: t.shift
+    };
+  });
+}
+function Io(e) {
+  if (e.flip === !1) return;
+  const t = typeof e.flip == "string" ? e.flip.split(" ") : void 0;
+  return jt(
+    !t || t.every(Do),
+    process.env.NODE_ENV !== "production" && "`flip` expects a spaced-delimited list of placements"
+  ), Co({
+    padding: e.overflowPadding,
+    fallbackPlacements: t
+  });
+}
+function Lo(e) {
+  if (!(!e.slide && !e.overlap))
+    return bo({
+      mainAxis: e.slide,
+      crossAxis: e.overlap,
+      padding: e.overflowPadding,
+      limiter: Po()
+    });
+}
+function Fo(e) {
+  return So({
+    padding: e.overflowPadding,
+    apply({ elements: t, availableWidth: n, availableHeight: o, rects: i }) {
+      const r = t.floating, s = Math.round(i.reference.width);
+      n = Math.floor(n), o = Math.floor(o), r.style.setProperty(
+        "--popover-anchor-width",
+        `${s}px`
+      ), r.style.setProperty(
+        "--popover-available-width",
+        `${n}px`
+      ), r.style.setProperty(
+        "--popover-available-height",
+        `${o}px`
+      ), e.sameWidth && (r.style.width = `${s}px`), e.fitViewport && (r.style.maxWidth = `${n}px`, r.style.maxHeight = `${o}px`);
+    }
+  });
+}
+function ko(e, t) {
+  if (e)
+    return Ao({
+      element: e,
+      padding: t.arrowPadding
+    });
+}
+var $o = at(
+  function({
+    store: t,
+    modal: n = !1,
+    portal: o = !!n,
+    preserveTabOrder: i = !0,
+    autoFocusOnShow: r = !0,
+    wrapperProps: s,
+    fixed: c = !1,
+    flip: a = !0,
+    shift: l = 0,
+    slide: d = !0,
+    overlap: f = !1,
+    sameWidth: h = !1,
+    fitViewport: u = !1,
+    gutter: m,
+    arrowPadding: p = 4,
+    overflowPadding: v = 8,
+    getAnchorRect: w,
+    updatePosition: y,
+    ...x
+  }) {
+    const S = Kt();
+    t = t || S, jt(
+      t,
+      process.env.NODE_ENV !== "production" && "Popover must receive a `store` prop or be wrapped in a PopoverProvider component."
+    );
+    const C = t.useState("arrowElement"), O = t.useState("anchorElement"), E = t.useState("disclosureElement"), P = t.useState("popoverElement"), D = t.useState("contentElement"), T = t.useState("placement"), M = t.useState("mounted"), I = t.useState("rendered"), L = bt(null), [R, $] = cn(!1), { portalRef: F, domReady: g } = Ge(o, x.portalRef), b = tt(w), A = tt(y), G = !!y;
+    oe(() => {
+      if (!(P != null && P.isConnected)) return;
+      P.style.setProperty(
+        "--popover-overflow-padding",
+        `${v}px`
+      );
+      const k = To(O, b), B = async () => {
+        if (!M) return;
+        C || (L.current = L.current || document.createElement("div"));
+        const U = C || L.current, gt = [
+          Mo(U, { gutter: m, shift: l }),
+          Io({ flip: a, overflowPadding: v }),
+          Lo({ slide: d, overlap: f, overflowPadding: v }),
+          ko(U, { arrowPadding: p }),
+          Fo({
+            sameWidth: h,
+            fitViewport: u,
+            overflowPadding: v
+          })
+        ], Y = await Eo(k, P, {
+          placement: T,
+          strategy: c ? "fixed" : "absolute",
+          middleware: gt
+        });
+        t == null || t.setState("currentPlacement", Y.placement), $(!0);
+        const It = me(Y.x), Lt = me(Y.y);
+        if (Object.assign(P.style, {
+          top: "0",
+          left: "0",
+          transform: `translate3d(${It}px,${Lt}px,0)`
+        }), U && Y.middlewareData.arrow) {
+          const { x: nt, y: ot } = Y.middlewareData.arrow, ht = Y.placement.split("-")[0], pt = U.clientWidth / 2, vt = U.clientHeight / 2, ee = nt != null ? nt + pt : -pt, ne = ot != null ? ot + vt : -vt;
+          P.style.setProperty(
+            "--popover-transform-origin",
+            {
+              top: `${ee}px calc(100% + ${vt}px)`,
+              bottom: `${ee}px ${-vt}px`,
+              left: `calc(100% + ${pt}px) ${ne}px`,
+              right: `${-pt}px ${ne}px`
+            }[ht]
+          ), Object.assign(U.style, {
+            left: nt != null ? `${nt}px` : "",
+            top: ot != null ? `${ot}px` : "",
+            [ht]: "100%"
+          });
+        }
+      }, te = wo(k, P, async () => {
+        G ? (await A({ updatePosition: B }), $(!0)) : await B();
+      }, {
+        // JSDOM doesn't support ResizeObserver
+        elementResize: typeof ResizeObserver == "function"
+      });
+      return () => {
+        $(!1), te();
+      };
+    }, [
+      t,
+      I,
+      P,
+      C,
+      O,
+      P,
+      T,
+      M,
+      g,
+      c,
+      a,
+      l,
+      d,
+      f,
+      h,
+      u,
+      m,
+      p,
+      v,
+      b,
+      G,
+      A
+    ]), oe(() => {
+      if (!M || !g || !(P != null && P.isConnected) || !(D != null && D.isConnected)) return;
+      const k = () => {
+        P.style.zIndex = getComputedStyle(D).zIndex;
+      };
+      k();
+      let B = requestAnimationFrame(() => {
+        B = requestAnimationFrame(k);
+      });
+      return () => cancelAnimationFrame(B);
+    }, [M, g, P, D]);
+    const z = c ? "fixed" : "absolute";
+    return x = Nt(
+      x,
+      (k) => /* @__PURE__ */ Vt(
+        "div",
+        {
+          ...s,
+          style: {
+            // https://floating-ui.com/docs/computeposition#initial-layout
+            position: z,
+            top: 0,
+            left: 0,
+            width: "max-content",
+            ...s == null ? void 0 : s.style
+          },
+          ref: t == null ? void 0 : t.setPopoverElement,
+          children: k
+        }
+      ),
+      [t, z, s]
+    ), x = Nt(
+      x,
+      (k) => /* @__PURE__ */ Vt(be, { value: t, children: k }),
+      [t]
+    ), x = {
+      // data-placing is not part of the public API. We're setting this here so
+      // we can wait for the popover to be positioned before other components
+      // move focus into it. For example, this attribute is observed by the
+      // Combobox component with the autoSelect behavior.
+      "data-placing": !R || void 0,
+      ...x,
+      style: {
+        position: "relative",
+        ...x.style
+      }
+    }, x = vn({
+      store: t,
+      modal: n,
+      portal: o,
+      preserveTabOrder: i,
+      preserveTabOrderAnchor: E || O,
+      autoFocusOnShow: R && r,
+      ...x,
+      portalRef: F
+    }), x;
+  }
+);
+xn(
+  ft(function(t) {
+    const n = $o(t);
+    return ut(Oo, n);
+  }),
+  Kt
+);
+function ri({
+  popover: e,
+  ...t
+} = {}) {
+  const n = fn(
+    t.store,
+    un(e, [
+      "arrowElement",
+      "anchorElement",
+      "contentElement",
+      "popoverElement",
+      "disclosureElement"
+    ])
+  );
+  dn(t, n);
+  const o = n == null ? void 0 : n.getState(), i = wn({ ...t, store: n }), r = xt(
+    t.placement,
+    o == null ? void 0 : o.placement,
+    "bottom"
+  ), s = {
+    ...i.getState(),
+    placement: r,
+    currentPlacement: r,
+    anchorElement: xt(o == null ? void 0 : o.anchorElement, null),
+    popoverElement: xt(o == null ? void 0 : o.popoverElement, null),
+    arrowElement: xt(o == null ? void 0 : o.arrowElement, null),
+    rendered: Symbol("rendered")
+  }, c = mn(s, i, n);
+  return {
+    ...i,
+    ...c,
+    setAnchorElement: (a) => c.setState("anchorElement", a),
+    setPopoverElement: (a) => c.setState("popoverElement", a),
+    setArrowElement: (a) => c.setState("arrowElement", a),
+    render: () => c.setState("rendered", Symbol("rendered"))
+  };
+}
+function si(e, t, n) {
+  return Je(t, [n.popover]), gn(e, n, "placement"), yn(e, t, n);
+}
+var No = "div", Vo = at(
+  function({ store: t, ...n }) {
+    const o = Kt();
+    return t = t || o, n = {
+      ...n,
+      ref: Pt(t == null ? void 0 : t.setAnchorElement, n.ref)
+    }, n;
+  }
+);
+ft(function(t) {
+  const n = Vo(t);
+  return ut(No, n);
+});
+var Bo = "div";
+function Ie(e) {
+  const t = e.relatedTarget;
+  return (t == null ? void 0 : t.nodeType) === Node.ELEMENT_NODE ? t : null;
+}
+function Ho(e) {
+  const t = Ie(e);
+  return t ? en(e.currentTarget, t) : !1;
+}
+var zt = Symbol("composite-hover");
+function Wo(e) {
+  let t = Ie(e);
+  if (!t) return !1;
+  do {
+    if (nn(t, zt) && t[zt]) return !0;
+    t = t.parentElement;
+  } while (t);
+  return !1;
+}
+var zo = at(
+  function({
+    store: t,
+    focusOnHover: n = !0,
+    blurOnHoverEnd: o = !!n,
+    ...i
+  }) {
+    const r = ge();
+    t = t || r, jt(
+      t,
+      process.env.NODE_ENV !== "production" && "CompositeHover must be wrapped in a Composite component."
+    );
+    const s = Qe(), c = i.onMouseMove, a = yt(n), l = tt((m) => {
+      if (c == null || c(m), !m.defaultPrevented && s() && a(m)) {
+        if (!Ze(m.currentTarget)) {
+          const p = t == null ? void 0 : t.getState().baseElement;
+          p && !tn(p) && p.focus();
+        }
+        t == null || t.setActiveId(m.currentTarget.id);
+      }
+    }), d = i.onMouseLeave, f = yt(o), h = tt((m) => {
+      var p;
+      d == null || d(m), !m.defaultPrevented && s() && (Ho(m) || Wo(m) || a(m) && f(m) && (t == null || t.setActiveId(null), (p = t == null ? void 0 : t.getState().baseElement) == null || p.focus()));
+    }), u = we((m) => {
+      m && (m[zt] = !0);
+    }, []);
+    return i = {
+      ...i,
+      ref: Pt(u, i.ref),
+      onMouseMove: l,
+      onMouseLeave: h
+    }, _t(i);
+  }
+);
+ve(
+  ft(function(t) {
+    const n = zo(t);
+    return ut(Bo, n);
+  })
+);
+export {
+  Jo as C,
+  be as P,
+  Vo as a,
+  Zo as b,
+  On as c,
+  zo as d,
+  oi as e,
+  ii as f,
+  Qo as g,
+  ni as h,
+  $o as i,
+  ri as j,
+  si as k,
+  ei as l,
+  Rn as m,
+  Kt as n,
+  Go as o,
+  ti as u
+};
+//# sourceMappingURL=X6LNAU2F-DroCIVyL.js.map