@iress-oss/ids-components 0.0.1-dev.9 → 5.14.0

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

@@ -0,0 +1,3453 @@
+import * as f from "react";
+import { useLayoutEffect as Wn, useEffect as $n } from "react";
+import { t as At, i as Bn, f as Or } from "./index.esm-BnSuefUA.js";
+import { jsx as ge, jsxs as Hn, Fragment as Ar } from "react/jsx-runtime";
+import * as tn from "react-dom";
+function Mt() {
+  return typeof window < "u";
+}
+function _e(e) {
+  return zn(e) ? (e.nodeName || "").toLowerCase() : "#document";
+}
+function he(e) {
+  var t;
+  return (e == null || (t = e.ownerDocument) == null ? void 0 : t.defaultView) || window;
+}
+function Te(e) {
+  var t;
+  return (t = (zn(e) ? e.ownerDocument : e.document) || window.document) == null ? void 0 : t.documentElement;
+}
+function zn(e) {
+  return Mt() ? e instanceof Node || e instanceof he(e).Node : !1;
+}
+function Y(e) {
+  return Mt() ? e instanceof Element || e instanceof he(e).Element : !1;
+}
+function oe(e) {
+  return Mt() ? e instanceof HTMLElement || e instanceof he(e).HTMLElement : !1;
+}
+function Xt(e) {
+  return !Mt() || typeof ShadowRoot > "u" ? !1 : e instanceof ShadowRoot || e instanceof he(e).ShadowRoot;
+}
+function ut(e) {
+  const {
+    overflow: t,
+    overflowX: n,
+    overflowY: r,
+    display: o
+  } = we(e);
+  return /auto|scroll|overlay|hidden|clip/.test(t + r + n) && !["inline", "contents"].includes(o);
+}
+function Mr(e) {
+  return ["table", "td", "th"].includes(_e(e));
+}
+function Pt(e) {
+  return [":popover-open", ":modal"].some((t) => {
+    try {
+      return e.matches(t);
+    } catch {
+      return !1;
+    }
+  });
+}
+function nn(e) {
+  const t = St(), n = Y(e) ? we(e) : e;
+  return ["transform", "translate", "scale", "rotate", "perspective"].some((r) => n[r] ? n[r] !== "none" : !1) || (n.containerType ? n.containerType !== "normal" : !1) || !t && (n.backdropFilter ? n.backdropFilter !== "none" : !1) || !t && (n.filter ? n.filter !== "none" : !1) || ["transform", "translate", "scale", "rotate", "perspective", "filter"].some((r) => (n.willChange || "").includes(r)) || ["paint", "layout", "strict", "content"].some((r) => (n.contain || "").includes(r));
+}
+function Pr(e) {
+  let t = Pe(e);
+  for (; oe(t) && !Me(t); ) {
+    if (nn(t))
+      return t;
+    if (Pt(t))
+      return null;
+    t = Pe(t);
+  }
+  return null;
+}
+function St() {
+  return typeof CSS > "u" || !CSS.supports ? !1 : CSS.supports("-webkit-backdrop-filter", "none");
+}
+function Me(e) {
+  return ["html", "body", "#document"].includes(_e(e));
+}
+function we(e) {
+  return he(e).getComputedStyle(e);
+}
+function Dt(e) {
+  return Y(e) ? {
+    scrollLeft: e.scrollLeft,
+    scrollTop: e.scrollTop
+  } : {
+    scrollLeft: e.scrollX,
+    scrollTop: e.scrollY
+  };
+}
+function Pe(e) {
+  if (_e(e) === "html")
+    return e;
+  const t = (
+    // Step into the shadow DOM of the parent of a slotted node.
+    e.assignedSlot || // DOM Element detected.
+    e.parentNode || // ShadowRoot detected.
+    Xt(e) && e.host || // Fallback.
+    Te(e)
+  );
+  return Xt(t) ? t.host : t;
+}
+function Un(e) {
+  const t = Pe(e);
+  return Me(t) ? e.ownerDocument ? e.ownerDocument.body : e.body : oe(t) && ut(t) ? t : Un(t);
+}
+function ke(e, t, n) {
+  var r;
+  t === void 0 && (t = []), n === void 0 && (n = !0);
+  const o = Un(e), s = o === ((r = e.ownerDocument) == null ? void 0 : r.body), i = he(o);
+  if (s) {
+    const c = Jt(i);
+    return t.concat(i, i.visualViewport || [], ut(o) ? o : [], c && n ? ke(c) : []);
+  }
+  return t.concat(o, ke(o, [], n));
+}
+function Jt(e) {
+  return e.parent && Object.getPrototypeOf(e.parent) ? e.frameElement : null;
+}
+const Sr = ["top", "right", "bottom", "left"], dn = ["start", "end"], mn = /* @__PURE__ */ Sr.reduce((e, t) => e.concat(t, t + "-" + dn[0], t + "-" + dn[1]), []), Je = Math.min, be = Math.max, wt = Math.round, je = Math.floor, Ee = (e) => ({
+  x: e,
+  y: e
+}), Dr = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+}, kr = {
+  start: "end",
+  end: "start"
+};
+function pn(e, t, n) {
+  return be(e, Je(t, n));
+}
+function Qe(e, t) {
+  return typeof e == "function" ? e(t) : e;
+}
+function Ce(e) {
+  return e.split("-")[0];
+}
+function Ie(e) {
+  return e.split("-")[1];
+}
+function Gn(e) {
+  return e === "x" ? "y" : "x";
+}
+function jn(e) {
+  return e === "y" ? "height" : "width";
+}
+function He(e) {
+  return ["top", "bottom"].includes(Ce(e)) ? "y" : "x";
+}
+function qn(e) {
+  return Gn(He(e));
+}
+function Yn(e, t, n) {
+  n === void 0 && (n = !1);
+  const r = Ie(e), o = qn(e), s = jn(o);
+  let i = o === "x" ? r === (n ? "end" : "start") ? "right" : "left" : r === "start" ? "bottom" : "top";
+  return t.reference[s] > t.floating[s] && (i = Et(i)), [i, Et(i)];
+}
+function Lr(e) {
+  const t = Et(e);
+  return [Rt(e), t, Rt(t)];
+}
+function Rt(e) {
+  return e.replace(/start|end/g, (t) => kr[t]);
+}
+function Fr(e, t, n) {
+  const r = ["left", "right"], o = ["right", "left"], s = ["top", "bottom"], i = ["bottom", "top"];
+  switch (e) {
+    case "top":
+    case "bottom":
+      return n ? t ? o : r : t ? r : o;
+    case "left":
+    case "right":
+      return t ? s : i;
+    default:
+      return [];
+  }
+}
+function Nr(e, t, n, r) {
+  const o = Ie(e);
+  let s = Fr(Ce(e), n === "start", r);
+  return o && (s = s.map((i) => i + "-" + o), t && (s = s.concat(s.map(Rt)))), s;
+}
+function Et(e) {
+  return e.replace(/left|right|bottom|top/g, (t) => Dr[t]);
+}
+function _r(e) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...e
+  };
+}
+function Kr(e) {
+  return typeof e != "number" ? _r(e) : {
+    top: e,
+    right: e,
+    bottom: e,
+    left: e
+  };
+}
+function It(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 rn() {
+  const e = navigator.userAgentData;
+  return e != null && e.platform ? e.platform : navigator.platform;
+}
+function Xn() {
+  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 Jn() {
+  return /apple/i.test(navigator.vendor);
+}
+function Qt() {
+  const e = /android/i;
+  return e.test(rn()) || e.test(Xn());
+}
+function Vr() {
+  return rn().toLowerCase().startsWith("mac") && !navigator.maxTouchPoints;
+}
+function Qn() {
+  return Xn().includes("jsdom/");
+}
+const gn = "data-floating-ui-focusable", Wr = "input:not([type='hidden']):not([disabled]),[contenteditable]:not([contenteditable='false']),textarea:not([disabled])", _t = "ArrowLeft", Kt = "ArrowRight", $r = "ArrowUp", Br = "ArrowDown";
+function Re(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 && Xt(n)) {
+    let r = t;
+    for (; r; ) {
+      if (e === r)
+        return !0;
+      r = r.parentNode || r.host;
+    }
+  }
+  return !1;
+}
+function De(e) {
+  return "composedPath" in e ? e.composedPath()[0] : e.target;
+}
+function Vt(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 Hr(e) {
+  return e.matches("html,body");
+}
+function ae(e) {
+  return (e == null ? void 0 : e.ownerDocument) || document;
+}
+function on(e) {
+  return oe(e) && e.matches(Wr);
+}
+function Zt(e) {
+  return e ? e.getAttribute("role") === "combobox" && on(e) : !1;
+}
+function zr(e) {
+  if (!e || Qn()) return !0;
+  try {
+    return e.matches(":focus-visible");
+  } catch {
+    return !0;
+  }
+}
+function Ct(e) {
+  return e ? e.hasAttribute(gn) ? e : e.querySelector("[" + gn + "]") || e : null;
+}
+function qe(e, t) {
+  let n = e.filter((o) => {
+    var s;
+    return o.parentId === t && ((s = o.context) == null ? void 0 : s.open);
+  }), r = n;
+  for (; r.length; )
+    r = e.filter((o) => {
+      var s;
+      return (s = r) == null ? void 0 : s.some((i) => {
+        var c;
+        return o.parentId === i.id && ((c = o.context) == null ? void 0 : c.open);
+      });
+    }), n = n.concat(r);
+  return n;
+}
+function Ur(e, t) {
+  let n, r = -1;
+  function o(s, i) {
+    i > r && (n = s, r = i), qe(e, s).forEach((a) => {
+      o(a.id, i + 1);
+    });
+  }
+  return o(t, 0), e.find((s) => s.id === n);
+}
+function hn(e, t) {
+  var n;
+  let r = [], o = (n = e.find((s) => s.id === t)) == null ? void 0 : n.parentId;
+  for (; o; ) {
+    const s = e.find((i) => i.id === o);
+    o = s == null ? void 0 : s.parentId, s && (r = r.concat(s));
+  }
+  return r;
+}
+function pe(e) {
+  e.preventDefault(), e.stopPropagation();
+}
+function Gr(e) {
+  return "nativeEvent" in e;
+}
+function Zn(e) {
+  return e.mozInputSource === 0 && e.isTrusted ? !0 : Qt() && e.pointerType ? e.type === "click" && e.buttons === 1 : e.detail === 0 && !e.pointerType;
+}
+function er(e) {
+  return Qn() ? !1 : !Qt() && e.width === 0 && e.height === 0 || Qt() && 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 it(e, t) {
+  const n = ["mouse", "pen"];
+  return t || n.push("", void 0), n.includes(e);
+}
+var X = typeof document < "u" ? Wn : $n;
+const jr = {
+  ...f
+};
+function xe(e) {
+  const t = f.useRef(e);
+  return X(() => {
+    t.current = e;
+  }), t;
+}
+const qr = jr.useInsertionEffect, Yr = qr || ((e) => e());
+function ce(e) {
+  const t = f.useRef(() => {
+    if (process.env.NODE_ENV !== "production")
+      throw new Error("Cannot call an event handler while rendering.");
+  });
+  return Yr(() => {
+    t.current = e;
+  }), f.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 pt(e, t, n) {
+  return Math.floor(e / t) !== n;
+}
+function Ye(e, t) {
+  return t < 0 || t >= e.current.length;
+}
+function yt(e, t) {
+  return le(e, {
+    disabledIndices: t
+  });
+}
+function en(e, t) {
+  return le(e, {
+    decrement: !0,
+    startingIndex: e.current.length,
+    disabledIndices: t
+  });
+}
+function le(e, t) {
+  let {
+    startingIndex: n = -1,
+    decrement: r = !1,
+    disabledIndices: o,
+    amount: s = 1
+  } = t === void 0 ? {} : t, i = n;
+  do
+    i += r ? -s : s;
+  while (i >= 0 && i <= e.current.length - 1 && Be(e, i, o));
+  return i;
+}
+function tr(e, t) {
+  let {
+    event: n,
+    orientation: r,
+    loop: o,
+    rtl: s,
+    cols: i,
+    disabledIndices: c,
+    minIndex: a,
+    maxIndex: u,
+    prevIndex: l,
+    stopEvent: p = !1
+  } = t, g = l;
+  if (n.key === $r) {
+    if (p && pe(n), l === -1)
+      g = u;
+    else if (g = le(e, {
+      startingIndex: g,
+      amount: i,
+      decrement: !0,
+      disabledIndices: c
+    }), o && (l - i < a || g < 0)) {
+      const d = l % i, h = u % i, m = u - (h - d);
+      h === d ? g = u : g = h > d ? m : m - i;
+    }
+    Ye(e, g) && (g = l);
+  }
+  if (n.key === Br && (p && pe(n), l === -1 ? g = a : (g = le(e, {
+    startingIndex: l,
+    amount: i,
+    disabledIndices: c
+  }), o && l + i > u && (g = le(e, {
+    startingIndex: l % i - i,
+    amount: i,
+    disabledIndices: c
+  }))), Ye(e, g) && (g = l)), r === "both") {
+    const d = je(l / i);
+    n.key === (s ? _t : Kt) && (p && pe(n), l % i !== i - 1 ? (g = le(e, {
+      startingIndex: l,
+      disabledIndices: c
+    }), o && pt(g, i, d) && (g = le(e, {
+      startingIndex: l - l % i - 1,
+      disabledIndices: c
+    }))) : o && (g = le(e, {
+      startingIndex: l - l % i - 1,
+      disabledIndices: c
+    })), pt(g, i, d) && (g = l)), n.key === (s ? Kt : _t) && (p && pe(n), l % i !== 0 ? (g = le(e, {
+      startingIndex: l,
+      decrement: !0,
+      disabledIndices: c
+    }), o && pt(g, i, d) && (g = le(e, {
+      startingIndex: l + (i - l % i),
+      decrement: !0,
+      disabledIndices: c
+    }))) : o && (g = le(e, {
+      startingIndex: l + (i - l % i),
+      decrement: !0,
+      disabledIndices: c
+    })), pt(g, i, d) && (g = l));
+    const h = je(u / i) === d;
+    Ye(e, g) && (o && h ? g = n.key === (s ? Kt : _t) ? u : le(e, {
+      startingIndex: l - l % i - 1,
+      disabledIndices: c
+    }) : g = l);
+  }
+  return g;
+}
+function nr(e, t, n) {
+  const r = [];
+  let o = 0;
+  return e.forEach((s, i) => {
+    let {
+      width: c,
+      height: a
+    } = s;
+    if (c > t && process.env.NODE_ENV !== "production")
+      throw new Error("[Floating UI]: Invalid grid - item width at index " + i + " is greater than grid columns");
+    let u = !1;
+    for (n && (o = 0); !u; ) {
+      const l = [];
+      for (let p = 0; p < c; p++)
+        for (let g = 0; g < a; g++)
+          l.push(o + p + g * t);
+      o % t + c <= t && l.every((p) => r[p] == null) ? (l.forEach((p) => {
+        r[p] = i;
+      }), u = !0) : o++;
+    }
+  }), [...r];
+}
+function rr(e, t, n, r, o) {
+  if (e === -1) return -1;
+  const s = n.indexOf(e), i = t[e];
+  switch (o) {
+    case "tl":
+      return s;
+    case "tr":
+      return i ? s + i.width - 1 : s;
+    case "bl":
+      return i ? s + (i.height - 1) * r : s;
+    case "br":
+      return n.lastIndexOf(e);
+  }
+}
+function or(e, t) {
+  return t.flatMap((n, r) => e.includes(n) ? [r] : []);
+}
+function Be(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 lt = () => ({
+  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 = At(e, lt()), r = n.length;
+  if (r === 0) return;
+  const o = Re(ae(e)), s = n.indexOf(o), i = s === -1 ? t === 1 ? 0 : r - 1 : s + t;
+  return n[i];
+}
+function sr(e) {
+  return ir(ae(e).body, 1) || e;
+}
+function cr(e) {
+  return ir(ae(e).body, -1) || e;
+}
+function ot(e, t) {
+  const n = t || e.currentTarget, r = e.relatedTarget;
+  return !r || !ue(n, r);
+}
+function Xr(e) {
+  At(e, lt()).forEach((n) => {
+    n.dataset.tabindex = n.getAttribute("tabindex") || "", n.setAttribute("tabindex", "-1");
+  });
+}
+function vn(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 bn(e, t, n) {
+  let {
+    reference: r,
+    floating: o
+  } = e;
+  const s = He(t), i = qn(t), c = jn(i), a = Ce(t), u = s === "y", l = r.x + r.width / 2 - o.width / 2, p = r.y + r.height / 2 - o.height / 2, g = r[c] / 2 - o[c] / 2;
+  let d;
+  switch (a) {
+    case "top":
+      d = {
+        x: l,
+        y: r.y - o.height
+      };
+      break;
+    case "bottom":
+      d = {
+        x: l,
+        y: r.y + r.height
+      };
+      break;
+    case "right":
+      d = {
+        x: r.x + r.width,
+        y: p
+      };
+      break;
+    case "left":
+      d = {
+        x: r.x - o.width,
+        y: p
+      };
+      break;
+    default:
+      d = {
+        x: r.x,
+        y: r.y
+      };
+  }
+  switch (Ie(t)) {
+    case "start":
+      d[i] -= g * (n && u ? -1 : 1);
+      break;
+    case "end":
+      d[i] += g * (n && u ? -1 : 1);
+      break;
+  }
+  return d;
+}
+const Jr = async (e, t, n) => {
+  const {
+    placement: r = "bottom",
+    strategy: o = "absolute",
+    middleware: s = [],
+    platform: i
+  } = n, c = s.filter(Boolean), a = await (i.isRTL == null ? void 0 : i.isRTL(t));
+  let u = await i.getElementRects({
+    reference: e,
+    floating: t,
+    strategy: o
+  }), {
+    x: l,
+    y: p
+  } = bn(u, r, a), g = r, d = {}, h = 0;
+  for (let m = 0; m < c.length; m++) {
+    const {
+      name: y,
+      fn: R
+    } = c[m], {
+      x: v,
+      y: x,
+      data: I,
+      reset: A
+    } = await R({
+      x: l,
+      y: p,
+      initialPlacement: r,
+      placement: g,
+      strategy: o,
+      middlewareData: d,
+      rects: u,
+      platform: i,
+      elements: {
+        reference: e,
+        floating: t
+      }
+    });
+    l = v ?? l, p = x ?? p, d = {
+      ...d,
+      [y]: {
+        ...d[y],
+        ...I
+      }
+    }, A && h <= 50 && (h++, typeof A == "object" && (A.placement && (g = A.placement), A.rects && (u = A.rects === !0 ? await i.getElementRects({
+      reference: e,
+      floating: t,
+      strategy: o
+    }) : A.rects), {
+      x: l,
+      y: p
+    } = bn(u, g, a)), m = -1);
+  }
+  return {
+    x: l,
+    y: p,
+    placement: g,
+    strategy: o,
+    middlewareData: d
+  };
+};
+async function kt(e, t) {
+  var n;
+  t === void 0 && (t = {});
+  const {
+    x: r,
+    y: o,
+    platform: s,
+    rects: i,
+    elements: c,
+    strategy: a
+  } = e, {
+    boundary: u = "clippingAncestors",
+    rootBoundary: l = "viewport",
+    elementContext: p = "floating",
+    altBoundary: g = !1,
+    padding: d = 0
+  } = Qe(t, e), h = Kr(d), y = c[g ? p === "floating" ? "reference" : "floating" : p], R = It(await s.getClippingRect({
+    element: (n = await (s.isElement == null ? void 0 : s.isElement(y))) == null || n ? y : y.contextElement || await (s.getDocumentElement == null ? void 0 : s.getDocumentElement(c.floating)),
+    boundary: u,
+    rootBoundary: l,
+    strategy: a
+  })), v = p === "floating" ? {
+    x: r,
+    y: o,
+    width: i.floating.width,
+    height: i.floating.height
+  } : i.reference, x = await (s.getOffsetParent == null ? void 0 : s.getOffsetParent(c.floating)), I = await (s.isElement == null ? void 0 : s.isElement(x)) ? await (s.getScale == null ? void 0 : s.getScale(x)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  }, A = It(s.convertOffsetParentRelativeRectToViewportRelativeRect ? await s.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: c,
+    rect: v,
+    offsetParent: x,
+    strategy: a
+  }) : v);
+  return {
+    top: (R.top - A.top + h.top) / I.y,
+    bottom: (A.bottom - R.bottom + h.bottom) / I.y,
+    left: (R.left - A.left + h.left) / I.x,
+    right: (A.right - R.right + h.right) / I.x
+  };
+}
+function Qr(e, t, n) {
+  return (e ? [...n.filter((o) => Ie(o) === e), ...n.filter((o) => Ie(o) !== e)] : n.filter((o) => Ce(o) === o)).filter((o) => e ? Ie(o) === e || (t ? Rt(o) !== o : !1) : !0);
+}
+const Zr = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "autoPlacement",
+    options: e,
+    async fn(t) {
+      var n, r, o;
+      const {
+        rects: s,
+        middlewareData: i,
+        placement: c,
+        platform: a,
+        elements: u
+      } = t, {
+        crossAxis: l = !1,
+        alignment: p,
+        allowedPlacements: g = mn,
+        autoAlignment: d = !0,
+        ...h
+      } = Qe(e, t), m = p !== void 0 || g === mn ? Qr(p || null, d, g) : g, y = await kt(t, h), R = ((n = i.autoPlacement) == null ? void 0 : n.index) || 0, v = m[R];
+      if (v == null)
+        return {};
+      const x = Yn(v, s, await (a.isRTL == null ? void 0 : a.isRTL(u.floating)));
+      if (c !== v)
+        return {
+          reset: {
+            placement: m[0]
+          }
+        };
+      const I = [y[Ce(v)], y[x[0]], y[x[1]]], A = [...((r = i.autoPlacement) == null ? void 0 : r.overflows) || [], {
+        placement: v,
+        overflows: I
+      }], k = m[R + 1];
+      if (k)
+        return {
+          data: {
+            index: R + 1,
+            overflows: A
+          },
+          reset: {
+            placement: k
+          }
+        };
+      const N = A.map((F) => {
+        const _ = Ie(F.placement);
+        return [F.placement, _ && l ? (
+          // Check along the mainAxis and main crossAxis side.
+          F.overflows.slice(0, 2).reduce((U, V) => U + V, 0)
+        ) : (
+          // Check only the mainAxis.
+          F.overflows[0]
+        ), F.overflows];
+      }).sort((F, _) => F[1] - _[1]), L = ((o = N.filter((F) => F[2].slice(
+        0,
+        // Aligned placements should not check their opposite crossAxis
+        // side.
+        Ie(F[0]) ? 2 : 3
+      ).every((_) => _ <= 0))[0]) == null ? void 0 : o[0]) || N[0][0];
+      return L !== c ? {
+        data: {
+          index: R + 1,
+          overflows: A
+        },
+        reset: {
+          placement: L
+        }
+      } : {};
+    }
+  };
+}, eo = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "flip",
+    options: e,
+    async fn(t) {
+      var n, r;
+      const {
+        placement: o,
+        middlewareData: s,
+        rects: i,
+        initialPlacement: c,
+        platform: a,
+        elements: u
+      } = t, {
+        mainAxis: l = !0,
+        crossAxis: p = !0,
+        fallbackPlacements: g,
+        fallbackStrategy: d = "bestFit",
+        fallbackAxisSideDirection: h = "none",
+        flipAlignment: m = !0,
+        ...y
+      } = Qe(e, t);
+      if ((n = s.arrow) != null && n.alignmentOffset)
+        return {};
+      const R = Ce(o), v = He(c), x = Ce(c) === c, I = await (a.isRTL == null ? void 0 : a.isRTL(u.floating)), A = g || (x || !m ? [Et(c)] : Lr(c)), k = h !== "none";
+      !g && k && A.push(...Nr(c, m, h, I));
+      const N = [c, ...A], S = await kt(t, y), L = [];
+      let F = ((r = s.flip) == null ? void 0 : r.overflows) || [];
+      if (l && L.push(S[R]), p) {
+        const O = Yn(o, i, I);
+        L.push(S[O[0]], S[O[1]]);
+      }
+      if (F = [...F, {
+        placement: o,
+        overflows: L
+      }], !L.every((O) => O <= 0)) {
+        var _, U;
+        const O = (((_ = s.flip) == null ? void 0 : _.index) || 0) + 1, w = N[O];
+        if (w)
+          return {
+            data: {
+              index: O,
+              overflows: F
+            },
+            reset: {
+              placement: w
+            }
+          };
+        let K = (U = F.filter((T) => T.overflows[0] <= 0).sort((T, b) => T.overflows[1] - b.overflows[1])[0]) == null ? void 0 : U.placement;
+        if (!K)
+          switch (d) {
+            case "bestFit": {
+              var V;
+              const T = (V = F.filter((b) => {
+                if (k) {
+                  const E = He(b.placement);
+                  return E === v || // Create a bias to the `y` side axis due to horizontal
+                  // reading directions favoring greater width.
+                  E === "y";
+                }
+                return !0;
+              }).map((b) => [b.placement, b.overflows.filter((E) => E > 0).reduce((E, M) => E + M, 0)]).sort((b, E) => b[1] - E[1])[0]) == null ? void 0 : V[0];
+              T && (K = T);
+              break;
+            }
+            case "initialPlacement":
+              K = c;
+              break;
+          }
+        if (o !== K)
+          return {
+            reset: {
+              placement: K
+            }
+          };
+      }
+      return {};
+    }
+  };
+};
+async function to(e, t) {
+  const {
+    placement: n,
+    platform: r,
+    elements: o
+  } = e, s = await (r.isRTL == null ? void 0 : r.isRTL(o.floating)), i = Ce(n), c = Ie(n), a = He(n) === "y", u = ["left", "top"].includes(i) ? -1 : 1, l = s && a ? -1 : 1, p = Qe(t, e);
+  let {
+    mainAxis: g,
+    crossAxis: d,
+    alignmentAxis: h
+  } = typeof p == "number" ? {
+    mainAxis: p,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: p.mainAxis || 0,
+    crossAxis: p.crossAxis || 0,
+    alignmentAxis: p.alignmentAxis
+  };
+  return c && typeof h == "number" && (d = c === "end" ? h * -1 : h), a ? {
+    x: d * l,
+    y: g * u
+  } : {
+    x: g * u,
+    y: d * l
+  };
+}
+const no = function(e) {
+  return e === void 0 && (e = 0), {
+    name: "offset",
+    options: e,
+    async fn(t) {
+      var n, r;
+      const {
+        x: o,
+        y: s,
+        placement: i,
+        middlewareData: c
+      } = t, a = await to(t, e);
+      return i === ((n = c.offset) == null ? void 0 : n.placement) && (r = c.arrow) != null && r.alignmentOffset ? {} : {
+        x: o + a.x,
+        y: s + a.y,
+        data: {
+          ...a,
+          placement: i
+        }
+      };
+    }
+  };
+}, ro = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "shift",
+    options: e,
+    async fn(t) {
+      const {
+        x: n,
+        y: r,
+        placement: o
+      } = t, {
+        mainAxis: s = !0,
+        crossAxis: i = !1,
+        limiter: c = {
+          fn: (y) => {
+            let {
+              x: R,
+              y: v
+            } = y;
+            return {
+              x: R,
+              y: v
+            };
+          }
+        },
+        ...a
+      } = Qe(e, t), u = {
+        x: n,
+        y: r
+      }, l = await kt(t, a), p = He(Ce(o)), g = Gn(p);
+      let d = u[g], h = u[p];
+      if (s) {
+        const y = g === "y" ? "top" : "left", R = g === "y" ? "bottom" : "right", v = d + l[y], x = d - l[R];
+        d = pn(v, d, x);
+      }
+      if (i) {
+        const y = p === "y" ? "top" : "left", R = p === "y" ? "bottom" : "right", v = h + l[y], x = h - l[R];
+        h = pn(v, h, x);
+      }
+      const m = c.fn({
+        ...t,
+        [g]: d,
+        [p]: h
+      });
+      return {
+        ...m,
+        data: {
+          x: m.x - n,
+          y: m.y - r,
+          enabled: {
+            [g]: s,
+            [p]: i
+          }
+        }
+      };
+    }
+  };
+}, oo = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "size",
+    options: e,
+    async fn(t) {
+      var n, r;
+      const {
+        placement: o,
+        rects: s,
+        platform: i,
+        elements: c
+      } = t, {
+        apply: a = () => {
+        },
+        ...u
+      } = Qe(e, t), l = await kt(t, u), p = Ce(o), g = Ie(o), d = He(o) === "y", {
+        width: h,
+        height: m
+      } = s.floating;
+      let y, R;
+      p === "top" || p === "bottom" ? (y = p, R = g === (await (i.isRTL == null ? void 0 : i.isRTL(c.floating)) ? "start" : "end") ? "left" : "right") : (R = p, y = g === "end" ? "top" : "bottom");
+      const v = m - l.top - l.bottom, x = h - l.left - l.right, I = Je(m - l[y], v), A = Je(h - l[R], x), k = !t.middlewareData.shift;
+      let N = I, S = A;
+      if ((n = t.middlewareData.shift) != null && n.enabled.x && (S = x), (r = t.middlewareData.shift) != null && r.enabled.y && (N = v), k && !g) {
+        const F = be(l.left, 0), _ = be(l.right, 0), U = be(l.top, 0), V = be(l.bottom, 0);
+        d ? S = h - 2 * (F !== 0 || _ !== 0 ? F + _ : be(l.left, l.right)) : N = m - 2 * (U !== 0 || V !== 0 ? U + V : be(l.top, l.bottom));
+      }
+      await a({
+        ...t,
+        availableWidth: S,
+        availableHeight: N
+      });
+      const L = await i.getDimensions(c.floating);
+      return h !== L.width || m !== L.height ? {
+        reset: {
+          rects: !0
+        }
+      } : {};
+    }
+  };
+};
+function ur(e) {
+  const t = we(e);
+  let n = parseFloat(t.width) || 0, r = parseFloat(t.height) || 0;
+  const o = oe(e), s = o ? e.offsetWidth : n, i = o ? e.offsetHeight : r, c = wt(n) !== s || wt(r) !== i;
+  return c && (n = s, r = i), {
+    width: n,
+    height: r,
+    $: c
+  };
+}
+function sn(e) {
+  return Y(e) ? e : e.contextElement;
+}
+function Xe(e) {
+  const t = sn(e);
+  if (!oe(t))
+    return Ee(1);
+  const n = t.getBoundingClientRect(), {
+    width: r,
+    height: o,
+    $: s
+  } = ur(t);
+  let i = (s ? wt(n.width) : n.width) / r, c = (s ? wt(n.height) : n.height) / o;
+  return (!i || !Number.isFinite(i)) && (i = 1), (!c || !Number.isFinite(c)) && (c = 1), {
+    x: i,
+    y: c
+  };
+}
+const io = /* @__PURE__ */ Ee(0);
+function lr(e) {
+  const t = he(e);
+  return !St() || !t.visualViewport ? io : {
+    x: t.visualViewport.offsetLeft,
+    y: t.visualViewport.offsetTop
+  };
+}
+function so(e, t, n) {
+  return t === void 0 && (t = !1), !n || t && n !== he(e) ? !1 : t;
+}
+function ze(e, t, n, r) {
+  t === void 0 && (t = !1), n === void 0 && (n = !1);
+  const o = e.getBoundingClientRect(), s = sn(e);
+  let i = Ee(1);
+  t && (r ? Y(r) && (i = Xe(r)) : i = Xe(e));
+  const c = so(s, n, r) ? lr(s) : Ee(0);
+  let a = (o.left + c.x) / i.x, u = (o.top + c.y) / i.y, l = o.width / i.x, p = o.height / i.y;
+  if (s) {
+    const g = he(s), d = r && Y(r) ? he(r) : r;
+    let h = g, m = Jt(h);
+    for (; m && r && d !== h; ) {
+      const y = Xe(m), R = m.getBoundingClientRect(), v = we(m), x = R.left + (m.clientLeft + parseFloat(v.paddingLeft)) * y.x, I = R.top + (m.clientTop + parseFloat(v.paddingTop)) * y.y;
+      a *= y.x, u *= y.y, l *= y.x, p *= y.y, a += x, u += I, h = he(m), m = Jt(h);
+    }
+  }
+  return It({
+    width: l,
+    height: p,
+    x: a,
+    y: u
+  });
+}
+function cn(e, t) {
+  const n = Dt(e).scrollLeft;
+  return t ? t.left + n : ze(Te(e)).left + n;
+}
+function ar(e, t, n) {
+  n === void 0 && (n = !1);
+  const r = e.getBoundingClientRect(), o = r.left + t.scrollLeft - (n ? 0 : (
+    // RTL <body> scrollbar.
+    cn(e, r)
+  )), s = r.top + t.scrollTop;
+  return {
+    x: o,
+    y: s
+  };
+}
+function co(e) {
+  let {
+    elements: t,
+    rect: n,
+    offsetParent: r,
+    strategy: o
+  } = e;
+  const s = o === "fixed", i = Te(r), c = t ? Pt(t.floating) : !1;
+  if (r === i || c && s)
+    return n;
+  let a = {
+    scrollLeft: 0,
+    scrollTop: 0
+  }, u = Ee(1);
+  const l = Ee(0), p = oe(r);
+  if ((p || !p && !s) && ((_e(r) !== "body" || ut(i)) && (a = Dt(r)), oe(r))) {
+    const d = ze(r);
+    u = Xe(r), l.x = d.x + r.clientLeft, l.y = d.y + r.clientTop;
+  }
+  const g = i && !p && !s ? ar(i, a, !0) : Ee(0);
+  return {
+    width: n.width * u.x,
+    height: n.height * u.y,
+    x: n.x * u.x - a.scrollLeft * u.x + l.x + g.x,
+    y: n.y * u.y - a.scrollTop * u.y + l.y + g.y
+  };
+}
+function uo(e) {
+  return Array.from(e.getClientRects());
+}
+function lo(e) {
+  const t = Te(e), n = Dt(e), r = e.ownerDocument.body, o = be(t.scrollWidth, t.clientWidth, r.scrollWidth, r.clientWidth), s = be(t.scrollHeight, t.clientHeight, r.scrollHeight, r.clientHeight);
+  let i = -n.scrollLeft + cn(e);
+  const c = -n.scrollTop;
+  return we(r).direction === "rtl" && (i += be(t.clientWidth, r.clientWidth) - o), {
+    width: o,
+    height: s,
+    x: i,
+    y: c
+  };
+}
+function ao(e, t) {
+  const n = he(e), r = Te(e), o = n.visualViewport;
+  let s = r.clientWidth, i = r.clientHeight, c = 0, a = 0;
+  if (o) {
+    s = o.width, i = o.height;
+    const u = St();
+    (!u || u && t === "fixed") && (c = o.offsetLeft, a = o.offsetTop);
+  }
+  return {
+    width: s,
+    height: i,
+    x: c,
+    y: a
+  };
+}
+function fo(e, t) {
+  const n = ze(e, !0, t === "fixed"), r = n.top + e.clientTop, o = n.left + e.clientLeft, s = oe(e) ? Xe(e) : Ee(1), i = e.clientWidth * s.x, c = e.clientHeight * s.y, a = o * s.x, u = r * s.y;
+  return {
+    width: i,
+    height: c,
+    x: a,
+    y: u
+  };
+}
+function yn(e, t, n) {
+  let r;
+  if (t === "viewport")
+    r = ao(e, n);
+  else if (t === "document")
+    r = lo(Te(e));
+  else if (Y(t))
+    r = fo(t, n);
+  else {
+    const o = lr(e);
+    r = {
+      x: t.x - o.x,
+      y: t.y - o.y,
+      width: t.width,
+      height: t.height
+    };
+  }
+  return It(r);
+}
+function fr(e, t) {
+  const n = Pe(e);
+  return n === t || !Y(n) || Me(n) ? !1 : we(n).position === "fixed" || fr(n, t);
+}
+function mo(e, t) {
+  const n = t.get(e);
+  if (n)
+    return n;
+  let r = ke(e, [], !1).filter((c) => Y(c) && _e(c) !== "body"), o = null;
+  const s = we(e).position === "fixed";
+  let i = s ? Pe(e) : e;
+  for (; Y(i) && !Me(i); ) {
+    const c = we(i), a = nn(i);
+    !a && c.position === "fixed" && (o = null), (s ? !a && !o : !a && c.position === "static" && !!o && ["absolute", "fixed"].includes(o.position) || ut(i) && !a && fr(e, i)) ? r = r.filter((l) => l !== i) : o = c, i = Pe(i);
+  }
+  return t.set(e, r), r;
+}
+function po(e) {
+  let {
+    element: t,
+    boundary: n,
+    rootBoundary: r,
+    strategy: o
+  } = e;
+  const i = [...n === "clippingAncestors" ? Pt(t) ? [] : mo(t, this._c) : [].concat(n), r], c = i[0], a = i.reduce((u, l) => {
+    const p = yn(t, l, o);
+    return u.top = be(p.top, u.top), u.right = Je(p.right, u.right), u.bottom = Je(p.bottom, u.bottom), u.left = be(p.left, u.left), u;
+  }, yn(t, c, o));
+  return {
+    width: a.right - a.left,
+    height: a.bottom - a.top,
+    x: a.left,
+    y: a.top
+  };
+}
+function go(e) {
+  const {
+    width: t,
+    height: n
+  } = ur(e);
+  return {
+    width: t,
+    height: n
+  };
+}
+function ho(e, t, n) {
+  const r = oe(t), o = Te(t), s = n === "fixed", i = ze(e, !0, s, t);
+  let c = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const a = Ee(0);
+  if (r || !r && !s)
+    if ((_e(t) !== "body" || ut(o)) && (c = Dt(t)), r) {
+      const g = ze(t, !0, s, t);
+      a.x = g.x + t.clientLeft, a.y = g.y + t.clientTop;
+    } else o && (a.x = cn(o));
+  const u = o && !r && !s ? ar(o, c) : Ee(0), l = i.left + c.scrollLeft - a.x - u.x, p = i.top + c.scrollTop - a.y - u.y;
+  return {
+    x: l,
+    y: p,
+    width: i.width,
+    height: i.height
+  };
+}
+function Wt(e) {
+  return we(e).position === "static";
+}
+function xn(e, t) {
+  if (!oe(e) || we(e).position === "fixed")
+    return null;
+  if (t)
+    return t(e);
+  let n = e.offsetParent;
+  return Te(e) === n && (n = n.ownerDocument.body), n;
+}
+function dr(e, t) {
+  const n = he(e);
+  if (Pt(e))
+    return n;
+  if (!oe(e)) {
+    let o = Pe(e);
+    for (; o && !Me(o); ) {
+      if (Y(o) && !Wt(o))
+        return o;
+      o = Pe(o);
+    }
+    return n;
+  }
+  let r = xn(e, t);
+  for (; r && Mr(r) && Wt(r); )
+    r = xn(r, t);
+  return r && Me(r) && Wt(r) && !nn(r) ? n : r || Pr(e) || n;
+}
+const vo = async function(e) {
+  const t = this.getOffsetParent || dr, n = this.getDimensions, r = await n(e.floating);
+  return {
+    reference: ho(e.reference, await t(e.floating), e.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      width: r.width,
+      height: r.height
+    }
+  };
+};
+function bo(e) {
+  return we(e).direction === "rtl";
+}
+const yo = {
+  convertOffsetParentRelativeRectToViewportRelativeRect: co,
+  getDocumentElement: Te,
+  getClippingRect: po,
+  getOffsetParent: dr,
+  getElementRects: vo,
+  getClientRects: uo,
+  getDimensions: go,
+  getScale: Xe,
+  isElement: Y,
+  isRTL: bo
+};
+function mr(e, t) {
+  return e.x === t.x && e.y === t.y && e.width === t.width && e.height === t.height;
+}
+function xo(e, t) {
+  let n = null, r;
+  const o = Te(e);
+  function s() {
+    var c;
+    clearTimeout(r), (c = n) == null || c.disconnect(), n = null;
+  }
+  function i(c, a) {
+    c === void 0 && (c = !1), a === void 0 && (a = 1), s();
+    const u = e.getBoundingClientRect(), {
+      left: l,
+      top: p,
+      width: g,
+      height: d
+    } = u;
+    if (c || t(), !g || !d)
+      return;
+    const h = je(p), m = je(o.clientWidth - (l + g)), y = je(o.clientHeight - (p + d)), R = je(l), x = {
+      rootMargin: -h + "px " + -m + "px " + -y + "px " + -R + "px",
+      threshold: be(0, Je(1, a)) || 1
+    };
+    let I = !0;
+    function A(k) {
+      const N = k[0].intersectionRatio;
+      if (N !== a) {
+        if (!I)
+          return i();
+        N ? i(!1, N) : r = setTimeout(() => {
+          i(!1, 1e-7);
+        }, 1e3);
+      }
+      N === 1 && !mr(u, e.getBoundingClientRect()) && i(), I = !1;
+    }
+    try {
+      n = new IntersectionObserver(A, {
+        ...x,
+        // Handle <iframe>s
+        root: o.ownerDocument
+      });
+    } catch {
+      n = new IntersectionObserver(A, x);
+    }
+    n.observe(e);
+  }
+  return i(!0), s;
+}
+function oi(e, t, n, r) {
+  r === void 0 && (r = {});
+  const {
+    ancestorScroll: o = !0,
+    ancestorResize: s = !0,
+    elementResize: i = typeof ResizeObserver == "function",
+    layoutShift: c = typeof IntersectionObserver == "function",
+    animationFrame: a = !1
+  } = r, u = sn(e), l = o || s ? [...u ? ke(u) : [], ...ke(t)] : [];
+  l.forEach((R) => {
+    o && R.addEventListener("scroll", n, {
+      passive: !0
+    }), s && R.addEventListener("resize", n);
+  });
+  const p = u && c ? xo(u, n) : null;
+  let g = -1, d = null;
+  i && (d = new ResizeObserver((R) => {
+    let [v] = R;
+    v && v.target === u && d && (d.unobserve(t), cancelAnimationFrame(g), g = requestAnimationFrame(() => {
+      var x;
+      (x = d) == null || x.observe(t);
+    })), n();
+  }), u && !a && d.observe(u), d.observe(t));
+  let h, m = a ? ze(e) : null;
+  a && y();
+  function y() {
+    const R = ze(e);
+    m && !mr(m, R) && n(), m = R, h = requestAnimationFrame(y);
+  }
+  return n(), () => {
+    var R;
+    l.forEach((v) => {
+      o && v.removeEventListener("scroll", n), s && v.removeEventListener("resize", n);
+    }), p == null || p(), (R = d) == null || R.disconnect(), d = null, a && cancelAnimationFrame(h);
+  };
+}
+const wo = no, Ro = Zr, Eo = ro, Io = eo, Co = oo, To = (e, t, n) => {
+  const r = /* @__PURE__ */ new Map(), o = {
+    platform: yo,
+    ...n
+  }, s = {
+    ...o.platform,
+    _c: r
+  };
+  return Jr(e, t, {
+    ...o,
+    platform: s
+  });
+};
+var xt = typeof document < "u" ? Wn : $n;
+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 s = o[r];
+      if (!(s === "_owner" && e.$$typeof) && !Tt(e[s], t[s]))
+        return !1;
+    }
+    return !0;
+  }
+  return e !== e && t !== t;
+}
+function pr(e) {
+  return typeof window > "u" ? 1 : (e.ownerDocument.defaultView || window).devicePixelRatio || 1;
+}
+function wn(e, t) {
+  const n = pr(e);
+  return Math.round(t * n) / n;
+}
+function $t(e) {
+  const t = f.useRef(e);
+  return xt(() => {
+    t.current = e;
+  }), t;
+}
+function Oo(e) {
+  e === void 0 && (e = {});
+  const {
+    placement: t = "bottom",
+    strategy: n = "absolute",
+    middleware: r = [],
+    platform: o,
+    elements: {
+      reference: s,
+      floating: i
+    } = {},
+    transform: c = !0,
+    whileElementsMounted: a,
+    open: u
+  } = e, [l, p] = f.useState({
+    x: 0,
+    y: 0,
+    strategy: n,
+    placement: t,
+    middlewareData: {},
+    isPositioned: !1
+  }), [g, d] = f.useState(r);
+  Tt(g, r) || d(r);
+  const [h, m] = f.useState(null), [y, R] = f.useState(null), v = f.useCallback((b) => {
+    b !== k.current && (k.current = b, m(b));
+  }, []), x = f.useCallback((b) => {
+    b !== N.current && (N.current = b, R(b));
+  }, []), I = s || h, A = i || y, k = f.useRef(null), N = f.useRef(null), S = f.useRef(l), L = a != null, F = $t(a), _ = $t(o), U = $t(u), V = f.useCallback(() => {
+    if (!k.current || !N.current)
+      return;
+    const b = {
+      placement: t,
+      strategy: n,
+      middleware: g
+    };
+    _.current && (b.platform = _.current), To(k.current, N.current, b).then((E) => {
+      const M = {
+        ...E,
+        // 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: U.current !== !1
+      };
+      O.current && !Tt(S.current, M) && (S.current = M, tn.flushSync(() => {
+        p(M);
+      }));
+    });
+  }, [g, t, n, _, U]);
+  xt(() => {
+    u === !1 && S.current.isPositioned && (S.current.isPositioned = !1, p((b) => ({
+      ...b,
+      isPositioned: !1
+    })));
+  }, [u]);
+  const O = f.useRef(!1);
+  xt(() => (O.current = !0, () => {
+    O.current = !1;
+  }), []), xt(() => {
+    if (I && (k.current = I), A && (N.current = A), I && A) {
+      if (F.current)
+        return F.current(I, A, V);
+      V();
+    }
+  }, [I, A, V, F, L]);
+  const w = f.useMemo(() => ({
+    reference: k,
+    floating: N,
+    setReference: v,
+    setFloating: x
+  }), [v, x]), K = f.useMemo(() => ({
+    reference: I,
+    floating: A
+  }), [I, A]), T = f.useMemo(() => {
+    const b = {
+      position: n,
+      left: 0,
+      top: 0
+    };
+    if (!K.floating)
+      return b;
+    const E = wn(K.floating, l.x), M = wn(K.floating, l.y);
+    return c ? {
+      ...b,
+      transform: "translate(" + E + "px, " + M + "px)",
+      ...pr(K.floating) >= 1.5 && {
+        willChange: "transform"
+      }
+    } : {
+      position: n,
+      left: E,
+      top: M
+    };
+  }, [n, c, K.floating, l.x, l.y]);
+  return f.useMemo(() => ({
+    ...l,
+    update: V,
+    refs: w,
+    elements: K,
+    floatingStyles: T
+  }), [l, V, w, K, T]);
+}
+const ii = (e, t) => ({
+  ...wo(e),
+  options: [e, t]
+}), si = (e, t) => ({
+  ...Eo(e),
+  options: [e, t]
+}), ci = (e, t) => ({
+  ...Io(e),
+  options: [e, t]
+}), ui = (e, t) => ({
+  ...Co(e),
+  options: [e, t]
+}), li = (e, t) => ({
+  ...Ro(e),
+  options: [e, t]
+});
+function Ao(e) {
+  const t = f.useRef(void 0), n = f.useCallback((r) => {
+    const o = e.map((s) => {
+      if (s != null) {
+        if (typeof s == "function") {
+          const i = s, c = i(r);
+          return typeof c == "function" ? c : () => {
+            i(null);
+          };
+        }
+        return s.current = r, () => {
+          s.current = null;
+        };
+      }
+    });
+    return () => {
+      o.forEach((s) => s == null ? void 0 : s());
+    };
+  }, e);
+  return f.useMemo(() => e.every((r) => r == null) ? null : (r) => {
+    t.current && (t.current(), t.current = void 0), r != null && (t.current = n(r));
+  }, e);
+}
+function Mo(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 gr = /* @__PURE__ */ f.createContext({
+  register: () => {
+  },
+  unregister: () => {
+  },
+  map: /* @__PURE__ */ new Map(),
+  elementsRef: {
+    current: []
+  }
+});
+function Po(e) {
+  const {
+    children: t,
+    elementsRef: n,
+    labelsRef: r
+  } = e, [o, s] = f.useState(() => /* @__PURE__ */ new Set()), i = f.useCallback((u) => {
+    s((l) => new Set(l).add(u));
+  }, []), c = f.useCallback((u) => {
+    s((l) => {
+      const p = new Set(l);
+      return p.delete(u), p;
+    });
+  }, []), a = f.useMemo(() => {
+    const u = /* @__PURE__ */ new Map();
+    return Array.from(o.keys()).sort(Mo).forEach((p, g) => {
+      u.set(p, g);
+    }), u;
+  }, [o]);
+  return /* @__PURE__ */ ge(gr.Provider, {
+    value: f.useMemo(() => ({
+      register: i,
+      unregister: c,
+      map: a,
+      elementsRef: n,
+      labelsRef: r
+    }), [i, c, a, n, r]),
+    children: t
+  });
+}
+function So(e) {
+  e === void 0 && (e = {});
+  const {
+    label: t
+  } = e, {
+    register: n,
+    unregister: r,
+    map: o,
+    elementsRef: s,
+    labelsRef: i
+  } = f.useContext(gr), [c, a] = f.useState(null), u = f.useRef(null), l = f.useCallback((p) => {
+    if (u.current = p, c !== null && (s.current[c] = p, i)) {
+      var g;
+      const d = t !== void 0;
+      i.current[c] = d ? t : (g = p == null ? void 0 : p.textContent) != null ? g : null;
+    }
+  }, [c, s, i, 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 && a(p);
+  }, [o]), f.useMemo(() => ({
+    ref: l,
+    index: c ?? -1
+  }), [c, l]);
+}
+const Do = "data-floating-ui-focusable", Rn = "active", En = "selected", Fe = "ArrowLeft", Ne = "ArrowRight", st = "ArrowUp", Le = "ArrowDown";
+function hr(e, t) {
+  return typeof e == "function" ? e(t) : e ? /* @__PURE__ */ f.cloneElement(e, t) : /* @__PURE__ */ ge("div", {
+    ...t
+  });
+}
+const vr = /* @__PURE__ */ f.createContext({
+  activeIndex: 0,
+  onNavigate: () => {
+  }
+}), br = [Fe, Ne], yr = [st, Le], Bt = [...br, ...yr], ai = /* @__PURE__ */ f.forwardRef(function(t, n) {
+  const {
+    render: r,
+    orientation: o = "both",
+    loop: s = !0,
+    rtl: i = !1,
+    cols: c = 1,
+    disabledIndices: a,
+    activeIndex: u,
+    onNavigate: l,
+    itemSizes: p,
+    dense: g = !1,
+    ...d
+  } = t, [h, m] = f.useState(0), y = u ?? h, R = ce(l ?? m), v = f.useRef([]), x = r && typeof r != "function" ? r.props : {}, I = f.useMemo(() => ({
+    activeIndex: y,
+    onNavigate: R
+  }), [y, R]), A = c > 1;
+  function k(S) {
+    if (!Bt.includes(S.key)) return;
+    let L = y;
+    const F = yt(v, a), _ = en(v, a), U = i ? Fe : Ne, V = i ? Ne : Fe;
+    if (A) {
+      const b = p || Array.from({
+        length: v.current.length
+      }, () => ({
+        width: 1,
+        height: 1
+      })), E = nr(b, c, g), M = E.findIndex((W) => W != null && !Be(v, W, a)), G = E.reduce((W, Z, fe) => Z != null && !Be(v, Z, a) ? fe : W, -1), C = E[tr({
+        current: E.map((W) => W ? v.current[W] : null)
+      }, {
+        event: S,
+        orientation: o,
+        loop: s,
+        rtl: i,
+        cols: c,
+        // treat undefined (empty grid spaces) as disabled indices so we
+        // don't end up in them
+        disabledIndices: or([...(typeof a != "function" ? a : null) || v.current.map((W, Z) => Be(v, Z, a) ? Z : void 0), void 0], E),
+        minIndex: M,
+        maxIndex: G,
+        prevIndex: rr(
+          y > _ ? F : y,
+          b,
+          E,
+          c,
+          // 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.
+          S.key === Le ? "bl" : S.key === U ? "tr" : "tl"
+        )
+      })];
+      C != null && (L = C);
+    }
+    const O = {
+      horizontal: [U],
+      vertical: [Le],
+      both: [U, Le]
+    }[o], w = {
+      horizontal: [V],
+      vertical: [st],
+      both: [V, st]
+    }[o], K = A ? Bt : {
+      horizontal: br,
+      vertical: yr,
+      both: Bt
+    }[o];
+    if (L === y && [...O, ...w].includes(S.key) && (s && L === _ && O.includes(S.key) ? L = F : s && L === F && w.includes(S.key) ? L = _ : L = le(v, {
+      startingIndex: L,
+      decrement: w.includes(S.key),
+      disabledIndices: a
+    })), L !== y && !Ye(v, L)) {
+      var T;
+      S.stopPropagation(), K.includes(S.key) && S.preventDefault(), R(L), (T = v.current[L]) == null || T.focus();
+    }
+  }
+  const N = {
+    ...d,
+    ...x,
+    ref: n,
+    "aria-orientation": o === "both" ? void 0 : o,
+    onKeyDown(S) {
+      d.onKeyDown == null || d.onKeyDown(S), x.onKeyDown == null || x.onKeyDown(S), k(S);
+    }
+  };
+  return /* @__PURE__ */ ge(vr.Provider, {
+    value: I,
+    children: /* @__PURE__ */ ge(Po, {
+      elementsRef: v,
+      children: hr(r, N)
+    })
+  });
+}), fi = /* @__PURE__ */ f.forwardRef(function(t, n) {
+  const {
+    render: r,
+    ...o
+  } = t, s = r && typeof r != "function" ? r.props : {}, {
+    activeIndex: i,
+    onNavigate: c
+  } = f.useContext(vr), {
+    ref: a,
+    index: u
+  } = So(), l = Ao([a, n, s.ref]), p = i === u, g = {
+    ...o,
+    ...s,
+    ref: l,
+    tabIndex: p ? 0 : -1,
+    "data-active": p ? "" : void 0,
+    onFocus(d) {
+      o.onFocus == null || o.onFocus(d), s.onFocus == null || s.onFocus(d), c(u);
+    }
+  };
+  return hr(r, g);
+}), ko = {
+  ...f
+};
+let In = !1, Lo = 0;
+const Cn = () => (
+  // Ensure the id is unique with multiple independent versions of Floating UI
+  // on <React 18
+  "floating-ui-" + Math.random().toString(36).slice(2, 6) + Lo++
+);
+function Fo() {
+  const [e, t] = f.useState(() => In ? Cn() : void 0);
+  return X(() => {
+    e == null && t(Cn());
+  }, []), f.useEffect(() => {
+    In = !0;
+  }, []), e;
+}
+const No = ko.useId, Lt = No || Fo;
+let ct;
+process.env.NODE_ENV !== "production" && (ct = /* @__PURE__ */ new Set());
+function Ht() {
+  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 = ct) != null && e.has(o))) {
+    var s;
+    (s = ct) == null || s.add(o), console.warn(o);
+  }
+}
+function _o() {
+  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 = ct) != null && e.has(o))) {
+    var s;
+    (s = ct) == null || s.add(o), console.error(o);
+  }
+}
+function xr() {
+  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 wr = /* @__PURE__ */ f.createContext(null), Rr = /* @__PURE__ */ f.createContext(null), Ze = () => {
+  var e;
+  return ((e = f.useContext(wr)) == null ? void 0 : e.id) || null;
+}, et = () => f.useContext(Rr);
+function di(e) {
+  const t = Lt(), n = et(), o = Ze();
+  return X(() => {
+    if (!t) return;
+    const s = {
+      id: t,
+      parentId: o
+    };
+    return n == null || n.addNode(s), () => {
+      n == null || n.removeNode(s);
+    };
+  }, [n, t, o]), t;
+}
+function mi(e) {
+  const {
+    children: t,
+    id: n
+  } = e, r = Ze();
+  return /* @__PURE__ */ ge(wr.Provider, {
+    value: f.useMemo(() => ({
+      id: n,
+      parentId: r
+    }), [n, r]),
+    children: t
+  });
+}
+function pi(e) {
+  const {
+    children: t
+  } = e, n = f.useRef([]), r = f.useCallback((i) => {
+    n.current = [...n.current, i];
+  }, []), o = f.useCallback((i) => {
+    n.current = n.current.filter((c) => c !== i);
+  }, []), [s] = f.useState(() => xr());
+  return /* @__PURE__ */ ge(Rr.Provider, {
+    value: f.useMemo(() => ({
+      nodesRef: n,
+      addNode: r,
+      removeNode: o,
+      events: s
+    }), [r, o, s]),
+    children: t
+  });
+}
+function Ue(e) {
+  return "data-floating-ui-" + e;
+}
+function ve(e) {
+  e.current !== -1 && (clearTimeout(e.current), e.current = -1);
+}
+const Tn = /* @__PURE__ */ Ue("safe-polygon");
+function zt(e, t, n) {
+  if (n && !it(n))
+    return 0;
+  if (typeof e == "number")
+    return e;
+  if (typeof e == "function") {
+    const r = e();
+    return typeof r == "number" ? r : r == null ? void 0 : r[t];
+  }
+  return e == null ? void 0 : e[t];
+}
+function Ut(e) {
+  return typeof e == "function" ? e() : e;
+}
+function gi(e, t) {
+  t === void 0 && (t = {});
+  const {
+    open: n,
+    onOpenChange: r,
+    dataRef: o,
+    events: s,
+    elements: i
+  } = e, {
+    enabled: c = !0,
+    delay: a = 0,
+    handleClose: u = null,
+    mouseOnly: l = !1,
+    restMs: p = 0,
+    move: g = !0
+  } = t, d = et(), h = Ze(), m = xe(u), y = xe(a), R = xe(n), v = xe(p), x = f.useRef(), I = f.useRef(-1), A = f.useRef(), k = f.useRef(-1), N = f.useRef(!0), S = f.useRef(!1), L = f.useRef(() => {
+  }), F = f.useRef(!1), _ = ce(() => {
+    var T;
+    const b = (T = o.current.openEvent) == null ? void 0 : T.type;
+    return (b == null ? void 0 : b.includes("mouse")) && b !== "mousedown";
+  });
+  f.useEffect(() => {
+    if (!c) return;
+    function T(b) {
+      let {
+        open: E
+      } = b;
+      E || (ve(I), ve(k), N.current = !0, F.current = !1);
+    }
+    return s.on("openchange", T), () => {
+      s.off("openchange", T);
+    };
+  }, [c, s]), f.useEffect(() => {
+    if (!c || !m.current || !n) return;
+    function T(E) {
+      _() && r(!1, E, "hover");
+    }
+    const b = ae(i.floating).documentElement;
+    return b.addEventListener("mouseleave", T), () => {
+      b.removeEventListener("mouseleave", T);
+    };
+  }, [i.floating, n, r, c, m, _]);
+  const U = f.useCallback(function(T, b, E) {
+    b === void 0 && (b = !0), E === void 0 && (E = "hover");
+    const M = zt(y.current, "close", x.current);
+    M && !A.current ? (ve(I), I.current = window.setTimeout(() => r(!1, T, E), M)) : b && (ve(I), r(!1, T, E));
+  }, [y, r]), V = ce(() => {
+    L.current(), A.current = void 0;
+  }), O = ce(() => {
+    if (S.current) {
+      const T = ae(i.floating).body;
+      T.style.pointerEvents = "", T.removeAttribute(Tn), S.current = !1;
+    }
+  }), w = ce(() => o.current.openEvent ? ["click", "mousedown"].includes(o.current.openEvent.type) : !1);
+  f.useEffect(() => {
+    if (!c) return;
+    function T(C) {
+      if (ve(I), N.current = !1, l && !it(x.current) || Ut(v.current) > 0 && !zt(y.current, "open"))
+        return;
+      const W = zt(y.current, "open", x.current);
+      W ? I.current = window.setTimeout(() => {
+        R.current || r(!0, C, "hover");
+      }, W) : n || r(!0, C, "hover");
+    }
+    function b(C) {
+      if (w()) {
+        O();
+        return;
+      }
+      L.current();
+      const W = ae(i.floating);
+      if (ve(k), F.current = !1, m.current && o.current.floatingContext) {
+        n || ve(I), A.current = m.current({
+          ...o.current.floatingContext,
+          tree: d,
+          x: C.clientX,
+          y: C.clientY,
+          onClose() {
+            O(), V(), w() || U(C, !0, "safe-polygon");
+          }
+        });
+        const fe = A.current;
+        W.addEventListener("mousemove", fe), L.current = () => {
+          W.removeEventListener("mousemove", fe);
+        };
+        return;
+      }
+      (x.current === "touch" ? !ue(i.floating, C.relatedTarget) : !0) && U(C);
+    }
+    function E(C) {
+      w() || o.current.floatingContext && (m.current == null || m.current({
+        ...o.current.floatingContext,
+        tree: d,
+        x: C.clientX,
+        y: C.clientY,
+        onClose() {
+          O(), V(), w() || U(C);
+        }
+      })(C));
+    }
+    function M() {
+      ve(I);
+    }
+    function G(C) {
+      w() || U(C, !1);
+    }
+    if (Y(i.domReference)) {
+      const C = i.domReference, W = i.floating;
+      return n && C.addEventListener("mouseleave", E), g && C.addEventListener("mousemove", T, {
+        once: !0
+      }), C.addEventListener("mouseenter", T), C.addEventListener("mouseleave", b), W && (W.addEventListener("mouseleave", E), W.addEventListener("mouseenter", M), W.addEventListener("mouseleave", G)), () => {
+        n && C.removeEventListener("mouseleave", E), g && C.removeEventListener("mousemove", T), C.removeEventListener("mouseenter", T), C.removeEventListener("mouseleave", b), W && (W.removeEventListener("mouseleave", E), W.removeEventListener("mouseenter", M), W.removeEventListener("mouseleave", G));
+      };
+    }
+  }, [i, c, e, l, g, U, V, O, r, n, R, d, y, m, o, w, v]), X(() => {
+    var T;
+    if (c && n && (T = m.current) != null && (T = T.__options) != null && T.blockPointerEvents && _()) {
+      S.current = !0;
+      const E = i.floating;
+      if (Y(i.domReference) && E) {
+        var b;
+        const M = ae(i.floating).body;
+        M.setAttribute(Tn, "");
+        const G = i.domReference, C = d == null || (b = d.nodesRef.current.find((W) => W.id === h)) == null || (b = b.context) == null ? void 0 : b.elements.floating;
+        return C && (C.style.pointerEvents = ""), M.style.pointerEvents = "none", G.style.pointerEvents = "auto", E.style.pointerEvents = "auto", () => {
+          M.style.pointerEvents = "", G.style.pointerEvents = "", E.style.pointerEvents = "";
+        };
+      }
+    }
+  }, [c, n, h, i, d, m, _]), X(() => {
+    n || (x.current = void 0, F.current = !1, V(), O());
+  }, [n, V, O]), f.useEffect(() => () => {
+    V(), ve(I), ve(k), O();
+  }, [c, i.domReference, V, O]);
+  const K = f.useMemo(() => {
+    function T(b) {
+      x.current = b.pointerType;
+    }
+    return {
+      onPointerDown: T,
+      onPointerEnter: T,
+      onMouseMove(b) {
+        const {
+          nativeEvent: E
+        } = b;
+        function M() {
+          !N.current && !R.current && r(!0, E, "hover");
+        }
+        l && !it(x.current) || n || Ut(v.current) === 0 || F.current && b.movementX ** 2 + b.movementY ** 2 < 2 || (ve(k), x.current === "touch" ? M() : (F.current = !0, k.current = window.setTimeout(M, Ut(v.current))));
+      }
+    };
+  }, [l, r, n, R, v]);
+  return f.useMemo(() => c ? {
+    reference: K
+  } : {}, [c, K]);
+}
+let On = 0;
+function We(e, t) {
+  t === void 0 && (t = {});
+  const {
+    preventScroll: n = !1,
+    cancelPrevious: r = !0,
+    sync: o = !1
+  } = t;
+  r && cancelAnimationFrame(On);
+  const s = () => e == null ? void 0 : e.focus({
+    preventScroll: n
+  });
+  o ? s() : On = requestAnimationFrame(s);
+}
+function Ko(e) {
+  return (e == null ? void 0 : e.ownerDocument) || document;
+}
+let Ge = /* @__PURE__ */ new WeakMap(), gt = /* @__PURE__ */ new WeakSet(), ht = {}, Gt = 0;
+const Vo = () => typeof HTMLElement < "u" && "inert" in HTMLElement.prototype, Er = (e) => e && (e.host || Er(e.parentNode)), Wo = (e, t) => t.map((n) => {
+  if (e.contains(n))
+    return n;
+  const r = Er(n);
+  return e.contains(r) ? r : null;
+}).filter((n) => n != null);
+function $o(e, t, n, r) {
+  const o = "data-floating-ui-inert", s = r ? "inert" : n ? "aria-hidden" : null, i = Wo(t, e), c = /* @__PURE__ */ new Set(), a = new Set(i), u = [];
+  ht[o] || (ht[o] = /* @__PURE__ */ new WeakMap());
+  const l = ht[o];
+  i.forEach(p), g(t), c.clear();
+  function p(d) {
+    !d || c.has(d) || (c.add(d), d.parentNode && p(d.parentNode));
+  }
+  function g(d) {
+    !d || a.has(d) || [].forEach.call(d.children, (h) => {
+      if (_e(h) !== "script")
+        if (c.has(h))
+          g(h);
+        else {
+          const m = s ? h.getAttribute(s) : null, y = m !== null && m !== "false", R = Ge.get(h) || 0, v = s ? R + 1 : R, x = (l.get(h) || 0) + 1;
+          Ge.set(h, v), l.set(h, x), u.push(h), v === 1 && y && gt.add(h), x === 1 && h.setAttribute(o, ""), !y && s && h.setAttribute(s, s === "inert" ? "" : "true");
+        }
+    });
+  }
+  return Gt++, () => {
+    u.forEach((d) => {
+      const h = Ge.get(d) || 0, m = s ? h - 1 : h, y = (l.get(d) || 0) - 1;
+      Ge.set(d, m), l.set(d, y), m || (!gt.has(d) && s && d.removeAttribute(s), gt.delete(d)), y || d.removeAttribute(o);
+    }), Gt--, Gt || (Ge = /* @__PURE__ */ new WeakMap(), Ge = /* @__PURE__ */ new WeakMap(), gt = /* @__PURE__ */ new WeakSet(), ht = {});
+  };
+}
+function An(e, t, n) {
+  t === void 0 && (t = !1), n === void 0 && (n = !1);
+  const r = Ko(e[0]).body;
+  return $o(e.concat(Array.from(r.querySelectorAll("[aria-live]"))), r, t, n);
+}
+const Ft = {
+  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__ */ f.forwardRef(function(t, n) {
+  const [r, o] = f.useState();
+  X(() => {
+    Jn() && o("button");
+  }, []);
+  const s = {
+    ref: n,
+    tabIndex: 0,
+    // Role is only for VoiceOver
+    role: r,
+    "aria-hidden": r ? void 0 : !0,
+    [Ue("focus-guard")]: "",
+    style: Ft
+  };
+  return /* @__PURE__ */ ge("span", {
+    ...t,
+    ...s
+  });
+}), Ir = /* @__PURE__ */ f.createContext(null), Mn = /* @__PURE__ */ Ue("portal");
+function Bo(e) {
+  e === void 0 && (e = {});
+  const {
+    id: t,
+    root: n
+  } = e, r = Lt(), o = Cr(), [s, i] = f.useState(null), c = f.useRef(null);
+  return X(() => () => {
+    s == null || s.remove(), queueMicrotask(() => {
+      c.current = null;
+    });
+  }, [s]), X(() => {
+    if (!r || c.current) return;
+    const a = t ? document.getElementById(t) : null;
+    if (!a) return;
+    const u = document.createElement("div");
+    u.id = r, u.setAttribute(Mn, ""), a.appendChild(u), c.current = u, i(u);
+  }, [t, r]), X(() => {
+    if (n === null || !r || c.current) return;
+    let a = n || (o == null ? void 0 : o.portalNode);
+    a && !Y(a) && (a = a.current), a = a || document.body;
+    let u = null;
+    t && (u = document.createElement("div"), u.id = t, a.appendChild(u));
+    const l = document.createElement("div");
+    l.id = r, l.setAttribute(Mn, ""), a = u || a, a.appendChild(l), c.current = l, i(l);
+  }, [t, n, r, o]), s;
+}
+function hi(e) {
+  const {
+    children: t,
+    id: n,
+    root: r,
+    preserveTabOrder: o = !0
+  } = e, s = Bo({
+    id: n,
+    root: r
+  }), [i, c] = f.useState(null), a = f.useRef(null), u = f.useRef(null), l = f.useRef(null), p = f.useRef(null), g = i == null ? void 0 : i.modal, d = i == null ? void 0 : i.open, h = (
+    // The FocusManager and therefore floating element are currently open/
+    // rendered.
+    !!i && // Guards are only for non-modal focus management.
+    !i.modal && // Don't render if unmount is transitioning.
+    i.open && o && !!(r || s)
+  );
+  return f.useEffect(() => {
+    if (!s || !o || g)
+      return;
+    function m(y) {
+      s && ot(y) && (y.type === "focusin" ? vn : Xr)(s);
+    }
+    return s.addEventListener("focusin", m, !0), s.addEventListener("focusout", m, !0), () => {
+      s.removeEventListener("focusin", m, !0), s.removeEventListener("focusout", m, !0);
+    };
+  }, [s, o, g]), f.useEffect(() => {
+    s && (d || vn(s));
+  }, [d, s]), /* @__PURE__ */ Hn(Ir.Provider, {
+    value: f.useMemo(() => ({
+      preserveTabOrder: o,
+      beforeOutsideRef: a,
+      afterOutsideRef: u,
+      beforeInsideRef: l,
+      afterInsideRef: p,
+      portalNode: s,
+      setFocusManagerState: c
+    }), [o, s]),
+    children: [h && s && /* @__PURE__ */ ge(Ot, {
+      "data-type": "outside",
+      ref: a,
+      onFocus: (m) => {
+        if (ot(m, s)) {
+          var y;
+          (y = l.current) == null || y.focus();
+        } else {
+          const R = i ? i.domReference : null, v = cr(R);
+          v == null || v.focus();
+        }
+      }
+    }), h && s && /* @__PURE__ */ ge("span", {
+      "aria-owns": s.id,
+      style: Ft
+    }), s && /* @__PURE__ */ tn.createPortal(t, s), h && s && /* @__PURE__ */ ge(Ot, {
+      "data-type": "outside",
+      ref: u,
+      onFocus: (m) => {
+        if (ot(m, s)) {
+          var y;
+          (y = p.current) == null || y.focus();
+        } else {
+          const R = i ? i.domReference : null, v = sr(R);
+          v == null || v.focus(), i != null && i.closeOnFocusOut && (i == null || i.onOpenChange(!1, m.nativeEvent, "focus-out"));
+        }
+      }
+    })]
+  });
+}
+const Cr = () => f.useContext(Ir);
+function Pn(e) {
+  return f.useMemo(() => (t) => {
+    e.forEach((n) => {
+      n && (n.current = t);
+    });
+  }, e);
+}
+const Ho = 20;
+let $e = [];
+function zo(e) {
+  $e = $e.filter((t) => t.isConnected), e && _e(e) !== "body" && ($e.push(e), $e.length > Ho && ($e = $e.slice(-20)));
+}
+function Sn() {
+  return $e.slice().reverse().find((e) => e.isConnected);
+}
+function Uo(e) {
+  const t = lt();
+  return Bn(e, t) ? e : At(e, t)[0] || e;
+}
+function Dn(e, t) {
+  var n;
+  if (!t.current.includes("floating") && !((n = e.getAttribute("role")) != null && n.includes("dialog")))
+    return;
+  const r = lt(), s = Or(e, r).filter((c) => {
+    const a = c.getAttribute("data-tabindex") || "";
+    return Bn(c, r) || c.hasAttribute("data-tabindex") && !a.startsWith("-");
+  }), i = e.getAttribute("tabindex");
+  t.current.includes("floating") || s.length === 0 ? i !== "0" && e.setAttribute("tabindex", "0") : (i !== "-1" || e.hasAttribute("data-tabindex") && e.getAttribute("data-tabindex") !== "-1") && (e.setAttribute("tabindex", "-1"), e.setAttribute("data-tabindex", "-1"));
+}
+const Go = /* @__PURE__ */ f.forwardRef(function(t, n) {
+  return /* @__PURE__ */ ge("button", {
+    ...t,
+    type: "button",
+    ref: n,
+    tabIndex: -1,
+    style: Ft
+  });
+});
+function vi(e) {
+  const {
+    context: t,
+    children: n,
+    disabled: r = !1,
+    order: o = ["content"],
+    guards: s = !0,
+    initialFocus: i = 0,
+    returnFocus: c = !0,
+    restoreFocus: a = !1,
+    modal: u = !0,
+    visuallyHiddenDismiss: l = !1,
+    closeOnFocusOut: p = !0,
+    outsideElementsInert: g = !1,
+    getInsideElements: d = () => []
+  } = e, {
+    open: h,
+    onOpenChange: m,
+    events: y,
+    dataRef: R,
+    elements: {
+      domReference: v,
+      floating: x
+    }
+  } = t, I = ce(() => {
+    var B;
+    return (B = R.current.floatingContext) == null ? void 0 : B.nodeId;
+  }), A = ce(d), k = typeof i == "number" && i < 0, N = Zt(v) && k, S = Vo(), L = S ? s : !0, F = !L || S && g, _ = xe(o), U = xe(i), V = xe(c), O = et(), w = Cr(), K = f.useRef(null), T = f.useRef(null), b = f.useRef(!1), E = f.useRef(!1), M = f.useRef(-1), G = w != null, C = Ct(x), W = ce(function(B) {
+    return B === void 0 && (B = C), B ? At(B, lt()) : [];
+  }), Z = ce((B) => {
+    const z = W(B);
+    return _.current.map((H) => v && H === "reference" ? v : C && H === "floating" ? C : z).filter(Boolean).flat();
+  });
+  f.useEffect(() => {
+    if (r || !u) return;
+    function B(H) {
+      if (H.key === "Tab") {
+        ue(C, Re(ae(C))) && W().length === 0 && !N && pe(H);
+        const $ = Z(), se = De(H);
+        _.current[0] === "reference" && se === v && (pe(H), H.shiftKey ? We($[$.length - 1]) : We($[1])), _.current[1] === "floating" && se === C && H.shiftKey && (pe(H), We($[0]));
+      }
+    }
+    const z = ae(C);
+    return z.addEventListener("keydown", B), () => {
+      z.removeEventListener("keydown", B);
+    };
+  }, [r, v, C, u, _, N, W, Z]), f.useEffect(() => {
+    if (r || !x) return;
+    function B(z) {
+      const H = De(z), se = W().indexOf(H);
+      se !== -1 && (M.current = se);
+    }
+    return x.addEventListener("focusin", B), () => {
+      x.removeEventListener("focusin", B);
+    };
+  }, [r, x, W]), f.useEffect(() => {
+    if (r || !p) return;
+    function B() {
+      E.current = !0, setTimeout(() => {
+        E.current = !1;
+      });
+    }
+    function z(H) {
+      const $ = H.relatedTarget, se = H.currentTarget;
+      queueMicrotask(() => {
+        const re = I(), me = !(ue(v, $) || ue(x, $) || ue($, x) || ue(w == null ? void 0 : w.portalNode, $) || $ != null && $.hasAttribute(Ue("focus-guard")) || O && (qe(O.nodesRef.current, re).find((ne) => {
+          var j, ee;
+          return ue((j = ne.context) == null ? void 0 : j.elements.floating, $) || ue((ee = ne.context) == null ? void 0 : ee.elements.domReference, $);
+        }) || hn(O.nodesRef.current, re).find((ne) => {
+          var j, ee, tt;
+          return [(j = ne.context) == null ? void 0 : j.elements.floating, Ct((ee = ne.context) == null ? void 0 : ee.elements.floating)].includes($) || ((tt = ne.context) == null ? void 0 : tt.elements.domReference) === $;
+        })));
+        if (se === v && C && Dn(C, _), a && me && Re(ae(C)) === ae(C).body) {
+          oe(C) && C.focus();
+          const ne = M.current, j = W(), ee = j[ne] || j[j.length - 1] || C;
+          oe(ee) && ee.focus();
+        }
+        if (R.current.insideReactTree) {
+          R.current.insideReactTree = !1;
+          return;
+        }
+        (N || !u) && $ && me && !E.current && // Fix React 18 Strict Mode returnFocus due to double rendering.
+        $ !== Sn() && (b.current = !0, m(!1, H, "focus-out"));
+      });
+    }
+    if (x && oe(v))
+      return v.addEventListener("focusout", z), v.addEventListener("pointerdown", B), x.addEventListener("focusout", z), () => {
+        v.removeEventListener("focusout", z), v.removeEventListener("pointerdown", B), x.removeEventListener("focusout", z);
+      };
+  }, [r, v, x, C, u, O, w, m, p, a, W, N, I, _, R]);
+  const fe = f.useRef(null), te = f.useRef(null), de = Pn([fe, w == null ? void 0 : w.beforeInsideRef]), Oe = Pn([te, w == null ? void 0 : w.afterInsideRef]);
+  f.useEffect(() => {
+    var B, z;
+    if (r || !x) return;
+    const H = Array.from((w == null || (B = w.portalNode) == null ? void 0 : B.querySelectorAll("[" + Ue("portal") + "]")) || []), $ = O ? hn(O.nodesRef.current, I()) : [], se = O && !u ? $.map((j) => {
+      var ee;
+      return (ee = j.context) == null ? void 0 : ee.elements.floating;
+    }) : [], re = (z = $.find((j) => {
+      var ee;
+      return Zt(((ee = j.context) == null ? void 0 : ee.elements.domReference) || null);
+    })) == null || (z = z.context) == null ? void 0 : z.elements.domReference, me = [x, re, ...H, ...se, ...A(), K.current, T.current, fe.current, te.current, w == null ? void 0 : w.beforeOutsideRef.current, w == null ? void 0 : w.afterOutsideRef.current, _.current.includes("reference") || N ? v : null].filter((j) => j != null), ne = u || N ? An(me, !F, F) : An(me);
+    return () => {
+      ne();
+    };
+  }, [r, v, x, u, _, w, N, L, F, O, I, A]), X(() => {
+    if (r || !oe(C)) return;
+    const B = ae(C), z = Re(B);
+    queueMicrotask(() => {
+      const H = Z(C), $ = U.current, se = (typeof $ == "number" ? H[$] : $.current) || C, re = ue(C, z);
+      !k && !re && h && We(se, {
+        preventScroll: se === C
+      });
+    });
+  }, [r, h, C, k, Z, U]), X(() => {
+    if (r || !C) return;
+    const B = ae(C), z = Re(B);
+    zo(z);
+    function H(re) {
+      let {
+        reason: me,
+        event: ne,
+        nested: j
+      } = re;
+      if (["hover", "safe-polygon"].includes(me) && ne.type === "mouseleave" && (b.current = !0), me === "outside-press")
+        if (j)
+          b.current = !1;
+        else if (Zn(ne) || er(ne))
+          b.current = !1;
+        else {
+          let ee = !1;
+          document.createElement("div").focus({
+            get preventScroll() {
+              return ee = !0, !1;
+            }
+          }), ee ? b.current = !1 : b.current = !0;
+        }
+    }
+    y.on("openchange", H);
+    const $ = B.createElement("span");
+    $.setAttribute("tabindex", "-1"), $.setAttribute("aria-hidden", "true"), Object.assign($.style, Ft), G && v && v.insertAdjacentElement("afterend", $);
+    function se() {
+      if (typeof V.current == "boolean") {
+        const re = v || Sn();
+        return re && re.isConnected ? re : $;
+      }
+      return V.current.current || $;
+    }
+    return () => {
+      y.off("openchange", H);
+      const re = Re(B), me = ue(x, re) || O && qe(O.nodesRef.current, I()).some((j) => {
+        var ee;
+        return ue((ee = j.context) == null ? void 0 : ee.elements.floating, re);
+      }), ne = se();
+      queueMicrotask(() => {
+        const j = Uo(ne);
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+        V.current && !b.current && oe(j) && // 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
+        (!(j !== re && re !== B.body) || me) && j.focus({
+          preventScroll: !0
+        }), $.remove();
+      });
+    };
+  }, [r, x, C, V, R, y, O, G, v, I]), f.useEffect(() => {
+    queueMicrotask(() => {
+      b.current = !1;
+    });
+  }, [r]), X(() => {
+    if (!r && w)
+      return w.setFocusManagerState({
+        modal: u,
+        closeOnFocusOut: p,
+        open: h,
+        onOpenChange: m,
+        domReference: v
+      }), () => {
+        w.setFocusManagerState(null);
+      };
+  }, [r, w, u, h, m, p, v]), X(() => {
+    r || C && Dn(C, _);
+  }, [r, C, _]);
+  function Ke(B) {
+    return r || !l || !u ? null : /* @__PURE__ */ ge(Go, {
+      ref: B === "start" ? K : T,
+      onClick: (z) => m(!1, z.nativeEvent),
+      children: typeof l == "string" ? l : "Dismiss"
+    });
+  }
+  const Ae = !r && L && (u ? !N : !0) && (G || u);
+  return /* @__PURE__ */ Hn(Ar, {
+    children: [Ae && /* @__PURE__ */ ge(Ot, {
+      "data-type": "inside",
+      ref: de,
+      onFocus: (B) => {
+        if (u) {
+          const H = Z();
+          We(o[0] === "reference" ? H[0] : H[H.length - 1]);
+        } else if (w != null && w.preserveTabOrder && w.portalNode)
+          if (b.current = !1, ot(B, w.portalNode)) {
+            const H = sr(v);
+            H == null || H.focus();
+          } else {
+            var z;
+            (z = w.beforeOutsideRef.current) == null || z.focus();
+          }
+      }
+    }), !N && Ke("start"), n, Ke("end"), Ae && /* @__PURE__ */ ge(Ot, {
+      "data-type": "inside",
+      ref: Oe,
+      onFocus: (B) => {
+        if (u)
+          We(Z()[0]);
+        else if (w != null && w.preserveTabOrder && w.portalNode)
+          if (p && (b.current = !0), ot(B, w.portalNode)) {
+            const H = cr(v);
+            H == null || H.focus();
+          } else {
+            var z;
+            (z = w.afterOutsideRef.current) == null || z.focus();
+          }
+      }
+    })]
+  });
+}
+let vt = 0;
+const kn = "--floating-ui-scrollbar-width";
+function jo() {
+  const e = rn(), 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", s = window.innerWidth - document.documentElement.clientWidth, i = n.left ? parseFloat(n.left) : window.scrollX, c = n.top ? parseFloat(n.top) : window.scrollY;
+  if (n.overflow = "hidden", n.setProperty(kn, s + "px"), s && (n[o] = s + "px"), t) {
+    var a, u;
+    const l = ((a = window.visualViewport) == null ? void 0 : a.offsetLeft) || 0, p = ((u = window.visualViewport) == null ? void 0 : u.offsetTop) || 0;
+    Object.assign(n, {
+      position: "fixed",
+      top: -(c - Math.floor(p)) + "px",
+      left: -(i - Math.floor(l)) + "px",
+      right: "0"
+    });
+  }
+  return () => {
+    Object.assign(n, {
+      overflow: "",
+      [o]: ""
+    }), n.removeProperty(kn), t && (Object.assign(n, {
+      position: "",
+      top: "",
+      left: "",
+      right: ""
+    }), window.scrollTo(i, c));
+  };
+}
+let Ln = () => {
+};
+const bi = /* @__PURE__ */ f.forwardRef(function(t, n) {
+  const {
+    lockScroll: r = !1,
+    ...o
+  } = t;
+  return X(() => {
+    if (r)
+      return vt++, vt === 1 && (Ln = jo()), () => {
+        vt--, vt === 0 && Ln();
+      };
+  }, [r]), /* @__PURE__ */ ge("div", {
+    ref: n,
+    ...o,
+    style: {
+      position: "fixed",
+      overflow: "auto",
+      top: 0,
+      right: 0,
+      bottom: 0,
+      left: 0,
+      ...o.style
+    }
+  });
+});
+function Fn(e) {
+  return oe(e.target) && e.target.tagName === "BUTTON";
+}
+function qo(e) {
+  return oe(e.target) && e.target.tagName === "A";
+}
+function Nn(e) {
+  return on(e);
+}
+function yi(e, t) {
+  t === void 0 && (t = {});
+  const {
+    open: n,
+    onOpenChange: r,
+    dataRef: o,
+    elements: {
+      domReference: s
+    }
+  } = e, {
+    enabled: i = !0,
+    event: c = "click",
+    toggle: a = !0,
+    ignoreMouse: u = !1,
+    keyboardHandlers: l = !0,
+    stickIfOpen: p = !0
+  } = t, g = f.useRef(), d = f.useRef(!1), h = f.useMemo(() => ({
+    onPointerDown(m) {
+      g.current = m.pointerType;
+    },
+    onMouseDown(m) {
+      const y = g.current;
+      m.button === 0 && c !== "click" && (it(y, !0) && u || (n && a && (!(o.current.openEvent && p) || o.current.openEvent.type === "mousedown") ? r(!1, m.nativeEvent, "click") : (m.preventDefault(), r(!0, m.nativeEvent, "click"))));
+    },
+    onClick(m) {
+      const y = g.current;
+      if (c === "mousedown" && g.current) {
+        g.current = void 0;
+        return;
+      }
+      it(y, !0) && u || (n && a && (!(o.current.openEvent && p) || o.current.openEvent.type === "click") ? r(!1, m.nativeEvent, "click") : r(!0, m.nativeEvent, "click"));
+    },
+    onKeyDown(m) {
+      g.current = void 0, !(m.defaultPrevented || !l || Fn(m)) && (m.key === " " && !Nn(s) && (m.preventDefault(), d.current = !0), !qo(m) && m.key === "Enter" && r(!(n && a), m.nativeEvent, "click"));
+    },
+    onKeyUp(m) {
+      m.defaultPrevented || !l || Fn(m) || Nn(s) || m.key === " " && d.current && (d.current = !1, r(!(n && a), m.nativeEvent, "click"));
+    }
+  }), [o, s, c, u, l, r, n, p, a]);
+  return f.useMemo(() => i ? {
+    reference: h
+  } : {}, [i, h]);
+}
+const Yo = {
+  pointerdown: "onPointerDown",
+  mousedown: "onMouseDown",
+  click: "onClick"
+}, Xo = {
+  pointerdown: "onPointerDownCapture",
+  mousedown: "onMouseDownCapture",
+  click: "onClickCapture"
+}, _n = (e) => {
+  var t, n;
+  return {
+    escapeKey: typeof e == "boolean" ? e : (t = e == null ? void 0 : e.escapeKey) != null ? t : !1,
+    outsidePress: typeof e == "boolean" ? e : (n = e == null ? void 0 : e.outsidePress) != null ? n : !0
+  };
+};
+function xi(e, t) {
+  t === void 0 && (t = {});
+  const {
+    open: n,
+    onOpenChange: r,
+    elements: o,
+    dataRef: s
+  } = e, {
+    enabled: i = !0,
+    escapeKey: c = !0,
+    outsidePress: a = !0,
+    outsidePressEvent: u = "pointerdown",
+    referencePress: l = !1,
+    referencePressEvent: p = "pointerdown",
+    ancestorScroll: g = !1,
+    bubbles: d,
+    capture: h
+  } = t, m = et(), y = ce(typeof a == "function" ? a : () => !1), R = typeof a == "function" ? y : a, v = f.useRef(!1), {
+    escapeKey: x,
+    outsidePress: I
+  } = _n(d), {
+    escapeKey: A,
+    outsidePress: k
+  } = _n(h), N = f.useRef(!1), S = f.useRef(-1), L = ce((w) => {
+    var K;
+    if (!n || !i || !c || w.key !== "Escape" || N.current)
+      return;
+    const T = (K = s.current.floatingContext) == null ? void 0 : K.nodeId, b = m ? qe(m.nodesRef.current, T) : [];
+    if (!x && (w.stopPropagation(), b.length > 0)) {
+      let E = !0;
+      if (b.forEach((M) => {
+        var G;
+        if ((G = M.context) != null && G.open && !M.context.dataRef.current.__escapeKeyBubbles) {
+          E = !1;
+          return;
+        }
+      }), !E)
+        return;
+    }
+    r(!1, Gr(w) ? w.nativeEvent : w, "escape-key");
+  }), F = ce((w) => {
+    var K;
+    const T = () => {
+      var b;
+      L(w), (b = De(w)) == null || b.removeEventListener("keydown", T);
+    };
+    (K = De(w)) == null || K.addEventListener("keydown", T);
+  }), _ = ce((w) => {
+    var K;
+    const T = s.current.insideReactTree;
+    s.current.insideReactTree = !1;
+    const b = v.current;
+    if (v.current = !1, u === "click" && b || T || typeof R == "function" && !R(w))
+      return;
+    const E = De(w), M = "[" + Ue("inert") + "]", G = ae(o.floating).querySelectorAll(M);
+    let C = Y(E) ? E : null;
+    for (; C && !Me(C); ) {
+      const te = Pe(C);
+      if (Me(te) || !Y(te))
+        break;
+      C = te;
+    }
+    if (G.length && Y(E) && !Hr(E) && // Clicked on a direct ancestor (e.g. FloatingOverlay).
+    !ue(E, o.floating) && // If the target root element contains none of the markers, then the
+    // element was injected after the floating element rendered.
+    Array.from(G).every((te) => !ue(C, te)))
+      return;
+    if (oe(E) && O) {
+      const te = Me(E), de = we(E), Oe = /auto|scroll/, Ke = te || Oe.test(de.overflowX), Ae = te || Oe.test(de.overflowY), B = Ke && E.clientWidth > 0 && E.scrollWidth > E.clientWidth, z = Ae && E.clientHeight > 0 && E.scrollHeight > E.clientHeight, H = de.direction === "rtl", $ = z && (H ? w.offsetX <= E.offsetWidth - E.clientWidth : w.offsetX > E.clientWidth), se = B && w.offsetY > E.clientHeight;
+      if ($ || se)
+        return;
+    }
+    const W = (K = s.current.floatingContext) == null ? void 0 : K.nodeId, Z = m && qe(m.nodesRef.current, W).some((te) => {
+      var de;
+      return Vt(w, (de = te.context) == null ? void 0 : de.elements.floating);
+    });
+    if (Vt(w, o.floating) || Vt(w, o.domReference) || Z)
+      return;
+    const fe = m ? qe(m.nodesRef.current, W) : [];
+    if (fe.length > 0) {
+      let te = !0;
+      if (fe.forEach((de) => {
+        var Oe;
+        if ((Oe = de.context) != null && Oe.open && !de.context.dataRef.current.__outsidePressBubbles) {
+          te = !1;
+          return;
+        }
+      }), !te)
+        return;
+    }
+    r(!1, w, "outside-press");
+  }), U = ce((w) => {
+    var K;
+    const T = () => {
+      var b;
+      _(w), (b = De(w)) == null || b.removeEventListener(u, T);
+    };
+    (K = De(w)) == null || K.addEventListener(u, T);
+  });
+  f.useEffect(() => {
+    if (!n || !i)
+      return;
+    s.current.__escapeKeyBubbles = x, s.current.__outsidePressBubbles = I;
+    let w = -1;
+    function K(G) {
+      r(!1, G, "ancestor-scroll");
+    }
+    function T() {
+      window.clearTimeout(w), N.current = !0;
+    }
+    function b() {
+      w = window.setTimeout(
+        () => {
+          N.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.
+        St() ? 5 : 0
+      );
+    }
+    const E = ae(o.floating);
+    c && (E.addEventListener("keydown", A ? F : L, A), E.addEventListener("compositionstart", T), E.addEventListener("compositionend", b)), R && E.addEventListener(u, k ? U : _, k);
+    let M = [];
+    return g && (Y(o.domReference) && (M = ke(o.domReference)), Y(o.floating) && (M = M.concat(ke(o.floating))), !Y(o.reference) && o.reference && o.reference.contextElement && (M = M.concat(ke(o.reference.contextElement)))), M = M.filter((G) => {
+      var C;
+      return G !== ((C = E.defaultView) == null ? void 0 : C.visualViewport);
+    }), M.forEach((G) => {
+      G.addEventListener("scroll", K, {
+        passive: !0
+      });
+    }), () => {
+      c && (E.removeEventListener("keydown", A ? F : L, A), E.removeEventListener("compositionstart", T), E.removeEventListener("compositionend", b)), R && E.removeEventListener(u, k ? U : _, k), M.forEach((G) => {
+        G.removeEventListener("scroll", K);
+      }), window.clearTimeout(w);
+    };
+  }, [s, o, c, R, u, n, r, g, i, x, I, L, A, F, _, k, U]), f.useEffect(() => {
+    s.current.insideReactTree = !1;
+  }, [s, R, u]);
+  const V = f.useMemo(() => ({
+    onKeyDown: L,
+    ...l && {
+      [Yo[p]]: (w) => {
+        r(!1, w.nativeEvent, "reference-press");
+      },
+      ...p !== "click" && {
+        onClick(w) {
+          r(!1, w.nativeEvent, "reference-press");
+        }
+      }
+    }
+  }), [L, r, l, p]), O = f.useMemo(() => ({
+    onKeyDown: L,
+    onMouseDown() {
+      v.current = !0;
+    },
+    onMouseUp() {
+      v.current = !0;
+    },
+    [Xo[u]]: () => {
+      s.current.insideReactTree = !0;
+    },
+    onBlurCapture() {
+      m || (ve(S), s.current.insideReactTree = !0, S.current = window.setTimeout(() => {
+        s.current.insideReactTree = !1;
+      }));
+    }
+  }), [L, u, s, m]);
+  return f.useMemo(() => i ? {
+    reference: V,
+    floating: O
+  } : {}, [i, V, O]);
+}
+function Jo(e) {
+  const {
+    open: t = !1,
+    onOpenChange: n,
+    elements: r
+  } = e, o = Lt(), s = f.useRef({}), [i] = f.useState(() => xr()), c = Ze() != null;
+  if (process.env.NODE_ENV !== "production") {
+    const d = r.reference;
+    d && !Y(d) && _o("Cannot pass a virtual element to the `elements.reference` option,", "as it must be a real DOM element. Use `refs.setPositionReference()`", "instead.");
+  }
+  const [a, u] = f.useState(r.reference), l = ce((d, h, m) => {
+    s.current.openEvent = d ? h : void 0, i.emit("openchange", {
+      open: d,
+      event: h,
+      reason: m,
+      nested: c
+    }), n == null || n(d, h, m);
+  }), p = f.useMemo(() => ({
+    setPositionReference: u
+  }), []), g = f.useMemo(() => ({
+    reference: a || r.reference || null,
+    floating: r.floating || null,
+    domReference: r.reference
+  }), [a, r.reference, r.floating]);
+  return f.useMemo(() => ({
+    dataRef: s,
+    open: t,
+    onOpenChange: l,
+    elements: g,
+    events: i,
+    floatingId: o,
+    refs: p
+  }), [t, l, g, i, o, p]);
+}
+function wi(e) {
+  e === void 0 && (e = {});
+  const {
+    nodeId: t
+  } = e, n = Jo({
+    ...e,
+    elements: {
+      reference: null,
+      floating: null,
+      ...e.elements
+    }
+  }), r = e.rootContext || n, o = r.elements, [s, i] = f.useState(null), [c, a] = f.useState(null), l = (o == null ? void 0 : o.domReference) || s, p = f.useRef(null), g = et();
+  X(() => {
+    l && (p.current = l);
+  }, [l]);
+  const d = Oo({
+    ...e,
+    elements: {
+      ...o,
+      ...c && {
+        reference: c
+      }
+    }
+  }), h = f.useCallback((x) => {
+    const I = Y(x) ? {
+      getBoundingClientRect: () => x.getBoundingClientRect(),
+      getClientRects: () => x.getClientRects(),
+      contextElement: x
+    } : x;
+    a(I), d.refs.setReference(I);
+  }, [d.refs]), m = f.useCallback((x) => {
+    (Y(x) || x === null) && (p.current = x, i(x)), (Y(d.refs.reference.current) || d.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 && !Y(x)) && d.refs.setReference(x);
+  }, [d.refs]), y = f.useMemo(() => ({
+    ...d.refs,
+    setReference: m,
+    setPositionReference: h,
+    domReference: p
+  }), [d.refs, m, h]), R = f.useMemo(() => ({
+    ...d.elements,
+    domReference: l
+  }), [d.elements, l]), v = f.useMemo(() => ({
+    ...d,
+    ...r,
+    refs: y,
+    elements: R,
+    nodeId: t
+  }), [d, y, R, t, r]);
+  return X(() => {
+    r.dataRef.current.floatingContext = v;
+    const x = g == null ? void 0 : g.nodesRef.current.find((I) => I.id === t);
+    x && (x.context = v);
+  }), f.useMemo(() => ({
+    ...d,
+    context: v,
+    refs: y,
+    elements: R
+  }), [d, y, R, v]);
+}
+function jt() {
+  return Vr() && Jn();
+}
+function Ri(e, t) {
+  t === void 0 && (t = {});
+  const {
+    open: n,
+    onOpenChange: r,
+    events: o,
+    dataRef: s,
+    elements: i
+  } = e, {
+    enabled: c = !0,
+    visibleOnly: a = !0
+  } = t, u = f.useRef(!1), l = f.useRef(-1), p = f.useRef(!0);
+  f.useEffect(() => {
+    if (!c) return;
+    const d = he(i.domReference);
+    function h() {
+      !n && oe(i.domReference) && i.domReference === Re(ae(i.domReference)) && (u.current = !0);
+    }
+    function m() {
+      p.current = !0;
+    }
+    function y() {
+      p.current = !1;
+    }
+    return d.addEventListener("blur", h), jt() && (d.addEventListener("keydown", m, !0), d.addEventListener("pointerdown", y, !0)), () => {
+      d.removeEventListener("blur", h), jt() && (d.removeEventListener("keydown", m, !0), d.removeEventListener("pointerdown", y, !0));
+    };
+  }, [i.domReference, n, c]), f.useEffect(() => {
+    if (!c) return;
+    function d(h) {
+      let {
+        reason: m
+      } = h;
+      (m === "reference-press" || m === "escape-key") && (u.current = !0);
+    }
+    return o.on("openchange", d), () => {
+      o.off("openchange", d);
+    };
+  }, [o, c]), f.useEffect(() => () => {
+    ve(l);
+  }, []);
+  const g = f.useMemo(() => ({
+    onMouseLeave() {
+      u.current = !1;
+    },
+    onFocus(d) {
+      if (u.current) return;
+      const h = De(d.nativeEvent);
+      if (a && Y(h)) {
+        if (jt() && !d.relatedTarget) {
+          if (!p.current && !on(h))
+            return;
+        } else if (!zr(h))
+          return;
+      }
+      r(!0, d.nativeEvent, "focus");
+    },
+    onBlur(d) {
+      u.current = !1;
+      const h = d.relatedTarget, m = d.nativeEvent, y = Y(h) && h.hasAttribute(Ue("focus-guard")) && h.getAttribute("data-type") === "outside";
+      l.current = window.setTimeout(() => {
+        var R;
+        const v = Re(i.domReference ? i.domReference.ownerDocument : document);
+        !h && v === i.domReference || ue((R = s.current.floatingContext) == null ? void 0 : R.refs.floating.current, v) || ue(i.domReference, v) || y || r(!1, m, "focus");
+      });
+    }
+  }), [s, i.domReference, r, a]);
+  return f.useMemo(() => c ? {
+    reference: g
+  } : {}, [c, g]);
+}
+function qt(e, t, n) {
+  const r = /* @__PURE__ */ new Map(), o = n === "item";
+  let s = e;
+  if (o && e) {
+    const {
+      [Rn]: i,
+      [En]: c,
+      ...a
+    } = e;
+    s = a;
+  }
+  return {
+    ...n === "floating" && {
+      tabIndex: -1,
+      [Do]: ""
+    },
+    ...s,
+    ...t.map((i) => {
+      const c = i ? i[n] : null;
+      return typeof c == "function" ? e ? c(e) : null : c;
+    }).concat(e).reduce((i, c) => (c && Object.entries(c).forEach((a) => {
+      let [u, l] = a;
+      if (!(o && [Rn, En].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), i[u] = function() {
+              for (var g, d = arguments.length, h = new Array(d), m = 0; m < d; m++)
+                h[m] = arguments[m];
+              return (g = r.get(u)) == null ? void 0 : g.map((y) => y(...h)).find((y) => y !== void 0);
+            };
+          }
+        } else
+          i[u] = l;
+    }), i), {})
+  };
+}
+function Ei(e) {
+  e === void 0 && (e = []);
+  const t = e.map((c) => c == null ? void 0 : c.reference), n = e.map((c) => c == null ? void 0 : c.floating), r = e.map((c) => c == null ? void 0 : c.item), o = f.useCallback(
+    (c) => qt(c, e, "reference"),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    t
+  ), s = f.useCallback(
+    (c) => qt(c, e, "floating"),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    n
+  ), i = f.useCallback(
+    (c) => qt(c, e, "item"),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    r
+  );
+  return f.useMemo(() => ({
+    getReferenceProps: o,
+    getFloatingProps: s,
+    getItemProps: i
+  }), [o, s, i]);
+}
+const Qo = "Escape";
+function Nt(e, t, n) {
+  switch (e) {
+    case "vertical":
+      return t;
+    case "horizontal":
+      return n;
+    default:
+      return t || n;
+  }
+}
+function bt(e, t) {
+  return Nt(t, e === st || e === Le, e === Fe || e === Ne);
+}
+function Yt(e, t, n) {
+  return Nt(t, e === Le, n ? e === Fe : e === Ne) || e === "Enter" || e === " " || e === "";
+}
+function Kn(e, t, n) {
+  return Nt(t, n ? e === Fe : e === Ne, e === Le);
+}
+function Vn(e, t, n, r) {
+  const o = n ? e === Ne : e === Fe, s = e === st;
+  return t === "both" || t === "horizontal" && r && r > 1 ? e === Qo : Nt(t, o, s);
+}
+function Ii(e, t) {
+  const {
+    open: n,
+    onOpenChange: r,
+    elements: o,
+    floatingId: s
+  } = e, {
+    listRef: i,
+    activeIndex: c,
+    onNavigate: a = () => {
+    },
+    enabled: u = !0,
+    selectedIndex: l = null,
+    allowEscape: p = !1,
+    loop: g = !1,
+    nested: d = !1,
+    rtl: h = !1,
+    virtual: m = !1,
+    focusItemOnOpen: y = "auto",
+    focusItemOnHover: R = !0,
+    openOnArrowKeyDown: v = !0,
+    disabledIndices: x = void 0,
+    orientation: I = "vertical",
+    parentOrientation: A,
+    cols: k = 1,
+    scrollItemIntoView: N = !0,
+    virtualItemRef: S,
+    itemSizes: L,
+    dense: F = !1
+  } = t;
+  process.env.NODE_ENV !== "production" && (p && (g || Ht("`useListNavigation` looping must be enabled to allow escaping."), m || Ht("`useListNavigation` must be virtual to allow escaping.")), I === "vertical" && k > 1 && Ht("In grid list navigation mode (`cols` > 1), the `orientation` should", 'be either "horizontal" or "both".'));
+  const _ = Ct(o.floating), U = xe(_), V = Ze(), O = et();
+  X(() => {
+    e.dataRef.current.orientation = I;
+  }, [e, I]);
+  const w = ce(() => {
+    a(b.current === -1 ? null : b.current);
+  }), K = Zt(o.domReference), T = f.useRef(y), b = f.useRef(l ?? -1), E = f.useRef(null), M = f.useRef(!0), G = f.useRef(w), C = f.useRef(!!o.floating), W = f.useRef(n), Z = f.useRef(!1), fe = f.useRef(!1), te = xe(x), de = xe(n), Oe = xe(N), Ke = xe(l), [Ae, B] = f.useState(), [z, H] = f.useState(), $ = ce(() => {
+    function D(Q) {
+      if (m) {
+        var ie;
+        (ie = Q.id) != null && ie.endsWith("-fui-option") && (Q.id = s + "-" + Math.random().toString(16).slice(2, 10)), B(Q.id), O == null || O.events.emit("virtualfocus", Q), S && (S.current = Q);
+      } else
+        We(Q, {
+          sync: Z.current,
+          preventScroll: !0
+        });
+    }
+    const q = i.current[b.current], P = fe.current;
+    q && D(q), (Z.current ? (Q) => Q() : requestAnimationFrame)(() => {
+      const Q = i.current[b.current] || q;
+      if (!Q) return;
+      q || D(Q);
+      const ie = Oe.current;
+      ie && re && (P || !M.current) && (Q.scrollIntoView == null || Q.scrollIntoView(typeof ie == "boolean" ? {
+        block: "nearest",
+        inline: "nearest"
+      } : ie));
+    });
+  });
+  X(() => {
+    u && (n && o.floating ? T.current && l != null && (fe.current = !0, b.current = l, w()) : C.current && (b.current = -1, G.current()));
+  }, [u, n, o.floating, l, w]), X(() => {
+    if (u && n && o.floating)
+      if (c == null) {
+        if (Z.current = !1, Ke.current != null)
+          return;
+        if (C.current && (b.current = -1, $()), (!W.current || !C.current) && T.current && (E.current != null || T.current === !0 && E.current == null)) {
+          let D = 0;
+          const q = () => {
+            i.current[0] == null ? (D < 2 && (D ? requestAnimationFrame : queueMicrotask)(q), D++) : (b.current = E.current == null || Yt(E.current, I, h) || d ? yt(i, te.current) : en(i, te.current), E.current = null, w());
+          };
+          q();
+        }
+      } else Ye(i, c) || (b.current = c, $(), fe.current = !1);
+  }, [u, n, o.floating, c, Ke, d, i, I, h, w, $, te]), X(() => {
+    var D;
+    if (!u || o.floating || !O || m || !C.current)
+      return;
+    const q = O.nodesRef.current, P = (D = q.find((ie) => ie.id === V)) == null || (D = D.context) == null ? void 0 : D.elements.floating, J = Re(ae(o.floating)), Q = q.some((ie) => ie.context && ue(ie.context.elements.floating, J));
+    P && !Q && M.current && P.focus({
+      preventScroll: !0
+    });
+  }, [u, o.floating, O, V, m]), X(() => {
+    if (!u || !O || !m || V) return;
+    function D(q) {
+      H(q.id), S && (S.current = q);
+    }
+    return O.events.on("virtualfocus", D), () => {
+      O.events.off("virtualfocus", D);
+    };
+  }, [u, O, m, V, S]), X(() => {
+    G.current = w, W.current = n, C.current = !!o.floating;
+  }), X(() => {
+    n || (E.current = null, T.current = y);
+  }, [n, y]);
+  const se = c != null, re = f.useMemo(() => {
+    function D(P) {
+      if (!de.current) return;
+      const J = i.current.indexOf(P);
+      J !== -1 && b.current !== J && (b.current = J, w());
+    }
+    return {
+      onFocus(P) {
+        let {
+          currentTarget: J
+        } = P;
+        Z.current = !0, D(J);
+      },
+      onClick: (P) => {
+        let {
+          currentTarget: J
+        } = P;
+        return J.focus({
+          preventScroll: !0
+        });
+      },
+      // Safari
+      ...R && {
+        onMouseMove(P) {
+          let {
+            currentTarget: J
+          } = P;
+          Z.current = !0, fe.current = !1, D(J);
+        },
+        onPointerLeave(P) {
+          let {
+            pointerType: J
+          } = P;
+          if (!(!M.current || J === "touch") && (Z.current = !0, b.current = -1, w(), !m)) {
+            var Q;
+            (Q = U.current) == null || Q.focus({
+              preventScroll: !0
+            });
+          }
+        }
+      }
+    };
+  }, [de, U, R, i, w, m]), me = f.useCallback(() => {
+    var D;
+    return A ?? (O == null || (D = O.nodesRef.current.find((q) => q.id === V)) == null || (D = D.context) == null || (D = D.dataRef) == null ? void 0 : D.current.orientation);
+  }, [V, O, A]), ne = ce((D) => {
+    if (M.current = !1, Z.current = !0, D.which === 229 || !de.current && D.currentTarget === U.current)
+      return;
+    if (d && Vn(D.key, I, h, k)) {
+      bt(D.key, me()) || pe(D), r(!1, D.nativeEvent, "list-navigation"), oe(o.domReference) && (m ? O == null || O.events.emit("virtualfocus", o.domReference) : o.domReference.focus());
+      return;
+    }
+    const q = b.current, P = yt(i, x), J = en(i, x);
+    if (K || (D.key === "Home" && (pe(D), b.current = P, w()), D.key === "End" && (pe(D), b.current = J, w())), k > 1) {
+      const Q = L || Array.from({
+        length: i.current.length
+      }, () => ({
+        width: 1,
+        height: 1
+      })), ie = nr(Q, k, F), nt = ie.findIndex((ye) => ye != null && !Be(i, ye, x)), at = ie.reduce((ye, Ve, ft) => Ve != null && !Be(i, Ve, x) ? ft : ye, -1), rt = ie[tr({
+        current: ie.map((ye) => ye != null ? i.current[ye] : null)
+      }, {
+        event: D,
+        orientation: I,
+        loop: g,
+        rtl: h,
+        cols: k,
+        // treat undefined (empty grid spaces) as disabled indices so we
+        // don't end up in them
+        disabledIndices: or([...(typeof x != "function" ? x : null) || i.current.map((ye, Ve) => Be(i, Ve, x) ? Ve : void 0), void 0], ie),
+        minIndex: nt,
+        maxIndex: at,
+        prevIndex: rr(
+          b.current > J ? P : b.current,
+          Q,
+          ie,
+          k,
+          // 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.
+          D.key === Le ? "bl" : D.key === (h ? Fe : Ne) ? "tr" : "tl"
+        ),
+        stopEvent: !0
+      })];
+      if (rt != null && (b.current = rt, w()), I === "both")
+        return;
+    }
+    if (bt(D.key, I)) {
+      if (pe(D), n && !m && Re(D.currentTarget.ownerDocument) === D.currentTarget) {
+        b.current = Yt(D.key, I, h) ? P : J, w();
+        return;
+      }
+      Yt(D.key, I, h) ? g ? b.current = q >= J ? p && q !== i.current.length ? -1 : P : le(i, {
+        startingIndex: q,
+        disabledIndices: x
+      }) : b.current = Math.min(J, le(i, {
+        startingIndex: q,
+        disabledIndices: x
+      })) : g ? b.current = q <= P ? p && q !== -1 ? i.current.length : J : le(i, {
+        startingIndex: q,
+        decrement: !0,
+        disabledIndices: x
+      }) : b.current = Math.max(P, le(i, {
+        startingIndex: q,
+        decrement: !0,
+        disabledIndices: x
+      })), Ye(i, b.current) && (b.current = -1), w();
+    }
+  }), j = f.useMemo(() => m && n && se && {
+    "aria-activedescendant": z || Ae
+  }, [m, n, se, z, Ae]), ee = f.useMemo(() => ({
+    "aria-orientation": I === "both" ? void 0 : I,
+    ...K ? {} : j,
+    onKeyDown: ne,
+    onPointerMove() {
+      M.current = !0;
+    }
+  }), [j, ne, I, K]), tt = f.useMemo(() => {
+    function D(P) {
+      y === "auto" && Zn(P.nativeEvent) && (T.current = !0);
+    }
+    function q(P) {
+      T.current = y, y === "auto" && er(P.nativeEvent) && (T.current = !0);
+    }
+    return {
+      ...j,
+      onKeyDown(P) {
+        M.current = !1;
+        const J = P.key.startsWith("Arrow"), Q = ["Home", "End"].includes(P.key), ie = J || Q, nt = Kn(P.key, I, h), at = Vn(P.key, I, h, k), rt = Kn(P.key, me(), h), ye = bt(P.key, I), Ve = (d ? rt : ye) || P.key === "Enter" || P.key.trim() === "";
+        if (m && n) {
+          const dt = O == null ? void 0 : O.nodesRef.current.find((mt) => mt.parentId == null), Se = O && dt ? Ur(O.nodesRef.current, dt.id) : null;
+          if (ie && Se && S) {
+            const mt = new KeyboardEvent("keydown", {
+              key: P.key,
+              bubbles: !0
+            });
+            if (nt || at) {
+              var ft, un;
+              const Tr = ((ft = Se.context) == null ? void 0 : ft.elements.domReference) === P.currentTarget, an = at && !Tr ? (un = Se.context) == null ? void 0 : un.elements.domReference : nt ? i.current.find((fn) => (fn == null ? void 0 : fn.id) === Ae) : null;
+              an && (pe(P), an.dispatchEvent(mt), H(void 0));
+            }
+            if ((ye || Q) && Se.context && Se.context.open && Se.parentId && P.currentTarget !== Se.context.elements.domReference) {
+              var ln;
+              pe(P), (ln = Se.context.elements.domReference) == null || ln.dispatchEvent(mt);
+              return;
+            }
+          }
+          return ne(P);
+        }
+        if (!(!n && !v && J)) {
+          if (Ve) {
+            const dt = bt(P.key, me());
+            E.current = d && dt ? null : P.key;
+          }
+          if (d) {
+            rt && (pe(P), n ? (b.current = yt(i, te.current), w()) : r(!0, P.nativeEvent, "list-navigation"));
+            return;
+          }
+          ye && (l != null && (b.current = l), pe(P), !n && v ? r(!0, P.nativeEvent, "list-navigation") : ne(P), n && w());
+        }
+      },
+      onFocus() {
+        n && !m && (b.current = -1, w());
+      },
+      onPointerDown: q,
+      onPointerEnter: q,
+      onMouseDown: D,
+      onClick: D
+    };
+  }, [Ae, j, k, ne, te, y, i, d, w, r, n, v, I, me, h, l, O, m, S]);
+  return f.useMemo(() => u ? {
+    reference: tt,
+    floating: ee,
+    item: re
+  } : {}, [u, tt, ee, re]);
+}
+const Zo = /* @__PURE__ */ new Map([["select", "listbox"], ["combobox", "listbox"], ["label", !1]]);
+function Ci(e, t) {
+  var n, r;
+  t === void 0 && (t = {});
+  const {
+    open: o,
+    elements: s,
+    floatingId: i
+  } = e, {
+    enabled: c = !0,
+    role: a = "dialog"
+  } = t, u = Lt(), l = ((n = s.domReference) == null ? void 0 : n.id) || u, p = f.useMemo(() => {
+    var v;
+    return ((v = Ct(s.floating)) == null ? void 0 : v.id) || i;
+  }, [s.floating, i]), g = (r = Zo.get(a)) != null ? r : a, h = Ze() != null, m = f.useMemo(() => g === "tooltip" || a === "label" ? {
+    ["aria-" + (a === "label" ? "labelledby" : "describedby")]: o ? p : void 0
+  } : {
+    "aria-expanded": o ? "true" : "false",
+    "aria-haspopup": g === "alertdialog" ? "dialog" : g,
+    "aria-controls": o ? p : void 0,
+    ...g === "listbox" && {
+      role: "combobox"
+    },
+    ...g === "menu" && {
+      id: l
+    },
+    ...g === "menu" && h && {
+      role: "menuitem"
+    },
+    ...a === "select" && {
+      "aria-autocomplete": "none"
+    },
+    ...a === "combobox" && {
+      "aria-autocomplete": "list"
+    }
+  }, [g, p, h, o, l, a]), y = f.useMemo(() => {
+    const v = {
+      id: p,
+      ...g && {
+        role: g
+      }
+    };
+    return g === "tooltip" || a === "label" ? v : {
+      ...v,
+      ...g === "menu" && {
+        "aria-labelledby": l
+      }
+    };
+  }, [g, p, l, a]), R = f.useCallback((v) => {
+    let {
+      active: x,
+      selected: I
+    } = v;
+    const A = {
+      role: "option",
+      ...x && {
+        id: p + "-fui-option"
+      }
+    };
+    switch (a) {
+      case "select":
+        return {
+          ...A,
+          "aria-selected": x && I
+        };
+      case "combobox":
+        return {
+          ...A,
+          "aria-selected": I
+        };
+    }
+    return {};
+  }, [p, a]);
+  return f.useMemo(() => c ? {
+    reference: m,
+    floating: y,
+    item: R
+  } : {}, [c, m, y, R]);
+}
+function ei(e, t) {
+  const [n, r] = f.useState(e);
+  return e && !n && r(!0), f.useEffect(() => {
+    if (!e && n) {
+      const o = setTimeout(() => r(!1), t);
+      return () => clearTimeout(o);
+    }
+  }, [e, n, t]), n;
+}
+function Ti(e, t) {
+  t === void 0 && (t = {});
+  const {
+    open: n,
+    elements: {
+      floating: r
+    }
+  } = e, {
+    duration: o = 250
+  } = t, i = (typeof o == "number" ? o : o.close) || 0, [c, a] = f.useState("unmounted"), u = ei(n, i);
+  return !u && c === "close" && a("unmounted"), X(() => {
+    if (r) {
+      if (n) {
+        a("initial");
+        const l = requestAnimationFrame(() => {
+          tn.flushSync(() => {
+            a("open");
+          });
+        });
+        return () => {
+          cancelAnimationFrame(l);
+        };
+      }
+      a("close");
+    }
+  }, [n, r]), {
+    isMounted: u,
+    status: c
+  };
+}
+export {
+  ai as C,
+  pi as F,
+  fi as a,
+  li as b,
+  ui as c,
+  wi as d,
+  yi as e,
+  ci as f,
+  xi as g,
+  Ci as h,
+  Ei as i,
+  oi as j,
+  Ze as k,
+  di as l,
+  mi as m,
+  hi as n,
+  ii as o,
+  Po as p,
+  vi as q,
+  Ii as r,
+  si as s,
+  gi as t,
+  So as u,
+  Ri as v,
+  Ti as w,
+  bi as x
+};