@g4rcez/components 3.0.1 → 4.0.0

package/dist/floating-ui.react-QNHG9W4N.js

@@ -0,0 +1,3706 @@
+import * as g from "react";
+import { useLayoutEffect as Xn } from "react";
+import { a as qn, b as ce, t as It, d as Ue, i as Z, e as Le, g as Se, f as fn, h as Ce, j as Xt, k as Xe, l as We, m as Or, n as Gn, o as Ir, p as rt, q as qt, r as Pt, s as Gt, c as Pr, u as Zn, v as Mr } from "./index.esm-BaIwleSE.js";
+import { jsxs as Zt, jsx as be, Fragment as Ar } from "react/jsx-runtime";
+import * as Jt from "react-dom";
+const Sr = ["top", "right", "bottom", "left"], dn = ["start", "end"], mn = /* @__PURE__ */ Sr.reduce((e, t) => e.concat(t, t + "-" + dn[0], t + "-" + dn[1]), []), Fe = Math.min, xe = Math.max, wt = Math.round, je = Math.floor, Pe = (e) => ({
+  x: e,
+  y: e
+}), Lr = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+}, kr = {
+  start: "end",
+  end: "start"
+};
+function Ut(e, t, n) {
+  return xe(e, Fe(t, n));
+}
+function Ke(e, t) {
+  return typeof e == "function" ? e(t) : e;
+}
+function Me(e) {
+  return e.split("-")[0];
+}
+function Ee(e) {
+  return e.split("-")[1];
+}
+function Jn(e) {
+  return e === "x" ? "y" : "x";
+}
+function Qt(e) {
+  return e === "y" ? "height" : "width";
+}
+const Dr = /* @__PURE__ */ new Set(["top", "bottom"]);
+function Ae(e) {
+  return Dr.has(Me(e)) ? "y" : "x";
+}
+function en(e) {
+  return Jn(Ae(e));
+}
+function Qn(e, t, n) {
+  n === void 0 && (n = !1);
+  const r = Ee(e), o = en(e), i = Qt(o);
+  let s = o === "x" ? r === (n ? "end" : "start") ? "right" : "left" : r === "start" ? "bottom" : "top";
+  return t.reference[i] > t.floating[i] && (s = Rt(s)), [s, Rt(s)];
+}
+function Fr(e) {
+  const t = Rt(e);
+  return [xt(e), t, xt(t)];
+}
+function xt(e) {
+  return e.replace(/start|end/g, (t) => kr[t]);
+}
+const gn = ["left", "right"], pn = ["right", "left"], Nr = ["top", "bottom"], _r = ["bottom", "top"];
+function Wr(e, t, n) {
+  switch (e) {
+    case "top":
+    case "bottom":
+      return n ? t ? pn : gn : t ? gn : pn;
+    case "left":
+    case "right":
+      return t ? Nr : _r;
+    default:
+      return [];
+  }
+}
+function $r(e, t, n, r) {
+  const o = Ee(e);
+  let i = Wr(Me(e), n === "start", r);
+  return o && (i = i.map((s) => s + "-" + o), t && (i = i.concat(i.map(xt)))), i;
+}
+function Rt(e) {
+  return e.replace(/left|right|bottom|top/g, (t) => Lr[t]);
+}
+function Br(e) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...e
+  };
+}
+function er(e) {
+  return typeof e != "number" ? Br(e) : {
+    top: e,
+    right: e,
+    bottom: e,
+    left: e
+  };
+}
+function Et(e) {
+  const {
+    x: t,
+    y: n,
+    width: r,
+    height: o
+  } = e;
+  return {
+    width: r,
+    height: o,
+    top: n,
+    left: t,
+    right: t + r,
+    bottom: n + o,
+    x: t,
+    y: n
+  };
+}
+function tn() {
+  const e = navigator.userAgentData;
+  return e != null && e.platform ? e.platform : navigator.platform;
+}
+function tr() {
+  const e = navigator.userAgentData;
+  return e && Array.isArray(e.brands) ? e.brands.map((t) => {
+    let {
+      brand: n,
+      version: r
+    } = t;
+    return n + "/" + r;
+  }).join(" ") : navigator.userAgent;
+}
+function nr() {
+  return /apple/i.test(navigator.vendor);
+}
+function Yt() {
+  const e = /android/i;
+  return e.test(tn()) || e.test(tr());
+}
+function Vr() {
+  return tn().toLowerCase().startsWith("mac") && !navigator.maxTouchPoints;
+}
+function rr() {
+  return tr().includes("jsdom/");
+}
+const hn = "data-floating-ui-focusable", Kr = "input:not([type='hidden']):not([disabled]),[contenteditable]:not([contenteditable='false']),textarea:not([disabled])", Lt = "ArrowLeft", kt = "ArrowRight", Hr = "ArrowUp", jr = "ArrowDown";
+function Oe(e) {
+  let t = e.activeElement;
+  for (; ((n = t) == null || (n = n.shadowRoot) == null ? void 0 : n.activeElement) != null; ) {
+    var n;
+    t = t.shadowRoot.activeElement;
+  }
+  return t;
+}
+function ue(e, t) {
+  if (!e || !t)
+    return !1;
+  const n = t.getRootNode == null ? void 0 : t.getRootNode();
+  if (e.contains(t))
+    return !0;
+  if (n && qn(n)) {
+    let r = t;
+    for (; r; ) {
+      if (e === r)
+        return !0;
+      r = r.parentNode || r.host;
+    }
+  }
+  return !1;
+}
+function Ie(e) {
+  return "composedPath" in e ? e.composedPath()[0] : e.target;
+}
+function Dt(e, t) {
+  if (t == null)
+    return !1;
+  if ("composedPath" in e)
+    return e.composedPath().includes(t);
+  const n = e;
+  return n.target != null && t.contains(n.target);
+}
+function Ur(e) {
+  return e.matches("html,body");
+}
+function pe(e) {
+  return e?.ownerDocument || document;
+}
+function nn(e) {
+  return ce(e) && e.matches(Kr);
+}
+function zt(e) {
+  return e ? e.getAttribute("role") === "combobox" && nn(e) : !1;
+}
+function Yr(e) {
+  if (!e || rr()) return !0;
+  try {
+    return e.matches(":focus-visible");
+  } catch {
+    return !0;
+  }
+}
+function Ct(e) {
+  return e ? e.hasAttribute(hn) ? e : e.querySelector("[" + hn + "]") || e : null;
+}
+function $e(e, t, n) {
+  return n === void 0 && (n = !0), e.filter((o) => {
+    var i;
+    return o.parentId === t && (!n || ((i = o.context) == null ? void 0 : i.open));
+  }).flatMap((o) => [o, ...$e(e, o.id, n)]);
+}
+function zr(e, t) {
+  let n, r = -1;
+  function o(i, s) {
+    s > r && (n = i, r = s), $e(e, i).forEach((f) => {
+      o(f.id, s + 1);
+    });
+  }
+  return o(t, 0), e.find((i) => i.id === n);
+}
+function vn(e, t) {
+  var n;
+  let r = [], o = (n = e.find((i) => i.id === t)) == null ? void 0 : n.parentId;
+  for (; o; ) {
+    const i = e.find((s) => s.id === o);
+    o = i?.parentId, i && (r = r.concat(i));
+  }
+  return r;
+}
+function ge(e) {
+  e.preventDefault(), e.stopPropagation();
+}
+function Xr(e) {
+  return "nativeEvent" in e;
+}
+function or(e) {
+  return e.mozInputSource === 0 && e.isTrusted ? !0 : Yt() && e.pointerType ? e.type === "click" && e.buttons === 1 : e.detail === 0 && !e.pointerType;
+}
+function sr(e) {
+  return rr() ? !1 : !Yt() && e.width === 0 && e.height === 0 || Yt() && e.width === 1 && e.height === 1 && e.pressure === 0 && e.detail === 0 && e.pointerType === "mouse" || // iOS VoiceOver returns 0.333• for width/height.
+  e.width < 1 && e.height < 1 && e.pressure === 0 && e.detail === 0 && e.pointerType === "touch";
+}
+function qe(e, t) {
+  const n = ["mouse", "pen"];
+  return t || n.push("", void 0), n.includes(e);
+}
+var qr = typeof document < "u", Gr = function() {
+}, X = qr ? Xn : Gr;
+const Zr = {
+  ...g
+};
+function le(e) {
+  const t = g.useRef(e);
+  return X(() => {
+    t.current = e;
+  }), t;
+}
+const Jr = Zr.useInsertionEffect, Qr = Jr || ((e) => e());
+function re(e) {
+  const t = g.useRef(() => {
+    if (process.env.NODE_ENV !== "production")
+      throw new Error("Cannot call an event handler while rendering.");
+  });
+  return Qr(() => {
+    t.current = e;
+  }), g.useCallback(function() {
+    for (var n = arguments.length, r = new Array(n), o = 0; o < n; o++)
+      r[o] = arguments[o];
+    return t.current == null ? void 0 : t.current(...r);
+  }, []);
+}
+function dt(e, t, n) {
+  return Math.floor(e / t) !== n;
+}
+function et(e, t) {
+  return t < 0 || t >= e.current.length;
+}
+function Ft(e, t) {
+  return ve(e, {
+    disabledIndices: t
+  });
+}
+function bn(e, t) {
+  return ve(e, {
+    decrement: !0,
+    startingIndex: e.current.length,
+    disabledIndices: t
+  });
+}
+function ve(e, t) {
+  let {
+    startingIndex: n = -1,
+    decrement: r = !1,
+    disabledIndices: o,
+    amount: i = 1
+  } = t === void 0 ? {} : t, s = n;
+  do
+    s += r ? -i : i;
+  while (s >= 0 && s <= e.current.length - 1 && vt(e, s, o));
+  return s;
+}
+function eo(e, t) {
+  let {
+    event: n,
+    orientation: r,
+    loop: o,
+    rtl: i,
+    cols: s,
+    disabledIndices: c,
+    minIndex: f,
+    maxIndex: u,
+    prevIndex: l,
+    stopEvent: p = !1
+  } = t, d = l;
+  if (n.key === Hr) {
+    if (p && ge(n), l === -1)
+      d = u;
+    else if (d = ve(e, {
+      startingIndex: d,
+      amount: s,
+      decrement: !0,
+      disabledIndices: c
+    }), o && (l - s < f || d < 0)) {
+      const a = l % s, v = u % s, m = u - (v - a);
+      v === a ? d = u : d = v > a ? m : m - s;
+    }
+    et(e, d) && (d = l);
+  }
+  if (n.key === jr && (p && ge(n), l === -1 ? d = f : (d = ve(e, {
+    startingIndex: l,
+    amount: s,
+    disabledIndices: c
+  }), o && l + s > u && (d = ve(e, {
+    startingIndex: l % s - s,
+    amount: s,
+    disabledIndices: c
+  }))), et(e, d) && (d = l)), r === "both") {
+    const a = je(l / s);
+    n.key === (i ? Lt : kt) && (p && ge(n), l % s !== s - 1 ? (d = ve(e, {
+      startingIndex: l,
+      disabledIndices: c
+    }), o && dt(d, s, a) && (d = ve(e, {
+      startingIndex: l - l % s - 1,
+      disabledIndices: c
+    }))) : o && (d = ve(e, {
+      startingIndex: l - l % s - 1,
+      disabledIndices: c
+    })), dt(d, s, a) && (d = l)), n.key === (i ? kt : Lt) && (p && ge(n), l % s !== 0 ? (d = ve(e, {
+      startingIndex: l,
+      decrement: !0,
+      disabledIndices: c
+    }), o && dt(d, s, a) && (d = ve(e, {
+      startingIndex: l + (s - l % s),
+      decrement: !0,
+      disabledIndices: c
+    }))) : o && (d = ve(e, {
+      startingIndex: l + (s - l % s),
+      decrement: !0,
+      disabledIndices: c
+    })), dt(d, s, a) && (d = l));
+    const v = je(u / s) === a;
+    et(e, d) && (o && v ? d = n.key === (i ? kt : Lt) ? u : ve(e, {
+      startingIndex: l - l % s - 1,
+      disabledIndices: c
+    }) : d = l);
+  }
+  return d;
+}
+function to(e, t, n) {
+  const r = [];
+  let o = 0;
+  return e.forEach((i, s) => {
+    let {
+      width: c,
+      height: f
+    } = i;
+    if (c > t && process.env.NODE_ENV !== "production")
+      throw new Error("[Floating UI]: Invalid grid - item width at index " + s + " is greater than grid columns");
+    let u = !1;
+    for (n && (o = 0); !u; ) {
+      const l = [];
+      for (let p = 0; p < c; p++)
+        for (let d = 0; d < f; d++)
+          l.push(o + p + d * t);
+      o % t + c <= t && l.every((p) => r[p] == null) ? (l.forEach((p) => {
+        r[p] = s;
+      }), u = !0) : o++;
+    }
+  }), [...r];
+}
+function no(e, t, n, r, o) {
+  if (e === -1) return -1;
+  const i = n.indexOf(e), s = t[e];
+  switch (o) {
+    case "tl":
+      return i;
+    case "tr":
+      return s ? i + s.width - 1 : i;
+    case "bl":
+      return s ? i + (s.height - 1) * r : i;
+    case "br":
+      return n.lastIndexOf(e);
+  }
+}
+function ro(e, t) {
+  return t.flatMap((n, r) => e.includes(n) ? [r] : []);
+}
+function vt(e, t, n) {
+  if (typeof n == "function")
+    return n(t);
+  if (n)
+    return n.includes(t);
+  const r = e.current[t];
+  return r == null || r.hasAttribute("disabled") || r.getAttribute("aria-disabled") === "true";
+}
+const ot = () => ({
+  getShadowRoot: !0,
+  displayCheck: (
+    // JSDOM does not support the `tabbable` library. To solve this we can
+    // check if `ResizeObserver` is a real function (not polyfilled), which
+    // determines if the current environment is JSDOM-like.
+    typeof ResizeObserver == "function" && ResizeObserver.toString().includes("[native code]") ? "full" : "none"
+  )
+});
+function ir(e, t) {
+  const n = It(e, ot()), r = n.length;
+  if (r === 0) return;
+  const o = Oe(pe(e)), i = n.indexOf(o), s = i === -1 ? t === 1 ? 0 : r - 1 : i + t;
+  return n[s];
+}
+function cr(e) {
+  return ir(pe(e).body, 1) || e;
+}
+function ur(e) {
+  return ir(pe(e).body, -1) || e;
+}
+function tt(e, t) {
+  const n = t || e.currentTarget, r = e.relatedTarget;
+  return !r || !ue(n, r);
+}
+function oo(e) {
+  It(e, ot()).forEach((n) => {
+    n.dataset.tabindex = n.getAttribute("tabindex") || "", n.setAttribute("tabindex", "-1");
+  });
+}
+function yn(e) {
+  e.querySelectorAll("[data-tabindex]").forEach((n) => {
+    const r = n.dataset.tabindex;
+    delete n.dataset.tabindex, r ? n.setAttribute("tabindex", r) : n.removeAttribute("tabindex");
+  });
+}
+function wn(e, t, n) {
+  let {
+    reference: r,
+    floating: o
+  } = e;
+  const i = Ae(t), s = en(t), c = Qt(s), f = Me(t), u = i === "y", l = r.x + r.width / 2 - o.width / 2, p = r.y + r.height / 2 - o.height / 2, d = r[c] / 2 - o[c] / 2;
+  let a;
+  switch (f) {
+    case "top":
+      a = {
+        x: l,
+        y: r.y - o.height
+      };
+      break;
+    case "bottom":
+      a = {
+        x: l,
+        y: r.y + r.height
+      };
+      break;
+    case "right":
+      a = {
+        x: r.x + r.width,
+        y: p
+      };
+      break;
+    case "left":
+      a = {
+        x: r.x - o.width,
+        y: p
+      };
+      break;
+    default:
+      a = {
+        x: r.x,
+        y: r.y
+      };
+  }
+  switch (Ee(t)) {
+    case "start":
+      a[s] -= d * (n && u ? -1 : 1);
+      break;
+    case "end":
+      a[s] += d * (n && u ? -1 : 1);
+      break;
+  }
+  return a;
+}
+async function so(e, t) {
+  var n;
+  t === void 0 && (t = {});
+  const {
+    x: r,
+    y: o,
+    platform: i,
+    rects: s,
+    elements: c,
+    strategy: f
+  } = e, {
+    boundary: u = "clippingAncestors",
+    rootBoundary: l = "viewport",
+    elementContext: p = "floating",
+    altBoundary: d = !1,
+    padding: a = 0
+  } = Ke(t, e), v = er(a), w = c[d ? p === "floating" ? "reference" : "floating" : p], R = Et(await i.getClippingRect({
+    element: (n = await (i.isElement == null ? void 0 : i.isElement(w))) == null || n ? w : w.contextElement || await (i.getDocumentElement == null ? void 0 : i.getDocumentElement(c.floating)),
+    boundary: u,
+    rootBoundary: l,
+    strategy: f
+  })), y = p === "floating" ? {
+    x: r,
+    y: o,
+    width: s.floating.width,
+    height: s.floating.height
+  } : s.reference, x = await (i.getOffsetParent == null ? void 0 : i.getOffsetParent(c.floating)), E = await (i.isElement == null ? void 0 : i.isElement(x)) ? await (i.getScale == null ? void 0 : i.getScale(x)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  }, A = Et(i.convertOffsetParentRelativeRectToViewportRelativeRect ? await i.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: c,
+    rect: y,
+    offsetParent: x,
+    strategy: f
+  }) : y);
+  return {
+    top: (R.top - A.top + v.top) / E.y,
+    bottom: (A.bottom - R.bottom + v.bottom) / E.y,
+    left: (R.left - A.left + v.left) / E.x,
+    right: (A.right - R.right + v.right) / E.x
+  };
+}
+const io = async (e, t, n) => {
+  const {
+    placement: r = "bottom",
+    strategy: o = "absolute",
+    middleware: i = [],
+    platform: s
+  } = n, c = i.filter(Boolean), f = await (s.isRTL == null ? void 0 : s.isRTL(t));
+  let u = await s.getElementRects({
+    reference: e,
+    floating: t,
+    strategy: o
+  }), {
+    x: l,
+    y: p
+  } = wn(u, r, f), d = r, a = {}, v = 0;
+  for (let w = 0; w < c.length; w++) {
+    var m;
+    const {
+      name: R,
+      fn: y
+    } = c[w], {
+      x,
+      y: E,
+      data: A,
+      reset: O
+    } = await y({
+      x: l,
+      y: p,
+      initialPlacement: r,
+      placement: d,
+      strategy: o,
+      middlewareData: a,
+      rects: u,
+      platform: {
+        ...s,
+        detectOverflow: (m = s.detectOverflow) != null ? m : so
+      },
+      elements: {
+        reference: e,
+        floating: t
+      }
+    });
+    l = x ?? l, p = E ?? p, a = {
+      ...a,
+      [R]: {
+        ...a[R],
+        ...A
+      }
+    }, O && v <= 50 && (v++, typeof O == "object" && (O.placement && (d = O.placement), O.rects && (u = O.rects === !0 ? await s.getElementRects({
+      reference: e,
+      floating: t,
+      strategy: o
+    }) : O.rects), {
+      x: l,
+      y: p
+    } = wn(u, d, f)), w = -1);
+  }
+  return {
+    x: l,
+    y: p,
+    placement: d,
+    strategy: o,
+    middlewareData: a
+  };
+}, co = (e) => ({
+  name: "arrow",
+  options: e,
+  async fn(t) {
+    const {
+      x: n,
+      y: r,
+      placement: o,
+      rects: i,
+      platform: s,
+      elements: c,
+      middlewareData: f
+    } = t, {
+      element: u,
+      padding: l = 0
+    } = Ke(e, t) || {};
+    if (u == null)
+      return {};
+    const p = er(l), d = {
+      x: n,
+      y: r
+    }, a = en(o), v = Qt(a), m = await s.getDimensions(u), w = a === "y", R = w ? "top" : "left", y = w ? "bottom" : "right", x = w ? "clientHeight" : "clientWidth", E = i.reference[v] + i.reference[a] - d[a] - i.floating[v], A = d[a] - i.reference[a], O = await (s.getOffsetParent == null ? void 0 : s.getOffsetParent(u));
+    let M = O ? O[x] : 0;
+    (!M || !await (s.isElement == null ? void 0 : s.isElement(O))) && (M = c.floating[x] || i.floating[v]);
+    const S = E / 2 - A / 2, $ = M / 2 - m[v] / 2 - 1, I = Fe(p[R], $), B = Fe(p[y], $), W = I, L = M - m[v] - B, h = M / 2 - m[v] / 2 + S, C = Ut(W, h, L), D = !f.arrow && Ee(o) != null && h !== C && i.reference[v] / 2 - (h < W ? I : B) - m[v] / 2 < 0, T = D ? h < W ? h - W : h - L : 0;
+    return {
+      [a]: d[a] + T,
+      data: {
+        [a]: C,
+        centerOffset: h - C - T,
+        ...D && {
+          alignmentOffset: T
+        }
+      },
+      reset: D
+    };
+  }
+});
+function uo(e, t, n) {
+  return (e ? [...n.filter((o) => Ee(o) === e), ...n.filter((o) => Ee(o) !== e)] : n.filter((o) => Me(o) === o)).filter((o) => e ? Ee(o) === e || (t ? xt(o) !== o : !1) : !0);
+}
+const lo = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "autoPlacement",
+    options: e,
+    async fn(t) {
+      var n, r, o;
+      const {
+        rects: i,
+        middlewareData: s,
+        placement: c,
+        platform: f,
+        elements: u
+      } = t, {
+        crossAxis: l = !1,
+        alignment: p,
+        allowedPlacements: d = mn,
+        autoAlignment: a = !0,
+        ...v
+      } = Ke(e, t), m = p !== void 0 || d === mn ? uo(p || null, a, d) : d, w = await f.detectOverflow(t, v), R = ((n = s.autoPlacement) == null ? void 0 : n.index) || 0, y = m[R];
+      if (y == null)
+        return {};
+      const x = Qn(y, i, await (f.isRTL == null ? void 0 : f.isRTL(u.floating)));
+      if (c !== y)
+        return {
+          reset: {
+            placement: m[0]
+          }
+        };
+      const E = [w[Me(y)], w[x[0]], w[x[1]]], A = [...((r = s.autoPlacement) == null ? void 0 : r.overflows) || [], {
+        placement: y,
+        overflows: E
+      }], O = m[R + 1];
+      if (O)
+        return {
+          data: {
+            index: R + 1,
+            overflows: A
+          },
+          reset: {
+            placement: O
+          }
+        };
+      const M = A.map((I) => {
+        const B = Ee(I.placement);
+        return [I.placement, B && l ? (
+          // Check along the mainAxis and main crossAxis side.
+          I.overflows.slice(0, 2).reduce((W, L) => W + L, 0)
+        ) : (
+          // Check only the mainAxis.
+          I.overflows[0]
+        ), I.overflows];
+      }).sort((I, B) => I[1] - B[1]), $ = ((o = M.filter((I) => I[2].slice(
+        0,
+        // Aligned placements should not check their opposite crossAxis
+        // side.
+        Ee(I[0]) ? 2 : 3
+      ).every((B) => B <= 0))[0]) == null ? void 0 : o[0]) || M[0][0];
+      return $ !== c ? {
+        data: {
+          index: R + 1,
+          overflows: A
+        },
+        reset: {
+          placement: $
+        }
+      } : {};
+    }
+  };
+}, ao = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "flip",
+    options: e,
+    async fn(t) {
+      var n, r;
+      const {
+        placement: o,
+        middlewareData: i,
+        rects: s,
+        initialPlacement: c,
+        platform: f,
+        elements: u
+      } = t, {
+        mainAxis: l = !0,
+        crossAxis: p = !0,
+        fallbackPlacements: d,
+        fallbackStrategy: a = "bestFit",
+        fallbackAxisSideDirection: v = "none",
+        flipAlignment: m = !0,
+        ...w
+      } = Ke(e, t);
+      if ((n = i.arrow) != null && n.alignmentOffset)
+        return {};
+      const R = Me(o), y = Ae(c), x = Me(c) === c, E = await (f.isRTL == null ? void 0 : f.isRTL(u.floating)), A = d || (x || !m ? [Rt(c)] : Fr(c)), O = v !== "none";
+      !d && O && A.push(...$r(c, m, v, E));
+      const M = [c, ...A], S = await f.detectOverflow(t, w), $ = [];
+      let I = ((r = i.flip) == null ? void 0 : r.overflows) || [];
+      if (l && $.push(S[R]), p) {
+        const h = Qn(o, s, E);
+        $.push(S[h[0]], S[h[1]]);
+      }
+      if (I = [...I, {
+        placement: o,
+        overflows: $
+      }], !$.every((h) => h <= 0)) {
+        var B, W;
+        const h = (((B = i.flip) == null ? void 0 : B.index) || 0) + 1, C = M[h];
+        if (C && (!(p === "alignment" ? y !== Ae(C) : !1) || // We leave the current main axis only if every placement on that axis
+        // overflows the main axis.
+        I.every((b) => Ae(b.placement) === y ? b.overflows[0] > 0 : !0)))
+          return {
+            data: {
+              index: h,
+              overflows: I
+            },
+            reset: {
+              placement: C
+            }
+          };
+        let D = (W = I.filter((T) => T.overflows[0] <= 0).sort((T, b) => T.overflows[1] - b.overflows[1])[0]) == null ? void 0 : W.placement;
+        if (!D)
+          switch (a) {
+            case "bestFit": {
+              var L;
+              const T = (L = I.filter((b) => {
+                if (O) {
+                  const P = Ae(b.placement);
+                  return P === y || // Create a bias to the `y` side axis due to horizontal
+                  // reading directions favoring greater width.
+                  P === "y";
+                }
+                return !0;
+              }).map((b) => [b.placement, b.overflows.filter((P) => P > 0).reduce((P, k) => P + k, 0)]).sort((b, P) => b[1] - P[1])[0]) == null ? void 0 : L[0];
+              T && (D = T);
+              break;
+            }
+            case "initialPlacement":
+              D = c;
+              break;
+          }
+        if (o !== D)
+          return {
+            reset: {
+              placement: D
+            }
+          };
+      }
+      return {};
+    }
+  };
+}, fo = /* @__PURE__ */ new Set(["left", "top"]);
+async function mo(e, t) {
+  const {
+    placement: n,
+    platform: r,
+    elements: o
+  } = e, i = await (r.isRTL == null ? void 0 : r.isRTL(o.floating)), s = Me(n), c = Ee(n), f = Ae(n) === "y", u = fo.has(s) ? -1 : 1, l = i && f ? -1 : 1, p = Ke(t, e);
+  let {
+    mainAxis: d,
+    crossAxis: a,
+    alignmentAxis: v
+  } = typeof p == "number" ? {
+    mainAxis: p,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: p.mainAxis || 0,
+    crossAxis: p.crossAxis || 0,
+    alignmentAxis: p.alignmentAxis
+  };
+  return c && typeof v == "number" && (a = c === "end" ? v * -1 : v), f ? {
+    x: a * l,
+    y: d * u
+  } : {
+    x: d * u,
+    y: a * l
+  };
+}
+const go = function(e) {
+  return e === void 0 && (e = 0), {
+    name: "offset",
+    options: e,
+    async fn(t) {
+      var n, r;
+      const {
+        x: o,
+        y: i,
+        placement: s,
+        middlewareData: c
+      } = t, f = await mo(t, e);
+      return s === ((n = c.offset) == null ? void 0 : n.placement) && (r = c.arrow) != null && r.alignmentOffset ? {} : {
+        x: o + f.x,
+        y: i + f.y,
+        data: {
+          ...f,
+          placement: s
+        }
+      };
+    }
+  };
+}, po = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "shift",
+    options: e,
+    async fn(t) {
+      const {
+        x: n,
+        y: r,
+        placement: o,
+        platform: i
+      } = t, {
+        mainAxis: s = !0,
+        crossAxis: c = !1,
+        limiter: f = {
+          fn: (R) => {
+            let {
+              x: y,
+              y: x
+            } = R;
+            return {
+              x: y,
+              y: x
+            };
+          }
+        },
+        ...u
+      } = Ke(e, t), l = {
+        x: n,
+        y: r
+      }, p = await i.detectOverflow(t, u), d = Ae(Me(o)), a = Jn(d);
+      let v = l[a], m = l[d];
+      if (s) {
+        const R = a === "y" ? "top" : "left", y = a === "y" ? "bottom" : "right", x = v + p[R], E = v - p[y];
+        v = Ut(x, v, E);
+      }
+      if (c) {
+        const R = d === "y" ? "top" : "left", y = d === "y" ? "bottom" : "right", x = m + p[R], E = m - p[y];
+        m = Ut(x, m, E);
+      }
+      const w = f.fn({
+        ...t,
+        [a]: v,
+        [d]: m
+      });
+      return {
+        ...w,
+        data: {
+          x: w.x - n,
+          y: w.y - r,
+          enabled: {
+            [a]: s,
+            [d]: c
+          }
+        }
+      };
+    }
+  };
+}, ho = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "size",
+    options: e,
+    async fn(t) {
+      var n, r;
+      const {
+        placement: o,
+        rects: i,
+        platform: s,
+        elements: c
+      } = t, {
+        apply: f = () => {
+        },
+        ...u
+      } = Ke(e, t), l = await s.detectOverflow(t, u), p = Me(o), d = Ee(o), a = Ae(o) === "y", {
+        width: v,
+        height: m
+      } = i.floating;
+      let w, R;
+      p === "top" || p === "bottom" ? (w = p, R = d === (await (s.isRTL == null ? void 0 : s.isRTL(c.floating)) ? "start" : "end") ? "left" : "right") : (R = p, w = d === "end" ? "top" : "bottom");
+      const y = m - l.top - l.bottom, x = v - l.left - l.right, E = Fe(m - l[w], y), A = Fe(v - l[R], x), O = !t.middlewareData.shift;
+      let M = E, S = A;
+      if ((n = t.middlewareData.shift) != null && n.enabled.x && (S = x), (r = t.middlewareData.shift) != null && r.enabled.y && (M = y), O && !d) {
+        const I = xe(l.left, 0), B = xe(l.right, 0), W = xe(l.top, 0), L = xe(l.bottom, 0);
+        a ? S = v - 2 * (I !== 0 || B !== 0 ? I + B : xe(l.left, l.right)) : M = m - 2 * (W !== 0 || L !== 0 ? W + L : xe(l.top, l.bottom));
+      }
+      await f({
+        ...t,
+        availableWidth: S,
+        availableHeight: M
+      });
+      const $ = await s.getDimensions(c.floating);
+      return v !== $.width || m !== $.height ? {
+        reset: {
+          rects: !0
+        }
+      } : {};
+    }
+  };
+};
+function lr(e) {
+  const t = Ce(e);
+  let n = parseFloat(t.width) || 0, r = parseFloat(t.height) || 0;
+  const o = ce(e), i = o ? e.offsetWidth : n, s = o ? e.offsetHeight : r, c = wt(n) !== i || wt(r) !== s;
+  return c && (n = i, r = s), {
+    width: n,
+    height: r,
+    $: c
+  };
+}
+function rn(e) {
+  return Z(e) ? e : e.contextElement;
+}
+function Ye(e) {
+  const t = rn(e);
+  if (!ce(t))
+    return Pe(1);
+  const n = t.getBoundingClientRect(), {
+    width: r,
+    height: o,
+    $: i
+  } = lr(t);
+  let s = (i ? wt(n.width) : n.width) / r, c = (i ? wt(n.height) : n.height) / o;
+  return (!s || !Number.isFinite(s)) && (s = 1), (!c || !Number.isFinite(c)) && (c = 1), {
+    x: s,
+    y: c
+  };
+}
+const vo = /* @__PURE__ */ Pe(0);
+function ar(e) {
+  const t = Se(e);
+  return !Gt() || !t.visualViewport ? vo : {
+    x: t.visualViewport.offsetLeft,
+    y: t.visualViewport.offsetTop
+  };
+}
+function bo(e, t, n) {
+  return t === void 0 && (t = !1), !n || t && n !== Se(e) ? !1 : t;
+}
+function Be(e, t, n, r) {
+  t === void 0 && (t = !1), n === void 0 && (n = !1);
+  const o = e.getBoundingClientRect(), i = rn(e);
+  let s = Pe(1);
+  t && (r ? Z(r) && (s = Ye(r)) : s = Ye(e));
+  const c = bo(i, n, r) ? ar(i) : Pe(0);
+  let f = (o.left + c.x) / s.x, u = (o.top + c.y) / s.y, l = o.width / s.x, p = o.height / s.y;
+  if (i) {
+    const d = Se(i), a = r && Z(r) ? Se(r) : r;
+    let v = d, m = fn(v);
+    for (; m && r && a !== v; ) {
+      const w = Ye(m), R = m.getBoundingClientRect(), y = Ce(m), x = R.left + (m.clientLeft + parseFloat(y.paddingLeft)) * w.x, E = R.top + (m.clientTop + parseFloat(y.paddingTop)) * w.y;
+      f *= w.x, u *= w.y, l *= w.x, p *= w.y, f += x, u += E, v = Se(m), m = fn(v);
+    }
+  }
+  return Et({
+    width: l,
+    height: p,
+    x: f,
+    y: u
+  });
+}
+function Mt(e, t) {
+  const n = Pt(e).scrollLeft;
+  return t ? t.left + n : Be(Le(e)).left + n;
+}
+function fr(e, t) {
+  const n = e.getBoundingClientRect(), r = n.left + t.scrollLeft - Mt(e, n), o = n.top + t.scrollTop;
+  return {
+    x: r,
+    y: o
+  };
+}
+function yo(e) {
+  let {
+    elements: t,
+    rect: n,
+    offsetParent: r,
+    strategy: o
+  } = e;
+  const i = o === "fixed", s = Le(r), c = t ? Xt(t.floating) : !1;
+  if (r === s || c && i)
+    return n;
+  let f = {
+    scrollLeft: 0,
+    scrollTop: 0
+  }, u = Pe(1);
+  const l = Pe(0), p = ce(r);
+  if ((p || !p && !i) && ((rt(r) !== "body" || qt(s)) && (f = Pt(r)), ce(r))) {
+    const a = Be(r);
+    u = Ye(r), l.x = a.x + r.clientLeft, l.y = a.y + r.clientTop;
+  }
+  const d = s && !p && !i ? fr(s, f) : Pe(0);
+  return {
+    width: n.width * u.x,
+    height: n.height * u.y,
+    x: n.x * u.x - f.scrollLeft * u.x + l.x + d.x,
+    y: n.y * u.y - f.scrollTop * u.y + l.y + d.y
+  };
+}
+function wo(e) {
+  return Array.from(e.getClientRects());
+}
+function xo(e) {
+  const t = Le(e), n = Pt(e), r = e.ownerDocument.body, o = xe(t.scrollWidth, t.clientWidth, r.scrollWidth, r.clientWidth), i = xe(t.scrollHeight, t.clientHeight, r.scrollHeight, r.clientHeight);
+  let s = -n.scrollLeft + Mt(e);
+  const c = -n.scrollTop;
+  return Ce(r).direction === "rtl" && (s += xe(t.clientWidth, r.clientWidth) - o), {
+    width: o,
+    height: i,
+    x: s,
+    y: c
+  };
+}
+const xn = 25;
+function Ro(e, t) {
+  const n = Se(e), r = Le(e), o = n.visualViewport;
+  let i = r.clientWidth, s = r.clientHeight, c = 0, f = 0;
+  if (o) {
+    i = o.width, s = o.height;
+    const l = Gt();
+    (!l || l && t === "fixed") && (c = o.offsetLeft, f = o.offsetTop);
+  }
+  const u = Mt(r);
+  if (u <= 0) {
+    const l = r.ownerDocument, p = l.body, d = getComputedStyle(p), a = l.compatMode === "CSS1Compat" && parseFloat(d.marginLeft) + parseFloat(d.marginRight) || 0, v = Math.abs(r.clientWidth - p.clientWidth - a);
+    v <= xn && (i -= v);
+  } else u <= xn && (i += u);
+  return {
+    width: i,
+    height: s,
+    x: c,
+    y: f
+  };
+}
+const Eo = /* @__PURE__ */ new Set(["absolute", "fixed"]);
+function Co(e, t) {
+  const n = Be(e, !0, t === "fixed"), r = n.top + e.clientTop, o = n.left + e.clientLeft, i = ce(e) ? Ye(e) : Pe(1), s = e.clientWidth * i.x, c = e.clientHeight * i.y, f = o * i.x, u = r * i.y;
+  return {
+    width: s,
+    height: c,
+    x: f,
+    y: u
+  };
+}
+function Rn(e, t, n) {
+  let r;
+  if (t === "viewport")
+    r = Ro(e, n);
+  else if (t === "document")
+    r = xo(Le(e));
+  else if (Z(t))
+    r = Co(t, n);
+  else {
+    const o = ar(e);
+    r = {
+      x: t.x - o.x,
+      y: t.y - o.y,
+      width: t.width,
+      height: t.height
+    };
+  }
+  return Et(r);
+}
+function dr(e, t) {
+  const n = Xe(e);
+  return n === t || !Z(n) || We(n) ? !1 : Ce(n).position === "fixed" || dr(n, t);
+}
+function To(e, t) {
+  const n = t.get(e);
+  if (n)
+    return n;
+  let r = Ue(e, [], !1).filter((c) => Z(c) && rt(c) !== "body"), o = null;
+  const i = Ce(e).position === "fixed";
+  let s = i ? Xe(e) : e;
+  for (; Z(s) && !We(s); ) {
+    const c = Ce(s), f = Gn(s);
+    !f && c.position === "fixed" && (o = null), (i ? !f && !o : !f && c.position === "static" && !!o && Eo.has(o.position) || qt(s) && !f && dr(e, s)) ? r = r.filter((l) => l !== s) : o = c, s = Xe(s);
+  }
+  return t.set(e, r), r;
+}
+function Oo(e) {
+  let {
+    element: t,
+    boundary: n,
+    rootBoundary: r,
+    strategy: o
+  } = e;
+  const s = [...n === "clippingAncestors" ? Xt(t) ? [] : To(t, this._c) : [].concat(n), r], c = s[0], f = s.reduce((u, l) => {
+    const p = Rn(t, l, o);
+    return u.top = xe(p.top, u.top), u.right = Fe(p.right, u.right), u.bottom = Fe(p.bottom, u.bottom), u.left = xe(p.left, u.left), u;
+  }, Rn(t, c, o));
+  return {
+    width: f.right - f.left,
+    height: f.bottom - f.top,
+    x: f.left,
+    y: f.top
+  };
+}
+function Io(e) {
+  const {
+    width: t,
+    height: n
+  } = lr(e);
+  return {
+    width: t,
+    height: n
+  };
+}
+function Po(e, t, n) {
+  const r = ce(t), o = Le(t), i = n === "fixed", s = Be(e, !0, i, t);
+  let c = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const f = Pe(0);
+  function u() {
+    f.x = Mt(o);
+  }
+  if (r || !r && !i)
+    if ((rt(t) !== "body" || qt(o)) && (c = Pt(t)), r) {
+      const a = Be(t, !0, i, t);
+      f.x = a.x + t.clientLeft, f.y = a.y + t.clientTop;
+    } else o && u();
+  i && !r && o && u();
+  const l = o && !r && !i ? fr(o, c) : Pe(0), p = s.left + c.scrollLeft - f.x - l.x, d = s.top + c.scrollTop - f.y - l.y;
+  return {
+    x: p,
+    y: d,
+    width: s.width,
+    height: s.height
+  };
+}
+function Nt(e) {
+  return Ce(e).position === "static";
+}
+function En(e, t) {
+  if (!ce(e) || Ce(e).position === "fixed")
+    return null;
+  if (t)
+    return t(e);
+  let n = e.offsetParent;
+  return Le(e) === n && (n = n.ownerDocument.body), n;
+}
+function mr(e, t) {
+  const n = Se(e);
+  if (Xt(e))
+    return n;
+  if (!ce(e)) {
+    let o = Xe(e);
+    for (; o && !We(o); ) {
+      if (Z(o) && !Nt(o))
+        return o;
+      o = Xe(o);
+    }
+    return n;
+  }
+  let r = En(e, t);
+  for (; r && Or(r) && Nt(r); )
+    r = En(r, t);
+  return r && We(r) && Nt(r) && !Gn(r) ? n : r || Ir(e) || n;
+}
+const Mo = async function(e) {
+  const t = this.getOffsetParent || mr, n = this.getDimensions, r = await n(e.floating);
+  return {
+    reference: Po(e.reference, await t(e.floating), e.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      width: r.width,
+      height: r.height
+    }
+  };
+};
+function Ao(e) {
+  return Ce(e).direction === "rtl";
+}
+const So = {
+  convertOffsetParentRelativeRectToViewportRelativeRect: yo,
+  getDocumentElement: Le,
+  getClippingRect: Oo,
+  getOffsetParent: mr,
+  getElementRects: Mo,
+  getClientRects: wo,
+  getDimensions: Io,
+  getScale: Ye,
+  isElement: Z,
+  isRTL: Ao
+};
+function gr(e, t) {
+  return e.x === t.x && e.y === t.y && e.width === t.width && e.height === t.height;
+}
+function Lo(e, t) {
+  let n = null, r;
+  const o = Le(e);
+  function i() {
+    var c;
+    clearTimeout(r), (c = n) == null || c.disconnect(), n = null;
+  }
+  function s(c, f) {
+    c === void 0 && (c = !1), f === void 0 && (f = 1), i();
+    const u = e.getBoundingClientRect(), {
+      left: l,
+      top: p,
+      width: d,
+      height: a
+    } = u;
+    if (c || t(), !d || !a)
+      return;
+    const v = je(p), m = je(o.clientWidth - (l + d)), w = je(o.clientHeight - (p + a)), R = je(l), x = {
+      rootMargin: -v + "px " + -m + "px " + -w + "px " + -R + "px",
+      threshold: xe(0, Fe(1, f)) || 1
+    };
+    let E = !0;
+    function A(O) {
+      const M = O[0].intersectionRatio;
+      if (M !== f) {
+        if (!E)
+          return s();
+        M ? s(!1, M) : r = setTimeout(() => {
+          s(!1, 1e-7);
+        }, 1e3);
+      }
+      M === 1 && !gr(u, e.getBoundingClientRect()) && s(), E = !1;
+    }
+    try {
+      n = new IntersectionObserver(A, {
+        ...x,
+        // Handle <iframe>s
+        root: o.ownerDocument
+      });
+    } catch {
+      n = new IntersectionObserver(A, x);
+    }
+    n.observe(e);
+  }
+  return s(!0), i;
+}
+function xs(e, t, n, r) {
+  r === void 0 && (r = {});
+  const {
+    ancestorScroll: o = !0,
+    ancestorResize: i = !0,
+    elementResize: s = typeof ResizeObserver == "function",
+    layoutShift: c = typeof IntersectionObserver == "function",
+    animationFrame: f = !1
+  } = r, u = rn(e), l = o || i ? [...u ? Ue(u) : [], ...Ue(t)] : [];
+  l.forEach((R) => {
+    o && R.addEventListener("scroll", n, {
+      passive: !0
+    }), i && R.addEventListener("resize", n);
+  });
+  const p = u && c ? Lo(u, n) : null;
+  let d = -1, a = null;
+  s && (a = new ResizeObserver((R) => {
+    let [y] = R;
+    y && y.target === u && a && (a.unobserve(t), cancelAnimationFrame(d), d = requestAnimationFrame(() => {
+      var x;
+      (x = a) == null || x.observe(t);
+    })), n();
+  }), u && !f && a.observe(u), a.observe(t));
+  let v, m = f ? Be(e) : null;
+  f && w();
+  function w() {
+    const R = Be(e);
+    m && !gr(m, R) && n(), m = R, v = requestAnimationFrame(w);
+  }
+  return n(), () => {
+    var R;
+    l.forEach((y) => {
+      o && y.removeEventListener("scroll", n), i && y.removeEventListener("resize", n);
+    }), p?.(), (R = a) == null || R.disconnect(), a = null, f && cancelAnimationFrame(v);
+  };
+}
+const ko = go, Do = lo, Fo = po, No = ao, _o = ho, Cn = co, Wo = (e, t, n) => {
+  const r = /* @__PURE__ */ new Map(), o = {
+    platform: So,
+    ...n
+  }, i = {
+    ...o.platform,
+    _c: r
+  };
+  return io(e, t, {
+    ...o,
+    platform: i
+  });
+};
+var $o = typeof document < "u", Bo = function() {
+}, bt = $o ? Xn : Bo;
+function Tt(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 n, r, o;
+  if (e && t && typeof e == "object") {
+    if (Array.isArray(e)) {
+      if (n = e.length, n !== t.length) return !1;
+      for (r = n; r-- !== 0; )
+        if (!Tt(e[r], t[r]))
+          return !1;
+      return !0;
+    }
+    if (o = Object.keys(e), n = o.length, n !== Object.keys(t).length)
+      return !1;
+    for (r = n; r-- !== 0; )
+      if (!{}.hasOwnProperty.call(t, o[r]))
+        return !1;
+    for (r = n; r-- !== 0; ) {
+      const i = o[r];
+      if (!(i === "_owner" && e.$$typeof) && !Tt(e[i], t[i]))
+        return !1;
+    }
+    return !0;
+  }
+  return e !== e && t !== t;
+}
+function pr(e) {
+  return typeof window > "u" ? 1 : (e.ownerDocument.defaultView || window).devicePixelRatio || 1;
+}
+function Tn(e, t) {
+  const n = pr(e);
+  return Math.round(t * n) / n;
+}
+function _t(e) {
+  const t = g.useRef(e);
+  return bt(() => {
+    t.current = e;
+  }), t;
+}
+function Vo(e) {
+  e === void 0 && (e = {});
+  const {
+    placement: t = "bottom",
+    strategy: n = "absolute",
+    middleware: r = [],
+    platform: o,
+    elements: {
+      reference: i,
+      floating: s
+    } = {},
+    transform: c = !0,
+    whileElementsMounted: f,
+    open: u
+  } = e, [l, p] = g.useState({
+    x: 0,
+    y: 0,
+    strategy: n,
+    placement: t,
+    middlewareData: {},
+    isPositioned: !1
+  }), [d, a] = g.useState(r);
+  Tt(d, r) || a(r);
+  const [v, m] = g.useState(null), [w, R] = g.useState(null), y = g.useCallback((b) => {
+    b !== O.current && (O.current = b, m(b));
+  }, []), x = g.useCallback((b) => {
+    b !== M.current && (M.current = b, R(b));
+  }, []), E = i || v, A = s || w, O = g.useRef(null), M = g.useRef(null), S = g.useRef(l), $ = f != null, I = _t(f), B = _t(o), W = _t(u), L = g.useCallback(() => {
+    if (!O.current || !M.current)
+      return;
+    const b = {
+      placement: t,
+      strategy: n,
+      middleware: d
+    };
+    B.current && (b.platform = B.current), Wo(O.current, M.current, b).then((P) => {
+      const k = {
+        ...P,
+        // 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: W.current !== !1
+      };
+      h.current && !Tt(S.current, k) && (S.current = k, Jt.flushSync(() => {
+        p(k);
+      }));
+    });
+  }, [d, t, n, B, W]);
+  bt(() => {
+    u === !1 && S.current.isPositioned && (S.current.isPositioned = !1, p((b) => ({
+      ...b,
+      isPositioned: !1
+    })));
+  }, [u]);
+  const h = g.useRef(!1);
+  bt(() => (h.current = !0, () => {
+    h.current = !1;
+  }), []), bt(() => {
+    if (E && (O.current = E), A && (M.current = A), E && A) {
+      if (I.current)
+        return I.current(E, A, L);
+      L();
+    }
+  }, [E, A, L, I, $]);
+  const C = g.useMemo(() => ({
+    reference: O,
+    floating: M,
+    setReference: y,
+    setFloating: x
+  }), [y, x]), D = g.useMemo(() => ({
+    reference: E,
+    floating: A
+  }), [E, A]), T = g.useMemo(() => {
+    const b = {
+      position: n,
+      left: 0,
+      top: 0
+    };
+    if (!D.floating)
+      return b;
+    const P = Tn(D.floating, l.x), k = Tn(D.floating, l.y);
+    return c ? {
+      ...b,
+      transform: "translate(" + P + "px, " + k + "px)",
+      ...pr(D.floating) >= 1.5 && {
+        willChange: "transform"
+      }
+    } : {
+      position: n,
+      left: P,
+      top: k
+    };
+  }, [n, c, D.floating, l.x, l.y]);
+  return g.useMemo(() => ({
+    ...l,
+    update: L,
+    refs: C,
+    elements: D,
+    floatingStyles: T
+  }), [l, L, C, D, T]);
+}
+const Ko = (e) => {
+  function t(n) {
+    return {}.hasOwnProperty.call(n, "current");
+  }
+  return {
+    name: "arrow",
+    options: e,
+    fn(n) {
+      const {
+        element: r,
+        padding: o
+      } = typeof e == "function" ? e(n) : e;
+      return r && t(r) ? r.current != null ? Cn({
+        element: r.current,
+        padding: o
+      }).fn(n) : {} : r ? Cn({
+        element: r,
+        padding: o
+      }).fn(n) : {};
+    }
+  };
+}, Rs = (e, t) => ({
+  ...ko(e),
+  options: [e, t]
+}), Es = (e, t) => ({
+  ...Fo(e),
+  options: [e, t]
+}), Cs = (e, t) => ({
+  ...No(e),
+  options: [e, t]
+}), Ts = (e, t) => ({
+  ..._o(e),
+  options: [e, t]
+}), Os = (e, t) => ({
+  ...Do(e),
+  options: [e, t]
+}), Is = (e, t) => ({
+  ...Ko(e),
+  options: [e, t]
+});
+function Ho(e, t) {
+  const n = e.compareDocumentPosition(t);
+  return n & Node.DOCUMENT_POSITION_FOLLOWING || n & Node.DOCUMENT_POSITION_CONTAINED_BY ? -1 : n & Node.DOCUMENT_POSITION_PRECEDING || n & Node.DOCUMENT_POSITION_CONTAINS ? 1 : 0;
+}
+const hr = /* @__PURE__ */ g.createContext({
+  register: () => {
+  },
+  unregister: () => {
+  },
+  map: /* @__PURE__ */ new Map(),
+  elementsRef: {
+    current: []
+  }
+});
+function Ps(e) {
+  const {
+    children: t,
+    elementsRef: n,
+    labelsRef: r
+  } = e, [o, i] = g.useState(() => /* @__PURE__ */ new Set()), s = g.useCallback((u) => {
+    i((l) => new Set(l).add(u));
+  }, []), c = g.useCallback((u) => {
+    i((l) => {
+      const p = new Set(l);
+      return p.delete(u), p;
+    });
+  }, []), f = g.useMemo(() => {
+    const u = /* @__PURE__ */ new Map();
+    return Array.from(o.keys()).sort(Ho).forEach((p, d) => {
+      u.set(p, d);
+    }), u;
+  }, [o]);
+  return /* @__PURE__ */ be(hr.Provider, {
+    value: g.useMemo(() => ({
+      register: s,
+      unregister: c,
+      map: f,
+      elementsRef: n,
+      labelsRef: r
+    }), [s, c, f, n, r]),
+    children: t
+  });
+}
+function Ms(e) {
+  e === void 0 && (e = {});
+  const {
+    label: t
+  } = e, {
+    register: n,
+    unregister: r,
+    map: o,
+    elementsRef: i,
+    labelsRef: s
+  } = g.useContext(hr), [c, f] = g.useState(null), u = g.useRef(null), l = g.useCallback((p) => {
+    if (u.current = p, c !== null && (i.current[c] = p, s)) {
+      var d;
+      const a = t !== void 0;
+      s.current[c] = a ? t : (d = p?.textContent) != null ? d : null;
+    }
+  }, [c, i, s, t]);
+  return X(() => {
+    const p = u.current;
+    if (p)
+      return n(p), () => {
+        r(p);
+      };
+  }, [n, r]), X(() => {
+    const p = u.current ? o.get(u.current) : null;
+    p != null && f(p);
+  }, [o]), g.useMemo(() => ({
+    ref: l,
+    index: c ?? -1
+  }), [c, l]);
+}
+const jo = "data-floating-ui-focusable", On = "active", In = "selected", st = "ArrowLeft", it = "ArrowRight", vr = "ArrowUp", At = "ArrowDown", Uo = {
+  ...g
+};
+let Pn = !1, Yo = 0;
+const Mn = () => (
+  // Ensure the id is unique with multiple independent versions of Floating UI
+  // on <React 18
+  "floating-ui-" + Math.random().toString(36).slice(2, 6) + Yo++
+);
+function zo() {
+  const [e, t] = g.useState(() => Pn ? Mn() : void 0);
+  return X(() => {
+    e == null && t(Mn());
+  }, []), g.useEffect(() => {
+    Pn = !0;
+  }, []), e;
+}
+const Xo = Uo.useId, ct = Xo || zo;
+let nt;
+process.env.NODE_ENV !== "production" && (nt = /* @__PURE__ */ new Set());
+function yt() {
+  for (var e, t = arguments.length, n = new Array(t), r = 0; r < t; r++)
+    n[r] = arguments[r];
+  const o = "Floating UI: " + n.join(" ");
+  if (!((e = nt) != null && e.has(o))) {
+    var i;
+    (i = nt) == null || i.add(o), console.warn(o);
+  }
+}
+function qo() {
+  for (var e, t = arguments.length, n = new Array(t), r = 0; r < t; r++)
+    n[r] = arguments[r];
+  const o = "Floating UI: " + n.join(" ");
+  if (!((e = nt) != null && e.has(o))) {
+    var i;
+    (i = nt) == null || i.add(o), console.error(o);
+  }
+}
+const As = /* @__PURE__ */ g.forwardRef(function(t, n) {
+  const {
+    context: {
+      placement: r,
+      elements: {
+        floating: o
+      },
+      middlewareData: {
+        arrow: i,
+        shift: s
+      }
+    },
+    width: c = 14,
+    height: f = 7,
+    tipRadius: u = 0,
+    strokeWidth: l = 0,
+    staticOffset: p,
+    stroke: d,
+    d: a,
+    style: {
+      transform: v,
+      ...m
+    } = {},
+    ...w
+  } = t;
+  process.env.NODE_ENV !== "production" && (n || yt("The `ref` prop is required for `FloatingArrow`."));
+  const R = ct(), [y, x] = g.useState(!1);
+  if (X(() => {
+    if (!o) return;
+    Ce(o).direction === "rtl" && x(!0);
+  }, [o]), !o)
+    return null;
+  const [E, A] = r.split("-"), O = E === "top" || E === "bottom";
+  let M = p;
+  (O && s != null && s.x || !O && s != null && s.y) && (M = null);
+  const S = l * 2, $ = S / 2, I = c / 2 * (u / -8 + 1), B = f / 2 * u / 4, W = !!a, L = M && A === "end" ? "bottom" : "top";
+  let h = M && A === "end" ? "right" : "left";
+  M && y && (h = A === "end" ? "left" : "right");
+  const C = i?.x != null ? M || i.x : "", D = i?.y != null ? M || i.y : "", T = a || "M0,0" + (" H" + c) + (" L" + (c - I) + "," + (f - B)) + (" Q" + c / 2 + "," + f + " " + I + "," + (f - B)) + " Z", b = {
+    top: W ? "rotate(180deg)" : "",
+    left: W ? "rotate(90deg)" : "rotate(-90deg)",
+    bottom: W ? "" : "rotate(180deg)",
+    right: W ? "rotate(-90deg)" : "rotate(90deg)"
+  }[E];
+  return /* @__PURE__ */ Zt("svg", {
+    ...w,
+    "aria-hidden": !0,
+    ref: n,
+    width: W ? c : c + S,
+    height: c,
+    viewBox: "0 0 " + c + " " + (f > c ? f : c),
+    style: {
+      position: "absolute",
+      pointerEvents: "none",
+      [h]: C,
+      [L]: D,
+      [E]: O || W ? "100%" : "calc(100% - " + S / 2 + "px)",
+      transform: [b, v].filter((P) => !!P).join(" "),
+      ...m
+    },
+    children: [S > 0 && /* @__PURE__ */ be("path", {
+      clipPath: "url(#" + R + ")",
+      fill: "none",
+      stroke: d,
+      strokeWidth: S + (a ? 0 : 1),
+      d: T
+    }), /* @__PURE__ */ be("path", {
+      stroke: S && !a ? w.fill : "none",
+      d: T
+    }), /* @__PURE__ */ be("clipPath", {
+      id: R,
+      children: /* @__PURE__ */ be("rect", {
+        x: -$,
+        y: $ * (W ? -1 : 1),
+        width: c + S,
+        height: c
+      })
+    })]
+  });
+});
+function br() {
+  const e = /* @__PURE__ */ new Map();
+  return {
+    emit(t, n) {
+      var r;
+      (r = e.get(t)) == null || r.forEach((o) => o(n));
+    },
+    on(t, n) {
+      e.has(t) || e.set(t, /* @__PURE__ */ new Set()), e.get(t).add(n);
+    },
+    off(t, n) {
+      var r;
+      (r = e.get(t)) == null || r.delete(n);
+    }
+  };
+}
+const yr = /* @__PURE__ */ g.createContext(null), wr = /* @__PURE__ */ g.createContext(null), Ge = () => {
+  var e;
+  return ((e = g.useContext(yr)) == null ? void 0 : e.id) || null;
+}, Ze = () => g.useContext(wr);
+function Ss(e) {
+  const t = ct(), n = Ze(), o = Ge();
+  return X(() => {
+    if (!t) return;
+    const i = {
+      id: t,
+      parentId: o
+    };
+    return n?.addNode(i), () => {
+      n?.removeNode(i);
+    };
+  }, [n, t, o]), t;
+}
+function Ls(e) {
+  const {
+    children: t,
+    id: n
+  } = e, r = Ge();
+  return /* @__PURE__ */ be(yr.Provider, {
+    value: g.useMemo(() => ({
+      id: n,
+      parentId: r
+    }), [n, r]),
+    children: t
+  });
+}
+function ks(e) {
+  const {
+    children: t
+  } = e, n = g.useRef([]), r = g.useCallback((s) => {
+    n.current = [...n.current, s];
+  }, []), o = g.useCallback((s) => {
+    n.current = n.current.filter((c) => c !== s);
+  }, []), [i] = g.useState(() => br());
+  return /* @__PURE__ */ be(wr.Provider, {
+    value: g.useMemo(() => ({
+      nodesRef: n,
+      addNode: r,
+      removeNode: o,
+      events: i
+    }), [r, o, i]),
+    children: t
+  });
+}
+function Ve(e) {
+  return "data-floating-ui-" + e;
+}
+function me(e) {
+  e.current !== -1 && (clearTimeout(e.current), e.current = -1);
+}
+const An = /* @__PURE__ */ Ve("safe-polygon");
+function Wt(e, t, n) {
+  if (n && !qe(n))
+    return 0;
+  if (typeof e == "number")
+    return e;
+  if (typeof e == "function") {
+    const r = e();
+    return typeof r == "number" ? r : r?.[t];
+  }
+  return e?.[t];
+}
+function $t(e) {
+  return typeof e == "function" ? e() : e;
+}
+function Ds(e, t) {
+  t === void 0 && (t = {});
+  const {
+    open: n,
+    onOpenChange: r,
+    dataRef: o,
+    events: i,
+    elements: s
+  } = e, {
+    enabled: c = !0,
+    delay: f = 0,
+    handleClose: u = null,
+    mouseOnly: l = !1,
+    restMs: p = 0,
+    move: d = !0
+  } = t, a = Ze(), v = Ge(), m = le(u), w = le(f), R = le(n), y = le(p), x = g.useRef(), E = g.useRef(-1), A = g.useRef(), O = g.useRef(-1), M = g.useRef(!0), S = g.useRef(!1), $ = g.useRef(() => {
+  }), I = g.useRef(!1), B = re(() => {
+    var T;
+    const b = (T = o.current.openEvent) == null ? void 0 : T.type;
+    return b?.includes("mouse") && b !== "mousedown";
+  });
+  g.useEffect(() => {
+    if (!c) return;
+    function T(b) {
+      let {
+        open: P
+      } = b;
+      P || (me(E), me(O), M.current = !0, I.current = !1);
+    }
+    return i.on("openchange", T), () => {
+      i.off("openchange", T);
+    };
+  }, [c, i]), g.useEffect(() => {
+    if (!c || !m.current || !n) return;
+    function T(P) {
+      B() && r(!1, P, "hover");
+    }
+    const b = pe(s.floating).documentElement;
+    return b.addEventListener("mouseleave", T), () => {
+      b.removeEventListener("mouseleave", T);
+    };
+  }, [s.floating, n, r, c, m, B]);
+  const W = g.useCallback(function(T, b, P) {
+    b === void 0 && (b = !0), P === void 0 && (P = "hover");
+    const k = Wt(w.current, "close", x.current);
+    k && !A.current ? (me(E), E.current = window.setTimeout(() => r(!1, T, P), k)) : b && (me(E), r(!1, T, P));
+  }, [w, r]), L = re(() => {
+    $.current(), A.current = void 0;
+  }), h = re(() => {
+    if (S.current) {
+      const T = pe(s.floating).body;
+      T.style.pointerEvents = "", T.removeAttribute(An), S.current = !1;
+    }
+  }), C = re(() => o.current.openEvent ? ["click", "mousedown"].includes(o.current.openEvent.type) : !1);
+  g.useEffect(() => {
+    if (!c) return;
+    function T(K) {
+      if (me(E), M.current = !1, l && !qe(x.current) || $t(y.current) > 0 && !Wt(w.current, "open"))
+        return;
+      const N = Wt(w.current, "open", x.current);
+      N ? E.current = window.setTimeout(() => {
+        R.current || r(!0, K, "hover");
+      }, N) : n || r(!0, K, "hover");
+    }
+    function b(K) {
+      if (C()) {
+        h();
+        return;
+      }
+      $.current();
+      const N = pe(s.floating);
+      if (me(O), I.current = !1, m.current && o.current.floatingContext) {
+        n || me(E), A.current = m.current({
+          ...o.current.floatingContext,
+          tree: a,
+          x: K.clientX,
+          y: K.clientY,
+          onClose() {
+            h(), L(), C() || W(K, !0, "safe-polygon");
+          }
+        });
+        const U = A.current;
+        N.addEventListener("mousemove", U), $.current = () => {
+          N.removeEventListener("mousemove", U);
+        };
+        return;
+      }
+      (x.current !== "touch" || !ue(s.floating, K.relatedTarget)) && W(K);
+    }
+    function P(K) {
+      C() || o.current.floatingContext && (m.current == null || m.current({
+        ...o.current.floatingContext,
+        tree: a,
+        x: K.clientX,
+        y: K.clientY,
+        onClose() {
+          h(), L(), C() || W(K);
+        }
+      })(K));
+    }
+    function k() {
+      me(E);
+    }
+    function G(K) {
+      C() || W(K, !1);
+    }
+    if (Z(s.domReference)) {
+      const K = s.domReference, N = s.floating;
+      return n && K.addEventListener("mouseleave", P), d && K.addEventListener("mousemove", T, {
+        once: !0
+      }), K.addEventListener("mouseenter", T), K.addEventListener("mouseleave", b), N && (N.addEventListener("mouseleave", P), N.addEventListener("mouseenter", k), N.addEventListener("mouseleave", G)), () => {
+        n && K.removeEventListener("mouseleave", P), d && K.removeEventListener("mousemove", T), K.removeEventListener("mouseenter", T), K.removeEventListener("mouseleave", b), N && (N.removeEventListener("mouseleave", P), N.removeEventListener("mouseenter", k), N.removeEventListener("mouseleave", G));
+      };
+    }
+  }, [s, c, e, l, d, W, L, h, r, n, R, a, w, m, o, C, y]), X(() => {
+    var T;
+    if (c && n && (T = m.current) != null && (T = T.__options) != null && T.blockPointerEvents && B()) {
+      S.current = !0;
+      const P = s.floating;
+      if (Z(s.domReference) && P) {
+        var b;
+        const k = pe(s.floating).body;
+        k.setAttribute(An, "");
+        const G = s.domReference, K = a == null || (b = a.nodesRef.current.find((N) => N.id === v)) == null || (b = b.context) == null ? void 0 : b.elements.floating;
+        return K && (K.style.pointerEvents = ""), k.style.pointerEvents = "none", G.style.pointerEvents = "auto", P.style.pointerEvents = "auto", () => {
+          k.style.pointerEvents = "", G.style.pointerEvents = "", P.style.pointerEvents = "";
+        };
+      }
+    }
+  }, [c, n, v, s, a, m, B]), X(() => {
+    n || (x.current = void 0, I.current = !1, L(), h());
+  }, [n, L, h]), g.useEffect(() => () => {
+    L(), me(E), me(O), h();
+  }, [c, s.domReference, L, h]);
+  const D = g.useMemo(() => {
+    function T(b) {
+      x.current = b.pointerType;
+    }
+    return {
+      onPointerDown: T,
+      onPointerEnter: T,
+      onMouseMove(b) {
+        const {
+          nativeEvent: P
+        } = b;
+        function k() {
+          !M.current && !R.current && r(!0, P, "hover");
+        }
+        l && !qe(x.current) || n || $t(y.current) === 0 || I.current && b.movementX ** 2 + b.movementY ** 2 < 2 || (me(O), x.current === "touch" ? k() : (I.current = !0, O.current = window.setTimeout(k, $t(y.current))));
+      }
+    };
+  }, [l, r, n, R, y]);
+  return g.useMemo(() => c ? {
+    reference: D
+  } : {}, [c, D]);
+}
+let Sn = 0;
+function _e(e, t) {
+  t === void 0 && (t = {});
+  const {
+    preventScroll: n = !1,
+    cancelPrevious: r = !0,
+    sync: o = !1
+  } = t;
+  r && cancelAnimationFrame(Sn);
+  const i = () => e?.focus({
+    preventScroll: n
+  });
+  o ? i() : Sn = requestAnimationFrame(i);
+}
+function Bt(e, t) {
+  if (!e || !t)
+    return !1;
+  const n = t.getRootNode == null ? void 0 : t.getRootNode();
+  if (e.contains(t))
+    return !0;
+  if (n && qn(n)) {
+    let r = t;
+    for (; r; ) {
+      if (e === r)
+        return !0;
+      r = r.parentNode || r.host;
+    }
+  }
+  return !1;
+}
+function Go(e) {
+  return "composedPath" in e ? e.composedPath()[0] : e.target;
+}
+function Zo(e) {
+  return e?.ownerDocument || document;
+}
+const ze = {
+  inert: /* @__PURE__ */ new WeakMap(),
+  "aria-hidden": /* @__PURE__ */ new WeakMap(),
+  none: /* @__PURE__ */ new WeakMap()
+};
+function Ln(e) {
+  return e === "inert" ? ze.inert : e === "aria-hidden" ? ze["aria-hidden"] : ze.none;
+}
+let mt = /* @__PURE__ */ new WeakSet(), gt = {}, Vt = 0;
+const Jo = () => typeof HTMLElement < "u" && "inert" in HTMLElement.prototype, xr = (e) => e && (e.host || xr(e.parentNode)), Qo = (e, t) => t.map((n) => {
+  if (e.contains(n))
+    return n;
+  const r = xr(n);
+  return e.contains(r) ? r : null;
+}).filter((n) => n != null);
+function es(e, t, n, r) {
+  const o = "data-floating-ui-inert", i = r ? "inert" : n ? "aria-hidden" : null, s = Qo(t, e), c = /* @__PURE__ */ new Set(), f = new Set(s), u = [];
+  gt[o] || (gt[o] = /* @__PURE__ */ new WeakMap());
+  const l = gt[o];
+  s.forEach(p), d(t), c.clear();
+  function p(a) {
+    !a || c.has(a) || (c.add(a), a.parentNode && p(a.parentNode));
+  }
+  function d(a) {
+    !a || f.has(a) || [].forEach.call(a.children, (v) => {
+      if (rt(v) !== "script")
+        if (c.has(v))
+          d(v);
+        else {
+          const m = i ? v.getAttribute(i) : null, w = m !== null && m !== "false", R = Ln(i), y = (R.get(v) || 0) + 1, x = (l.get(v) || 0) + 1;
+          R.set(v, y), l.set(v, x), u.push(v), y === 1 && w && mt.add(v), x === 1 && v.setAttribute(o, ""), !w && i && v.setAttribute(i, i === "inert" ? "" : "true");
+        }
+    });
+  }
+  return Vt++, () => {
+    u.forEach((a) => {
+      const v = Ln(i), w = (v.get(a) || 0) - 1, R = (l.get(a) || 0) - 1;
+      v.set(a, w), l.set(a, R), w || (!mt.has(a) && i && a.removeAttribute(i), mt.delete(a)), R || a.removeAttribute(o);
+    }), Vt--, Vt || (ze.inert = /* @__PURE__ */ new WeakMap(), ze["aria-hidden"] = /* @__PURE__ */ new WeakMap(), ze.none = /* @__PURE__ */ new WeakMap(), mt = /* @__PURE__ */ new WeakSet(), gt = {});
+  };
+}
+function kn(e, t, n) {
+  t === void 0 && (t = !1), n === void 0 && (n = !1);
+  const r = Zo(e[0]).body;
+  return es(e.concat(Array.from(r.querySelectorAll('[aria-live],[role="status"],output'))), r, t, n);
+}
+const on = {
+  border: 0,
+  clip: "rect(0 0 0 0)",
+  height: "1px",
+  margin: "-1px",
+  overflow: "hidden",
+  padding: 0,
+  position: "fixed",
+  whiteSpace: "nowrap",
+  width: "1px",
+  top: 0,
+  left: 0
+}, Ot = /* @__PURE__ */ g.forwardRef(function(t, n) {
+  const [r, o] = g.useState();
+  X(() => {
+    nr() && o("button");
+  }, []);
+  const i = {
+    ref: n,
+    tabIndex: 0,
+    // Role is only for VoiceOver
+    role: r,
+    "aria-hidden": r ? void 0 : !0,
+    [Ve("focus-guard")]: "",
+    style: on
+  };
+  return /* @__PURE__ */ be("span", {
+    ...t,
+    ...i
+  });
+}), ts = {
+  clipPath: "inset(50%)",
+  position: "fixed",
+  top: 0,
+  left: 0
+}, Rr = /* @__PURE__ */ g.createContext(null), Dn = /* @__PURE__ */ Ve("portal");
+function ns(e) {
+  e === void 0 && (e = {});
+  const {
+    id: t,
+    root: n
+  } = e, r = ct(), o = Er(), [i, s] = g.useState(null), c = g.useRef(null);
+  return X(() => () => {
+    i?.remove(), queueMicrotask(() => {
+      c.current = null;
+    });
+  }, [i]), X(() => {
+    if (!r || c.current) return;
+    const f = t ? document.getElementById(t) : null;
+    if (!f) return;
+    const u = document.createElement("div");
+    u.id = r, u.setAttribute(Dn, ""), f.appendChild(u), c.current = u, s(u);
+  }, [t, r]), X(() => {
+    if (n === null || !r || c.current) return;
+    let f = n || o?.portalNode;
+    f && !Pr(f) && (f = f.current), f = f || document.body;
+    let u = null;
+    t && (u = document.createElement("div"), u.id = t, f.appendChild(u));
+    const l = document.createElement("div");
+    l.id = r, l.setAttribute(Dn, ""), f = u || f, f.appendChild(l), c.current = l, s(l);
+  }, [t, n, r, o]), i;
+}
+function Fs(e) {
+  const {
+    children: t,
+    id: n,
+    root: r,
+    preserveTabOrder: o = !0
+  } = e, i = ns({
+    id: n,
+    root: r
+  }), [s, c] = g.useState(null), f = g.useRef(null), u = g.useRef(null), l = g.useRef(null), p = g.useRef(null), d = s?.modal, a = s?.open, v = (
+    // The FocusManager and therefore floating element are currently open/
+    // rendered.
+    !!s && // Guards are only for non-modal focus management.
+    !s.modal && // Don't render if unmount is transitioning.
+    s.open && o && !!(r || i)
+  );
+  return g.useEffect(() => {
+    if (!i || !o || d)
+      return;
+    function m(w) {
+      i && tt(w) && (w.type === "focusin" ? yn : oo)(i);
+    }
+    return i.addEventListener("focusin", m, !0), i.addEventListener("focusout", m, !0), () => {
+      i.removeEventListener("focusin", m, !0), i.removeEventListener("focusout", m, !0);
+    };
+  }, [i, o, d]), g.useEffect(() => {
+    i && (a || yn(i));
+  }, [a, i]), /* @__PURE__ */ Zt(Rr.Provider, {
+    value: g.useMemo(() => ({
+      preserveTabOrder: o,
+      beforeOutsideRef: f,
+      afterOutsideRef: u,
+      beforeInsideRef: l,
+      afterInsideRef: p,
+      portalNode: i,
+      setFocusManagerState: c
+    }), [o, i]),
+    children: [v && i && /* @__PURE__ */ be(Ot, {
+      "data-type": "outside",
+      ref: f,
+      onFocus: (m) => {
+        if (tt(m, i)) {
+          var w;
+          (w = l.current) == null || w.focus();
+        } else {
+          const R = s ? s.domReference : null, y = ur(R);
+          y?.focus();
+        }
+      }
+    }), v && i && /* @__PURE__ */ be("span", {
+      "aria-owns": i.id,
+      style: ts
+    }), i && /* @__PURE__ */ Jt.createPortal(t, i), v && i && /* @__PURE__ */ be(Ot, {
+      "data-type": "outside",
+      ref: u,
+      onFocus: (m) => {
+        if (tt(m, i)) {
+          var w;
+          (w = p.current) == null || w.focus();
+        } else {
+          const R = s ? s.domReference : null, y = cr(R);
+          y?.focus(), s?.closeOnFocusOut && s?.onOpenChange(!1, m.nativeEvent, "focus-out");
+        }
+      }
+    })]
+  });
+}
+const Er = () => g.useContext(Rr);
+function Fn(e) {
+  return g.useMemo(() => (t) => {
+    e.forEach((n) => {
+      n && (n.current = t);
+    });
+  }, e);
+}
+const rs = 20;
+let De = [];
+function sn() {
+  De = De.filter((e) => {
+    var t;
+    return (t = e.deref()) == null ? void 0 : t.isConnected;
+  });
+}
+function os(e) {
+  sn(), e && rt(e) !== "body" && (De.push(new WeakRef(e)), De.length > rs && (De = De.slice(-20)));
+}
+function Nn() {
+  sn();
+  const e = De[De.length - 1];
+  return e?.deref();
+}
+function ss(e) {
+  const t = ot();
+  return Zn(e, t) ? e : It(e, t)[0] || e;
+}
+function _n(e, t) {
+  var n;
+  if (!t.current.includes("floating") && !((n = e.getAttribute("role")) != null && n.includes("dialog")))
+    return;
+  const r = ot(), i = Mr(e, r).filter((c) => {
+    const f = c.getAttribute("data-tabindex") || "";
+    return Zn(c, r) || c.hasAttribute("data-tabindex") && !f.startsWith("-");
+  }), s = e.getAttribute("tabindex");
+  t.current.includes("floating") || i.length === 0 ? s !== "0" && e.setAttribute("tabindex", "0") : (s !== "-1" || e.hasAttribute("data-tabindex") && e.getAttribute("data-tabindex") !== "-1") && (e.setAttribute("tabindex", "-1"), e.setAttribute("data-tabindex", "-1"));
+}
+const is = /* @__PURE__ */ g.forwardRef(function(t, n) {
+  return /* @__PURE__ */ be("button", {
+    ...t,
+    type: "button",
+    ref: n,
+    tabIndex: -1,
+    style: on
+  });
+});
+function Ns(e) {
+  const {
+    context: t,
+    children: n,
+    disabled: r = !1,
+    order: o = ["content"],
+    guards: i = !0,
+    initialFocus: s = 0,
+    returnFocus: c = !0,
+    restoreFocus: f = !1,
+    modal: u = !0,
+    visuallyHiddenDismiss: l = !1,
+    closeOnFocusOut: p = !0,
+    outsideElementsInert: d = !1,
+    getInsideElements: a = () => []
+  } = e, {
+    open: v,
+    onOpenChange: m,
+    events: w,
+    dataRef: R,
+    elements: {
+      domReference: y,
+      floating: x
+    }
+  } = t, E = re(() => {
+    var V;
+    return (V = R.current.floatingContext) == null ? void 0 : V.nodeId;
+  }), A = re(a), O = typeof s == "number" && s < 0, M = zt(y) && O, S = Jo(), $ = S ? i : !0, I = !$ || S && d, B = le(o), W = le(s), L = le(c), h = Ze(), C = Er(), D = g.useRef(null), T = g.useRef(null), b = g.useRef(!1), P = g.useRef(!1), k = g.useRef(-1), G = g.useRef(-1), K = C != null, N = Ct(x), J = re(function(V) {
+    return V === void 0 && (V = N), V ? It(V, ot()) : [];
+  }), U = re((V) => {
+    const Y = J(V);
+    return B.current.map((H) => y && H === "reference" ? y : N && H === "floating" ? N : Y).filter(Boolean).flat();
+  });
+  g.useEffect(() => {
+    if (r || !u) return;
+    function V(H) {
+      if (H.key === "Tab") {
+        ue(N, Oe(pe(N))) && J().length === 0 && !M && ge(H);
+        const Q = U(), oe = Ie(H);
+        B.current[0] === "reference" && oe === y && (ge(H), H.shiftKey ? _e(Q[Q.length - 1]) : _e(Q[1])), B.current[1] === "floating" && oe === N && H.shiftKey && (ge(H), _e(Q[0]));
+      }
+    }
+    const Y = pe(N);
+    return Y.addEventListener("keydown", V), () => {
+      Y.removeEventListener("keydown", V);
+    };
+  }, [r, y, N, u, B, M, J, U]), g.useEffect(() => {
+    if (r || !x) return;
+    function V(Y) {
+      const H = Ie(Y), oe = J().indexOf(H);
+      oe !== -1 && (k.current = oe);
+    }
+    return x.addEventListener("focusin", V), () => {
+      x.removeEventListener("focusin", V);
+    };
+  }, [r, x, J]), g.useEffect(() => {
+    if (r || !p) return;
+    function V() {
+      P.current = !0, setTimeout(() => {
+        P.current = !1;
+      });
+    }
+    function Y(oe) {
+      const z = oe.relatedTarget, ye = oe.currentTarget, de = Ie(oe);
+      queueMicrotask(() => {
+        const he = E(), Te = !(ue(y, z) || ue(x, z) || ue(z, x) || ue(C?.portalNode, z) || z != null && z.hasAttribute(Ve("focus-guard")) || h && ($e(h.nodesRef.current, he).find((_) => {
+          var j, F;
+          return ue((j = _.context) == null ? void 0 : j.elements.floating, z) || ue((F = _.context) == null ? void 0 : F.elements.domReference, z);
+        }) || vn(h.nodesRef.current, he).find((_) => {
+          var j, F, q;
+          return [(j = _.context) == null ? void 0 : j.elements.floating, Ct((F = _.context) == null ? void 0 : F.elements.floating)].includes(z) || ((q = _.context) == null ? void 0 : q.elements.domReference) === z;
+        })));
+        if (ye === y && N && _n(N, B), f && ye !== y && !(de != null && de.isConnected) && Oe(pe(N)) === pe(N).body) {
+          ce(N) && N.focus();
+          const _ = k.current, j = J(), F = j[_] || j[j.length - 1] || N;
+          ce(F) && F.focus();
+        }
+        if (R.current.insideReactTree) {
+          R.current.insideReactTree = !1;
+          return;
+        }
+        (M || !u) && z && Te && !P.current && // Fix React 18 Strict Mode returnFocus due to double rendering.
+        z !== Nn() && (b.current = !0, m(!1, oe, "focus-out"));
+      });
+    }
+    const H = !!(!h && C);
+    function Q() {
+      me(G), R.current.insideReactTree = !0, G.current = window.setTimeout(() => {
+        R.current.insideReactTree = !1;
+      });
+    }
+    if (x && ce(y))
+      return y.addEventListener("focusout", Y), y.addEventListener("pointerdown", V), x.addEventListener("focusout", Y), H && x.addEventListener("focusout", Q, !0), () => {
+        y.removeEventListener("focusout", Y), y.removeEventListener("pointerdown", V), x.removeEventListener("focusout", Y), H && x.removeEventListener("focusout", Q, !0);
+      };
+  }, [r, y, x, N, u, h, C, m, p, f, J, M, E, B, R]);
+  const se = g.useRef(null), ae = g.useRef(null), te = Fn([se, C?.beforeInsideRef]), ne = Fn([ae, C?.afterInsideRef]);
+  g.useEffect(() => {
+    var V, Y;
+    if (r || !x) return;
+    const H = Array.from((C == null || (V = C.portalNode) == null ? void 0 : V.querySelectorAll("[" + Ve("portal") + "]")) || []), oe = (Y = (h ? vn(h.nodesRef.current, E()) : []).find((de) => {
+      var he;
+      return zt(((he = de.context) == null ? void 0 : he.elements.domReference) || null);
+    })) == null || (Y = Y.context) == null ? void 0 : Y.elements.domReference, z = [x, oe, ...H, ...A(), D.current, T.current, se.current, ae.current, C?.beforeOutsideRef.current, C?.afterOutsideRef.current, B.current.includes("reference") || M ? y : null].filter((de) => de != null), ye = u || M ? kn(z, !I, I) : kn(z);
+    return () => {
+      ye();
+    };
+  }, [r, y, x, u, B, C, M, $, I, h, E, A]), X(() => {
+    if (r || !ce(N)) return;
+    const V = pe(N), Y = Oe(V);
+    queueMicrotask(() => {
+      const H = U(N), Q = W.current, oe = (typeof Q == "number" ? H[Q] : Q.current) || N, z = ue(N, Y);
+      !O && !z && v && _e(oe, {
+        preventScroll: oe === N
+      });
+    });
+  }, [r, v, N, O, U, W]), X(() => {
+    if (r || !N) return;
+    const V = pe(N), Y = Oe(V);
+    os(Y);
+    function H(z) {
+      let {
+        reason: ye,
+        event: de,
+        nested: he
+      } = z;
+      if (["hover", "safe-polygon"].includes(ye) && de.type === "mouseleave" && (b.current = !0), ye === "outside-press")
+        if (he)
+          b.current = !1;
+        else if (or(de) || sr(de))
+          b.current = !1;
+        else {
+          let Te = !1;
+          document.createElement("div").focus({
+            get preventScroll() {
+              return Te = !0, !1;
+            }
+          }), Te ? b.current = !1 : b.current = !0;
+        }
+    }
+    w.on("openchange", H);
+    const Q = V.createElement("span");
+    Q.setAttribute("tabindex", "-1"), Q.setAttribute("aria-hidden", "true"), Object.assign(Q.style, on), K && y && y.insertAdjacentElement("afterend", Q);
+    function oe() {
+      if (typeof L.current == "boolean") {
+        const z = y || Nn();
+        return z && z.isConnected ? z : Q;
+      }
+      return L.current.current || Q;
+    }
+    return () => {
+      w.off("openchange", H);
+      const z = Oe(V), ye = ue(x, z) || h && $e(h.nodesRef.current, E(), !1).some((he) => {
+        var Te;
+        return ue((Te = he.context) == null ? void 0 : Te.elements.floating, z);
+      }), de = oe();
+      queueMicrotask(() => {
+        const he = ss(de);
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+        L.current && !b.current && ce(he) && // If the focus moved somewhere else after mount, avoid returning focus
+        // since it likely entered a different element which should be
+        // respected: https://github.com/floating-ui/floating-ui/issues/2607
+        (!(he !== z && z !== V.body) || ye) && he.focus({
+          preventScroll: !0
+        }), Q.remove();
+      });
+    };
+  }, [r, x, N, L, R, w, h, K, y, E]), g.useEffect(() => (queueMicrotask(() => {
+    b.current = !1;
+  }), () => {
+    queueMicrotask(sn);
+  }), [r]), X(() => {
+    if (!r && C)
+      return C.setFocusManagerState({
+        modal: u,
+        closeOnFocusOut: p,
+        open: v,
+        onOpenChange: m,
+        domReference: y
+      }), () => {
+        C.setFocusManagerState(null);
+      };
+  }, [r, C, u, v, m, p, y]), X(() => {
+    r || N && _n(N, B);
+  }, [r, N, B]);
+  function fe(V) {
+    return r || !l || !u ? null : /* @__PURE__ */ be(is, {
+      ref: V === "start" ? D : T,
+      onClick: (Y) => m(!1, Y.nativeEvent),
+      children: typeof l == "string" ? l : "Dismiss"
+    });
+  }
+  const we = !r && $ && (u ? !M : !0) && (K || u);
+  return /* @__PURE__ */ Zt(Ar, {
+    children: [we && /* @__PURE__ */ be(Ot, {
+      "data-type": "inside",
+      ref: te,
+      onFocus: (V) => {
+        if (u) {
+          const H = U();
+          _e(o[0] === "reference" ? H[0] : H[H.length - 1]);
+        } else if (C != null && C.preserveTabOrder && C.portalNode)
+          if (b.current = !1, tt(V, C.portalNode)) {
+            const H = cr(y);
+            H?.focus();
+          } else {
+            var Y;
+            (Y = C.beforeOutsideRef.current) == null || Y.focus();
+          }
+      }
+    }), !M && fe("start"), n, fe("end"), we && /* @__PURE__ */ be(Ot, {
+      "data-type": "inside",
+      ref: ne,
+      onFocus: (V) => {
+        if (u)
+          _e(U()[0]);
+        else if (C != null && C.preserveTabOrder && C.portalNode)
+          if (p && (b.current = !0), tt(V, C.portalNode)) {
+            const H = ur(y);
+            H?.focus();
+          } else {
+            var Y;
+            (Y = C.afterOutsideRef.current) == null || Y.focus();
+          }
+      }
+    })]
+  });
+}
+let pt = 0;
+const Wn = "--floating-ui-scrollbar-width";
+function cs() {
+  const e = tn(), t = /iP(hone|ad|od)|iOS/.test(e) || // iPads can claim to be MacIntel
+  e === "MacIntel" && navigator.maxTouchPoints > 1, n = document.body.style, o = Math.round(document.documentElement.getBoundingClientRect().left) + document.documentElement.scrollLeft ? "paddingLeft" : "paddingRight", i = window.innerWidth - document.documentElement.clientWidth, s = n.left ? parseFloat(n.left) : window.scrollX, c = n.top ? parseFloat(n.top) : window.scrollY;
+  if (n.overflow = "hidden", n.setProperty(Wn, i + "px"), i && (n[o] = i + "px"), t) {
+    var f, u;
+    const l = ((f = window.visualViewport) == null ? void 0 : f.offsetLeft) || 0, p = ((u = window.visualViewport) == null ? void 0 : u.offsetTop) || 0;
+    Object.assign(n, {
+      position: "fixed",
+      top: -(c - Math.floor(p)) + "px",
+      left: -(s - Math.floor(l)) + "px",
+      right: "0"
+    });
+  }
+  return () => {
+    Object.assign(n, {
+      overflow: "",
+      [o]: ""
+    }), n.removeProperty(Wn), t && (Object.assign(n, {
+      position: "",
+      top: "",
+      left: "",
+      right: ""
+    }), window.scrollTo(s, c));
+  };
+}
+let $n = () => {
+};
+const _s = /* @__PURE__ */ g.forwardRef(function(t, n) {
+  const {
+    lockScroll: r = !1,
+    ...o
+  } = t;
+  return X(() => {
+    if (r)
+      return pt++, pt === 1 && ($n = cs()), () => {
+        pt--, pt === 0 && $n();
+      };
+  }, [r]), /* @__PURE__ */ be("div", {
+    ref: n,
+    ...o,
+    style: {
+      position: "fixed",
+      overflow: "auto",
+      top: 0,
+      right: 0,
+      bottom: 0,
+      left: 0,
+      ...o.style
+    }
+  });
+});
+function Bn(e) {
+  return ce(e.target) && e.target.tagName === "BUTTON";
+}
+function us(e) {
+  return ce(e.target) && e.target.tagName === "A";
+}
+function Vn(e) {
+  return nn(e);
+}
+function Ws(e, t) {
+  t === void 0 && (t = {});
+  const {
+    open: n,
+    onOpenChange: r,
+    dataRef: o,
+    elements: {
+      domReference: i
+    }
+  } = e, {
+    enabled: s = !0,
+    event: c = "click",
+    toggle: f = !0,
+    ignoreMouse: u = !1,
+    keyboardHandlers: l = !0,
+    stickIfOpen: p = !0
+  } = t, d = g.useRef(), a = g.useRef(!1), v = g.useMemo(() => ({
+    onPointerDown(m) {
+      d.current = m.pointerType;
+    },
+    onMouseDown(m) {
+      const w = d.current;
+      m.button === 0 && c !== "click" && (qe(w, !0) && u || (n && f && (!(o.current.openEvent && p) || o.current.openEvent.type === "mousedown") ? r(!1, m.nativeEvent, "click") : (m.preventDefault(), r(!0, m.nativeEvent, "click"))));
+    },
+    onClick(m) {
+      const w = d.current;
+      if (c === "mousedown" && d.current) {
+        d.current = void 0;
+        return;
+      }
+      qe(w, !0) && u || (n && f && (!(o.current.openEvent && p) || o.current.openEvent.type === "click") ? r(!1, m.nativeEvent, "click") : r(!0, m.nativeEvent, "click"));
+    },
+    onKeyDown(m) {
+      d.current = void 0, !(m.defaultPrevented || !l || Bn(m)) && (m.key === " " && !Vn(i) && (m.preventDefault(), a.current = !0), !us(m) && m.key === "Enter" && r(!(n && f), m.nativeEvent, "click"));
+    },
+    onKeyUp(m) {
+      m.defaultPrevented || !l || Bn(m) || Vn(i) || m.key === " " && a.current && (a.current = !1, r(!(n && f), m.nativeEvent, "click"));
+    }
+  }), [o, i, c, u, l, r, n, p, f]);
+  return g.useMemo(() => s ? {
+    reference: v
+  } : {}, [s, v]);
+}
+function ls(e, t) {
+  let n = null, r = null, o = !1;
+  return {
+    contextElement: e || void 0,
+    getBoundingClientRect() {
+      var i;
+      const s = e?.getBoundingClientRect() || {
+        width: 0,
+        height: 0,
+        x: 0,
+        y: 0
+      }, c = t.axis === "x" || t.axis === "both", f = t.axis === "y" || t.axis === "both", u = ["mouseenter", "mousemove"].includes(((i = t.dataRef.current.openEvent) == null ? void 0 : i.type) || "") && t.pointerType !== "touch";
+      let l = s.width, p = s.height, d = s.x, a = s.y;
+      return n == null && t.x && c && (n = s.x - t.x), r == null && t.y && f && (r = s.y - t.y), d -= n || 0, a -= r || 0, l = 0, p = 0, !o || u ? (l = t.axis === "y" ? s.width : 0, p = t.axis === "x" ? s.height : 0, d = c && t.x != null ? t.x : d, a = f && t.y != null ? t.y : a) : o && !u && (p = t.axis === "x" ? s.height : p, l = t.axis === "y" ? s.width : l), o = !0, {
+        width: l,
+        height: p,
+        x: d,
+        y: a,
+        top: a,
+        right: d + l,
+        bottom: a + p,
+        left: d
+      };
+    }
+  };
+}
+function Kn(e) {
+  return e != null && e.clientX != null;
+}
+function $s(e, t) {
+  t === void 0 && (t = {});
+  const {
+    open: n,
+    dataRef: r,
+    elements: {
+      floating: o,
+      domReference: i
+    },
+    refs: s
+  } = e, {
+    enabled: c = !0,
+    axis: f = "both",
+    x: u = null,
+    y: l = null
+  } = t, p = g.useRef(!1), d = g.useRef(null), [a, v] = g.useState(), [m, w] = g.useState([]), R = re((O, M) => {
+    p.current || r.current.openEvent && !Kn(r.current.openEvent) || s.setPositionReference(ls(i, {
+      x: O,
+      y: M,
+      axis: f,
+      dataRef: r,
+      pointerType: a
+    }));
+  }), y = re((O) => {
+    u != null || l != null || (n ? d.current || w([]) : R(O.clientX, O.clientY));
+  }), x = qe(a) ? o : n, E = g.useCallback(() => {
+    if (!x || !c || u != null || l != null) return;
+    const O = Se(o);
+    function M(S) {
+      const $ = Ie(S);
+      ue(o, $) ? (O.removeEventListener("mousemove", M), d.current = null) : R(S.clientX, S.clientY);
+    }
+    if (!r.current.openEvent || Kn(r.current.openEvent)) {
+      O.addEventListener("mousemove", M);
+      const S = () => {
+        O.removeEventListener("mousemove", M), d.current = null;
+      };
+      return d.current = S, S;
+    }
+    s.setPositionReference(i);
+  }, [x, c, u, l, o, r, s, i, R]);
+  g.useEffect(() => E(), [E, m]), g.useEffect(() => {
+    c && !o && (p.current = !1);
+  }, [c, o]), g.useEffect(() => {
+    !c && n && (p.current = !0);
+  }, [c, n]), X(() => {
+    c && (u != null || l != null) && (p.current = !1, R(u, l));
+  }, [c, u, l, R]);
+  const A = g.useMemo(() => {
+    function O(M) {
+      let {
+        pointerType: S
+      } = M;
+      v(S);
+    }
+    return {
+      onPointerDown: O,
+      onPointerEnter: O,
+      onMouseMove: y,
+      onMouseEnter: y
+    };
+  }, [y]);
+  return g.useMemo(() => c ? {
+    reference: A
+  } : {}, [c, A]);
+}
+const as = {
+  pointerdown: "onPointerDown",
+  mousedown: "onMouseDown",
+  click: "onClick"
+}, fs = {
+  pointerdown: "onPointerDownCapture",
+  mousedown: "onMouseDownCapture",
+  click: "onClickCapture"
+}, Hn = (e) => {
+  var t, n;
+  return {
+    escapeKey: typeof e == "boolean" ? e : (t = e?.escapeKey) != null ? t : !1,
+    outsidePress: typeof e == "boolean" ? e : (n = e?.outsidePress) != null ? n : !0
+  };
+};
+function Bs(e, t) {
+  t === void 0 && (t = {});
+  const {
+    open: n,
+    onOpenChange: r,
+    elements: o,
+    dataRef: i
+  } = e, {
+    enabled: s = !0,
+    escapeKey: c = !0,
+    outsidePress: f = !0,
+    outsidePressEvent: u = "pointerdown",
+    referencePress: l = !1,
+    referencePressEvent: p = "pointerdown",
+    ancestorScroll: d = !1,
+    bubbles: a,
+    capture: v
+  } = t, m = Ze(), w = re(typeof f == "function" ? f : () => !1), R = typeof f == "function" ? w : f, y = g.useRef(!1), {
+    escapeKey: x,
+    outsidePress: E
+  } = Hn(a), {
+    escapeKey: A,
+    outsidePress: O
+  } = Hn(v), M = g.useRef(!1), S = re((h) => {
+    var C;
+    if (!n || !s || !c || h.key !== "Escape" || M.current)
+      return;
+    const D = (C = i.current.floatingContext) == null ? void 0 : C.nodeId, T = m ? $e(m.nodesRef.current, D) : [];
+    if (!x && (h.stopPropagation(), T.length > 0)) {
+      let b = !0;
+      if (T.forEach((P) => {
+        var k;
+        if ((k = P.context) != null && k.open && !P.context.dataRef.current.__escapeKeyBubbles) {
+          b = !1;
+          return;
+        }
+      }), !b)
+        return;
+    }
+    r(!1, Xr(h) ? h.nativeEvent : h, "escape-key");
+  }), $ = re((h) => {
+    var C;
+    const D = () => {
+      var T;
+      S(h), (T = Ie(h)) == null || T.removeEventListener("keydown", D);
+    };
+    (C = Ie(h)) == null || C.addEventListener("keydown", D);
+  }), I = re((h) => {
+    var C;
+    const D = i.current.insideReactTree;
+    i.current.insideReactTree = !1;
+    const T = y.current;
+    if (y.current = !1, u === "click" && T || D || typeof R == "function" && !R(h))
+      return;
+    const b = Ie(h), P = "[" + Ve("inert") + "]", k = pe(o.floating).querySelectorAll(P);
+    let G = Z(b) ? b : null;
+    for (; G && !We(G); ) {
+      const U = Xe(G);
+      if (We(U) || !Z(U))
+        break;
+      G = U;
+    }
+    if (k.length && Z(b) && !Ur(b) && // Clicked on a direct ancestor (e.g. FloatingOverlay).
+    !ue(b, o.floating) && // If the target root element contains none of the markers, then the
+    // element was injected after the floating element rendered.
+    Array.from(k).every((U) => !ue(G, U)))
+      return;
+    if (ce(b) && L) {
+      const U = We(b), se = Ce(b), ae = /auto|scroll/, te = U || ae.test(se.overflowX), ne = U || ae.test(se.overflowY), fe = te && b.clientWidth > 0 && b.scrollWidth > b.clientWidth, we = ne && b.clientHeight > 0 && b.scrollHeight > b.clientHeight, V = se.direction === "rtl", Y = we && (V ? h.offsetX <= b.offsetWidth - b.clientWidth : h.offsetX > b.clientWidth), H = fe && h.offsetY > b.clientHeight;
+      if (Y || H)
+        return;
+    }
+    const K = (C = i.current.floatingContext) == null ? void 0 : C.nodeId, N = m && $e(m.nodesRef.current, K).some((U) => {
+      var se;
+      return Dt(h, (se = U.context) == null ? void 0 : se.elements.floating);
+    });
+    if (Dt(h, o.floating) || Dt(h, o.domReference) || N)
+      return;
+    const J = m ? $e(m.nodesRef.current, K) : [];
+    if (J.length > 0) {
+      let U = !0;
+      if (J.forEach((se) => {
+        var ae;
+        if ((ae = se.context) != null && ae.open && !se.context.dataRef.current.__outsidePressBubbles) {
+          U = !1;
+          return;
+        }
+      }), !U)
+        return;
+    }
+    r(!1, h, "outside-press");
+  }), B = re((h) => {
+    var C;
+    const D = () => {
+      var T;
+      I(h), (T = Ie(h)) == null || T.removeEventListener(u, D);
+    };
+    (C = Ie(h)) == null || C.addEventListener(u, D);
+  });
+  g.useEffect(() => {
+    if (!n || !s)
+      return;
+    i.current.__escapeKeyBubbles = x, i.current.__outsidePressBubbles = E;
+    let h = -1;
+    function C(k) {
+      r(!1, k, "ancestor-scroll");
+    }
+    function D() {
+      window.clearTimeout(h), M.current = !0;
+    }
+    function T() {
+      h = window.setTimeout(
+        () => {
+          M.current = !1;
+        },
+        // 0ms or 1ms don't work in Safari. 5ms appears to consistently work.
+        // Only apply to WebKit for the test to remain 0ms.
+        Gt() ? 5 : 0
+      );
+    }
+    const b = pe(o.floating);
+    c && (b.addEventListener("keydown", A ? $ : S, A), b.addEventListener("compositionstart", D), b.addEventListener("compositionend", T)), R && b.addEventListener(u, O ? B : I, O);
+    let P = [];
+    return d && (Z(o.domReference) && (P = Ue(o.domReference)), Z(o.floating) && (P = P.concat(Ue(o.floating))), !Z(o.reference) && o.reference && o.reference.contextElement && (P = P.concat(Ue(o.reference.contextElement)))), P = P.filter((k) => {
+      var G;
+      return k !== ((G = b.defaultView) == null ? void 0 : G.visualViewport);
+    }), P.forEach((k) => {
+      k.addEventListener("scroll", C, {
+        passive: !0
+      });
+    }), () => {
+      c && (b.removeEventListener("keydown", A ? $ : S, A), b.removeEventListener("compositionstart", D), b.removeEventListener("compositionend", T)), R && b.removeEventListener(u, O ? B : I, O), P.forEach((k) => {
+        k.removeEventListener("scroll", C);
+      }), window.clearTimeout(h);
+    };
+  }, [i, o, c, R, u, n, r, d, s, x, E, S, A, $, I, O, B]), g.useEffect(() => {
+    i.current.insideReactTree = !1;
+  }, [i, R, u]);
+  const W = g.useMemo(() => ({
+    onKeyDown: S,
+    ...l && {
+      [as[p]]: (h) => {
+        r(!1, h.nativeEvent, "reference-press");
+      },
+      ...p !== "click" && {
+        onClick(h) {
+          r(!1, h.nativeEvent, "reference-press");
+        }
+      }
+    }
+  }), [S, r, l, p]), L = g.useMemo(() => ({
+    onKeyDown: S,
+    onMouseDown() {
+      y.current = !0;
+    },
+    onMouseUp() {
+      y.current = !0;
+    },
+    [fs[u]]: () => {
+      i.current.insideReactTree = !0;
+    }
+  }), [S, u, i]);
+  return g.useMemo(() => s ? {
+    reference: W,
+    floating: L
+  } : {}, [s, W, L]);
+}
+function ds(e) {
+  const {
+    open: t = !1,
+    onOpenChange: n,
+    elements: r
+  } = e, o = ct(), i = g.useRef({}), [s] = g.useState(() => br()), c = Ge() != null;
+  if (process.env.NODE_ENV !== "production") {
+    const a = r.reference;
+    a && !Z(a) && qo("Cannot pass a virtual element to the `elements.reference` option,", "as it must be a real DOM element. Use `refs.setPositionReference()`", "instead.");
+  }
+  const [f, u] = g.useState(r.reference), l = re((a, v, m) => {
+    i.current.openEvent = a ? v : void 0, s.emit("openchange", {
+      open: a,
+      event: v,
+      reason: m,
+      nested: c
+    }), n?.(a, v, m);
+  }), p = g.useMemo(() => ({
+    setPositionReference: u
+  }), []), d = g.useMemo(() => ({
+    reference: f || r.reference || null,
+    floating: r.floating || null,
+    domReference: r.reference
+  }), [f, r.reference, r.floating]);
+  return g.useMemo(() => ({
+    dataRef: i,
+    open: t,
+    onOpenChange: l,
+    elements: d,
+    events: s,
+    floatingId: o,
+    refs: p
+  }), [t, l, d, s, o, p]);
+}
+function Vs(e) {
+  e === void 0 && (e = {});
+  const {
+    nodeId: t
+  } = e, n = ds({
+    ...e,
+    elements: {
+      reference: null,
+      floating: null,
+      ...e.elements
+    }
+  }), r = e.rootContext || n, o = r.elements, [i, s] = g.useState(null), [c, f] = g.useState(null), l = o?.domReference || i, p = g.useRef(null), d = Ze();
+  X(() => {
+    l && (p.current = l);
+  }, [l]);
+  const a = Vo({
+    ...e,
+    elements: {
+      ...o,
+      ...c && {
+        reference: c
+      }
+    }
+  }), v = g.useCallback((x) => {
+    const E = Z(x) ? {
+      getBoundingClientRect: () => x.getBoundingClientRect(),
+      getClientRects: () => x.getClientRects(),
+      contextElement: x
+    } : x;
+    f(E), a.refs.setReference(E);
+  }, [a.refs]), m = g.useCallback((x) => {
+    (Z(x) || x === null) && (p.current = x, s(x)), (Z(a.refs.reference.current) || a.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.
+    x !== null && !Z(x)) && a.refs.setReference(x);
+  }, [a.refs]), w = g.useMemo(() => ({
+    ...a.refs,
+    setReference: m,
+    setPositionReference: v,
+    domReference: p
+  }), [a.refs, m, v]), R = g.useMemo(() => ({
+    ...a.elements,
+    domReference: l
+  }), [a.elements, l]), y = g.useMemo(() => ({
+    ...a,
+    ...r,
+    refs: w,
+    elements: R,
+    nodeId: t
+  }), [a, w, R, t, r]);
+  return X(() => {
+    r.dataRef.current.floatingContext = y;
+    const x = d?.nodesRef.current.find((E) => E.id === t);
+    x && (x.context = y);
+  }), g.useMemo(() => ({
+    ...a,
+    context: y,
+    refs: w,
+    elements: R
+  }), [a, w, R, y]);
+}
+function Kt() {
+  return Vr() && nr();
+}
+function Ks(e, t) {
+  t === void 0 && (t = {});
+  const {
+    open: n,
+    onOpenChange: r,
+    events: o,
+    dataRef: i,
+    elements: s
+  } = e, {
+    enabled: c = !0,
+    visibleOnly: f = !0
+  } = t, u = g.useRef(!1), l = g.useRef(-1), p = g.useRef(!0);
+  g.useEffect(() => {
+    if (!c) return;
+    const a = Se(s.domReference);
+    function v() {
+      !n && ce(s.domReference) && s.domReference === Oe(pe(s.domReference)) && (u.current = !0);
+    }
+    function m() {
+      p.current = !0;
+    }
+    function w() {
+      p.current = !1;
+    }
+    return a.addEventListener("blur", v), Kt() && (a.addEventListener("keydown", m, !0), a.addEventListener("pointerdown", w, !0)), () => {
+      a.removeEventListener("blur", v), Kt() && (a.removeEventListener("keydown", m, !0), a.removeEventListener("pointerdown", w, !0));
+    };
+  }, [s.domReference, n, c]), g.useEffect(() => {
+    if (!c) return;
+    function a(v) {
+      let {
+        reason: m
+      } = v;
+      (m === "reference-press" || m === "escape-key") && (u.current = !0);
+    }
+    return o.on("openchange", a), () => {
+      o.off("openchange", a);
+    };
+  }, [o, c]), g.useEffect(() => () => {
+    me(l);
+  }, []);
+  const d = g.useMemo(() => ({
+    onMouseLeave() {
+      u.current = !1;
+    },
+    onFocus(a) {
+      if (u.current) return;
+      const v = Ie(a.nativeEvent);
+      if (f && Z(v)) {
+        if (Kt() && !a.relatedTarget) {
+          if (!p.current && !nn(v))
+            return;
+        } else if (!Yr(v))
+          return;
+      }
+      r(!0, a.nativeEvent, "focus");
+    },
+    onBlur(a) {
+      u.current = !1;
+      const v = a.relatedTarget, m = a.nativeEvent, w = Z(v) && v.hasAttribute(Ve("focus-guard")) && v.getAttribute("data-type") === "outside";
+      l.current = window.setTimeout(() => {
+        var R;
+        const y = Oe(s.domReference ? s.domReference.ownerDocument : document);
+        !v && y === s.domReference || ue((R = i.current.floatingContext) == null ? void 0 : R.refs.floating.current, y) || ue(s.domReference, y) || w || r(!1, m, "focus");
+      });
+    }
+  }), [i, s.domReference, r, f]);
+  return g.useMemo(() => c ? {
+    reference: d
+  } : {}, [c, d]);
+}
+function Ht(e, t, n) {
+  const r = /* @__PURE__ */ new Map(), o = n === "item";
+  let i = e;
+  if (o && e) {
+    const {
+      [On]: s,
+      [In]: c,
+      ...f
+    } = e;
+    i = f;
+  }
+  return {
+    ...n === "floating" && {
+      tabIndex: -1,
+      [jo]: ""
+    },
+    ...i,
+    ...t.map((s) => {
+      const c = s ? s[n] : null;
+      return typeof c == "function" ? e ? c(e) : null : c;
+    }).concat(e).reduce((s, c) => (c && Object.entries(c).forEach((f) => {
+      let [u, l] = f;
+      if (!(o && [On, In].includes(u)))
+        if (u.indexOf("on") === 0) {
+          if (r.has(u) || r.set(u, []), typeof l == "function") {
+            var p;
+            (p = r.get(u)) == null || p.push(l), s[u] = function() {
+              for (var d, a = arguments.length, v = new Array(a), m = 0; m < a; m++)
+                v[m] = arguments[m];
+              return (d = r.get(u)) == null ? void 0 : d.map((w) => w(...v)).find((w) => w !== void 0);
+            };
+          }
+        } else
+          s[u] = l;
+    }), s), {})
+  };
+}
+function Hs(e) {
+  e === void 0 && (e = []);
+  const t = e.map((c) => c?.reference), n = e.map((c) => c?.floating), r = e.map((c) => c?.item), o = g.useCallback(
+    (c) => Ht(c, e, "reference"),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    t
+  ), i = g.useCallback(
+    (c) => Ht(c, e, "floating"),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    n
+  ), s = g.useCallback(
+    (c) => Ht(c, e, "item"),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    r
+  );
+  return g.useMemo(() => ({
+    getReferenceProps: o,
+    getFloatingProps: i,
+    getItemProps: s
+  }), [o, i, s]);
+}
+const ms = "Escape";
+function St(e, t, n) {
+  switch (e) {
+    case "vertical":
+      return t;
+    case "horizontal":
+      return n;
+    default:
+      return t || n;
+  }
+}
+function ht(e, t) {
+  return St(t, e === vr || e === At, e === st || e === it);
+}
+function jt(e, t, n) {
+  return St(t, e === At, n ? e === st : e === it) || e === "Enter" || e === " " || e === "";
+}
+function jn(e, t, n) {
+  return St(t, n ? e === st : e === it, e === At);
+}
+function Un(e, t, n, r) {
+  const o = n ? e === it : e === st, i = e === vr;
+  return t === "both" || t === "horizontal" && r && r > 1 ? e === ms : St(t, o, i);
+}
+function js(e, t) {
+  const {
+    open: n,
+    onOpenChange: r,
+    elements: o,
+    floatingId: i
+  } = e, {
+    listRef: s,
+    activeIndex: c,
+    onNavigate: f = () => {
+    },
+    enabled: u = !0,
+    selectedIndex: l = null,
+    allowEscape: p = !1,
+    loop: d = !1,
+    nested: a = !1,
+    rtl: v = !1,
+    virtual: m = !1,
+    focusItemOnOpen: w = "auto",
+    focusItemOnHover: R = !0,
+    openOnArrowKeyDown: y = !0,
+    disabledIndices: x = void 0,
+    orientation: E = "vertical",
+    parentOrientation: A,
+    cols: O = 1,
+    scrollItemIntoView: M = !0,
+    virtualItemRef: S,
+    itemSizes: $,
+    dense: I = !1
+  } = t;
+  process.env.NODE_ENV !== "production" && (p && (d || yt("`useListNavigation` looping must be enabled to allow escaping."), m || yt("`useListNavigation` must be virtual to allow escaping.")), E === "vertical" && O > 1 && yt("In grid list navigation mode (`cols` > 1), the `orientation` should", 'be either "horizontal" or "both".'));
+  const B = Ct(o.floating), W = le(B), L = Ge(), h = Ze();
+  X(() => {
+    e.dataRef.current.orientation = E;
+  }, [e, E]);
+  const C = re(() => {
+    f(b.current === -1 ? null : b.current);
+  }), D = zt(o.domReference), T = g.useRef(w), b = g.useRef(l ?? -1), P = g.useRef(null), k = g.useRef(!0), G = g.useRef(C), K = g.useRef(!!o.floating), N = g.useRef(n), J = g.useRef(!1), U = g.useRef(!1), se = le(x), ae = le(n), te = le(M), ne = le(l), [fe, we] = g.useState(), [V, Y] = g.useState(), H = re(() => {
+    function _(ee) {
+      if (m) {
+        var ie;
+        (ie = ee.id) != null && ie.endsWith("-fui-option") && (ee.id = i + "-" + Math.random().toString(16).slice(2, 10)), we(ee.id), h?.events.emit("virtualfocus", ee), S && (S.current = ee);
+      } else
+        _e(ee, {
+          sync: J.current,
+          preventScroll: !0
+        });
+    }
+    const j = s.current[b.current], F = U.current;
+    j && _(j), (J.current ? (ee) => ee() : requestAnimationFrame)(() => {
+      const ee = s.current[b.current] || j;
+      if (!ee) return;
+      j || _(ee);
+      const ie = te.current;
+      ie && oe && (F || !k.current) && (ee.scrollIntoView == null || ee.scrollIntoView(typeof ie == "boolean" ? {
+        block: "nearest",
+        inline: "nearest"
+      } : ie));
+    });
+  });
+  X(() => {
+    u && (n && o.floating ? T.current && l != null && (U.current = !0, b.current = l, C()) : K.current && (b.current = -1, G.current()));
+  }, [u, n, o.floating, l, C]), X(() => {
+    if (u && n && o.floating)
+      if (c == null) {
+        if (J.current = !1, ne.current != null)
+          return;
+        if (K.current && (b.current = -1, H()), (!N.current || !K.current) && T.current && (P.current != null || T.current === !0 && P.current == null)) {
+          let _ = 0;
+          const j = () => {
+            s.current[0] == null ? (_ < 2 && (_ ? requestAnimationFrame : queueMicrotask)(j), _++) : (b.current = P.current == null || jt(P.current, E, v) || a ? Ft(s, se.current) : bn(s, se.current), P.current = null, C());
+          };
+          j();
+        }
+      } else et(s, c) || (b.current = c, H(), U.current = !1);
+  }, [u, n, o.floating, c, ne, a, s, E, v, C, H, se]), X(() => {
+    var _;
+    if (!u || o.floating || !h || m || !K.current)
+      return;
+    const j = h.nodesRef.current, F = (_ = j.find((ie) => ie.id === L)) == null || (_ = _.context) == null ? void 0 : _.elements.floating, q = Oe(pe(o.floating)), ee = j.some((ie) => ie.context && ue(ie.context.elements.floating, q));
+    F && !ee && k.current && F.focus({
+      preventScroll: !0
+    });
+  }, [u, o.floating, h, L, m]), X(() => {
+    if (!u || !h || !m || L) return;
+    function _(j) {
+      Y(j.id), S && (S.current = j);
+    }
+    return h.events.on("virtualfocus", _), () => {
+      h.events.off("virtualfocus", _);
+    };
+  }, [u, h, m, L, S]), X(() => {
+    G.current = C, N.current = n, K.current = !!o.floating;
+  }), X(() => {
+    n || (P.current = null, T.current = w);
+  }, [n, w]);
+  const Q = c != null, oe = g.useMemo(() => {
+    function _(F) {
+      if (!ae.current) return;
+      const q = s.current.indexOf(F);
+      q !== -1 && b.current !== q && (b.current = q, C());
+    }
+    return {
+      onFocus(F) {
+        let {
+          currentTarget: q
+        } = F;
+        J.current = !0, _(q);
+      },
+      onClick: (F) => {
+        let {
+          currentTarget: q
+        } = F;
+        return q.focus({
+          preventScroll: !0
+        });
+      },
+      // Safari
+      onMouseMove(F) {
+        let {
+          currentTarget: q
+        } = F;
+        J.current = !0, U.current = !1, R && _(q);
+      },
+      onPointerLeave(F) {
+        let {
+          pointerType: q
+        } = F;
+        if (!(!k.current || q === "touch") && (J.current = !0, !!R && (b.current = -1, C(), !m))) {
+          var ee;
+          (ee = W.current) == null || ee.focus({
+            preventScroll: !0
+          });
+        }
+      }
+    };
+  }, [ae, W, R, s, C, m]), z = g.useCallback(() => {
+    var _;
+    return A ?? (h == null || (_ = h.nodesRef.current.find((j) => j.id === L)) == null || (_ = _.context) == null || (_ = _.dataRef) == null ? void 0 : _.current.orientation);
+  }, [L, h, A]), ye = re((_) => {
+    if (k.current = !1, J.current = !0, _.which === 229 || !ae.current && _.currentTarget === W.current)
+      return;
+    if (a && Un(_.key, E, v, O)) {
+      ht(_.key, z()) || ge(_), r(!1, _.nativeEvent, "list-navigation"), ce(o.domReference) && (m ? h?.events.emit("virtualfocus", o.domReference) : o.domReference.focus());
+      return;
+    }
+    const j = b.current, F = Ft(s, x), q = bn(s, x);
+    if (D || (_.key === "Home" && (ge(_), b.current = F, C()), _.key === "End" && (ge(_), b.current = q, C())), O > 1) {
+      const ee = $ || Array.from({
+        length: s.current.length
+      }, () => ({
+        width: 1,
+        height: 1
+      })), ie = to(ee, O, I), Je = ie.findIndex((Re) => Re != null && !vt(s, Re, x)), ut = ie.reduce((Re, Ne, lt) => Ne != null && !vt(s, Ne, x) ? lt : Re, -1), Qe = ie[eo({
+        current: ie.map((Re) => Re != null ? s.current[Re] : null)
+      }, {
+        event: _,
+        orientation: E,
+        loop: d,
+        rtl: v,
+        cols: O,
+        // treat undefined (empty grid spaces) as disabled indices so we
+        // don't end up in them
+        disabledIndices: ro([...(typeof x != "function" ? x : null) || s.current.map((Re, Ne) => vt(s, Ne, x) ? Ne : void 0), void 0], ie),
+        minIndex: Je,
+        maxIndex: ut,
+        prevIndex: no(
+          b.current > q ? F : b.current,
+          ee,
+          ie,
+          O,
+          // use a corner matching the edge closest to the direction
+          // we're moving in so we don't end up in the same item. Prefer
+          // top/left over bottom/right.
+          _.key === At ? "bl" : _.key === (v ? st : it) ? "tr" : "tl"
+        ),
+        stopEvent: !0
+      })];
+      if (Qe != null && (b.current = Qe, C()), E === "both")
+        return;
+    }
+    if (ht(_.key, E)) {
+      if (ge(_), n && !m && Oe(_.currentTarget.ownerDocument) === _.currentTarget) {
+        b.current = jt(_.key, E, v) ? F : q, C();
+        return;
+      }
+      jt(_.key, E, v) ? d ? b.current = j >= q ? p && j !== s.current.length ? -1 : F : ve(s, {
+        startingIndex: j,
+        disabledIndices: x
+      }) : b.current = Math.min(q, ve(s, {
+        startingIndex: j,
+        disabledIndices: x
+      })) : d ? b.current = j <= F ? p && j !== -1 ? s.current.length : q : ve(s, {
+        startingIndex: j,
+        decrement: !0,
+        disabledIndices: x
+      }) : b.current = Math.max(F, ve(s, {
+        startingIndex: j,
+        decrement: !0,
+        disabledIndices: x
+      })), et(s, b.current) && (b.current = -1), C();
+    }
+  }), de = g.useMemo(() => m && n && Q && {
+    "aria-activedescendant": V || fe
+  }, [m, n, Q, V, fe]), he = g.useMemo(() => ({
+    "aria-orientation": E === "both" ? void 0 : E,
+    ...D ? {} : de,
+    onKeyDown: ye,
+    onPointerMove() {
+      k.current = !0;
+    }
+  }), [de, ye, E, D]), Te = g.useMemo(() => {
+    function _(F) {
+      w === "auto" && or(F.nativeEvent) && (T.current = !0);
+    }
+    function j(F) {
+      T.current = w, w === "auto" && sr(F.nativeEvent) && (T.current = !0);
+    }
+    return {
+      ...de,
+      onKeyDown(F) {
+        k.current = !1;
+        const q = F.key.startsWith("Arrow"), ee = ["Home", "End"].includes(F.key), ie = q || ee, Je = jn(F.key, E, v), ut = Un(F.key, E, v, O), Qe = jn(F.key, z(), v), Re = ht(F.key, E), Ne = (a ? Qe : Re) || F.key === "Enter" || F.key.trim() === "";
+        if (m && n) {
+          const at = h?.nodesRef.current.find((ft) => ft.parentId == null), ke = h && at ? zr(h.nodesRef.current, at.id) : null;
+          if (ie && ke && S) {
+            const ft = new KeyboardEvent("keydown", {
+              key: F.key,
+              bubbles: !0
+            });
+            if (Je || ut) {
+              var lt, cn;
+              const Tr = ((lt = ke.context) == null ? void 0 : lt.elements.domReference) === F.currentTarget, ln = ut && !Tr ? (cn = ke.context) == null ? void 0 : cn.elements.domReference : Je ? s.current.find((an) => an?.id === fe) : null;
+              ln && (ge(F), ln.dispatchEvent(ft), Y(void 0));
+            }
+            if ((Re || ee) && ke.context && ke.context.open && ke.parentId && F.currentTarget !== ke.context.elements.domReference) {
+              var un;
+              ge(F), (un = ke.context.elements.domReference) == null || un.dispatchEvent(ft);
+              return;
+            }
+          }
+          return ye(F);
+        }
+        if (!(!n && !y && q)) {
+          if (Ne) {
+            const at = ht(F.key, z());
+            P.current = a && at ? null : F.key;
+          }
+          if (a) {
+            Qe && (ge(F), n ? (b.current = Ft(s, se.current), C()) : r(!0, F.nativeEvent, "list-navigation"));
+            return;
+          }
+          Re && (l != null && (b.current = l), ge(F), !n && y ? r(!0, F.nativeEvent, "list-navigation") : ye(F), n && C());
+        }
+      },
+      onFocus() {
+        n && !m && (b.current = -1, C());
+      },
+      onPointerDown: j,
+      onPointerEnter: j,
+      onMouseDown: _,
+      onClick: _
+    };
+  }, [fe, de, O, ye, se, w, s, a, C, r, n, y, E, z, v, l, h, m, S]);
+  return g.useMemo(() => u ? {
+    reference: Te,
+    floating: he,
+    item: oe
+  } : {}, [u, Te, he, oe]);
+}
+const gs = /* @__PURE__ */ new Map([["select", "listbox"], ["combobox", "listbox"], ["label", !1]]);
+function Us(e, t) {
+  var n, r;
+  t === void 0 && (t = {});
+  const {
+    open: o,
+    elements: i,
+    floatingId: s
+  } = e, {
+    enabled: c = !0,
+    role: f = "dialog"
+  } = t, u = ct(), l = ((n = i.domReference) == null ? void 0 : n.id) || u, p = g.useMemo(() => {
+    var y;
+    return ((y = Ct(i.floating)) == null ? void 0 : y.id) || s;
+  }, [i.floating, s]), d = (r = gs.get(f)) != null ? r : f, v = Ge() != null, m = g.useMemo(() => d === "tooltip" || f === "label" ? {
+    ["aria-" + (f === "label" ? "labelledby" : "describedby")]: o ? p : void 0
+  } : {
+    "aria-expanded": o ? "true" : "false",
+    "aria-haspopup": d === "alertdialog" ? "dialog" : d,
+    "aria-controls": o ? p : void 0,
+    ...d === "listbox" && {
+      role: "combobox"
+    },
+    ...d === "menu" && {
+      id: l
+    },
+    ...d === "menu" && v && {
+      role: "menuitem"
+    },
+    ...f === "select" && {
+      "aria-autocomplete": "none"
+    },
+    ...f === "combobox" && {
+      "aria-autocomplete": "list"
+    }
+  }, [d, p, v, o, l, f]), w = g.useMemo(() => {
+    const y = {
+      id: p,
+      ...d && {
+        role: d
+      }
+    };
+    return d === "tooltip" || f === "label" ? y : {
+      ...y,
+      ...d === "menu" && {
+        "aria-labelledby": l
+      }
+    };
+  }, [d, p, l, f]), R = g.useCallback((y) => {
+    let {
+      active: x,
+      selected: E
+    } = y;
+    const A = {
+      role: "option",
+      ...x && {
+        id: p + "-fui-option"
+      }
+    };
+    switch (f) {
+      case "select":
+      case "combobox":
+        return {
+          ...A,
+          "aria-selected": E
+        };
+    }
+    return {};
+  }, [p, f]);
+  return g.useMemo(() => c ? {
+    reference: m,
+    floating: w,
+    item: R
+  } : {}, [c, m, w, R]);
+}
+const Yn = (e) => e.replace(/[A-Z]+(?![a-z])|[A-Z]/g, (t, n) => (n ? "-" : "") + t.toLowerCase());
+function He(e, t) {
+  return typeof e == "function" ? e(t) : e;
+}
+function ps(e, t) {
+  const [n, r] = g.useState(e);
+  return e && !n && r(!0), g.useEffect(() => {
+    if (!e && n) {
+      const o = setTimeout(() => r(!1), t);
+      return () => clearTimeout(o);
+    }
+  }, [e, n, t]), n;
+}
+function hs(e, t) {
+  t === void 0 && (t = {});
+  const {
+    open: n,
+    elements: {
+      floating: r
+    }
+  } = e, {
+    duration: o = 250
+  } = t, s = (typeof o == "number" ? o : o.close) || 0, [c, f] = g.useState("unmounted"), u = ps(n, s);
+  return !u && c === "close" && f("unmounted"), X(() => {
+    if (r) {
+      if (n) {
+        f("initial");
+        const l = requestAnimationFrame(() => {
+          Jt.flushSync(() => {
+            f("open");
+          });
+        });
+        return () => {
+          cancelAnimationFrame(l);
+        };
+      }
+      f("close");
+    }
+  }, [n, r]), {
+    isMounted: u,
+    status: c
+  };
+}
+function Ys(e, t) {
+  t === void 0 && (t = {});
+  const {
+    initial: n = {
+      opacity: 0
+    },
+    open: r,
+    close: o,
+    common: i,
+    duration: s = 250
+  } = t, c = e.placement, f = c.split("-")[0], u = g.useMemo(() => ({
+    side: f,
+    placement: c
+  }), [f, c]), l = typeof s == "number", p = (l ? s : s.open) || 0, d = (l ? s : s.close) || 0, [a, v] = g.useState(() => ({
+    ...He(i, u),
+    ...He(n, u)
+  })), {
+    isMounted: m,
+    status: w
+  } = hs(e, {
+    duration: s
+  }), R = le(n), y = le(r), x = le(o), E = le(i);
+  return X(() => {
+    const A = He(R.current, u), O = He(x.current, u), M = He(E.current, u), S = He(y.current, u) || Object.keys(A).reduce(($, I) => ($[I] = "", $), {});
+    if (w === "initial" && v(($) => ({
+      transitionProperty: $.transitionProperty,
+      ...M,
+      ...A
+    })), w === "open" && v({
+      transitionProperty: Object.keys(S).map(Yn).join(","),
+      transitionDuration: p + "ms",
+      ...M,
+      ...S
+    }), w === "close") {
+      const $ = O || A;
+      v({
+        transitionProperty: Object.keys($).map(Yn).join(","),
+        transitionDuration: d + "ms",
+        ...M,
+        ...$
+      });
+    }
+  }, [d, x, R, y, E, p, w, u]), {
+    isMounted: m,
+    styles: a
+  };
+}
+function zs(e, t) {
+  var n;
+  const {
+    open: r,
+    dataRef: o
+  } = e, {
+    listRef: i,
+    activeIndex: s,
+    onMatch: c,
+    onTypingChange: f,
+    enabled: u = !0,
+    findMatch: l = null,
+    resetMs: p = 750,
+    ignoreKeys: d = [],
+    selectedIndex: a = null
+  } = t, v = g.useRef(-1), m = g.useRef(""), w = g.useRef((n = a ?? s) != null ? n : -1), R = g.useRef(null), y = re(c), x = re(f), E = le(l), A = le(d);
+  X(() => {
+    r && (me(v), R.current = null, m.current = "");
+  }, [r]), X(() => {
+    if (r && m.current === "") {
+      var I;
+      w.current = (I = a ?? s) != null ? I : -1;
+    }
+  }, [r, a, s]);
+  const O = re((I) => {
+    I ? o.current.typing || (o.current.typing = I, x(I)) : o.current.typing && (o.current.typing = I, x(I));
+  }), M = re((I) => {
+    function B(D, T, b) {
+      const P = E.current ? E.current(T, b) : T.find((k) => k?.toLocaleLowerCase().indexOf(b.toLocaleLowerCase()) === 0);
+      return P ? D.indexOf(P) : -1;
+    }
+    const W = i.current;
+    if (m.current.length > 0 && m.current[0] !== " " && (B(W, W, m.current) === -1 ? O(!1) : I.key === " " && ge(I)), W == null || A.current.includes(I.key) || // Character key.
+    I.key.length !== 1 || // Modifier key.
+    I.ctrlKey || I.metaKey || I.altKey)
+      return;
+    r && I.key !== " " && (ge(I), O(!0)), W.every((D) => {
+      var T, b;
+      return D ? ((T = D[0]) == null ? void 0 : T.toLocaleLowerCase()) !== ((b = D[1]) == null ? void 0 : b.toLocaleLowerCase()) : !0;
+    }) && m.current === I.key && (m.current = "", w.current = R.current), m.current += I.key, me(v), v.current = window.setTimeout(() => {
+      m.current = "", w.current = R.current, O(!1);
+    }, p);
+    const h = w.current, C = B(W, [...W.slice((h || 0) + 1), ...W.slice(0, (h || 0) + 1)], m.current);
+    C !== -1 ? (y(C), R.current = C) : I.key !== " " && (m.current = "", O(!1));
+  }), S = g.useMemo(() => ({
+    onKeyDown: M
+  }), [M]), $ = g.useMemo(() => ({
+    onKeyDown: M,
+    onKeyUp(I) {
+      I.key === " " && O(!1);
+    }
+  }), [M, O]);
+  return g.useMemo(() => u ? {
+    reference: S,
+    floating: $
+  } : {}, [u, S, $]);
+}
+function Cr(e, t, n) {
+  return n === void 0 && (n = !0), e.filter((o) => {
+    var i;
+    return o.parentId === t && (!n || ((i = o.context) == null ? void 0 : i.open));
+  }).flatMap((o) => [o, ...Cr(e, o.id, n)]);
+}
+function zn(e, t) {
+  const [n, r] = e;
+  let o = !1;
+  const i = t.length;
+  for (let s = 0, c = i - 1; s < i; c = s++) {
+    const [f, u] = t[s] || [0, 0], [l, p] = t[c] || [0, 0];
+    u >= r != p >= r && n <= (l - f) * (r - u) / (p - u) + f && (o = !o);
+  }
+  return o;
+}
+function vs(e, t) {
+  return e[0] >= t.x && e[0] <= t.x + t.width && e[1] >= t.y && e[1] <= t.y + t.height;
+}
+function Xs(e) {
+  e === void 0 && (e = {});
+  const {
+    buffer: t = 0.5,
+    blockPointerEvents: n = !1,
+    requireIntent: r = !0
+  } = e, o = {
+    current: -1
+  };
+  let i = !1, s = null, c = null, f = typeof performance < "u" ? performance.now() : 0;
+  function u(p, d) {
+    const a = performance.now(), v = a - f;
+    if (s === null || c === null || v === 0)
+      return s = p, c = d, f = a, null;
+    const m = p - s, w = d - c, y = Math.sqrt(m * m + w * w) / v;
+    return s = p, c = d, f = a, y;
+  }
+  const l = (p) => {
+    let {
+      x: d,
+      y: a,
+      placement: v,
+      elements: m,
+      onClose: w,
+      nodeId: R,
+      tree: y
+    } = p;
+    return function(E) {
+      function A() {
+        me(o), w();
+      }
+      if (me(o), !m.domReference || !m.floating || v == null || d == null || a == null)
+        return;
+      const {
+        clientX: O,
+        clientY: M
+      } = E, S = [O, M], $ = Go(E), I = E.type === "mouseleave", B = Bt(m.floating, $), W = Bt(m.domReference, $), L = m.domReference.getBoundingClientRect(), h = m.floating.getBoundingClientRect(), C = v.split("-")[0], D = d > h.right - h.width / 2, T = a > h.bottom - h.height / 2, b = vs(S, L), P = h.width > L.width, k = h.height > L.height, G = (P ? L : h).left, K = (P ? L : h).right, N = (k ? L : h).top, J = (k ? L : h).bottom;
+      if (B && (i = !0, !I))
+        return;
+      if (W && (i = !1), W && !I) {
+        i = !0;
+        return;
+      }
+      if (I && Z(E.relatedTarget) && Bt(m.floating, E.relatedTarget) || y && Cr(y.nodesRef.current, R).length)
+        return;
+      if (C === "top" && a >= L.bottom - 1 || C === "bottom" && a <= L.top + 1 || C === "left" && d >= L.right - 1 || C === "right" && d <= L.left + 1)
+        return A();
+      let U = [];
+      switch (C) {
+        case "top":
+          U = [[G, L.top + 1], [G, h.bottom - 1], [K, h.bottom - 1], [K, L.top + 1]];
+          break;
+        case "bottom":
+          U = [[G, h.top + 1], [G, L.bottom - 1], [K, L.bottom - 1], [K, h.top + 1]];
+          break;
+        case "left":
+          U = [[h.right - 1, J], [h.right - 1, N], [L.left + 1, N], [L.left + 1, J]];
+          break;
+        case "right":
+          U = [[L.right - 1, J], [L.right - 1, N], [h.left + 1, N], [h.left + 1, J]];
+          break;
+      }
+      function se(ae) {
+        let [te, ne] = ae;
+        switch (C) {
+          case "top": {
+            const fe = [P ? te + t / 2 : D ? te + t * 4 : te - t * 4, ne + t + 1], we = [P ? te - t / 2 : D ? te + t * 4 : te - t * 4, ne + t + 1], V = [[h.left, D || P ? h.bottom - t : h.top], [h.right, D ? P ? h.bottom - t : h.top : h.bottom - t]];
+            return [fe, we, ...V];
+          }
+          case "bottom": {
+            const fe = [P ? te + t / 2 : D ? te + t * 4 : te - t * 4, ne - t], we = [P ? te - t / 2 : D ? te + t * 4 : te - t * 4, ne - t], V = [[h.left, D || P ? h.top + t : h.bottom], [h.right, D ? P ? h.top + t : h.bottom : h.top + t]];
+            return [fe, we, ...V];
+          }
+          case "left": {
+            const fe = [te + t + 1, k ? ne + t / 2 : T ? ne + t * 4 : ne - t * 4], we = [te + t + 1, k ? ne - t / 2 : T ? ne + t * 4 : ne - t * 4];
+            return [...[[T || k ? h.right - t : h.left, h.top], [T ? k ? h.right - t : h.left : h.right - t, h.bottom]], fe, we];
+          }
+          case "right": {
+            const fe = [te - t, k ? ne + t / 2 : T ? ne + t * 4 : ne - t * 4], we = [te - t, k ? ne - t / 2 : T ? ne + t * 4 : ne - t * 4], V = [[T || k ? h.left + t : h.right, h.top], [T ? k ? h.left + t : h.right : h.left + t, h.bottom]];
+            return [fe, we, ...V];
+          }
+        }
+      }
+      if (!zn([O, M], U)) {
+        if (i && !b)
+          return A();
+        if (!I && r) {
+          const ae = u(E.clientX, E.clientY);
+          if (ae !== null && ae < 0.1)
+            return A();
+        }
+        zn([O, M], se([d, a])) ? !i && r && (o.current = window.setTimeout(A, 40)) : A();
+      }
+    };
+  };
+  return l.__options = {
+    blockPointerEvents: n
+  }, l;
+}
+export {
+  ks as A,
+  Ks as B,
+  $s as C,
+  Fs as F,
+  Is as a,
+  xs as b,
+  Hs as c,
+  Us as d,
+  As as e,
+  Cs as f,
+  Ts as g,
+  Ys as h,
+  Bs as i,
+  js as j,
+  _s as k,
+  Ns as l,
+  Os as m,
+  Ws as n,
+  Rs as o,
+  Ge as p,
+  Ze as q,
+  Ss as r,
+  Es as s,
+  Ms as t,
+  Vs as u,
+  Ds as v,
+  Xs as w,
+  zs as x,
+  Ls as y,
+  Ps as z
+};
+//# sourceMappingURL=floating-ui.react-QNHG9W4N.js.map