ics-ui-kit 0.1.12 → 0.1.14

package/dist/components/context-menu.js

@@ -0,0 +1,2675 @@
+var Dt = (e) => {
+  throw TypeError(e);
+};
+var Ft = (e, t, n) => t.has(e) || Dt("Cannot " + n);
+var K = (e, t, n) => (Ft(e, t, "read from private field"), n ? n.call(e) : t.get(e)), kt = (e, t, n) => t.has(e) ? Dt("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(e) : t.set(e, n), Xe = (e, t, n, r) => (Ft(e, t, "write to private field"), r ? r.call(e, n) : t.set(e, n), n);
+import { jsx as h, jsxs as Ge, Fragment as Rr } from "react/jsx-runtime";
+import * as s from "react";
+import * as Yt from "react-dom";
+import { u as Ir, o as _r, s as Or, f as Tr, a as Ar, b as Nr, h as Dr, l as Fr, c as kr } from "../floating-ui.react-dom-BwDfy92G.js";
+import { c as Lr, _ as $r, u as Ur, a as ye, z as Gr, f as Br, s as Kr, b as jr, R as zr, e as Wr, h as Vr } from "../index-BjtNfqNq.js";
+import { I as vt } from "../Icon-DH3ev9GK.js";
+import { T as ie } from "../index-BVqs-uqP.js";
+import { C as Hr } from "../check-CeyaOoZv.js";
+import { C as Yr } from "../circle-BbEzypQJ.js";
+import { C as Xr } from "../chevron-right-D3juAhA-.js";
+var Zr = Object.defineProperty, Ee = (e, t) => Zr(e, "name", { value: t, configurable: !0 }), Xt = !!(typeof window < "u" && window.document && window.document.createElement);
+function R(e, t, { checkForDefaultPrevented: n = !0 } = {}) {
+  return /* @__PURE__ */ Ee(function(o) {
+    if (e?.(o), n === !1 || !o || !o.defaultPrevented)
+      return t?.(o);
+  }, "handleEvent");
+}
+Ee(R, "composeEventHandlers");
+function qr(e) {
+  if (!Xt)
+    throw new Error("Cannot access window outside of the DOM");
+  return e?.ownerDocument?.defaultView ?? window;
+}
+Ee(qr, "getOwnerWindow");
+function nt(e) {
+  if (!Xt)
+    throw new Error("Cannot access document outside of the DOM");
+  return e?.ownerDocument ?? document;
+}
+Ee(nt, "getOwnerDocument");
+function Zt(e, t = !1) {
+  const { activeElement: n } = nt(e);
+  if (!n?.nodeName)
+    return null;
+  if (qt(n) && n.contentDocument)
+    return Zt(n.contentDocument.body, t);
+  if (t) {
+    const r = n.getAttribute("aria-activedescendant");
+    if (r) {
+      const o = nt(n).getElementById(r);
+      if (o)
+        return o;
+    }
+  }
+  return n;
+}
+Ee(Zt, "getActiveElement");
+function qt(e) {
+  return e.tagName === "IFRAME";
+}
+Ee(qt, "isFrame");
+var Qr = Object.defineProperty, X = (e, t) => Qr(e, "name", { value: t, configurable: !0 });
+// @__NO_SIDE_EFFECTS__
+function Jr(e, t) {
+  const n = s.createContext(t);
+  n.displayName = e + "Context";
+  const r = /* @__PURE__ */ X((i) => {
+    const { children: a, ...u } = i, c = s.useMemo(() => u, Object.values(u));
+    return /* @__PURE__ */ h(n.Provider, { value: c, children: a });
+  }, "Provider");
+  r.displayName = e + "Provider";
+  function o(i, a = {}) {
+    const { optional: u = !1 } = a, c = s.useContext(n);
+    if (c) return c;
+    if (t !== void 0) return t;
+    if (!u)
+      throw new Error(`\`${i}\` must be used within \`${e}\``);
+  }
+  return X(o, "useContext"), [r, o];
+}
+X(Jr, "createContext");
+// @__NO_SIDE_EFFECTS__
+function fe(e, t = []) {
+  let n = [];
+  function r(i, a) {
+    const u = s.createContext(a);
+    u.displayName = i + "Context";
+    const c = n.length;
+    n = [...n, a];
+    const m = /* @__PURE__ */ X((l) => {
+      const { scope: d, children: v, ...f } = l, p = d?.[e]?.[c] || u, g = s.useMemo(() => f, Object.values(f));
+      return /* @__PURE__ */ h(p.Provider, { value: g, children: v });
+    }, "Provider");
+    m.displayName = i + "Provider";
+    function C(l, d, v = {}) {
+      const { optional: f = !1 } = v, p = d?.[e]?.[c] || u, g = s.useContext(p);
+      if (g) return g;
+      if (a !== void 0) return a;
+      if (!f)
+        throw new Error(`\`${l}\` must be used within \`${i}\``);
+    }
+    return X(C, "useContext"), [m, C];
+  }
+  X(r, "createContext");
+  const o = /* @__PURE__ */ X(() => {
+    const i = n.map((a) => s.createContext(a));
+    return /* @__PURE__ */ X(function(u) {
+      const c = u?.[e] || i;
+      return s.useMemo(
+        () => ({ [`__scope${e}`]: { ...u, [e]: c } }),
+        [u, c]
+      );
+    }, "useScope");
+  }, "createScope");
+  return o.scopeName = e, [r, Qt(o, ...t)];
+}
+X(fe, "createContextScope");
+function Qt(...e) {
+  const t = e[0];
+  if (e.length === 1) return t;
+  const n = /* @__PURE__ */ X(() => {
+    const r = e.map((o) => ({
+      useScope: o(),
+      scopeName: o.scopeName
+    }));
+    return /* @__PURE__ */ X(function(i) {
+      const a = r.reduce((u, { useScope: c, scopeName: m }) => {
+        const l = c(i)[`__scope${m}`];
+        return { ...u, ...l };
+      }, {});
+      return s.useMemo(() => ({ [`__scope${t.scopeName}`]: a }), [a]);
+    }, "useComposedScopes");
+  }, "createScope");
+  return n.scopeName = t.scopeName, n;
+}
+X(Qt, "composeContextScopes");
+var eo = Object.defineProperty, gt = (e, t) => eo(e, "name", { value: t, configurable: !0 });
+function rt(e, t) {
+  if (typeof e == "function")
+    return e(t);
+  e != null && (e.current = t);
+}
+gt(rt, "setRef");
+function Jt(...e) {
+  return (t) => {
+    let n = !1;
+    const r = e.map((o) => {
+      const i = rt(o, t);
+      return !n && typeof i == "function" && (n = !0), i;
+    });
+    if (n)
+      return () => {
+        for (let o = 0; o < r.length; o++) {
+          const i = r[o];
+          typeof i == "function" ? i() : rt(e[o], null);
+        }
+      };
+  };
+}
+gt(Jt, "composeRefs");
+function $(...e) {
+  return s.useCallback(Jt(...e), e);
+}
+gt($, "useComposedRefs");
+var to = Object.defineProperty, ee = (e, t) => to(e, "name", { value: t, configurable: !0 });
+// @__NO_SIDE_EFFECTS__
+function de(e) {
+  const t = s.forwardRef((n, r) => {
+    let { children: o, ...i } = n, a = null, u = !1;
+    const c = [];
+    ot(o) && typeof Ne == "function" && (o = Ne(o._payload)), s.Children.forEach(o, (d) => {
+      if (rn(d)) {
+        u = !0;
+        const v = d;
+        let f = "child" in v.props ? v.props.child : v.props.children;
+        ot(f) && typeof Ne == "function" && (f = Ne(f._payload)), a = ro(v, f), c.push(a?.props?.children);
+      } else
+        c.push(d);
+    }), a ? a = s.cloneElement(a, void 0, c) : (
+      // A `Slottable` was found but it didn't resolve to a single element (e.g.
+      // it wrapped multiple elements, text, or a render-prop `child` that
+      // wasn't an element). Don't fall back to treating the `Slottable` wrapper
+      // itself as the slot target — throw a descriptive error below instead.
+      !u && s.Children.count(o) === 1 && s.isValidElement(o) && (a = o)
+    );
+    const m = a ? nn(a) : void 0, C = $(r, m);
+    if (!a) {
+      if (o || o === 0)
+        throw new Error(
+          u ? io(e) : so(e)
+        );
+      return o;
+    }
+    const l = tn(i, a.props ?? {});
+    return a.type !== s.Fragment && (l.ref = r ? C : m), s.cloneElement(a, l);
+  });
+  return t.displayName = `${e}.Slot`, t;
+}
+ee(de, "createSlot");
+var en = Symbol.for("radix.slottable");
+// @__NO_SIDE_EFFECTS__
+function no(e) {
+  const t = /* @__PURE__ */ ee((n) => "child" in n ? n.children(n.child) : n.children, "Slottable");
+  return t.displayName = `${e}.Slottable`, t.__radixId = en, t;
+}
+ee(no, "createSlottable");
+var ro = /* @__PURE__ */ ee((e, t) => {
+  if ("child" in e.props) {
+    const n = e.props.child;
+    return s.isValidElement(n) ? s.cloneElement(n, void 0, e.props.children(n.props.children)) : null;
+  }
+  return s.isValidElement(t) ? t : null;
+}, "getSlottableElementFromSlottable");
+function tn(e, t) {
+  const n = { ...t };
+  for (const r in t) {
+    const o = e[r], i = t[r];
+    /^on[A-Z]/.test(r) ? o && i ? n[r] = (...u) => {
+      const c = i(...u);
+      return o(...u), c;
+    } : o && (n[r] = o) : r === "style" ? n[r] = { ...o, ...i } : r === "className" && (n[r] = [o, i].filter(Boolean).join(" "));
+  }
+  return { ...e, ...n };
+}
+ee(tn, "mergeProps");
+function nn(e) {
+  let t = Object.getOwnPropertyDescriptor(e.props, "ref")?.get, n = t && "isReactWarning" in t && t.isReactWarning;
+  return n ? e.ref : (t = Object.getOwnPropertyDescriptor(e, "ref")?.get, n = t && "isReactWarning" in t && t.isReactWarning, n ? e.props.ref : e.props.ref || e.ref);
+}
+ee(nn, "getElementRef");
+function rn(e) {
+  return s.isValidElement(e) && typeof e.type == "function" && "__radixId" in e.type && e.type.__radixId === en;
+}
+ee(rn, "isSlottable");
+var oo = Symbol.for("react.lazy");
+function ot(e) {
+  return e != null && typeof e == "object" && "$$typeof" in e && e.$$typeof === oo && "_payload" in e && on(e._payload);
+}
+ee(ot, "isLazyComponent");
+function on(e) {
+  return typeof e == "object" && e !== null && "then" in e;
+}
+ee(on, "isPromiseLike");
+var so = /* @__PURE__ */ ee((e) => `${e} failed to slot onto its children. Expected a single React element child or \`Slottable\`.`, "createSlotError"), io = /* @__PURE__ */ ee((e) => `${e} failed to slot onto its \`Slottable\`. Expected \`Slottable\` to receive a single React element child.`, "createSlottableError"), Ne = s[" use ".trim().toString()], ao = Object.defineProperty, co = (e, t) => ao(e, "name", { value: t, configurable: !0 }), uo = [
+  "a",
+  "button",
+  "div",
+  "form",
+  "h2",
+  "h3",
+  "img",
+  "input",
+  "label",
+  "li",
+  "nav",
+  "ol",
+  "p",
+  "select",
+  "span",
+  "svg",
+  "ul"
+], Y = uo.reduce((e, t) => {
+  const n = /* @__PURE__ */ de(`Primitive.${t}`), r = s.forwardRef((o, i) => {
+    const { asChild: a, ...u } = o, c = a ? n : t;
+    return typeof window < "u" && (window[Symbol.for("radix-ui")] = !0), /* @__PURE__ */ h(c, { ...u, ref: i });
+  });
+  return r.displayName = `Primitive.${t}`, { ...e, [t]: r };
+}, {});
+function Ct(e, t) {
+  e && Yt.flushSync(() => e.dispatchEvent(t));
+}
+co(Ct, "dispatchDiscreteCustomEvent");
+var lo = Object.defineProperty, L = (e, t) => lo(e, "name", { value: t, configurable: !0 });
+// @__NO_SIDE_EFFECTS__
+function bt(e) {
+  const t = e + "CollectionProvider", [n, r] = /* @__PURE__ */ fe(t), [o, i] = n(
+    t,
+    { collectionRef: { current: null }, itemMap: /* @__PURE__ */ new Map() }
+  ), a = /* @__PURE__ */ L((p) => {
+    const { scope: g, children: S } = p, b = s.useRef(null), y = s.useRef(/* @__PURE__ */ new Map()).current;
+    return /* @__PURE__ */ h(o, { scope: g, itemMap: y, collectionRef: b, children: S });
+  }, "CollectionProvider");
+  a.displayName = t;
+  const u = e + "CollectionSlot", c = /* @__PURE__ */ de(u), m = s.forwardRef(
+    (p, g) => {
+      const { scope: S, children: b } = p, y = i(u, S), x = $(g, y.collectionRef);
+      return /* @__PURE__ */ h(c, { ref: x, children: b });
+    }
+  );
+  m.displayName = u;
+  const C = e + "CollectionItemSlot", l = "data-radix-collection-item", d = /* @__PURE__ */ de(C), v = s.forwardRef(
+    (p, g) => {
+      const { scope: S, children: b, ...y } = p, x = s.useRef(null), E = $(g, x), w = i(C, S);
+      return s.useEffect(() => (w.itemMap.set(x, { ref: x, ...y }), () => void w.itemMap.delete(x))), /* @__PURE__ */ h(d, { [l]: "", ref: E, children: b });
+    }
+  );
+  v.displayName = C;
+  function f(p) {
+    const g = i(e + "CollectionConsumer", p);
+    return s.useCallback(() => {
+      const b = g.collectionRef.current;
+      if (!b) return [];
+      const y = Array.from(b.querySelectorAll(`[${l}]`));
+      return Array.from(g.itemMap.values()).sort(
+        (w, O) => y.indexOf(w.ref.current) - y.indexOf(O.ref.current)
+      );
+    }, [g.collectionRef, g.itemMap]);
+  }
+  return L(f, "useCollection"), [
+    { Provider: a, Slot: m, ItemSlot: v },
+    f,
+    r
+  ];
+}
+L(bt, "createCollection");
+var Lt = /* @__PURE__ */ new WeakMap(), D, H, Ze = (H = class extends Map {
+  constructor(n) {
+    super(n);
+    kt(this, D);
+    Xe(this, D, [...super.keys()]), Lt.set(this, !0);
+  }
+  set(n, r) {
+    return Lt.get(this) && (this.has(n) ? K(this, D)[K(this, D).indexOf(n)] = n : K(this, D).push(n)), super.set(n, r), this;
+  }
+  insert(n, r, o) {
+    const i = this.has(r), a = K(this, D).length, u = yt(n);
+    let c = u >= 0 ? u : a + u;
+    const m = c < 0 || c >= a ? -1 : c;
+    if (m === this.size || i && m === this.size - 1 || m === -1)
+      return this.set(r, o), this;
+    const C = this.size + (i ? 0 : 1);
+    u < 0 && c++;
+    const l = [...K(this, D)];
+    let d, v = !1;
+    for (let f = c; f < C; f++)
+      if (c === f) {
+        let p = l[f];
+        l[f] === r && (p = l[f + 1]), i && this.delete(r), d = this.get(p), this.set(r, o);
+      } else {
+        !v && l[f - 1] === r && (v = !0);
+        const p = l[v ? f : f - 1], g = d;
+        d = this.get(p), this.delete(p), this.set(p, g);
+      }
+    return this;
+  }
+  with(n, r, o) {
+    const i = new H(this);
+    return i.insert(n, r, o), i;
+  }
+  before(n) {
+    const r = K(this, D).indexOf(n) - 1;
+    if (!(r < 0))
+      return this.entryAt(r);
+  }
+  /**
+   * Sets a new key-value pair at the position before the given key.
+   */
+  setBefore(n, r, o) {
+    const i = K(this, D).indexOf(n);
+    return i === -1 ? this : this.insert(i, r, o);
+  }
+  after(n) {
+    let r = K(this, D).indexOf(n);
+    if (r = r === -1 || r === this.size - 1 ? -1 : r + 1, r !== -1)
+      return this.entryAt(r);
+  }
+  /**
+   * Sets a new key-value pair at the position after the given key.
+   */
+  setAfter(n, r, o) {
+    const i = K(this, D).indexOf(n);
+    return i === -1 ? this : this.insert(i + 1, r, o);
+  }
+  first() {
+    return this.entryAt(0);
+  }
+  last() {
+    return this.entryAt(-1);
+  }
+  clear() {
+    return Xe(this, D, []), super.clear();
+  }
+  delete(n) {
+    const r = super.delete(n);
+    return r && K(this, D).splice(K(this, D).indexOf(n), 1), r;
+  }
+  deleteAt(n) {
+    const r = this.keyAt(n);
+    return r !== void 0 ? this.delete(r) : !1;
+  }
+  at(n) {
+    const r = $e(K(this, D), n);
+    if (r !== void 0)
+      return this.get(r);
+  }
+  entryAt(n) {
+    const r = $e(K(this, D), n);
+    if (r !== void 0)
+      return [r, this.get(r)];
+  }
+  indexOf(n) {
+    return K(this, D).indexOf(n);
+  }
+  keyAt(n) {
+    return $e(K(this, D), n);
+  }
+  from(n, r) {
+    const o = this.indexOf(n);
+    if (o === -1)
+      return;
+    let i = o + r;
+    return i < 0 && (i = 0), i >= this.size && (i = this.size - 1), this.at(i);
+  }
+  keyFrom(n, r) {
+    const o = this.indexOf(n);
+    if (o === -1)
+      return;
+    let i = o + r;
+    return i < 0 && (i = 0), i >= this.size && (i = this.size - 1), this.keyAt(i);
+  }
+  find(n, r) {
+    let o = 0;
+    for (const i of this) {
+      if (Reflect.apply(n, r, [i, o, this]))
+        return i;
+      o++;
+    }
+  }
+  findIndex(n, r) {
+    let o = 0;
+    for (const i of this) {
+      if (Reflect.apply(n, r, [i, o, this]))
+        return o;
+      o++;
+    }
+    return -1;
+  }
+  filter(n, r) {
+    const o = [];
+    let i = 0;
+    for (const a of this)
+      Reflect.apply(n, r, [a, i, this]) && o.push(a), i++;
+    return new H(o);
+  }
+  map(n, r) {
+    const o = [];
+    let i = 0;
+    for (const a of this)
+      o.push([a[0], Reflect.apply(n, r, [a, i, this])]), i++;
+    return new H(o);
+  }
+  reduce(...n) {
+    const [r, o] = n;
+    let i = 0, a = o ?? this.at(0);
+    for (const u of this)
+      i === 0 && n.length === 1 ? a = u : a = Reflect.apply(r, this, [a, u, i, this]), i++;
+    return a;
+  }
+  reduceRight(...n) {
+    const [r, o] = n;
+    let i = o ?? this.at(-1);
+    for (let a = this.size - 1; a >= 0; a--) {
+      const u = this.at(a);
+      a === this.size - 1 && n.length === 1 ? i = u : i = Reflect.apply(r, this, [i, u, a, this]);
+    }
+    return i;
+  }
+  toSorted(n) {
+    const r = [...this.entries()].sort(n);
+    return new H(r);
+  }
+  toReversed() {
+    const n = new H();
+    for (let r = this.size - 1; r >= 0; r--) {
+      const o = this.keyAt(r), i = this.get(o);
+      n.set(o, i);
+    }
+    return n;
+  }
+  toSpliced(...n) {
+    const r = [...this.entries()];
+    return r.splice(...n), new H(r);
+  }
+  slice(n, r) {
+    const o = new H();
+    let i = this.size - 1;
+    if (n === void 0)
+      return o;
+    n < 0 && (n = n + this.size), r !== void 0 && r > 0 && (i = r - 1);
+    for (let a = n; a <= i; a++) {
+      const u = this.keyAt(a), c = this.get(u);
+      o.set(u, c);
+    }
+    return o;
+  }
+  every(n, r) {
+    let o = 0;
+    for (const i of this) {
+      if (!Reflect.apply(n, r, [i, o, this]))
+        return !1;
+      o++;
+    }
+    return !0;
+  }
+  some(n, r) {
+    let o = 0;
+    for (const i of this) {
+      if (Reflect.apply(n, r, [i, o, this]))
+        return !0;
+      o++;
+    }
+    return !1;
+  }
+}, D = new WeakMap(), L(H, "OrderedDict"), H);
+function $e(e, t) {
+  if ("at" in Array.prototype)
+    return Array.prototype.at.call(e, t);
+  const n = sn(e, t);
+  return n === -1 ? void 0 : e[n];
+}
+L($e, "at");
+function sn(e, t) {
+  const n = e.length, r = yt(t), o = r >= 0 ? r : n + r;
+  return o < 0 || o >= n ? -1 : o;
+}
+L(sn, "toSafeIndex");
+function yt(e) {
+  return e !== e || e === 0 ? 0 : Math.trunc(e);
+}
+L(yt, "toSafeInteger");
+// @__NO_SIDE_EFFECTS__
+function fo(e) {
+  const t = e + "CollectionProvider", [n, r] = /* @__PURE__ */ fe(t), [o, i] = n(
+    t,
+    {
+      collectionElement: null,
+      collectionRef: { current: null },
+      collectionRefObject: { current: null },
+      itemMap: new Ze(),
+      setItemMap: /* @__PURE__ */ L(() => {
+      }, "setItemMap")
+    }
+  ), a = /* @__PURE__ */ L(({ state: y, ...x }) => y ? /* @__PURE__ */ h(c, { ...x, state: y }) : /* @__PURE__ */ h(u, { ...x }), "CollectionProvider");
+  a.displayName = t;
+  const u = /* @__PURE__ */ L((y) => {
+    const x = g();
+    return /* @__PURE__ */ h(c, { ...y, state: x });
+  }, "CollectionInit");
+  u.displayName = t + "Init";
+  const c = /* @__PURE__ */ L((y) => {
+    const { scope: x, children: E, state: w } = y, O = s.useRef(null), [A, P] = s.useState(
+      null
+    ), G = $(O, P), [N, I] = w;
+    return s.useEffect(() => {
+      if (!A) return;
+      const F = un(() => {
+      });
+      return F.observe(A, {
+        childList: !0,
+        subtree: !0
+      }), () => {
+        F.disconnect();
+      };
+    }, [A]), /* @__PURE__ */ h(
+      o,
+      {
+        scope: x,
+        itemMap: N,
+        setItemMap: I,
+        collectionRef: G,
+        collectionRefObject: O,
+        collectionElement: A,
+        children: E
+      }
+    );
+  }, "CollectionProviderImpl");
+  c.displayName = t + "Impl";
+  const m = e + "CollectionSlot", C = /* @__PURE__ */ de(m), l = s.forwardRef(
+    (y, x) => {
+      const { scope: E, children: w } = y, O = i(m, E), A = $(x, O.collectionRef);
+      return /* @__PURE__ */ h(C, { ref: A, children: w });
+    }
+  );
+  l.displayName = m;
+  const d = e + "CollectionItemSlot", v = "data-radix-collection-item", f = /* @__PURE__ */ de(d), p = s.forwardRef(
+    (y, x) => {
+      const { scope: E, children: w, ...O } = y, A = s.useRef(null), [P, G] = s.useState(null), N = $(x, A, G), I = i(d, E), { setItemMap: F } = I, B = s.useRef(O);
+      an(B.current, O) || (B.current = O);
+      const Z = B.current;
+      return s.useEffect(() => {
+        const ne = Z;
+        return F((T) => P ? T.has(P) ? T.set(P, { ...ne, element: P }).toSorted(st) : (T.set(P, { ...ne, element: P }), T.toSorted(st)) : T), () => {
+          F((T) => !P || !T.has(P) ? T : (T.delete(P), new Ze(T)));
+        };
+      }, [P, Z, F]), /* @__PURE__ */ h(f, { [v]: "", ref: N, children: w });
+    }
+  );
+  p.displayName = d;
+  function g() {
+    return s.useState(new Ze());
+  }
+  L(g, "useInitCollection");
+  function S(y) {
+    const { itemMap: x } = i(e + "CollectionConsumer", y);
+    return x;
+  }
+  return L(S, "useCollection"), [
+    { Provider: a, Slot: l, ItemSlot: p },
+    {
+      createCollectionScope: r,
+      useCollection: S,
+      useInitCollection: g
+    }
+  ];
+}
+L(fo, "createCollection");
+function an(e, t) {
+  if (e === t) return !0;
+  if (typeof e != "object" || typeof t != "object" || e == null || t == null) return !1;
+  const n = Object.keys(e), r = Object.keys(t);
+  if (n.length !== r.length) return !1;
+  for (const o of n)
+    if (!Object.prototype.hasOwnProperty.call(t, o) || e[o] !== t[o]) return !1;
+  return !0;
+}
+L(an, "shallowEqual");
+function cn(e, t) {
+  return !!(t.compareDocumentPosition(e) & Node.DOCUMENT_POSITION_PRECEDING);
+}
+L(cn, "isElementPreceding");
+function st(e, t) {
+  return !e[1].element || !t[1].element ? 0 : cn(e[1].element, t[1].element) ? -1 : 1;
+}
+L(st, "sortByDocumentPosition");
+function un(e) {
+  return new MutationObserver((n) => {
+    for (const r of n)
+      if (r.type === "childList") {
+        e();
+        return;
+      }
+  });
+}
+L(un, "getChildListObserver");
+var po = Object.defineProperty, mo = (e, t) => po(e, "name", { value: t, configurable: !0 }), ho = s.createContext(void 0);
+function St(e) {
+  const t = s.useContext(ho);
+  return e || t || "ltr";
+}
+mo(St, "useDirection");
+var vo = Object.defineProperty, go = (e, t) => vo(e, "name", { value: t, configurable: !0 });
+function J(e) {
+  const t = s.useRef(e);
+  return s.useEffect(() => {
+    t.current = e;
+  }), s.useMemo(() => (...n) => t.current?.(...n), []);
+}
+go(J, "useCallbackRef");
+var Co = Object.defineProperty, k = (e, t) => Co(e, "name", { value: t, configurable: !0 }), it = "dismissableLayer.update", bo = "dismissableLayer.pointerDownOutside", yo = "dismissableLayer.focusOutside", $t, ln = s.createContext({
+  layers: /* @__PURE__ */ new Set(),
+  layersWithOutsidePointerEventsDisabled: /* @__PURE__ */ new Set(),
+  branches: /* @__PURE__ */ new Set(),
+  // Outside elements that belong to a layer's own dismiss affordance (eg, a
+  // dialog overlay). Pressing them should dismiss the layer regardless of
+  // whether or not they stop propagation.
+  //
+  // See https://github.com/radix-ui/primitives/issues/3346
+  dismissableSurfaces: /* @__PURE__ */ new Set()
+}), So = /* @__PURE__ */ s.forwardRef(
+  // blank line to reduce diff noise
+  /* @__PURE__ */ k(function(t, n) {
+    const {
+      disableOutsidePointerEvents: r = !1,
+      deferPointerDownOutside: o = !1,
+      onEscapeKeyDown: i,
+      onPointerDownOutside: a,
+      onFocusOutside: u,
+      onInteractOutside: c,
+      onDismiss: m,
+      ...C
+    } = t, l = s.useContext(ln), [d, v] = s.useState(null), f = d?.ownerDocument ?? globalThis?.document, [, p] = s.useState({}), g = $(n, v), S = Array.from(l.layers), [b] = [
+      ...l.layersWithOutsidePointerEventsDisabled
+    ].slice(-1), y = b ? S.indexOf(b) : -1, x = d ? S.indexOf(d) : -1, E = l.layersWithOutsidePointerEventsDisabled.size > 0, w = x >= y, O = s.useRef(!1), A = dn(
+      (I) => {
+        a?.(I), c?.(I), I.defaultPrevented || m?.();
+      },
+      {
+        ownerDocument: f,
+        deferPointerDownOutside: o,
+        isDeferredPointerDownOutsideRef: O,
+        dismissableSurfaces: l.dismissableSurfaces,
+        shouldHandlePointerDownOutside: s.useCallback(
+          (I) => {
+            if (!(I instanceof Node))
+              return !1;
+            const F = [...l.branches].some(
+              (B) => B.contains(I)
+            );
+            return w && !F;
+          },
+          [l.branches, w]
+        )
+      }
+    ), P = fn((I) => {
+      if (o && O.current)
+        return;
+      const F = I.target;
+      [...l.branches].some((Z) => Z.contains(F)) || (u?.(I), c?.(I), I.defaultPrevented || m?.());
+    }, f), G = d ? x === S.length - 1 : !1, N = J((I) => {
+      I.key === "Escape" && (i?.(I), !I.defaultPrevented && m && (I.preventDefault(), m()));
+    });
+    return s.useEffect(() => {
+      if (G)
+        return f.addEventListener("keydown", N, { capture: !0 }), () => f.removeEventListener("keydown", N, { capture: !0 });
+    }, [f, G, N]), s.useEffect(() => {
+      if (d)
+        return r && (l.layersWithOutsidePointerEventsDisabled.size === 0 && ($t = f.body.style.pointerEvents, f.body.style.pointerEvents = "none"), l.layersWithOutsidePointerEventsDisabled.add(d)), l.layers.add(d), at(), () => {
+          r && (l.layersWithOutsidePointerEventsDisabled.delete(d), l.layersWithOutsidePointerEventsDisabled.size === 0 && (f.body.style.pointerEvents = $t));
+        };
+    }, [d, f, r, l]), s.useEffect(() => () => {
+      d && (l.layers.delete(d), l.layersWithOutsidePointerEventsDisabled.delete(d), at());
+    }, [d, l]), s.useEffect(() => {
+      const I = /* @__PURE__ */ k(() => p({}), "handleUpdate");
+      return document.addEventListener(it, I), () => document.removeEventListener(it, I);
+    }, []), /* @__PURE__ */ h(
+      Y.div,
+      {
+        ...C,
+        ref: g,
+        style: {
+          pointerEvents: E ? w ? "auto" : "none" : void 0,
+          ...t.style
+        },
+        onFocusCapture: R(t.onFocusCapture, P.onFocusCapture),
+        onBlurCapture: R(t.onBlurCapture, P.onBlurCapture),
+        onPointerDownCapture: R(
+          t.onPointerDownCapture,
+          A.onPointerDownCapture
+        )
+      }
+    );
+  }, "DismissableLayer")
+);
+function xo() {
+  const e = s.useContext(ln), [t, n] = s.useState(null);
+  return s.useEffect(() => {
+    if (t)
+      return e.dismissableSurfaces.add(t), () => {
+        e.dismissableSurfaces.delete(t);
+      };
+  }, [t, e.dismissableSurfaces]), n;
+}
+k(xo, "useDismissableLayerSurface");
+var Eo = /* @__PURE__ */ k(() => !0, "IS_TRUE");
+function dn(e, t) {
+  const {
+    ownerDocument: n = globalThis?.document,
+    deferPointerDownOutside: r = !1,
+    isDeferredPointerDownOutsideRef: o,
+    dismissableSurfaces: i,
+    shouldHandlePointerDownOutside: a = Eo
+  } = t, u = J(e), c = s.useRef(!1), m = s.useRef(!1), C = s.useRef(/* @__PURE__ */ new Map()), l = s.useRef(() => {
+  });
+  return s.useEffect(() => {
+    function d() {
+      m.current = !1, o.current = !1, C.current.clear();
+    }
+    k(d, "resetOutsideInteraction");
+    function v() {
+      return Array.from(C.current.values()).some(Boolean);
+    }
+    k(v, "isOutsideInteractionIntercepted");
+    function f(y) {
+      if (!m.current)
+        return;
+      const x = y.target;
+      x instanceof Node && [...i].some((w) => w.contains(x)) || C.current.set(y.type, !0), y.type === "click" && window.setTimeout(() => {
+        m.current && l.current();
+      }, 0);
+    }
+    k(f, "handleInteractionCapture");
+    function p(y) {
+      m.current && C.current.set(y.type, !1);
+    }
+    k(p, "handleInteractionBubble");
+    const g = /* @__PURE__ */ k((y) => {
+      if (y.target && !c.current) {
+        let x = function() {
+          n.removeEventListener("click", l.current);
+          const w = v();
+          d(), w || xt(
+            bo,
+            u,
+            E,
+            { discrete: !0 }
+          );
+        };
+        if (k(x, "handleAndDispatchPointerDownOutsideEvent"), !a(y.target)) {
+          n.removeEventListener("click", l.current), d(), c.current = !1;
+          return;
+        }
+        const E = { originalEvent: y };
+        m.current = !0, o.current = r && y.button === 0, C.current.clear(), !r || y.button !== 0 ? x() : (n.removeEventListener("click", l.current), l.current = x, n.addEventListener("click", l.current, { once: !0 }));
+      } else
+        n.removeEventListener("click", l.current), d();
+      c.current = !1;
+    }, "handlePointerDown"), S = [
+      "pointerup",
+      "mousedown",
+      "mouseup",
+      "touchstart",
+      "touchend",
+      "click"
+    ];
+    for (const y of S)
+      n.addEventListener(y, f, !0), n.addEventListener(y, p);
+    const b = window.setTimeout(() => {
+      n.addEventListener("pointerdown", g);
+    }, 0);
+    return () => {
+      window.clearTimeout(b), n.removeEventListener("pointerdown", g), n.removeEventListener("click", l.current);
+      for (const y of S)
+        n.removeEventListener(y, f, !0), n.removeEventListener(y, p);
+    };
+  }, [
+    n,
+    u,
+    r,
+    o,
+    i,
+    a
+  ]), {
+    // ensures we check React component tree (not just DOM tree)
+    onPointerDownCapture: /* @__PURE__ */ k(() => c.current = !0, "onPointerDownCapture")
+  };
+}
+k(dn, "usePointerDownOutside");
+function fn(e, t = globalThis?.document) {
+  const n = J(e), r = s.useRef(!1);
+  return s.useEffect(() => {
+    const o = /* @__PURE__ */ k((i) => {
+      i.target && !r.current && xt(yo, n, { originalEvent: i }, {
+        discrete: !1
+      });
+    }, "handleFocus");
+    return t.addEventListener("focusin", o), () => t.removeEventListener("focusin", o);
+  }, [t, n]), {
+    onFocusCapture: /* @__PURE__ */ k(() => r.current = !0, "onFocusCapture"),
+    onBlurCapture: /* @__PURE__ */ k(() => r.current = !1, "onBlurCapture")
+  };
+}
+k(fn, "useFocusOutside");
+function at() {
+  const e = new CustomEvent(it);
+  document.dispatchEvent(e);
+}
+k(at, "dispatchUpdate");
+function xt(e, t, n, { discrete: r }) {
+  const o = n.originalEvent.target, i = new CustomEvent(e, { bubbles: !1, cancelable: !0, detail: n });
+  t && o.addEventListener(e, t, { once: !0 }), r ? Ct(o, i) : o.dispatchEvent(i);
+}
+k(xt, "handleAndDispatchCustomEvent");
+var wo = Object.defineProperty, Et = (e, t) => wo(e, "name", { value: t, configurable: !0 }), De = 0, ge = null;
+function Mo(e) {
+  return wt(), e.children;
+}
+Et(Mo, "FocusGuards");
+function wt() {
+  s.useEffect(() => {
+    ge || (ge = { start: ct(), end: ct() });
+    const { start: e, end: t } = ge;
+    return document.body.firstElementChild !== e && document.body.insertAdjacentElement("afterbegin", e), document.body.lastElementChild !== t && document.body.insertAdjacentElement("beforeend", t), De++, () => {
+      De === 1 && (ge?.start.remove(), ge?.end.remove(), ge = null), De = Math.max(0, De - 1);
+    };
+  }, []);
+}
+Et(wt, "useFocusGuards");
+function ct() {
+  const e = document.createElement("span");
+  return e.setAttribute("data-radix-focus-guard", ""), e.tabIndex = 0, e.style.outline = "none", e.style.opacity = "0", e.style.position = "fixed", e.style.pointerEvents = "none", e;
+}
+Et(ct, "createFocusGuard");
+var Po = Object.defineProperty, z = (e, t) => Po(e, "name", { value: t, configurable: !0 }), qe = "focusScope.autoFocusOnMount", Qe = "focusScope.autoFocusOnUnmount", Ut = { bubbles: !1, cancelable: !0 }, Ro = /* @__PURE__ */ s.forwardRef(
+  /* @__PURE__ */ z(function(t, n) {
+    const {
+      loop: r = !1,
+      trapped: o = !1,
+      onMountAutoFocus: i,
+      onUnmountAutoFocus: a,
+      ...u
+    } = t, [c, m] = s.useState(null), C = J(i), l = J(a), d = s.useRef(null), v = $(n, m), f = s.useRef({
+      paused: !1,
+      pause() {
+        this.paused = !0;
+      },
+      resume() {
+        this.paused = !1;
+      }
+    }).current;
+    s.useEffect(() => {
+      if (o) {
+        let g = function(x) {
+          if (f.paused || !c) return;
+          const E = x.target;
+          c.contains(E) ? d.current = E : oe(d.current, { select: !0 });
+        }, S = function(x) {
+          if (f.paused || !c) return;
+          const E = x.relatedTarget;
+          E !== null && (c.contains(E) || oe(d.current, { select: !0 }));
+        }, b = function(x) {
+          if (document.activeElement === document.body)
+            for (const w of x)
+              w.removedNodes.length > 0 && oe(c);
+        };
+        z(g, "handleFocusIn"), z(S, "handleFocusOut"), z(b, "handleMutations"), document.addEventListener("focusin", g), document.addEventListener("focusout", S);
+        const y = new MutationObserver(b);
+        return c && y.observe(c, { childList: !0, subtree: !0 }), () => {
+          document.removeEventListener("focusin", g), document.removeEventListener("focusout", S), y.disconnect();
+        };
+      }
+    }, [o, c, f.paused]), s.useEffect(() => {
+      if (c) {
+        Gt.add(f);
+        const g = document.activeElement;
+        if (!c.contains(g)) {
+          const b = new CustomEvent(qe, Ut);
+          c.addEventListener(qe, C), c.dispatchEvent(b), b.defaultPrevented || (pn(Cn(Mt(c)), { select: !0 }), document.activeElement === g && oe(c));
+        }
+        return () => {
+          c.removeEventListener(qe, C), setTimeout(() => {
+            const b = new CustomEvent(Qe, Ut);
+            c.addEventListener(Qe, l), c.dispatchEvent(b), b.defaultPrevented || oe(g ?? document.body, { select: !0 }), c.removeEventListener(Qe, l), Gt.remove(f);
+          }, 0);
+        };
+      }
+    }, [c, C, l, f]);
+    const p = s.useCallback(
+      (g) => {
+        if (!r && !o || f.paused) return;
+        const S = g.key === "Tab" && !g.altKey && !g.ctrlKey && !g.metaKey, b = document.activeElement;
+        if (S && b) {
+          const y = g.currentTarget, [x, E] = mn(y);
+          x && E ? !g.shiftKey && b === E ? (g.preventDefault(), r && oe(x, { select: !0 })) : g.shiftKey && b === x && (g.preventDefault(), r && oe(E, { select: !0 })) : b === y && g.preventDefault();
+        }
+      },
+      [r, o, f.paused]
+    );
+    return /* @__PURE__ */ h(Y.div, { tabIndex: -1, ...u, ref: v, onKeyDown: p });
+  }, "FocusScope")
+);
+function pn(e, { select: t = !1 } = {}) {
+  const n = document.activeElement;
+  for (const r of e)
+    if (oe(r, { select: t }), document.activeElement !== n) return;
+}
+z(pn, "focusFirst");
+function mn(e) {
+  const t = Mt(e), n = ut(t, e), r = ut(t.reverse(), e);
+  return [n, r];
+}
+z(mn, "getTabbableEdges");
+function Mt(e) {
+  const t = [], n = document.createTreeWalker(e, NodeFilter.SHOW_ELEMENT, {
+    acceptNode: /* @__PURE__ */ z((r) => {
+      const o = r.tagName === "INPUT" && r.type === "hidden";
+      return r.disabled || r.hidden || o ? NodeFilter.FILTER_SKIP : r.tabIndex >= 0 ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
+    }, "acceptNode")
+  });
+  for (; n.nextNode(); ) t.push(n.currentNode);
+  return t;
+}
+z(Mt, "getTabbableCandidates");
+function ut(e, t) {
+  const n = typeof t.checkVisibility == "function" && t.checkVisibility({ checkVisibilityCSS: !0 });
+  for (const r of e)
+    if (!(n ? !r.checkVisibility({ checkVisibilityCSS: !0 }) : hn(r, { upTo: t })))
+      return r;
+}
+z(ut, "findVisible");
+function hn(e, { upTo: t }) {
+  if (getComputedStyle(e).visibility === "hidden") return !0;
+  for (; e; ) {
+    if (t !== void 0 && e === t) return !1;
+    if (getComputedStyle(e).display === "none") return !0;
+    e = e.parentElement;
+  }
+  return !1;
+}
+z(hn, "isHidden");
+function vn(e) {
+  return e instanceof HTMLInputElement && "select" in e;
+}
+z(vn, "isSelectableInput");
+function oe(e, { select: t = !1 } = {}) {
+  if (e && e.focus) {
+    const n = document.activeElement;
+    e.focus({ preventScroll: !0 }), e !== n && vn(e) && t && e.select();
+  }
+}
+z(oe, "focus");
+var Gt = gn();
+function gn() {
+  let e = [];
+  return {
+    add(t) {
+      const n = e[0];
+      t !== n && n?.pause(), e = lt(e, t), e.unshift(t);
+    },
+    remove(t) {
+      e = lt(e, t), e[0]?.resume();
+    }
+  };
+}
+z(gn, "createFocusScopesStack");
+function lt(e, t) {
+  const n = [...e], r = n.indexOf(t);
+  return r !== -1 && n.splice(r, 1), n;
+}
+z(lt, "arrayRemove");
+function Cn(e) {
+  return e.filter((t) => t.tagName !== "A");
+}
+z(Cn, "removeLinks");
+var q = globalThis?.document ? s.useLayoutEffect : () => {
+}, Io = Object.defineProperty, _o = (e, t) => Io(e, "name", { value: t, configurable: !0 }), Oo = s[" useId ".trim().toString()] || (() => {
+}), To = 0;
+function Ue(e) {
+  const [t, n] = s.useState(Oo());
+  return q(() => {
+    e || n((r) => r ?? String(To++));
+  }, [e]), e || (t ? `radix-${t}` : "");
+}
+_o(Ue, "useId");
+var Ao = Object.defineProperty, No = (e, t) => Ao(e, "name", { value: t, configurable: !0 });
+function bn(e) {
+  const [t, n] = s.useState(void 0);
+  return q(() => {
+    if (e) {
+      n({ width: e.offsetWidth, height: e.offsetHeight });
+      const r = new ResizeObserver((o) => {
+        if (!Array.isArray(o) || !o.length)
+          return;
+        const i = o[0];
+        let a, u;
+        if ("borderBoxSize" in i) {
+          const c = i.borderBoxSize, m = Array.isArray(c) ? c[0] : c;
+          a = m.inlineSize, u = m.blockSize;
+        } else
+          a = e.offsetWidth, u = e.offsetHeight;
+        n({ width: a, height: u });
+      });
+      return r.observe(e, { box: "border-box" }), () => r.unobserve(e);
+    } else
+      n(void 0);
+  }, [e]), t;
+}
+No(bn, "useSize");
+var Do = Object.defineProperty, ce = (e, t) => Do(e, "name", { value: t, configurable: !0 }), yn = "Popper", [Sn, xn] = /* @__PURE__ */ fe(yn), [Fo, En] = Sn(yn), ko = /* @__PURE__ */ ce((e) => {
+  const { __scopePopper: t, children: n } = e, [r, o] = s.useState(null), [i, a] = s.useState(void 0);
+  return /* @__PURE__ */ h(
+    Fo,
+    {
+      scope: t,
+      anchor: r,
+      onAnchorChange: o,
+      placementState: i,
+      setPlacementState: a,
+      children: n
+    }
+  );
+}, "Popper"), Lo = "PopperAnchor", $o = /* @__PURE__ */ s.forwardRef(
+  /* @__PURE__ */ ce(function(t, n) {
+    const { __scopePopper: r, virtualRef: o, ...i } = t, a = En(Lo, r), u = s.useRef(null), c = a.onAnchorChange, m = s.useCallback(
+      (p) => {
+        u.current = p, p && c(p);
+      },
+      [c]
+    ), C = $(n, m), l = s.useRef(null);
+    s.useEffect(() => {
+      if (!o)
+        return;
+      const p = l.current;
+      l.current = o.current, p !== l.current && c(l.current);
+    });
+    const d = a.placementState && Be(a.placementState), v = d?.[0], f = d?.[1];
+    return o ? null : /* @__PURE__ */ h(
+      Y.div,
+      {
+        "data-radix-popper-side": v,
+        "data-radix-popper-align": f,
+        ...i,
+        ref: C
+      }
+    );
+  }, "PopperAnchor")
+), wn = "PopperContent", [Uo, ba] = Sn(wn), Go = /* @__PURE__ */ s.forwardRef(
+  /* @__PURE__ */ ce(function(t, n) {
+    const {
+      __scopePopper: r,
+      side: o = "bottom",
+      sideOffset: i = 0,
+      align: a = "center",
+      alignOffset: u = 0,
+      arrowPadding: c = 0,
+      avoidCollisions: m = !0,
+      collisionBoundary: C = [],
+      collisionPadding: l = 0,
+      sticky: d = "partial",
+      hideWhenDetached: v = !1,
+      updatePositionStrategy: f = "optimized",
+      onPlaced: p,
+      ...g
+    } = t, S = En(wn, r), [b, y] = s.useState(null), x = $(n, y), [E, w] = s.useState(null), O = bn(E), A = O?.width ?? 0, P = O?.height ?? 0, G = o + (a !== "center" ? "-" + a : ""), N = typeof l == "number" ? l : { top: 0, right: 0, bottom: 0, left: 0, ...l }, I = Array.isArray(C) ? C : [C], F = I.length > 0, B = {
+      padding: N,
+      boundary: I.filter(Mn),
+      // with `strategy: 'fixed'`, this is the only way to get it to respect boundaries
+      altBoundary: F
+    }, { refs: Z, floatingStyles: ne, placement: T, isPositioned: he, middlewareData: V } = Ir({
+      // default to `fixed` strategy so users don't have to pick and we also avoid focus scroll issues
+      strategy: "fixed",
+      placement: G,
+      whileElementsMounted: /* @__PURE__ */ ce((...ve) => kr(...ve, {
+        animationFrame: f === "always"
+      }), "whileElementsMounted"),
+      elements: {
+        reference: S.anchor
+      },
+      middleware: [
+        _r({ mainAxis: i + P, alignmentAxis: u }),
+        m && Or({
+          mainAxis: !0,
+          crossAxis: !1,
+          limiter: d === "partial" ? Fr() : void 0,
+          ...B
+        }),
+        m && Tr({ ...B }),
+        Ar({
+          ...B,
+          apply: /* @__PURE__ */ ce(({ elements: ve, rects: Nt, availableWidth: Er, availableHeight: wr }) => {
+            const { width: Mr, height: Pr } = Nt.reference, Ae = ve.floating.style;
+            Ae.setProperty("--radix-popper-available-width", `${Er}px`), Ae.setProperty("--radix-popper-available-height", `${wr}px`), Ae.setProperty("--radix-popper-anchor-width", `${Mr}px`), Ae.setProperty("--radix-popper-anchor-height", `${Pr}px`);
+          }, "apply")
+        }),
+        E && Nr({ element: E, padding: c }),
+        Bo({ arrowWidth: A, arrowHeight: P }),
+        v && Dr({
+          strategy: "referenceHidden",
+          ...B,
+          // `hide` detects whether the anchor (reference) is clipped, so when
+          // no explicit `collisionBoundary` is set we fall back to Floating
+          // UI's default clipping ancestors (e.g. a scrollable menu). This
+          // lets an occluded submenu hide once its anchor scrolls out of view
+          // (#3237). The collision/size middlewares deliberately keep the
+          // viewport-based default to avoid clamping content rendered inside
+          // transformed or overflow-clipping portal containers.
+          boundary: F ? B.boundary : void 0
+        })
+      ]
+    }), M = S.setPlacementState;
+    q(() => (M(T), () => {
+      M(void 0);
+    }), [T, M]);
+    const [re, te] = Be(T), ae = J(p);
+    q(() => {
+      he && ae?.();
+    }, [he, ae]);
+    const we = V.arrow?.x, Me = V.arrow?.y, Te = V.arrow?.centerOffset !== 0, [le, j] = s.useState();
+    return q(() => {
+      b && j(window.getComputedStyle(b).zIndex);
+    }, [b]), /* @__PURE__ */ h(
+      "div",
+      {
+        ref: Z.setFloating,
+        "data-radix-popper-content-wrapper": "",
+        style: {
+          ...ne,
+          transform: he ? ne.transform : "translate(0, -200%)",
+          // keep off the page when measuring
+          minWidth: "max-content",
+          zIndex: le,
+          "--radix-popper-transform-origin": [
+            V.transformOrigin?.x,
+            V.transformOrigin?.y
+          ].join(" "),
+          // hide the content if using the hide middleware and should be hidden
+          // set visibility to hidden and disable pointer events so the UI behaves
+          // as if the PopperContent isn't there at all
+          ...V.hide?.referenceHidden && {
+            visibility: "hidden",
+            pointerEvents: "none"
+          }
+        },
+        dir: t.dir,
+        children: /* @__PURE__ */ h(
+          Uo,
+          {
+            scope: r,
+            placedSide: re,
+            placedAlign: te,
+            onArrowChange: w,
+            arrowX: we,
+            arrowY: Me,
+            shouldHideArrow: Te,
+            children: /* @__PURE__ */ h(
+              Y.div,
+              {
+                "data-side": re,
+                "data-align": te,
+                ...g,
+                ref: x,
+                style: {
+                  ...g.style,
+                  // if the PopperContent hasn't been placed yet (not all
+                  // measurements done) we prevent animations so that users'
+                  // animations don't kick in too early from the wrong sides.
+                  animation: he ? g.style?.animation : "none"
+                }
+              }
+            )
+          }
+        )
+      }
+    );
+  }, "PopperContent")
+);
+function Mn(e) {
+  return e !== null;
+}
+ce(Mn, "isNotNull");
+var Bo = /* @__PURE__ */ ce((e) => ({
+  name: "transformOrigin",
+  options: e,
+  fn(t) {
+    const { placement: n, rects: r, middlewareData: o } = t, a = o.arrow?.centerOffset !== 0, u = a ? 0 : e.arrowWidth, c = a ? 0 : e.arrowHeight, [m, C] = Be(n), l = { start: "0%", center: "50%", end: "100%" }[C], d = (o.arrow?.x ?? 0) + u / 2, v = (o.arrow?.y ?? 0) + c / 2;
+    let f = "", p = "";
+    return m === "bottom" ? (f = a ? l : `${d}px`, p = `${-c}px`) : m === "top" ? (f = a ? l : `${d}px`, p = `${r.floating.height + c}px`) : m === "right" ? (f = `${-c}px`, p = a ? l : `${v}px`) : m === "left" && (f = `${r.floating.width + c}px`, p = a ? l : `${v}px`), { data: { x: f, y: p } };
+  }
+}), "transformOrigin");
+function Be(e) {
+  const [t, n = "center"] = e.split("-");
+  return [t, n];
+}
+ce(Be, "getSideAndAlignFromPlacement");
+var Pn = ko, Ko = $o, jo = Go, zo = Object.defineProperty, Wo = (e, t) => zo(e, "name", { value: t, configurable: !0 }), Vo = /* @__PURE__ */ s.forwardRef(
+  /* @__PURE__ */ Wo(function(t, n) {
+    const { container: r, ...o } = t, [i, a] = s.useState(!1);
+    q(() => a(!0), []);
+    const u = r || i && globalThis?.document?.body;
+    return u ? Yt.createPortal(/* @__PURE__ */ h(Y.div, { ...o, ref: n }), u) : null;
+  }, "Portal")
+), Ho = Object.defineProperty, se = (e, t) => Ho(e, "name", { value: t, configurable: !0 });
+function Rn(e, t) {
+  return s.useReducer((n, r) => t[n][r] ?? n, e);
+}
+se(Rn, "useStateMachine");
+var Ke = /* @__PURE__ */ se((e) => {
+  const { present: t, children: n } = e, r = In(t), o = typeof n == "function" ? n({ present: r.isPresent }) : s.Children.only(n), i = _n(r.ref, On(o));
+  return typeof n == "function" || r.isPresent ? s.cloneElement(o, { ref: i }) : null;
+}, "Presence");
+function In(e) {
+  const [t, n] = s.useState(), r = s.useRef(null), o = s.useRef(e), i = s.useRef("none"), a = s.useRef(void 0), u = e ? "mounted" : "unmounted", [c, m] = Rn(u, {
+    mounted: {
+      UNMOUNT: "unmounted",
+      ANIMATION_OUT: "unmountSuspended"
+    },
+    unmountSuspended: {
+      MOUNT: "mounted",
+      ANIMATION_END: "unmounted"
+    },
+    unmounted: {
+      MOUNT: "mounted"
+    }
+  });
+  return s.useEffect(() => {
+    c === "mounted" ? (i.current = a.current ?? Se(r.current), a.current = void 0) : i.current = "none";
+  }, [c]), q(() => {
+    const C = r.current, l = o.current;
+    if (l !== e) {
+      const v = i.current, f = Se(C);
+      e ? (a.current = f, m("MOUNT")) : f === "none" || C?.display === "none" ? m("UNMOUNT") : m(l && v !== f ? "ANIMATION_OUT" : "UNMOUNT"), o.current = e;
+    }
+  }, [e, m]), q(() => {
+    if (t) {
+      let C;
+      const l = t.ownerDocument.defaultView ?? window, d = /* @__PURE__ */ se((f) => {
+        const g = Se(r.current).includes(CSS.escape(f.animationName));
+        if (f.target === t && g && (m("ANIMATION_END"), !o.current)) {
+          const S = t.style.animationFillMode;
+          t.style.animationFillMode = "forwards", C = l.setTimeout(() => {
+            t.style.animationFillMode === "forwards" && (t.style.animationFillMode = S);
+          });
+        }
+      }, "handleAnimationEnd"), v = /* @__PURE__ */ se((f) => {
+        f.target === t && (i.current = Se(r.current));
+      }, "handleAnimationStart");
+      return t.addEventListener("animationstart", v), t.addEventListener("animationcancel", d), t.addEventListener("animationend", d), () => {
+        l.clearTimeout(C), t.removeEventListener("animationstart", v), t.removeEventListener("animationcancel", d), t.removeEventListener("animationend", d);
+      };
+    } else
+      m("ANIMATION_END");
+  }, [t, m]), {
+    isPresent: ["mounted", "unmountSuspended"].includes(c),
+    ref: s.useCallback((C) => {
+      if (C) {
+        const l = getComputedStyle(C);
+        r.current = l, a.current = Se(l);
+      } else
+        r.current = null;
+      n(C);
+    }, [])
+  };
+}
+se(In, "usePresence");
+function dt(e, t) {
+  if (typeof e == "function")
+    return e(t);
+  e != null && (e.current = t);
+}
+se(dt, "setRef");
+function _n(...e) {
+  const t = s.useRef(e);
+  return t.current = e, s.useCallback((n) => {
+    const r = t.current;
+    let o = !1;
+    const i = r.map((a) => {
+      const u = dt(a, n);
+      return !o && typeof u == "function" && (o = !0), u;
+    });
+    if (o)
+      return () => {
+        for (let a = 0; a < i.length; a++) {
+          const u = i[a];
+          typeof u == "function" ? u() : dt(r[a], null);
+        }
+      };
+  }, []);
+}
+se(_n, "useStableComposedRefs");
+function Se(e) {
+  return e?.animationName || "none";
+}
+se(Se, "getAnimationName");
+function On(e) {
+  let t = Object.getOwnPropertyDescriptor(e.props, "ref")?.get, n = t && "isReactWarning" in t && t.isReactWarning;
+  return n ? e.ref : (t = Object.getOwnPropertyDescriptor(e, "ref")?.get, n = t && "isReactWarning" in t && t.isReactWarning, n ? e.props.ref : e.props.ref || e.ref);
+}
+se(On, "getElementRef");
+var Yo = Object.defineProperty, Xo = (e, t) => Yo(e, "name", { value: t, configurable: !0 }), Bt = s[" useEffectEvent ".trim().toString()], Kt = s[" useInsertionEffect ".trim().toString()];
+function Tn(e) {
+  if (typeof Bt == "function")
+    return Bt(e);
+  const t = s.useRef(() => {
+    throw new Error("Cannot call an event handler while rendering.");
+  });
+  return typeof Kt == "function" ? Kt(() => {
+    t.current = e;
+  }) : q(() => {
+    t.current = e;
+  }), s.useMemo(() => (...n) => t.current?.(...n), []);
+}
+Xo(Tn, "useEffectEvent");
+var Zo = Object.defineProperty, _e = (e, t) => Zo(e, "name", { value: t, configurable: !0 }), qo = s[" useInsertionEffect ".trim().toString()] || q;
+function je({
+  prop: e,
+  defaultProp: t,
+  onChange: n = /* @__PURE__ */ _e(() => {
+  }, "onChange"),
+  caller: r
+}) {
+  const [o, i, a] = An({
+    defaultProp: t,
+    onChange: n
+  }), u = e !== void 0, c = u ? e : o, m = s.useCallback(
+    (C) => {
+      if (u) {
+        const l = Nn(C) ? C(e) : C;
+        l !== e && a.current?.(l);
+      } else
+        i(C);
+    },
+    [u, e, i, a]
+  );
+  return [c, m];
+}
+_e(je, "useControllableState");
+function An({
+  defaultProp: e,
+  onChange: t
+}) {
+  const [n, r] = s.useState(e), o = s.useRef(n), i = s.useRef(t);
+  return qo(() => {
+    i.current = t;
+  }, [t]), s.useEffect(() => {
+    o.current !== n && (i.current?.(n), o.current = n);
+  }, [n, o]), [n, r, i];
+}
+_e(An, "useUncontrolledState");
+function Nn(e) {
+  return typeof e == "function";
+}
+_e(Nn, "isFunction");
+var jt = Symbol("RADIX:SYNC_STATE");
+function Qo(e, t, n, r) {
+  const { prop: o, defaultProp: i, onChange: a, caller: u } = t, c = o !== void 0, m = Tn(a), C = [{ ...n, state: i }];
+  r && C.push(r);
+  const [l, d] = s.useReducer(
+    (g, S) => {
+      if (S.type === jt)
+        return { ...g, state: S.state };
+      const b = e(g, S);
+      return c && !Object.is(b.state, g.state) && m(b.state), b;
+    },
+    ...C
+  ), v = l.state, f = s.useRef(v);
+  s.useEffect(() => {
+    f.current !== v && (f.current = v, c || m(v));
+  }, [v, f, c]);
+  const p = s.useMemo(() => o !== void 0 ? { ...l, state: o } : l, [l, o]);
+  return s.useEffect(() => {
+    c && !Object.is(o, l.state) && d({ type: jt, state: o });
+  }, [o, l.state, c]), [p, d];
+}
+_e(Qo, "useControllableStateReducer");
+var Jo = Object.defineProperty, Pt = (e, t) => Jo(e, "name", { value: t, configurable: !0 }), Je = !1;
+function Dn() {
+  const [e, t] = s.useState(Je);
+  return s.useEffect(() => {
+    Je || (Je = !0, t(!0));
+  }, []), e;
+}
+Pt(Dn, "useIsHydrated");
+var Fn = s[" useSyncExternalStore ".trim().toString()];
+function kn() {
+  return () => {
+  };
+}
+Pt(kn, "subscribe");
+function Ln() {
+  return Fn(
+    kn,
+    () => !0,
+    () => !1
+  );
+}
+Pt(Ln, "useIsHydratedModern");
+var es = typeof Fn == "function" ? Ln : Dn, ts = Object.defineProperty, pe = (e, t) => ts(e, "name", { value: t, configurable: !0 }), et = "rovingFocusGroup.onEntryFocus", ns = { bubbles: !1, cancelable: !0 }, ze = "RovingFocusGroup", [ft, $n, rs] = /* @__PURE__ */ bt(ze), [os, Un] = /* @__PURE__ */ fe(
+  ze,
+  [rs]
+), [ss, is] = os(ze), as = /* @__PURE__ */ s.forwardRef(
+  // blank line to reduce diff noise
+  /* @__PURE__ */ pe(function(t, n) {
+    return /* @__PURE__ */ h(ft.Provider, { scope: t.__scopeRovingFocusGroup, children: /* @__PURE__ */ h(ft.Slot, { scope: t.__scopeRovingFocusGroup, children: /* @__PURE__ */ h(cs, { ...t, ref: n }) }) });
+  }, "RovingFocusGroup")
+), cs = /* @__PURE__ */ s.forwardRef(/* @__PURE__ */ pe(function(t, n) {
+  const {
+    __scopeRovingFocusGroup: r,
+    orientation: o,
+    loop: i = !1,
+    dir: a,
+    currentTabStopId: u,
+    defaultCurrentTabStopId: c,
+    onCurrentTabStopIdChange: m,
+    onEntryFocus: C,
+    preventScrollOnEntryFocus: l = !1,
+    ...d
+  } = t, v = s.useRef(null), f = $(n, v), p = St(a), [g, S] = je({
+    prop: u,
+    defaultProp: c ?? null,
+    onChange: m,
+    caller: ze
+  }), [b, y] = s.useState(!1), x = J(C), E = $n(r), w = s.useRef(!1), [O, A] = s.useState(0);
+  return s.useEffect(() => {
+    const P = v.current;
+    if (P)
+      return P.addEventListener(et, x), () => P.removeEventListener(et, x);
+  }, [x]), /* @__PURE__ */ h(
+    ss,
+    {
+      scope: r,
+      orientation: o,
+      dir: p,
+      loop: i,
+      currentTabStopId: g,
+      onItemFocus: s.useCallback(
+        (P) => S(P),
+        [S]
+      ),
+      onItemShiftTab: s.useCallback(() => y(!0), []),
+      onFocusableItemAdd: s.useCallback(
+        () => A((P) => P + 1),
+        []
+      ),
+      onFocusableItemRemove: s.useCallback(
+        () => A((P) => P - 1),
+        []
+      ),
+      children: /* @__PURE__ */ h(
+        Y.div,
+        {
+          tabIndex: b || O === 0 ? -1 : 0,
+          "data-orientation": o,
+          ...d,
+          ref: f,
+          style: { outline: "none", ...t.style },
+          onMouseDown: R(t.onMouseDown, () => {
+            w.current = !0;
+          }),
+          onFocus: R(t.onFocus, (P) => {
+            const G = !w.current;
+            if (P.target === P.currentTarget && G && !b) {
+              const N = new CustomEvent(et, ns);
+              if (P.currentTarget.dispatchEvent(N), !N.defaultPrevented) {
+                const I = E().filter((T) => T.focusable), F = I.find((T) => T.active), B = I.find((T) => T.id === g), ne = [F, B, ...I].filter(
+                  Boolean
+                ).map((T) => T.ref.current);
+                Rt(ne, l);
+              }
+            }
+            w.current = !1;
+          }),
+          onBlur: R(t.onBlur, () => y(!1))
+        }
+      )
+    }
+  );
+}, "RovingFocusGroupImpl")), us = "RovingFocusGroupItem", ls = /* @__PURE__ */ s.forwardRef(
+  // blank line to reduce diff noise
+  /* @__PURE__ */ pe(function(t, n) {
+    const {
+      __scopeRovingFocusGroup: r,
+      focusable: o = !0,
+      active: i = !1,
+      tabStopId: a,
+      children: u,
+      ...c
+    } = t, m = Ue(), C = a || m, l = is(us, r), d = l.currentTabStopId === C, v = $n(r), { onFocusableItemAdd: f, onFocusableItemRemove: p, currentTabStopId: g } = l, S = es();
+    return q(() => {
+      if (!(!S || !o))
+        return f(), () => p();
+    }, [S, o, f, p]), s.useEffect(() => {
+      if (!(S || !o))
+        return f(), () => p();
+    }, [S, o, f, p]), /* @__PURE__ */ h(
+      ft.ItemSlot,
+      {
+        scope: r,
+        id: C,
+        focusable: o,
+        active: i,
+        children: /* @__PURE__ */ h(
+          Y.span,
+          {
+            tabIndex: d ? 0 : -1,
+            "data-orientation": l.orientation,
+            ...c,
+            ref: n,
+            onMouseDown: R(t.onMouseDown, (b) => {
+              o ? l.onItemFocus(C) : b.preventDefault();
+            }),
+            onFocus: R(t.onFocus, () => l.onItemFocus(C)),
+            onKeyDown: R(t.onKeyDown, (b) => {
+              if (b.key === "Tab" && b.shiftKey) {
+                l.onItemShiftTab();
+                return;
+              }
+              if (b.target !== b.currentTarget) return;
+              const y = Bn(b, l.orientation, l.dir);
+              if (y !== void 0) {
+                if (b.metaKey || b.ctrlKey || b.altKey || b.shiftKey) return;
+                b.preventDefault();
+                let E = v().filter((w) => w.focusable).map((w) => w.ref.current);
+                if (y === "last") E.reverse();
+                else if (y === "prev" || y === "next") {
+                  y === "prev" && E.reverse();
+                  const w = E.indexOf(b.currentTarget);
+                  E = l.loop ? Kn(E, w + 1) : E.slice(w + 1);
+                }
+                setTimeout(() => Rt(E));
+              }
+            }),
+            children: typeof u == "function" ? u({ isCurrentTabStop: d, hasTabStop: g != null }) : u
+          }
+        )
+      }
+    );
+  }, "RovingFocusGroupItem")
+), ds = {
+  ArrowLeft: "prev",
+  ArrowUp: "prev",
+  ArrowRight: "next",
+  ArrowDown: "next",
+  PageUp: "first",
+  Home: "first",
+  PageDown: "last",
+  End: "last"
+};
+function Gn(e, t) {
+  return t !== "rtl" ? e : e === "ArrowLeft" ? "ArrowRight" : e === "ArrowRight" ? "ArrowLeft" : e;
+}
+pe(Gn, "getDirectionAwareKey");
+function Bn(e, t, n) {
+  const r = Gn(e.key, n);
+  if (!(t === "vertical" && ["ArrowLeft", "ArrowRight"].includes(r)) && !(t === "horizontal" && ["ArrowUp", "ArrowDown"].includes(r)))
+    return ds[r];
+}
+pe(Bn, "getFocusIntent");
+function Rt(e, t = !1) {
+  const n = document.activeElement;
+  for (const r of e)
+    if (r === n || (r.focus({ preventScroll: t }), document.activeElement !== n)) return;
+}
+pe(Rt, "focusFirst");
+function Kn(e, t) {
+  return e.map((n, r) => e[(t + r) % e.length]);
+}
+pe(Kn, "wrapArray");
+var fs = as, ps = ls, jn = Lr(), tt = function() {
+}, We = s.forwardRef(function(e, t) {
+  var n = s.useRef(null), r = s.useState({
+    onScrollCapture: tt,
+    onWheelCapture: tt,
+    onTouchMoveCapture: tt
+  }), o = r[0], i = r[1], a = e.forwardProps, u = e.children, c = e.className, m = e.removeScrollBar, C = e.enabled, l = e.shards, d = e.sideCar, v = e.noRelative, f = e.noIsolation, p = e.inert, g = e.allowPinchZoom, S = e.as, b = S === void 0 ? "div" : S, y = e.gapMode, x = $r(e, ["forwardProps", "children", "className", "removeScrollBar", "enabled", "shards", "sideCar", "noRelative", "noIsolation", "inert", "allowPinchZoom", "as", "gapMode"]), E = d, w = Ur([n, t]), O = ye(ye({}, x), o);
+  return s.createElement(
+    s.Fragment,
+    null,
+    C && s.createElement(E, { sideCar: jn, removeScrollBar: m, shards: l, noRelative: v, noIsolation: f, inert: p, setCallbacks: i, allowPinchZoom: !!g, lockRef: n, gapMode: y }),
+    a ? s.cloneElement(s.Children.only(u), ye(ye({}, O), { ref: w })) : s.createElement(b, ye({}, O, { className: c, ref: w }), u)
+  );
+});
+We.defaultProps = {
+  enabled: !0,
+  removeScrollBar: !0,
+  inert: !1
+};
+We.classNames = {
+  fullWidth: Br,
+  zeroRight: Gr
+};
+var pt = !1;
+if (typeof window < "u")
+  try {
+    var Fe = Object.defineProperty({}, "passive", {
+      get: function() {
+        return pt = !0, !0;
+      }
+    });
+    window.addEventListener("test", Fe, Fe), window.removeEventListener("test", Fe, Fe);
+  } catch {
+    pt = !1;
+  }
+var Ce = pt ? { passive: !1 } : !1, ms = function(e) {
+  return e.tagName === "TEXTAREA";
+}, zn = function(e, t) {
+  if (!(e instanceof Element))
+    return !1;
+  var n = window.getComputedStyle(e);
+  return (
+    // not-not-scrollable
+    n[t] !== "hidden" && // contains scroll inside self
+    !(n.overflowY === n.overflowX && !ms(e) && n[t] === "visible")
+  );
+}, hs = function(e) {
+  return zn(e, "overflowY");
+}, vs = function(e) {
+  return zn(e, "overflowX");
+}, zt = function(e, t) {
+  var n = t.ownerDocument, r = t;
+  do {
+    typeof ShadowRoot < "u" && r instanceof ShadowRoot && (r = r.host);
+    var o = Wn(e, r);
+    if (o) {
+      var i = Vn(e, r), a = i[1], u = i[2];
+      if (a > u)
+        return !0;
+    }
+    r = r.parentNode;
+  } while (r && r !== n.body);
+  return !1;
+}, gs = function(e) {
+  var t = e.scrollTop, n = e.scrollHeight, r = e.clientHeight;
+  return [
+    t,
+    n,
+    r
+  ];
+}, Cs = function(e) {
+  var t = e.scrollLeft, n = e.scrollWidth, r = e.clientWidth;
+  return [
+    t,
+    n,
+    r
+  ];
+}, Wn = function(e, t) {
+  return e === "v" ? hs(t) : vs(t);
+}, Vn = function(e, t) {
+  return e === "v" ? gs(t) : Cs(t);
+}, bs = function(e, t) {
+  return e === "h" && t === "rtl" ? -1 : 1;
+}, ys = function(e, t, n, r, o) {
+  var i = bs(e, window.getComputedStyle(t).direction), a = i * r, u = n.target, c = t.contains(u), m = !1, C = a > 0, l = 0, d = 0;
+  do {
+    if (!u)
+      break;
+    var v = Vn(e, u), f = v[0], p = v[1], g = v[2], S = p - g - i * f;
+    (f || S) && Wn(e, u) && (l += S, d += f);
+    var b = u.parentNode;
+    u = b && b.nodeType === Node.DOCUMENT_FRAGMENT_NODE ? b.host : b;
+  } while (
+    // portaled content
+    !c && u !== document.body || // self content
+    c && (t.contains(u) || t === u)
+  );
+  return (C && Math.abs(l) < 1 || !C && Math.abs(d) < 1) && (m = !0), m;
+}, ke = function(e) {
+  return "changedTouches" in e ? [e.changedTouches[0].clientX, e.changedTouches[0].clientY] : [0, 0];
+}, Wt = function(e) {
+  return [e.deltaX, e.deltaY];
+}, Vt = function(e) {
+  return e && "current" in e ? e.current : e;
+}, Ss = function(e, t) {
+  return e[0] === t[0] && e[1] === t[1];
+}, xs = function(e) {
+  return `
+  .block-interactivity-`.concat(e, ` {pointer-events: none;}
+  .allow-interactivity-`).concat(e, ` {pointer-events: all;}
+`);
+}, Es = 0, be = [];
+function ws(e) {
+  var t = s.useRef([]), n = s.useRef([0, 0]), r = s.useRef(), o = s.useState(Es++)[0], i = s.useState(Kr)[0], a = s.useRef(e);
+  s.useEffect(function() {
+    a.current = e;
+  }, [e]), s.useEffect(function() {
+    if (e.inert) {
+      document.body.classList.add("block-interactivity-".concat(o));
+      var p = jr([e.lockRef.current], (e.shards || []).map(Vt), !0).filter(Boolean);
+      return p.forEach(function(g) {
+        return g.classList.add("allow-interactivity-".concat(o));
+      }), function() {
+        document.body.classList.remove("block-interactivity-".concat(o)), p.forEach(function(g) {
+          return g.classList.remove("allow-interactivity-".concat(o));
+        });
+      };
+    }
+  }, [e.inert, e.lockRef.current, e.shards]);
+  var u = s.useCallback(function(p, g) {
+    if ("touches" in p && p.touches.length === 2 || p.type === "wheel" && p.ctrlKey)
+      return !a.current.allowPinchZoom;
+    var S = ke(p), b = n.current, y = "deltaX" in p ? p.deltaX : b[0] - S[0], x = "deltaY" in p ? p.deltaY : b[1] - S[1], E, w = p.target, O = Math.abs(y) > Math.abs(x) ? "h" : "v";
+    if ("touches" in p && O === "h" && w.type === "range")
+      return !1;
+    var A = window.getSelection(), P = A && A.anchorNode, G = P ? P === w || P.contains(w) : !1;
+    if (G)
+      return !1;
+    var N = zt(O, w);
+    if (!N)
+      return !0;
+    if (N ? E = O : (E = O === "v" ? "h" : "v", N = zt(O, w)), !N)
+      return !1;
+    if (!r.current && "changedTouches" in p && (y || x) && (r.current = E), !E)
+      return !0;
+    var I = r.current || E;
+    return ys(I, g, p, I === "h" ? y : x);
+  }, []), c = s.useCallback(function(p) {
+    var g = p;
+    if (!(!be.length || be[be.length - 1] !== i)) {
+      var S = "deltaY" in g ? Wt(g) : ke(g), b = t.current.filter(function(E) {
+        return E.name === g.type && (E.target === g.target || g.target === E.shadowParent) && Ss(E.delta, S);
+      })[0];
+      if (b && b.should) {
+        g.cancelable && g.preventDefault();
+        return;
+      }
+      if (!b) {
+        var y = (a.current.shards || []).map(Vt).filter(Boolean).filter(function(E) {
+          return E.contains(g.target);
+        }), x = y.length > 0 ? u(g, y[0]) : !a.current.noIsolation;
+        x && g.cancelable && g.preventDefault();
+      }
+    }
+  }, []), m = s.useCallback(function(p, g, S, b) {
+    var y = { name: p, delta: g, target: S, should: b, shadowParent: Ms(S) };
+    t.current.push(y), setTimeout(function() {
+      t.current = t.current.filter(function(x) {
+        return x !== y;
+      });
+    }, 1);
+  }, []), C = s.useCallback(function(p) {
+    n.current = ke(p), r.current = void 0;
+  }, []), l = s.useCallback(function(p) {
+    m(p.type, Wt(p), p.target, u(p, e.lockRef.current));
+  }, []), d = s.useCallback(function(p) {
+    m(p.type, ke(p), p.target, u(p, e.lockRef.current));
+  }, []);
+  s.useEffect(function() {
+    return be.push(i), e.setCallbacks({
+      onScrollCapture: l,
+      onWheelCapture: l,
+      onTouchMoveCapture: d
+    }), document.addEventListener("wheel", c, Ce), document.addEventListener("touchmove", c, Ce), document.addEventListener("touchstart", C, Ce), function() {
+      be = be.filter(function(p) {
+        return p !== i;
+      }), document.removeEventListener("wheel", c, Ce), document.removeEventListener("touchmove", c, Ce), document.removeEventListener("touchstart", C, Ce);
+    };
+  }, []);
+  var v = e.removeScrollBar, f = e.inert;
+  return s.createElement(
+    s.Fragment,
+    null,
+    f ? s.createElement(i, { styles: xs(o) }) : null,
+    v ? s.createElement(zr, { noRelative: e.noRelative, gapMode: e.gapMode }) : null
+  );
+}
+function Ms(e) {
+  for (var t = null; e !== null; )
+    e instanceof ShadowRoot && (t = e.host, e = e.host), e = e.parentNode;
+  return t;
+}
+const Ps = Wr(jn, ws);
+var Hn = s.forwardRef(function(e, t) {
+  return s.createElement(We, ye({}, e, { ref: t, sideCar: Ps }));
+});
+Hn.classNames = We.classNames;
+var Rs = Object.defineProperty, _ = (e, t) => Rs(e, "name", { value: t, configurable: !0 }), mt = ["Enter", " "], Is = ["ArrowDown", "PageUp", "Home"], Yn = ["ArrowUp", "PageDown", "End"], _s = [...Is, ...Yn], Os = {
+  ltr: [...mt, "ArrowRight"],
+  rtl: [...mt, "ArrowLeft"]
+}, Ts = {
+  ltr: ["ArrowLeft"],
+  rtl: ["ArrowRight"]
+}, Ve = "Menu", [Re, As, Ns] = /* @__PURE__ */ bt(Ve), [me, Xn] = /* @__PURE__ */ fe(Ve, [
+  Ns,
+  xn,
+  Un
+]), He = xn(), Zn = Un(), [qn, ue] = me(Ve), [Ds, Oe] = me(Ve), Fs = /* @__PURE__ */ _((e) => {
+  const { __scopeMenu: t, open: n = !1, children: r, dir: o, onOpenChange: i, modal: a = !0 } = e, u = He(t), [c, m] = s.useState(null), C = s.useRef(!1), l = J(i), d = St(o);
+  return s.useEffect(() => {
+    const v = /* @__PURE__ */ _(() => {
+      C.current = !0, document.addEventListener("pointerdown", f, { capture: !0, once: !0 }), document.addEventListener("pointermove", f, { capture: !0, once: !0 });
+    }, "handleKeyDown"), f = /* @__PURE__ */ _(() => C.current = !1, "handlePointer");
+    return document.addEventListener("keydown", v, { capture: !0 }), () => {
+      document.removeEventListener("keydown", v, { capture: !0 }), document.removeEventListener("pointerdown", f, { capture: !0 }), document.removeEventListener("pointermove", f, { capture: !0 });
+    };
+  }, []), s.useEffect(() => {
+    if (!n)
+      return;
+    const v = /* @__PURE__ */ _(() => l(!1), "handleBlur");
+    return window.addEventListener("blur", v), () => window.removeEventListener("blur", v);
+  }, [n, l]), /* @__PURE__ */ h(Pn, { ...u, children: /* @__PURE__ */ h(
+    qn,
+    {
+      scope: t,
+      open: n,
+      onOpenChange: l,
+      content: c,
+      onContentChange: m,
+      children: /* @__PURE__ */ h(
+        Ds,
+        {
+          scope: t,
+          onClose: s.useCallback(() => l(!1), [l]),
+          isUsingKeyboardRef: C,
+          dir: d,
+          modal: a,
+          children: r
+        }
+      )
+    }
+  ) });
+}, "Menu"), Qn = /* @__PURE__ */ s.forwardRef(
+  /* @__PURE__ */ _(function(t, n) {
+    const { __scopeMenu: r, ...o } = t, i = He(r);
+    return /* @__PURE__ */ h(Ko, { ...i, ...o, ref: n });
+  }, "MenuAnchor")
+), Jn = "MenuPortal", [ks, er] = me(Jn, {
+  forceMount: void 0
+}), Ls = /* @__PURE__ */ _((e) => {
+  const { __scopeMenu: t, forceMount: n, children: r, container: o } = e, i = ue(Jn, t);
+  return /* @__PURE__ */ h(ks, { scope: t, forceMount: n, children: /* @__PURE__ */ h(Ke, { present: n || i.open, children: /* @__PURE__ */ h(Vo, { asChild: !0, container: o, children: r }) }) });
+}, "MenuPortal"), Q = "MenuContent", [$s, It] = me(Q), Us = /* @__PURE__ */ s.forwardRef(
+  /* @__PURE__ */ _(function(t, n) {
+    const r = er(Q, t.__scopeMenu), { forceMount: o = r.forceMount, ...i } = t, a = ue(Q, t.__scopeMenu), u = Oe(Q, t.__scopeMenu);
+    return /* @__PURE__ */ h(Re.Provider, { scope: t.__scopeMenu, children: /* @__PURE__ */ h(Ke, { present: o || a.open, children: /* @__PURE__ */ h(Re.Slot, { scope: t.__scopeMenu, children: u.modal ? /* @__PURE__ */ h(Gs, { ...i, ref: n }) : /* @__PURE__ */ h(Bs, { ...i, ref: n }) }) }) });
+  }, "MenuContent")
+), Gs = /* @__PURE__ */ s.forwardRef(
+  // blank line to reduce diff noise
+  /* @__PURE__ */ _(function(t, n) {
+    const r = ue(Q, t.__scopeMenu), o = s.useRef(null), i = $(n, o);
+    return s.useEffect(() => {
+      const a = o.current;
+      if (a) return Vr(a);
+    }, []), /* @__PURE__ */ h(
+      _t,
+      {
+        ...t,
+        ref: i,
+        trapFocus: r.open,
+        disableOutsidePointerEvents: r.open,
+        disableOutsideScroll: !0,
+        onFocusOutside: R(
+          t.onFocusOutside,
+          (a) => a.preventDefault(),
+          { checkForDefaultPrevented: !1 }
+        ),
+        onDismiss: () => r.onOpenChange(!1)
+      }
+    );
+  }, "MenuRootContentModal")
+), Bs = /* @__PURE__ */ s.forwardRef(/* @__PURE__ */ _(function(t, n) {
+  const r = ue(Q, t.__scopeMenu);
+  return /* @__PURE__ */ h(
+    _t,
+    {
+      ...t,
+      ref: n,
+      trapFocus: !1,
+      disableOutsidePointerEvents: !1,
+      disableOutsideScroll: !1,
+      onDismiss: () => r.onOpenChange(!1)
+    }
+  );
+}, "MenuRootContentNonModal")), Ks = /* @__PURE__ */ de("MenuContent.ScrollLock"), _t = /* @__PURE__ */ s.forwardRef(
+  // blank line to reduce diff noise
+  /* @__PURE__ */ _(function(t, n) {
+    const {
+      __scopeMenu: r,
+      loop: o = !1,
+      trapFocus: i,
+      onOpenAutoFocus: a,
+      onCloseAutoFocus: u,
+      disableOutsidePointerEvents: c,
+      onEntryFocus: m,
+      onEscapeKeyDown: C,
+      onPointerDownOutside: l,
+      onFocusOutside: d,
+      onInteractOutside: v,
+      onDismiss: f,
+      disableOutsideScroll: p,
+      ...g
+    } = t, S = ue(Q, r), b = Oe(Q, r), y = He(r), x = Zn(r), E = As(r), [w, O] = s.useState(null), A = s.useRef(null), P = $(n, A, S.onContentChange), G = s.useRef(0), N = s.useRef(""), I = s.useRef(0), F = s.useRef(null), B = s.useRef("right"), Z = s.useRef(0), ne = p ? Hn : s.Fragment, T = p ? { as: Ks, allowPinchZoom: !0 } : void 0, he = /* @__PURE__ */ _((M) => {
+      const re = N.current + M, te = E().filter((j) => !j.disabled), ae = document.activeElement, we = te.find((j) => j.ref.current === ae)?.textValue, Me = te.map((j) => j.textValue), Te = ur(Me, re, we), le = te.find((j) => j.textValue === Te)?.ref.current;
+      (/* @__PURE__ */ _(function j(ve) {
+        N.current = ve, window.clearTimeout(G.current), ve !== "" && (G.current = window.setTimeout(() => j(""), 1e3));
+      }, "updateSearch"))(re), le && setTimeout(() => le.focus());
+    }, "handleTypeaheadSearch");
+    s.useEffect(() => () => window.clearTimeout(G.current), []), wt();
+    const V = s.useCallback((M) => B.current === F.current?.side && dr(M, F.current?.area), []);
+    return /* @__PURE__ */ h(
+      $s,
+      {
+        scope: r,
+        searchRef: N,
+        onItemEnter: s.useCallback(
+          (M) => {
+            V(M) && M.preventDefault();
+          },
+          [V]
+        ),
+        onItemLeave: s.useCallback(
+          (M) => {
+            V(M) || (A.current?.focus(), O(null));
+          },
+          [V]
+        ),
+        onTriggerLeave: s.useCallback(
+          (M) => {
+            V(M) && M.preventDefault();
+          },
+          [V]
+        ),
+        pointerGraceTimerRef: I,
+        onPointerGraceIntentChange: s.useCallback((M) => {
+          F.current = M;
+        }, []),
+        children: /* @__PURE__ */ h(ne, { ...T, children: /* @__PURE__ */ h(
+          Ro,
+          {
+            asChild: !0,
+            trapped: i,
+            onMountAutoFocus: R(a, (M) => {
+              M.preventDefault(), A.current?.focus({ preventScroll: !0 });
+            }),
+            onUnmountAutoFocus: u,
+            children: /* @__PURE__ */ h(
+              So,
+              {
+                asChild: !0,
+                disableOutsidePointerEvents: c,
+                onEscapeKeyDown: C,
+                onPointerDownOutside: l,
+                onFocusOutside: d,
+                onInteractOutside: v,
+                onDismiss: f,
+                children: /* @__PURE__ */ h(
+                  fs,
+                  {
+                    asChild: !0,
+                    ...x,
+                    dir: b.dir,
+                    orientation: "vertical",
+                    loop: o,
+                    currentTabStopId: w,
+                    onCurrentTabStopIdChange: O,
+                    onEntryFocus: R(m, (M) => {
+                      b.isUsingKeyboardRef.current || M.preventDefault();
+                    }),
+                    preventScrollOnEntryFocus: !0,
+                    children: /* @__PURE__ */ h(
+                      jo,
+                      {
+                        role: "menu",
+                        "aria-orientation": "vertical",
+                        "data-state": Tt(S.open),
+                        "data-radix-menu-content": "",
+                        dir: b.dir,
+                        ...y,
+                        ...g,
+                        ref: P,
+                        style: { outline: "none", ...g.style },
+                        onKeyDown: R(g.onKeyDown, (M) => {
+                          const te = M.target.closest("[data-radix-menu-content]") === M.currentTarget, ae = M.ctrlKey || M.altKey || M.metaKey, we = M.key.length === 1;
+                          te && (M.key === "Tab" && M.preventDefault(), !ae && we && he(M.key));
+                          const Me = A.current;
+                          if (M.target !== Me || !_s.includes(M.key)) return;
+                          M.preventDefault();
+                          const le = E().filter((j) => !j.disabled).map((j) => j.ref.current);
+                          Yn.includes(M.key) && le.reverse(), ar(le);
+                        }),
+                        onBlur: R(t.onBlur, (M) => {
+                          M.currentTarget.contains(M.target) || (window.clearTimeout(G.current), N.current = "");
+                        }),
+                        onPointerMove: R(
+                          t.onPointerMove,
+                          xe((M) => {
+                            const re = M.target, te = Z.current !== M.clientX;
+                            if (M.currentTarget.contains(re) && te) {
+                              const ae = M.clientX > Z.current ? "right" : "left";
+                              B.current = ae, Z.current = M.clientX;
+                            }
+                          })
+                        )
+                      }
+                    )
+                  }
+                )
+              }
+            )
+          }
+        ) })
+      }
+    );
+  }, "MenuContentImpl")
+), tr = /* @__PURE__ */ s.forwardRef(
+  /* @__PURE__ */ _(function(t, n) {
+    const { __scopeMenu: r, ...o } = t;
+    return /* @__PURE__ */ h(Y.div, { role: "group", ...o, ref: n });
+  }, "MenuGroup")
+), js = /* @__PURE__ */ s.forwardRef(
+  /* @__PURE__ */ _(function(t, n) {
+    const { __scopeMenu: r, ...o } = t;
+    return /* @__PURE__ */ h(Y.div, { ...o, ref: n });
+  }, "MenuLabel")
+), ht = "MenuItem", Ht = "menu.itemSelect", Ot = /* @__PURE__ */ s.forwardRef(
+  // blank line to reduce diff noise
+  /* @__PURE__ */ _(function(t, n) {
+    const { disabled: r = !1, onSelect: o, ...i } = t, a = s.useRef(null), u = Oe(ht, t.__scopeMenu), c = It(ht, t.__scopeMenu), m = $(n, a), C = s.useRef(!1), l = /* @__PURE__ */ _(() => {
+      const d = a.current;
+      if (!r && d) {
+        const v = new CustomEvent(Ht, { bubbles: !0, cancelable: !0 });
+        d.addEventListener(Ht, (f) => o?.(f), { once: !0 }), Ct(d, v), v.defaultPrevented ? C.current = !1 : u.onClose();
+      }
+    }, "handleSelect");
+    return /* @__PURE__ */ h(
+      nr,
+      {
+        ...i,
+        ref: m,
+        disabled: r,
+        onClick: R(t.onClick, l),
+        onPointerDown: (d) => {
+          t.onPointerDown?.(d), C.current = !0;
+        },
+        onPointerUp: R(t.onPointerUp, (d) => {
+          C.current || d.currentTarget?.click();
+        }),
+        onKeyDown: R(t.onKeyDown, (d) => {
+          r || d.target !== d.currentTarget || c.searchRef.current !== "" && d.key === " " || mt.includes(d.key) && (d.currentTarget.click(), d.preventDefault());
+        })
+      }
+    );
+  }, "MenuItem")
+), nr = /* @__PURE__ */ s.forwardRef(
+  /* @__PURE__ */ _(function(t, n) {
+    const { __scopeMenu: r, disabled: o = !1, textValue: i, ...a } = t, u = It(ht, r), c = Zn(r), m = s.useRef(null), C = $(n, m), [l, d] = s.useState(!1), [v, f] = s.useState("");
+    return s.useEffect(() => {
+      const p = m.current;
+      p && f((p.textContent ?? "").trim());
+    }, [a.children]), /* @__PURE__ */ h(
+      Re.ItemSlot,
+      {
+        scope: r,
+        disabled: o,
+        textValue: i ?? v,
+        children: /* @__PURE__ */ h(ps, { asChild: !0, ...c, focusable: !o, children: /* @__PURE__ */ h(
+          Y.div,
+          {
+            role: "menuitem",
+            "data-highlighted": l ? "" : void 0,
+            "aria-disabled": o || void 0,
+            "data-disabled": o ? "" : void 0,
+            ...a,
+            ref: C,
+            onPointerMove: R(
+              t.onPointerMove,
+              xe((p) => {
+                o ? u.onItemLeave(p) : (u.onItemEnter(p), p.defaultPrevented || p.currentTarget.focus({ preventScroll: !0 }));
+              })
+            ),
+            onPointerLeave: R(
+              t.onPointerLeave,
+              xe((p) => u.onItemLeave(p))
+            ),
+            onFocus: R(t.onFocus, () => d(!0)),
+            onBlur: R(t.onBlur, () => d(!1))
+          }
+        ) })
+      }
+    );
+  }, "MenuItemImpl")
+), zs = /* @__PURE__ */ s.forwardRef(
+  // blank line to reduce diff noise
+  /* @__PURE__ */ _(function(t, n) {
+    const { checked: r = !1, onCheckedChange: o, ...i } = t;
+    return /* @__PURE__ */ h(or, { scope: t.__scopeMenu, checked: r, children: /* @__PURE__ */ h(
+      Ot,
+      {
+        role: "menuitemcheckbox",
+        "aria-checked": Ie(r) ? "mixed" : r,
+        ...i,
+        ref: n,
+        "data-state": Ye(r),
+        onSelect: R(
+          i.onSelect,
+          () => o?.(Ie(r) ? !0 : !r),
+          { checkForDefaultPrevented: !1 }
+        )
+      }
+    ) });
+  }, "MenuCheckboxItem")
+), Ws = "MenuRadioGroup", [Vs, Hs] = me(
+  Ws,
+  { value: void 0, onValueChange: /* @__PURE__ */ _(() => {
+  }, "onValueChange") }
+), Ys = /* @__PURE__ */ s.forwardRef(
+  /* @__PURE__ */ _(function(t, n) {
+    const { value: r, onValueChange: o, ...i } = t, a = J(o);
+    return /* @__PURE__ */ h(Vs, { scope: t.__scopeMenu, value: r, onValueChange: a, children: /* @__PURE__ */ h(tr, { ...i, ref: n }) });
+  }, "MenuRadioGroup")
+), Xs = "MenuRadioItem", Zs = /* @__PURE__ */ s.forwardRef(
+  /* @__PURE__ */ _(function(t, n) {
+    const { value: r, ...o } = t, i = Hs(Xs, t.__scopeMenu), a = r === i.value;
+    return /* @__PURE__ */ h(or, { scope: t.__scopeMenu, checked: a, children: /* @__PURE__ */ h(
+      Ot,
+      {
+        role: "menuitemradio",
+        "aria-checked": a,
+        ...o,
+        ref: n,
+        "data-state": Ye(a),
+        onSelect: R(
+          o.onSelect,
+          () => i.onValueChange?.(r),
+          { checkForDefaultPrevented: !1 }
+        )
+      }
+    ) });
+  }, "MenuRadioItem")
+), rr = "MenuItemIndicator", [or, qs] = me(
+  rr,
+  { checked: !1 }
+), Qs = /* @__PURE__ */ s.forwardRef(
+  // blank line to reduce diff noise
+  /* @__PURE__ */ _(function(t, n) {
+    const { __scopeMenu: r, forceMount: o, ...i } = t, a = qs(rr, r);
+    return /* @__PURE__ */ h(
+      Ke,
+      {
+        present: o || Ie(a.checked) || a.checked === !0,
+        children: /* @__PURE__ */ h(
+          Y.span,
+          {
+            ...i,
+            ref: n,
+            "data-state": Ye(a.checked)
+          }
+        )
+      }
+    );
+  }, "MenuItemIndicator")
+), Js = /* @__PURE__ */ s.forwardRef(
+  /* @__PURE__ */ _(function(t, n) {
+    const { __scopeMenu: r, ...o } = t;
+    return /* @__PURE__ */ h(
+      Y.div,
+      {
+        role: "separator",
+        "aria-orientation": "horizontal",
+        ...o,
+        ref: n
+      }
+    );
+  }, "MenuSeparator")
+), sr = "MenuSub", [ei, ir] = me(sr), ti = /* @__PURE__ */ _((e) => {
+  const { __scopeMenu: t, children: n, open: r = !1, onOpenChange: o } = e, i = ue(sr, t), a = He(t), [u, c] = s.useState(null), [m, C] = s.useState(null), l = J(o);
+  return s.useEffect(() => (i.open === !1 && l(!1), () => l(!1)), [i.open, l]), /* @__PURE__ */ h(Pn, { ...a, children: /* @__PURE__ */ h(
+    qn,
+    {
+      scope: t,
+      open: r,
+      onOpenChange: l,
+      content: m,
+      onContentChange: C,
+      children: /* @__PURE__ */ h(
+        ei,
+        {
+          scope: t,
+          contentId: Ue(),
+          triggerId: Ue(),
+          trigger: u,
+          onTriggerChange: c,
+          children: n
+        }
+      )
+    }
+  ) });
+}, "MenuSub"), Le = "MenuSubTrigger", ni = /* @__PURE__ */ s.forwardRef(
+  /* @__PURE__ */ _(function(t, n) {
+    const r = ue(Le, t.__scopeMenu), o = Oe(Le, t.__scopeMenu), i = ir(Le, t.__scopeMenu), a = It(Le, t.__scopeMenu), u = s.useRef(null), { pointerGraceTimerRef: c, onPointerGraceIntentChange: m } = a, C = { __scopeMenu: t.__scopeMenu }, l = s.useCallback(() => {
+      u.current && window.clearTimeout(u.current), u.current = null;
+    }, []);
+    s.useEffect(() => l, [l]), s.useEffect(() => {
+      const v = c.current;
+      return () => {
+        window.clearTimeout(v), m(null);
+      };
+    }, [c, m]);
+    const d = $(n, i.onTriggerChange);
+    return /* @__PURE__ */ h(Qn, { asChild: !0, ...C, children: /* @__PURE__ */ h(
+      nr,
+      {
+        id: i.triggerId,
+        "aria-haspopup": "menu",
+        "aria-expanded": r.open,
+        "aria-controls": r.open ? i.contentId : void 0,
+        "data-state": Tt(r.open),
+        ...t,
+        ref: d,
+        onClick: (v) => {
+          t.onClick?.(v), !(t.disabled || v.defaultPrevented) && (v.currentTarget.focus(), r.open || r.onOpenChange(!0));
+        },
+        onPointerMove: R(
+          t.onPointerMove,
+          xe((v) => {
+            a.onItemEnter(v), !v.defaultPrevented && !t.disabled && !r.open && !u.current && (a.onPointerGraceIntentChange(null), u.current = window.setTimeout(() => {
+              r.onOpenChange(!0), l();
+            }, 100));
+          })
+        ),
+        onPointerLeave: R(
+          t.onPointerLeave,
+          xe((v) => {
+            l();
+            const f = r.content?.getBoundingClientRect();
+            if (f) {
+              const p = r.content?.dataset.side, g = p === "right", S = g ? -5 : 5, b = f[g ? "left" : "right"], y = f[g ? "right" : "left"];
+              a.onPointerGraceIntentChange({
+                area: [
+                  // Apply a bleed on clientX to ensure that our exit point is
+                  // consistently within polygon bounds
+                  { x: v.clientX + S, y: v.clientY },
+                  { x: b, y: f.top },
+                  { x: y, y: f.top },
+                  { x: y, y: f.bottom },
+                  { x: b, y: f.bottom }
+                ],
+                side: p
+              }), window.clearTimeout(c.current), c.current = window.setTimeout(
+                () => a.onPointerGraceIntentChange(null),
+                300
+              );
+            } else {
+              if (a.onTriggerLeave(v), v.defaultPrevented) return;
+              a.onPointerGraceIntentChange(null);
+            }
+          })
+        ),
+        onKeyDown: R(t.onKeyDown, (v) => {
+          t.disabled || v.target !== v.currentTarget || a.searchRef.current !== "" && v.key === " " || Os[o.dir].includes(v.key) && (r.onOpenChange(!0), r.content?.focus(), v.preventDefault());
+        })
+      }
+    ) });
+  }, "MenuSubTrigger")
+), ri = "MenuSubContent", oi = /* @__PURE__ */ s.forwardRef(
+  /* @__PURE__ */ _(function(t, n) {
+    const r = er(Q, t.__scopeMenu), { forceMount: o = r.forceMount, align: i = "start", ...a } = t, u = ue(Q, t.__scopeMenu), c = Oe(Q, t.__scopeMenu), m = ir(ri, t.__scopeMenu), C = s.useRef(null), l = $(n, C);
+    return /* @__PURE__ */ h(Re.Provider, { scope: t.__scopeMenu, children: /* @__PURE__ */ h(Ke, { present: o || u.open, children: /* @__PURE__ */ h(Re.Slot, { scope: t.__scopeMenu, children: /* @__PURE__ */ h(
+      _t,
+      {
+        id: m.contentId,
+        "aria-labelledby": m.triggerId,
+        ...a,
+        ref: l,
+        align: i,
+        side: c.dir === "rtl" ? "left" : "right",
+        disableOutsidePointerEvents: !1,
+        disableOutsideScroll: !1,
+        trapFocus: !1,
+        onOpenAutoFocus: (d) => {
+          c.isUsingKeyboardRef.current && C.current?.focus(), d.preventDefault();
+        },
+        onCloseAutoFocus: (d) => d.preventDefault(),
+        onFocusOutside: R(t.onFocusOutside, (d) => {
+          d.target !== m.trigger && u.onOpenChange(!1);
+        }),
+        onEscapeKeyDown: R(t.onEscapeKeyDown, (d) => {
+          c.onClose(), d.preventDefault();
+        }),
+        onKeyDown: R(t.onKeyDown, (d) => {
+          const v = d.currentTarget.contains(d.target), f = Ts[c.dir].includes(d.key);
+          v && f && (u.onOpenChange(!1), m.trigger?.focus(), d.preventDefault());
+        })
+      }
+    ) }) }) });
+  }, "MenuSubContent")
+);
+function Tt(e) {
+  return e ? "open" : "closed";
+}
+_(Tt, "getOpenState");
+function Ie(e) {
+  return e === "indeterminate";
+}
+_(Ie, "isIndeterminate");
+function Ye(e) {
+  return Ie(e) ? "indeterminate" : e ? "checked" : "unchecked";
+}
+_(Ye, "getCheckedState");
+function ar(e) {
+  const t = document.activeElement;
+  for (const n of e)
+    if (n === t || (n.focus(), document.activeElement !== t)) return;
+}
+_(ar, "focusFirst");
+function cr(e, t) {
+  return e.map((n, r) => e[(t + r) % e.length]);
+}
+_(cr, "wrapArray");
+function ur(e, t, n) {
+  const o = t.length > 1 && Array.from(t).every((m) => m === t[0]) ? t[0] : t, i = n ? e.indexOf(n) : -1;
+  let a = cr(e, Math.max(i, 0));
+  o.length === 1 && (a = a.filter((m) => m !== n));
+  const c = a.find(
+    (m) => m.toLowerCase().startsWith(o.toLowerCase())
+  );
+  return c !== n ? c : void 0;
+}
+_(ur, "getNextMatch");
+function lr(e, t) {
+  const { x: n, y: r } = e;
+  let o = !1;
+  for (let i = 0, a = t.length - 1; i < t.length; a = i++) {
+    const u = t[i], c = t[a], m = u.x, C = u.y, l = c.x, d = c.y;
+    C > r != d > r && n < (l - m) * (r - C) / (d - C) + m && (o = !o);
+  }
+  return o;
+}
+_(lr, "isPointInPolygon");
+function dr(e, t) {
+  if (!t) return !1;
+  const n = { x: e.clientX, y: e.clientY };
+  return lr(n, t);
+}
+_(dr, "isPointerInGraceArea");
+function xe(e) {
+  return (t) => t.pointerType === "mouse" ? e(t) : void 0;
+}
+_(xe, "whenMouse");
+var si = Fs, ii = Qn, ai = Ls, ci = Us, ui = tr, li = js, di = Ot, fi = zs, pi = Ys, mi = Zs, hi = Qs, vi = Js, gi = ti, Ci = ni, bi = oi, yi = Object.defineProperty, U = (e, t) => yi(e, "name", { value: t, configurable: !0 }), At = "ContextMenu", [Si, ya] = /* @__PURE__ */ fe(At, [
+  Xn
+]), W = Xn(), [xi, fr] = Si(At), Ei = /* @__PURE__ */ U((e) => {
+  const { __scopeContextMenu: t, children: n, onOpenChange: r, open: o, dir: i, modal: a = !0 } = e, u = s.useRef(!1), [c, m] = je({
+    prop: o,
+    defaultProp: !1,
+    onChange: r,
+    caller: At
+  }), C = W(t);
+  return /* @__PURE__ */ h(
+    xi,
+    {
+      scope: t,
+      open: c,
+      onOpenChange: m,
+      modal: a,
+      hasInteractedRef: u,
+      children: /* @__PURE__ */ h(si, { ...C, dir: i, open: c, onOpenChange: m, modal: a, children: n })
+    }
+  );
+}, "ContextMenu"), wi = "ContextMenuTrigger", Mi = /* @__PURE__ */ s.forwardRef(
+  // blank line to reduce diff noise
+  /* @__PURE__ */ U(function(t, n) {
+    const { __scopeContextMenu: r, disabled: o = !1, ...i } = t, a = fr(wi, r), u = W(r), [c, m] = s.useState({ x: 0, y: 0 }), C = s.useMemo(
+      () => ({
+        current: {
+          getBoundingClientRect: /* @__PURE__ */ U(() => DOMRect.fromRect({ width: 0, height: 0, ...c }), "getBoundingClientRect")
+        }
+      }),
+      [c]
+    ), l = s.useRef(0), d = s.useCallback(
+      () => window.clearTimeout(l.current),
+      []
+    ), v = /* @__PURE__ */ U((f) => {
+      a.hasInteractedRef.current = !0, m({ x: f.clientX, y: f.clientY }), a.onOpenChange(!0);
+    }, "handleOpen");
+    return s.useEffect(() => d, [d]), s.useEffect(() => void (o && d()), [o, d]), /* @__PURE__ */ Ge(Rr, { children: [
+      /* @__PURE__ */ h(ii, { ...u, virtualRef: C }),
+      /* @__PURE__ */ h(
+        Y.span,
+        {
+          "data-state": a.open ? "open" : "closed",
+          "data-disabled": o ? "" : void 0,
+          ...i,
+          ref: n,
+          style: { WebkitTouchCallout: "none", ...t.style },
+          onContextMenu: o ? t.onContextMenu : R(t.onContextMenu, (f) => {
+            d(), v(f), f.preventDefault();
+          }),
+          onPointerDown: o ? t.onPointerDown : R(
+            t.onPointerDown,
+            Pe((f) => {
+              d(), a.open && a.onOpenChange(!1), l.current = window.setTimeout(() => v(f), 700);
+            })
+          ),
+          onPointerMove: o ? t.onPointerMove : R(t.onPointerMove, Pe(d)),
+          onPointerCancel: o ? t.onPointerCancel : R(t.onPointerCancel, Pe(d)),
+          onPointerUp: o ? t.onPointerUp : R(t.onPointerUp, Pe(d))
+        }
+      )
+    ] });
+  }, "ContextMenuTrigger")
+), Pi = /* @__PURE__ */ U((e) => {
+  const { __scopeContextMenu: t, ...n } = e, r = W(t);
+  return /* @__PURE__ */ h(ai, { ...r, ...n });
+}, "ContextMenuPortal"), Ri = "ContextMenuContent", Ii = /* @__PURE__ */ s.forwardRef(
+  // blank line to reduce diff noise
+  /* @__PURE__ */ U(function(t, n) {
+    const { __scopeContextMenu: r, ...o } = t, i = fr(Ri, r), a = W(r), u = s.useRef(!1);
+    return /* @__PURE__ */ h(
+      ci,
+      {
+        ...a,
+        ...o,
+        ref: n,
+        side: "right",
+        sideOffset: 2,
+        align: "start",
+        onCloseAutoFocus: (c) => {
+          t.onCloseAutoFocus?.(c), !c.defaultPrevented && u.current && c.preventDefault(), u.current = !1;
+        },
+        onInteractOutside: (c) => {
+          t.onInteractOutside?.(c), !c.defaultPrevented && !i.modal && (u.current = !0);
+        },
+        style: {
+          ...t.style,
+          "--radix-context-menu-content-transform-origin": "var(--radix-popper-transform-origin)",
+          "--radix-context-menu-content-available-width": "var(--radix-popper-available-width)",
+          "--radix-context-menu-content-available-height": "var(--radix-popper-available-height)",
+          "--radix-context-menu-trigger-width": "var(--radix-popper-anchor-width)",
+          "--radix-context-menu-trigger-height": "var(--radix-popper-anchor-height)"
+        }
+      }
+    );
+  }, "ContextMenuContent")
+), _i = /* @__PURE__ */ s.forwardRef(
+  // blank line to reduce diff noise
+  /* @__PURE__ */ U(function(t, n) {
+    const { __scopeContextMenu: r, ...o } = t, i = W(r);
+    return /* @__PURE__ */ h(ui, { ...i, ...o, ref: n });
+  }, "ContextMenuGroup")
+), Oi = /* @__PURE__ */ s.forwardRef(
+  // blank line to reduce diff noise
+  /* @__PURE__ */ U(function(t, n) {
+    const { __scopeContextMenu: r, ...o } = t, i = W(r);
+    return /* @__PURE__ */ h(li, { ...i, ...o, ref: n });
+  }, "ContextMenuLabel")
+), Ti = /* @__PURE__ */ s.forwardRef(
+  // blank line to reduce diff noise
+  /* @__PURE__ */ U(function(t, n) {
+    const { __scopeContextMenu: r, ...o } = t, i = W(r);
+    return /* @__PURE__ */ h(di, { ...i, ...o, ref: n });
+  }, "ContextMenuItem")
+), Ai = /* @__PURE__ */ s.forwardRef(/* @__PURE__ */ U(function(t, n) {
+  const { __scopeContextMenu: r, ...o } = t, i = W(r);
+  return /* @__PURE__ */ h(fi, { ...i, ...o, ref: n });
+}, "ContextMenuCheckboxItem")), Ni = /* @__PURE__ */ s.forwardRef(/* @__PURE__ */ U(function(t, n) {
+  const { __scopeContextMenu: r, ...o } = t, i = W(r);
+  return /* @__PURE__ */ h(pi, { ...i, ...o, ref: n });
+}, "ContextMenuRadioGroup")), Di = /* @__PURE__ */ s.forwardRef(/* @__PURE__ */ U(function(t, n) {
+  const { __scopeContextMenu: r, ...o } = t, i = W(r);
+  return /* @__PURE__ */ h(mi, { ...i, ...o, ref: n });
+}, "ContextMenuRadioItem")), Fi = /* @__PURE__ */ s.forwardRef(/* @__PURE__ */ U(function(t, n) {
+  const { __scopeContextMenu: r, ...o } = t, i = W(r);
+  return /* @__PURE__ */ h(hi, { ...i, ...o, ref: n });
+}, "ContextMenuItemIndicator")), ki = /* @__PURE__ */ s.forwardRef(/* @__PURE__ */ U(function(t, n) {
+  const { __scopeContextMenu: r, ...o } = t, i = W(r);
+  return /* @__PURE__ */ h(vi, { ...i, ...o, ref: n });
+}, "ContextMenuSeparator")), Li = "ContextMenuSub", $i = /* @__PURE__ */ U((e) => {
+  const { __scopeContextMenu: t, children: n, onOpenChange: r, open: o, defaultOpen: i } = e, a = W(t), [u, c] = je({
+    prop: o,
+    defaultProp: i ?? !1,
+    onChange: r,
+    caller: Li
+  });
+  return /* @__PURE__ */ h(gi, { ...a, open: u, onOpenChange: c, children: n });
+}, "ContextMenuSub"), Ui = /* @__PURE__ */ s.forwardRef(/* @__PURE__ */ U(function(t, n) {
+  const { __scopeContextMenu: r, ...o } = t, i = W(r);
+  return /* @__PURE__ */ h(Ci, { ...i, ...o, ref: n });
+}, "ContextMenuSubTrigger")), Gi = /* @__PURE__ */ s.forwardRef(/* @__PURE__ */ U(function(t, n) {
+  const { __scopeContextMenu: r, ...o } = t, i = W(r);
+  return /* @__PURE__ */ h(
+    bi,
+    {
+      ...i,
+      ...o,
+      ref: n,
+      style: {
+        ...t.style,
+        "--radix-context-menu-content-transform-origin": "var(--radix-popper-transform-origin)",
+        "--radix-context-menu-content-available-width": "var(--radix-popper-available-width)",
+        "--radix-context-menu-content-available-height": "var(--radix-popper-available-height)",
+        "--radix-context-menu-trigger-width": "var(--radix-popper-anchor-width)",
+        "--radix-context-menu-trigger-height": "var(--radix-popper-anchor-height)"
+      }
+    }
+  );
+}, "ContextMenuSubContent"));
+function Pe(e) {
+  return (t) => t.pointerType !== "mouse" ? e(t) : void 0;
+}
+U(Pe, "whenTouchOrPen");
+var Bi = Ei, Ki = Mi, pr = Pi, mr = Ii, ji = _i, hr = Oi, vr = Ti, gr = Ai, zi = Ni, Cr = Di, br = Fi, yr = ki, Wi = $i, Sr = Ui, xr = Gi;
+const Sa = Bi, xa = Ki, Ea = ji, wa = pr, Ma = Wi, Pa = zi, Vi = ie({
+  base: [
+    "flex cursor-default select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none",
+    "focus:bg-secondary-bg-hover focus:text-primary-fg",
+    "data-[state=open]:bg-secondary-bg-hover data-[state=open]:text-primary-fg"
+  ],
+  variants: {
+    inset: {
+      true: "pl-8"
+    }
+  }
+}), Hi = s.forwardRef(({ className: e, inset: t, children: n, ...r }, o) => /* @__PURE__ */ Ge(
+  Sr,
+  {
+    ref: o,
+    className: Vi({ className: e, inset: t }),
+    ...r,
+    children: [
+      n,
+      /* @__PURE__ */ h(vt, { icon: Xr, className: "ml-auto" })
+    ]
+  }
+));
+Hi.displayName = Sr.displayName;
+const Yi = ie({
+  base: [
+    "z-50 min-w-[8rem] origin-[--radix-context-menu-content-transform-origin] overflow-hidden rounded-lg border border-secondary-border bg-secondary-bg p-1 text-primary-fg shadow-lg",
+    "data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95",
+    "data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2"
+  ]
+}), Xi = s.forwardRef(({ className: e, ...t }, n) => /* @__PURE__ */ h(xr, { ref: n, className: Yi({ className: e }), ...t }));
+Xi.displayName = xr.displayName;
+const Zi = ie({
+  base: [
+    "z-50 max-h-[--radix-context-menu-content-available-height] min-w-[8rem] origin-[--radix-context-menu-content-transform-origin] overflow-y-auto overflow-x-hidden rounded-lg border border-secondary-border bg-secondary-bg p-1 text-primary-fg shadow-md",
+    "data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95",
+    "data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2"
+  ]
+}), qi = s.forwardRef(({ className: e, ...t }, n) => /* @__PURE__ */ h(pr, { children: /* @__PURE__ */ h(mr, { ref: n, className: Zi({ className: e }), ...t }) }));
+qi.displayName = mr.displayName;
+const Qi = ie({
+  base: [
+    "relative flex cursor-default select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none",
+    "focus:bg-secondary-bg-hover focus:text-primary-fg",
+    "data-[disabled]:pointer-events-none data-[disabled]:opacity-50"
+  ],
+  variants: {
+    inset: {
+      true: "pl-8"
+    }
+  }
+}), Ji = s.forwardRef(({ className: e, inset: t, ...n }, r) => /* @__PURE__ */ h(vr, { ref: r, className: Qi({ className: e, inset: t }), ...n }));
+Ji.displayName = vr.displayName;
+const ea = ie({
+  slots: {
+    container: [
+      "relative flex cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none",
+      "focus:bg-secondary-bg-hover focus:text-primary-fg",
+      "data-[disabled]:pointer-events-none data-[disabled]:opacity-50"
+    ],
+    indicator: "absolute left-2 flex h-3.5 w-3.5 items-center justify-center"
+  }
+}), ta = s.forwardRef(({ className: e, children: t, checked: n, ...r }, o) => {
+  const i = ea();
+  return /* @__PURE__ */ Ge(
+    gr,
+    {
+      ref: o,
+      className: i.container({ className: e }),
+      checked: n,
+      ...r,
+      children: [
+        /* @__PURE__ */ h("span", { className: i.indicator(), children: /* @__PURE__ */ h(br, { children: /* @__PURE__ */ h(vt, { icon: Hr }) }) }),
+        t
+      ]
+    }
+  );
+});
+ta.displayName = gr.displayName;
+const na = ie({
+  slots: {
+    container: [
+      "relative flex cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none",
+      "focus:bg-secondary-bg-hover focus:text-primary-fg",
+      "data-[disabled]:pointer-events-none data-[disabled]:opacity-50"
+    ],
+    indicator: "absolute left-2 flex h-3.5 w-3.5 items-center justify-center"
+  }
+}), ra = s.forwardRef(({ className: e, children: t, ...n }, r) => {
+  const o = na();
+  return /* @__PURE__ */ Ge(Cr, { ref: r, className: o.container({ className: e }), ...n, children: [
+    /* @__PURE__ */ h("span", { className: o.indicator(), children: /* @__PURE__ */ h(br, { children: /* @__PURE__ */ h(vt, { icon: Yr, className: "size-2 fill-current" }) }) }),
+    t
+  ] });
+});
+ra.displayName = Cr.displayName;
+const oa = ie({
+  base: "px-2 py-1.5 text-sm font-semibold text-primary-fg",
+  variants: {
+    inset: {
+      true: "pl-8"
+    }
+  }
+}), sa = s.forwardRef(({ className: e, inset: t, ...n }, r) => /* @__PURE__ */ h(hr, { ref: r, className: oa({ className: e, inset: t }), ...n }));
+sa.displayName = hr.displayName;
+const ia = ie({
+  base: "-mx-1 my-1 h-px bg-secondary-border"
+}), aa = s.forwardRef(({ className: e, ...t }, n) => /* @__PURE__ */ h(yr, { ref: n, className: ia({ className: e }), ...t }));
+aa.displayName = yr.displayName;
+const ca = ie({
+  base: "ml-auto text-xs tracking-widest text-muted"
+}), ua = ({ className: e, ...t }) => /* @__PURE__ */ h("span", { className: ca({ className: e }), ...t });
+ua.displayName = "ContextMenuShortcut";
+export {
+  Sa as ContextMenu,
+  ta as ContextMenuCheckboxItem,
+  qi as ContextMenuContent,
+  Ea as ContextMenuGroup,
+  Ji as ContextMenuItem,
+  sa as ContextMenuLabel,
+  wa as ContextMenuPortal,
+  Pa as ContextMenuRadioGroup,
+  ra as ContextMenuRadioItem,
+  aa as ContextMenuSeparator,
+  ua as ContextMenuShortcut,
+  Ma as ContextMenuSub,
+  Xi as ContextMenuSubContent,
+  Hi as ContextMenuSubTrigger,
+  xa as ContextMenuTrigger
+};
+//# sourceMappingURL=context-menu.js.map