@koide-labs/ui 0.0.14 → 0.1.0

package/dist/components/context-menu/context-menu.js

@@ -0,0 +1,1445 @@
+import { jsx as c, jsxs as ee } from "react/jsx-runtime";
+import { c as de } from "../../clsx-OuTLNxxd.js";
+import * as t from "react";
+import { createContext as Wt, useContext as Xt } from "react";
+import { textify as Ce } from "../../-utils.js";
+import { tokens as st } from "../../styles/tokens.js";
+import { p as it, k as jt, R as $t, P as qt, c as U, m as zt, j as Jt, u as Qt, d as Zt, e as at, h as en, f as tn, i as nn, t as ut } from "../../transitions.module-D9mMAtfI.js";
+import { Surface as ct } from "../surface/surface.js";
+import { View as Re } from "../view/view.js";
+import { Icon as ce } from "../icon/icon.js";
+import { Text as lt } from "../text/text.js";
+import { S as on, a as rn } from "../../separator-fh_wDZNf.js";
+import { u as dt } from "../../useControlled-Du4sJyMj.js";
+import { u as le } from "../../useStableCallback-DKZHlUAT.js";
+import { f as J } from "../../formatErrorMessage-BqPuTBN-.js";
+import { m as Se, d as sn, u as Y, a as an, E as un, b as cn } from "../../useRenderElement-DngNDu_P.js";
+import { u as pt } from "../../useId-C5kyn6tA.js";
+import * as ln from "react-dom";
+import { u as Me } from "../../useTimeout-BNni6aw5.js";
+import { u as Te } from "../../useIsoLayoutEffect-CIDbvm3Q.js";
+import { u as dn } from "../../useAnimationFrame-DvK1s63A.js";
+import { F as pn, I as fn, u as mn, a as gn, b as hn } from "../../InternalBackdrop-BSMKU-hc.js";
+import { h as xn, m as Mn, P as Cn, T as Rn } from "../../FloatingPortal-BQsQhvIr.js";
+import { u as bn } from "../../DirectionContext-C2o_MF_i.js";
+import { x as be, c as z, o as vn, t as xe, y as ue, b as et, a as ft, f as En, l as In, e as yn, i as Nn, v as Pn } from "../../createBaseUIEventDetails-CCSfZ2vM.js";
+import { p as Sn, c as Tn, u as On, a as kn, b as _n, e as wn } from "../../useSyncedFloatingRootContext-BB1vwkV-.js";
+import { u as Dn } from "../../useRole-BD3OL1rr.js";
+import { u as Vn, a as An } from "../../useTypeahead-BiL5IAVb.js";
+import { o as tt } from "../../owner-rKN292Q9.js";
+import { i as Un, o as Ln, n as Fn } from "../../floating-ui.utils.dom-cbi420Pg.js";
+import { h as nt, f as he } from "../../element-u5WgOZX1.js";
+import { s as Gn } from "../../event-B89-Ng5h.js";
+import { i as Bn } from "../../inertValue-BTpPjX30.js";
+import { g as Hn, a as Yn } from "../../getDisabledMountTransitionStyles-E2x-_lte.js";
+import { u as ve, C as Kn } from "../../useCompositeListItem-CZp9WTnF.js";
+import { t as mt, u as Oe } from "../../useOpenChangeComplete-BHd-N7Ig.js";
+import { u as Wn } from "../../ToolbarRootContext-CvvL0Tk1.js";
+import { C as Xn } from "../../composite-BwEK5cWH.js";
+import { b as jn, a as $n, s as qn } from "../../safePolygon-DnkzOIur.js";
+import { u as pe } from "../../useBaseUiId-B7WyxtIE.js";
+import { u as zn } from "../../useButton-d3_JgBNr.js";
+import { u as gt } from "../../useTransitionStatus-CmMyUh74.js";
+import '../../context-menu.css';const ke = /* @__PURE__ */ t.createContext(void 0);
+process.env.NODE_ENV !== "production" && (ke.displayName = "ContextMenuRootContext");
+function Ee(e = !0) {
+  const o = t.useContext(ke);
+  if (o === void 0 && !e)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: ContextMenuRootContext is missing. ContextMenu parts must be placed within <ContextMenu.Root>." : J(25));
+  return o;
+}
+const _e = /* @__PURE__ */ t.createContext(void 0);
+process.env.NODE_ENV !== "production" && (_e.displayName = "MenuPositionerContext");
+function fe(e) {
+  const o = t.useContext(_e);
+  if (o === void 0 && !e)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: MenuPositionerContext is missing. MenuPositioner parts must be placed within <Menu.Positioner>." : J(33));
+  return o;
+}
+const Ie = /* @__PURE__ */ t.createContext(void 0);
+process.env.NODE_ENV !== "production" && (Ie.displayName = "MenuRootContext");
+function q(e) {
+  const o = t.useContext(Ie);
+  if (o === void 0 && !e)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: MenuRootContext is missing. Menu parts must be placed within <Menu.Root>." : J(36));
+  return o;
+}
+const we = /* @__PURE__ */ t.createContext(void 0);
+process.env.NODE_ENV !== "production" && (we.displayName = "MenuCheckboxItemContext");
+function Jn() {
+  const e = t.useContext(we);
+  if (e === void 0)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: MenuCheckboxItemContext is missing. MenuCheckboxItem parts must be placed within <Menu.CheckboxItem>." : J(30));
+  return e;
+}
+const De = {
+  type: "regular-item"
+};
+function ye(e) {
+  const {
+    closeOnClick: o,
+    disabled: i = !1,
+    highlighted: C,
+    id: E,
+    store: d,
+    nativeButton: R,
+    itemMetadata: r,
+    nodeId: a
+  } = e, f = t.useRef(null), g = Ee(!0), b = g !== void 0, {
+    events: I
+  } = d.useState("floatingTreeRoot"), {
+    getButtonProps: P,
+    buttonRef: k
+  } = zn({
+    disabled: i,
+    focusableWhenDisabled: !0,
+    native: R
+  }), l = t.useCallback((u) => Se({
+    id: E,
+    role: "menuitem",
+    tabIndex: C ? 0 : -1,
+    onMouseMove(s) {
+      a && I.emit("itemhover", {
+        nodeId: a,
+        target: s.currentTarget
+      });
+    },
+    onMouseEnter() {
+      r.type === "submenu-trigger" && r.setActive();
+    },
+    onKeyUp(s) {
+      s.key === " " && d.context.typingRef.current && s.preventBaseUIHandler();
+    },
+    onClick(s) {
+      o && I.emit("close", {
+        domEvent: s,
+        reason: be
+      });
+    },
+    onMouseUp(s) {
+      if (g) {
+        const _ = g.initialCursorPointRef.current;
+        if (g.initialCursorPointRef.current = null, b && _ && Math.abs(s.clientX - _.x) <= 1 && Math.abs(s.clientY - _.y) <= 1)
+          return;
+      }
+      f.current && d.context.allowMouseUpTriggerRef.current && (!b || s.button === 2) && r.type === "regular-item" && f.current.click();
+    }
+  }, u, P), [E, C, P, o, I, d, b, g, r, a]), h = sn(f, k);
+  return t.useMemo(() => ({
+    getItemProps: l,
+    itemRef: h
+  }), [l, h]);
+}
+let ot = /* @__PURE__ */ (function(e) {
+  return e.checked = "data-checked", e.unchecked = "data-unchecked", e.disabled = "data-disabled", e.highlighted = "data-highlighted", e;
+})({});
+const Ne = {
+  checked(e) {
+    return e ? {
+      [ot.checked]: ""
+    } : {
+      [ot.unchecked]: ""
+    };
+  },
+  ...mt
+}, ht = /* @__PURE__ */ t.forwardRef(function(o, i) {
+  const {
+    render: C,
+    className: E,
+    id: d,
+    label: R,
+    nativeButton: r = !1,
+    disabled: a = !1,
+    closeOnClick: f = !1,
+    checked: g,
+    defaultChecked: b,
+    onCheckedChange: I,
+    ...P
+  } = o, k = ve({
+    label: R
+  }), l = fe(!0), h = pe(d), {
+    store: u
+  } = q(), s = u.useState("isActive", k.index), _ = u.useState("itemProps"), [O, n] = dt({
+    controlled: g,
+    default: b ?? !1,
+    name: "MenuCheckboxItem",
+    state: "checked"
+  }), {
+    getItemProps: A,
+    itemRef: y
+  } = ye({
+    closeOnClick: f,
+    disabled: a,
+    highlighted: s,
+    id: h,
+    store: u,
+    nativeButton: r,
+    nodeId: l?.nodeId,
+    itemMetadata: De
+  }), D = t.useMemo(() => ({
+    disabled: a,
+    highlighted: s,
+    checked: O
+  }), [a, s, O]), p = le((w) => {
+    const x = {
+      ...z(be, w.nativeEvent),
+      preventUnmountOnClose: () => {
+      }
+    };
+    I?.(!O, x), !x.isCanceled && n((m) => !m);
+  }), G = Y("div", o, {
+    state: D,
+    stateAttributesMapping: Ne,
+    props: [_, {
+      role: "menuitemcheckbox",
+      "aria-checked": O,
+      onClick: p
+    }, P, A],
+    ref: [y, i, k.ref]
+  });
+  return /* @__PURE__ */ c(we.Provider, {
+    value: D,
+    children: G
+  });
+});
+process.env.NODE_ENV !== "production" && (ht.displayName = "MenuCheckboxItem");
+const xt = /* @__PURE__ */ t.forwardRef(function(o, i) {
+  const {
+    render: C,
+    className: E,
+    keepMounted: d = !1,
+    ...R
+  } = o, r = Jn(), a = t.useRef(null), {
+    transitionStatus: f,
+    setMounted: g
+  } = gt(r.checked);
+  Oe({
+    open: r.checked,
+    ref: a,
+    onComplete() {
+      r.checked || g(!1);
+    }
+  });
+  const b = t.useMemo(() => ({
+    checked: r.checked,
+    disabled: r.disabled,
+    highlighted: r.highlighted,
+    transitionStatus: f
+  }), [r.checked, r.disabled, r.highlighted, f]);
+  return Y("span", o, {
+    state: b,
+    ref: [i, a],
+    stateAttributesMapping: Ne,
+    props: {
+      "aria-hidden": !0,
+      ...R
+    },
+    enabled: d || r.checked
+  });
+});
+process.env.NODE_ENV !== "production" && (xt.displayName = "MenuCheckboxItemIndicator");
+const Ve = /* @__PURE__ */ t.createContext(void 0);
+process.env.NODE_ENV !== "production" && (Ve.displayName = "MenuGroupContext");
+function Qn() {
+  const e = t.useContext(Ve);
+  if (e === void 0)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: MenuGroupRootContext is missing. Menu group parts must be used within <Menu.Group>." : J(31));
+  return e;
+}
+const Mt = /* @__PURE__ */ t.forwardRef(function(o, i) {
+  const {
+    render: C,
+    className: E,
+    ...d
+  } = o, [R, r] = t.useState(void 0), a = t.useMemo(() => ({
+    setLabelId: r
+  }), [r]), f = Y("div", o, {
+    ref: i,
+    props: {
+      role: "group",
+      "aria-labelledby": R,
+      ...d
+    }
+  });
+  return /* @__PURE__ */ c(Ve.Provider, {
+    value: a,
+    children: f
+  });
+});
+process.env.NODE_ENV !== "production" && (Mt.displayName = "MenuGroup");
+const Ct = /* @__PURE__ */ t.forwardRef(function(o, i) {
+  const {
+    className: C,
+    render: E,
+    id: d,
+    ...R
+  } = o, r = pe(d), {
+    setLabelId: a
+  } = Qn();
+  return Te(() => (a(r), () => {
+    a(void 0);
+  }), [a, r]), Y("div", o, {
+    ref: i,
+    props: {
+      id: r,
+      role: "presentation",
+      ...R
+    }
+  });
+});
+process.env.NODE_ENV !== "production" && (Ct.displayName = "MenuGroupLabel");
+const Rt = /* @__PURE__ */ t.forwardRef(function(o, i) {
+  const {
+    render: C,
+    className: E,
+    id: d,
+    label: R,
+    nativeButton: r = !1,
+    disabled: a = !1,
+    closeOnClick: f = !0,
+    ...g
+  } = o, b = ve({
+    label: R
+  }), I = fe(!0), P = pe(d), {
+    store: k
+  } = q(), l = k.useState("isActive", b.index), h = k.useState("itemProps"), {
+    getItemProps: u,
+    itemRef: s
+  } = ye({
+    closeOnClick: f,
+    disabled: a,
+    highlighted: l,
+    id: P,
+    store: k,
+    nativeButton: r,
+    nodeId: I?.nodeId,
+    itemMetadata: De
+  }), _ = t.useMemo(() => ({
+    disabled: a,
+    highlighted: l
+  }), [a, l]);
+  return Y("div", o, {
+    state: _,
+    props: [h, g, u],
+    ref: [s, i, b.ref]
+  });
+});
+process.env.NODE_ENV !== "production" && (Rt.displayName = "MenuItem");
+const Zn = {
+  ...it,
+  ...mt
+}, Ae = /* @__PURE__ */ t.forwardRef(function(o, i) {
+  const {
+    render: C,
+    className: E,
+    finalFocus: d,
+    ...R
+  } = o, {
+    store: r
+  } = q(), {
+    side: a,
+    align: f
+  } = fe(), g = Wn() != null, b = r.useState("open"), I = r.useState("transitionStatus"), P = r.useState("popupProps"), k = r.useState("mounted"), l = r.useState("instantType"), h = r.useState("activeTriggerElement"), u = r.useState("parent"), s = r.useState("lastOpenChangeReason"), _ = r.useState("rootId"), O = r.useState("floatingRootContext"), n = r.useState("floatingTreeRoot"), A = r.useState("closeDelay"), y = r.useState("activeTriggerElement");
+  Oe({
+    open: b,
+    ref: r.context.popupRef,
+    onComplete() {
+      b && r.context.onOpenChangeComplete?.(!0);
+    }
+  }), t.useEffect(() => {
+    function m(N) {
+      r.setOpen(!1, z(N.reason, N.domEvent));
+    }
+    return n.events.on("close", m), () => {
+      n.events.off("close", m);
+    };
+  }, [n.events, r]);
+  const D = r.useState("hoverEnabled"), p = r.useState("disabled");
+  jn(O, {
+    enabled: D && !p && u.type !== "context-menu" && u.type !== "menubar",
+    closeDelay: A
+  });
+  const G = t.useMemo(() => ({
+    transitionStatus: I,
+    side: a,
+    align: f,
+    open: b,
+    nested: u.type === "menu",
+    instant: l
+  }), [I, a, f, b, u.type, l]), w = Y("div", o, {
+    state: G,
+    ref: [i, r.context.popupRef],
+    stateAttributesMapping: Zn,
+    props: [P, {
+      onKeyDown(m) {
+        g && Xn.has(m.key) && m.stopPropagation();
+      }
+    }, Hn(I), R, {
+      "data-rootownerid": _
+    }]
+  });
+  let x = u.type === void 0 || u.type === "context-menu";
+  return (h || u.type === "menubar" && s !== vn) && (x = !0), /* @__PURE__ */ c(pn, {
+    context: O,
+    modal: !1,
+    disabled: !k,
+    returnFocus: d === void 0 ? x : d,
+    initialFocus: u.type !== "menu",
+    restoreFocus: !0,
+    externalTree: u.type !== "menubar" ? n : void 0,
+    previousFocusableElement: y,
+    nextFocusableElement: u.type === void 0 ? r.context.triggerFocusTargetRef : void 0,
+    beforeContentFocusGuardRef: u.type === void 0 ? r.context.beforeContentFocusGuardRef : void 0,
+    children: w
+  });
+});
+process.env.NODE_ENV !== "production" && (Ae.displayName = "MenuPopup");
+const Ue = /* @__PURE__ */ t.createContext(void 0);
+process.env.NODE_ENV !== "production" && (Ue.displayName = "MenuPortalContext");
+function eo() {
+  const e = t.useContext(Ue);
+  if (e === void 0)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: <Menu.Portal> is missing." : J(32));
+  return e;
+}
+const Le = /* @__PURE__ */ t.forwardRef(function(o, i) {
+  const {
+    keepMounted: C = !1,
+    ...E
+  } = o, {
+    store: d
+  } = q();
+  return d.useState("mounted") || C ? /* @__PURE__ */ c(Ue.Provider, {
+    value: C,
+    children: /* @__PURE__ */ c(xn, {
+      ref: i,
+      ...E
+    })
+  }) : null;
+});
+process.env.NODE_ENV !== "production" && (Le.displayName = "MenuPortal");
+const Fe = /* @__PURE__ */ t.forwardRef(function(o, i) {
+  const {
+    anchor: C,
+    positionMethod: E = "absolute",
+    className: d,
+    render: R,
+    side: r,
+    align: a,
+    sideOffset: f = 0,
+    alignOffset: g = 0,
+    collisionBoundary: b = "clipping-ancestors",
+    collisionPadding: I = 5,
+    arrowPadding: P = 5,
+    sticky: k = !1,
+    disableAnchorTracking: l = !1,
+    collisionAvoidance: h = Mn,
+    ...u
+  } = o, {
+    store: s
+  } = q(), _ = eo(), O = Ee(!0), n = s.useState("parent"), A = s.useState("floatingRootContext"), y = s.useState("floatingTreeRoot"), D = s.useState("mounted"), p = s.useState("open"), G = s.useState("modal"), w = s.useState("activeTriggerElement"), x = s.useState("lastOpenChangeReason"), m = s.useState("floatingNodeId"), N = s.useState("floatingParentNodeId");
+  let L = C, v = f, j = g, Q = a, ne = h;
+  n.type === "context-menu" && (L = C ?? n.context?.anchor, Q = Q ?? "start", !r && Q !== "center" && (j = o.alignOffset ?? 2, v = o.sideOffset ?? -5));
+  let K = r, W = Q;
+  n.type === "menu" ? (K = K ?? "inline-end", W = W ?? "start", ne = o.collisionAvoidance ?? Cn) : n.type === "menubar" && (K = K ?? "bottom", W = W ?? "start");
+  const X = n.type === "context-menu", T = Yn({
+    anchor: L,
+    floatingRootContext: A,
+    positionMethod: O ? "fixed" : E,
+    mounted: D,
+    side: K,
+    sideOffset: v,
+    align: W,
+    alignOffset: j,
+    arrowPadding: X ? 0 : P,
+    collisionBoundary: b,
+    collisionPadding: I,
+    sticky: k,
+    nodeId: m,
+    keepMounted: _,
+    disableAnchorTracking: l,
+    collisionAvoidance: ne,
+    shiftCrossAxis: X,
+    externalTree: y
+  }), te = t.useMemo(() => {
+    const F = {};
+    return p || (F.pointerEvents = "none"), {
+      role: "presentation",
+      hidden: !D,
+      style: {
+        ...T.positionerStyles,
+        ...F
+      }
+    };
+  }, [p, D, T.positionerStyles]);
+  t.useEffect(() => {
+    function F(V) {
+      V.open ? (V.parentNodeId === m && s.set("hoverEnabled", !1), V.nodeId !== m && V.parentNodeId === s.select("floatingParentNodeId") && s.setOpen(!1, z(ue))) : V.parentNodeId === m && V.reason !== ue && s.set("hoverEnabled", !0);
+    }
+    return y.events.on("menuopenchange", F), () => {
+      y.events.off("menuopenchange", F);
+    };
+  }, [s, y.events, m]), t.useEffect(() => {
+    if (s.select("floatingParentNodeId") == null)
+      return;
+    function F(V) {
+      if (V.open || V.nodeId !== s.select("floatingParentNodeId"))
+        return;
+      const me = V.reason ?? ue;
+      s.setOpen(!1, z(me));
+    }
+    return y.events.on("menuopenchange", F), () => {
+      y.events.off("menuopenchange", F);
+    };
+  }, [y.events, s]), t.useEffect(() => {
+    function F(V) {
+      !p || V.nodeId !== s.select("floatingParentNodeId") || V.target && w && w !== V.target && s.setOpen(!1, z(ue));
+    }
+    return y.events.on("itemhover", F), () => {
+      y.events.off("itemhover", F);
+    };
+  }, [y.events, p, w, s]), t.useEffect(() => {
+    const F = {
+      open: p,
+      nodeId: m,
+      parentNodeId: N,
+      reason: s.select("lastOpenChangeReason")
+    };
+    y.events.emit("menuopenchange", F);
+  }, [y.events, p, s, m, N]);
+  const $ = t.useMemo(() => ({
+    open: p,
+    side: T.side,
+    align: T.align,
+    anchorHidden: T.anchorHidden,
+    nested: n.type === "menu"
+  }), [p, T.side, T.align, T.anchorHidden, n.type]), oe = t.useMemo(() => ({
+    side: T.side,
+    align: T.align,
+    arrowRef: T.arrowRef,
+    arrowUncentered: T.arrowUncentered,
+    arrowStyles: T.arrowStyles,
+    nodeId: T.context.nodeId
+  }), [T.side, T.align, T.arrowRef, T.arrowUncentered, T.arrowStyles, T.context.nodeId]), se = Y("div", o, {
+    state: $,
+    stateAttributesMapping: it,
+    ref: [i, s.useStateSetter("positionerElement")],
+    props: [te, u]
+  }), ie = D && n.type !== "menu" && (n.type !== "menubar" && G && x !== xe || n.type === "menubar" && n.context.modal);
+  let Z = null;
+  return n.type === "menubar" ? Z = n.context.contentElement : n.type === void 0 && (Z = w), /* @__PURE__ */ ee(_e.Provider, {
+    value: oe,
+    children: [ie && /* @__PURE__ */ c(fn, {
+      ref: n.type === "context-menu" || n.type === "nested-context-menu" ? n.context.internalBackdropRef : null,
+      inert: Bn(!p),
+      cutout: Z
+    }), /* @__PURE__ */ c(jt, {
+      id: m,
+      children: /* @__PURE__ */ c(Kn, {
+        elementsRef: s.context.itemDomElements,
+        labelsRef: s.context.itemLabels,
+        children: se
+      })
+    })]
+  });
+});
+process.env.NODE_ENV !== "production" && (Fe.displayName = "MenuPositioner");
+const Ge = /* @__PURE__ */ t.createContext(void 0);
+process.env.NODE_ENV !== "production" && (Ge.displayName = "MenuRadioGroupContext");
+function to() {
+  const e = t.useContext(Ge);
+  if (e === void 0)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: MenuRadioGroupContext is missing. MenuRadioGroup parts must be placed within <Menu.RadioGroup>." : J(34));
+  return e;
+}
+const bt = /* @__PURE__ */ t.memo(/* @__PURE__ */ t.forwardRef(function(o, i) {
+  const {
+    render: C,
+    className: E,
+    value: d,
+    defaultValue: R,
+    onValueChange: r,
+    disabled: a = !1,
+    ...f
+  } = o, [g, b] = dt({
+    controlled: d,
+    default: R,
+    name: "MenuRadioGroup"
+  }), I = le(r), P = le((u, s) => {
+    I?.(u, s), !s.isCanceled && b(u);
+  }), k = t.useMemo(() => ({
+    disabled: a
+  }), [a]), l = Y("div", o, {
+    state: k,
+    ref: i,
+    props: {
+      role: "group",
+      "aria-disabled": a || void 0,
+      ...f
+    }
+  }), h = t.useMemo(() => ({
+    value: g,
+    setValue: P,
+    disabled: a
+  }), [g, P, a]);
+  return /* @__PURE__ */ c(Ge.Provider, {
+    value: h,
+    children: l
+  });
+}));
+process.env.NODE_ENV !== "production" && (bt.displayName = "MenuRadioGroup");
+const Be = /* @__PURE__ */ t.createContext(void 0);
+process.env.NODE_ENV !== "production" && (Be.displayName = "MenuRadioItemContext");
+function no() {
+  const e = t.useContext(Be);
+  if (e === void 0)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: MenuRadioItemContext is missing. MenuRadioItem parts must be placed within <Menu.RadioItem>." : J(35));
+  return e;
+}
+const vt = /* @__PURE__ */ t.forwardRef(function(o, i) {
+  const {
+    render: C,
+    className: E,
+    id: d,
+    label: R,
+    nativeButton: r = !1,
+    disabled: a = !1,
+    closeOnClick: f = !1,
+    value: g,
+    ...b
+  } = o, I = ve({
+    label: R
+  }), P = fe(!0), k = pe(d), {
+    store: l
+  } = q(), h = l.useState("isActive", I.index), u = l.useState("itemProps"), {
+    value: s,
+    setValue: _,
+    disabled: O
+  } = to(), n = O || a, A = s === g, {
+    getItemProps: y,
+    itemRef: D
+  } = ye({
+    closeOnClick: f,
+    disabled: n,
+    highlighted: h,
+    id: k,
+    store: l,
+    nativeButton: r,
+    nodeId: P?.nodeId,
+    itemMetadata: De
+  }), p = t.useMemo(() => ({
+    disabled: n,
+    highlighted: h,
+    checked: A
+  }), [n, h, A]), G = le((x) => {
+    const m = {
+      ...z(be, x.nativeEvent),
+      preventUnmountOnClose: () => {
+      }
+    };
+    _(g, m);
+  }), w = Y("div", o, {
+    state: p,
+    stateAttributesMapping: Ne,
+    props: [u, {
+      role: "menuitemradio",
+      "aria-checked": A,
+      onClick: G
+    }, b, y],
+    ref: [D, i, I.ref]
+  });
+  return /* @__PURE__ */ c(Be.Provider, {
+    value: p,
+    children: w
+  });
+});
+process.env.NODE_ENV !== "production" && (vt.displayName = "MenuRadioItem");
+const Et = /* @__PURE__ */ t.forwardRef(function(o, i) {
+  const {
+    render: C,
+    className: E,
+    keepMounted: d = !1,
+    ...R
+  } = o, r = no(), a = t.useRef(null), {
+    transitionStatus: f,
+    setMounted: g
+  } = gt(r.checked);
+  Oe({
+    open: r.checked,
+    ref: a,
+    onComplete() {
+      r.checked || g(!1);
+    }
+  });
+  const b = t.useMemo(() => ({
+    checked: r.checked,
+    disabled: r.disabled,
+    highlighted: r.highlighted,
+    transitionStatus: f
+  }), [r.checked, r.disabled, r.highlighted, f]);
+  return Y("span", o, {
+    state: b,
+    stateAttributesMapping: Ne,
+    ref: [i, a],
+    props: {
+      "aria-hidden": !0,
+      ...R
+    },
+    enabled: d || r.checked
+  });
+});
+process.env.NODE_ENV !== "production" && (Et.displayName = "MenuRadioItemIndicator");
+const It = /* @__PURE__ */ t.createContext(null);
+process.env.NODE_ENV !== "production" && (It.displayName = "MenubarContext");
+function oo(e) {
+  return t.useContext(It);
+}
+const ro = {
+  ...Sn,
+  disabled: U((e) => e.parent.type === "menubar" && e.parent.context.disabled || e.disabled),
+  modal: U((e) => (e.parent.type === void 0 || e.parent.type === "context-menu") && (e.modal ?? !0)),
+  allowMouseEnter: U((e) => e.parent.type === "menu" ? e.parent.store.select("allowMouseEnter") : e.allowMouseEnter),
+  stickIfOpen: U((e) => e.stickIfOpen),
+  parent: U((e) => e.parent),
+  rootId: U((e) => e.parent.type === "menu" ? e.parent.store.select("rootId") : e.parent.type !== void 0 ? e.parent.context.rootId : e.rootId),
+  activeIndex: U((e) => e.activeIndex),
+  isActive: U((e, o) => e.activeIndex === o),
+  hoverEnabled: U((e) => e.hoverEnabled),
+  instantType: U((e) => e.instantType),
+  lastOpenChangeReason: U((e) => e.openChangeReason),
+  floatingTreeRoot: U((e) => e.parent.type === "menu" ? e.parent.store.select("floatingTreeRoot") : e.floatingTreeRoot),
+  floatingNodeId: U((e) => e.floatingNodeId),
+  floatingParentNodeId: U((e) => e.floatingParentNodeId),
+  itemProps: U((e) => e.itemProps),
+  closeDelay: U((e) => e.closeDelay),
+  keyboardEventRelay: U((e) => {
+    if (e.keyboardEventRelay)
+      return e.keyboardEventRelay;
+    if (e.parent.type === "menu")
+      return e.parent.store.select("keyboardEventRelay");
+  })
+};
+class He extends $t {
+  constructor(o) {
+    super({
+      ...so(),
+      ...o
+    }, {
+      positionerRef: /* @__PURE__ */ t.createRef(),
+      popupRef: /* @__PURE__ */ t.createRef(),
+      typingRef: {
+        current: !1
+      },
+      itemDomElements: {
+        current: []
+      },
+      itemLabels: {
+        current: []
+      },
+      allowMouseUpTriggerRef: {
+        current: !1
+      },
+      triggerFocusTargetRef: /* @__PURE__ */ t.createRef(),
+      beforeContentFocusGuardRef: /* @__PURE__ */ t.createRef(),
+      onOpenChangeComplete: void 0,
+      triggerElements: new qt()
+    }, ro), this.observe(U((i) => i.allowMouseEnter), (i, C) => {
+      this.state.parent.type === "menu" && i !== C && this.state.parent.store.set("allowMouseEnter", i);
+    }), this.unsubscribeParentListener = this.observe("parent", (i) => {
+      if (this.unsubscribeParentListener?.(), i.type === "menu") {
+        this.unsubscribeParentListener = i.store.subscribe(() => {
+          this.notifyAll();
+        }), this.context.allowMouseUpTriggerRef = i.store.context.allowMouseUpTriggerRef;
+        return;
+      }
+      i.type !== void 0 && (this.context.allowMouseUpTriggerRef = i.context.allowMouseUpTriggerRef), this.unsubscribeParentListener = null;
+    });
+  }
+  setOpen(o, i) {
+    this.state.floatingRootContext.context.events.emit("setOpen", {
+      open: o,
+      eventDetails: i
+    });
+  }
+  static useStore(o, i) {
+    return an(() => o ?? new He(i)).current;
+  }
+  unsubscribeParentListener = null;
+}
+function so() {
+  return {
+    ...Tn(),
+    disabled: !1,
+    modal: !0,
+    allowMouseEnter: !0,
+    stickIfOpen: !0,
+    parent: {
+      type: void 0
+    },
+    rootId: void 0,
+    activeIndex: null,
+    hoverEnabled: !0,
+    instantType: void 0,
+    openChangeReason: null,
+    floatingTreeRoot: new zt(),
+    floatingNodeId: void 0,
+    floatingParentNodeId: null,
+    itemProps: un,
+    keyboardEventRelay: void 0,
+    closeDelay: 0
+  };
+}
+const Ye = /* @__PURE__ */ t.createContext(void 0);
+process.env.NODE_ENV !== "production" && (Ye.displayName = "MenuSubmenuRootContext");
+function yt() {
+  return t.useContext(Ye);
+}
+function Nt(e) {
+  const {
+    children: o,
+    open: i,
+    onOpenChange: C,
+    onOpenChangeComplete: E,
+    defaultOpen: d = !1,
+    disabled: R = !1,
+    modal: r,
+    loopFocus: a = !0,
+    orientation: f = "vertical",
+    actionsRef: g,
+    closeParentOnEsc: b = !1,
+    handle: I,
+    triggerId: P,
+    defaultTriggerId: k = null,
+    highlightItemOnHover: l = !0
+  } = e, h = Ee(!0), u = q(!0), s = oo(), _ = yt(), O = t.useMemo(() => _ && u ? {
+    type: "menu",
+    store: u.store
+  } : s ? {
+    type: "menubar",
+    context: s
+  } : h && !u ? {
+    type: "context-menu",
+    context: h
+  } : {
+    type: void 0
+  }, [h, u, s, _]), n = He.useStore(I?.store, {
+    parent: O
+  }), A = n.useState("floatingTreeRoot"), y = Jt(A), D = Qt();
+  Te(() => {
+    h && !u ? n.update({
+      parent: {
+        type: "context-menu",
+        context: h
+      },
+      floatingNodeId: y,
+      floatingParentNodeId: D
+    }) : u && n.update({
+      floatingNodeId: y,
+      floatingParentNodeId: D
+    });
+  }, [h, u, y, D, n]), n.useControlledProp("open", i, d), n.useControlledProp("activeTriggerId", P, k), n.useContextCallback("onOpenChangeComplete", E);
+  const p = n.useState("open"), G = n.useState("activeTriggerElement"), w = n.useState("positionerElement"), x = n.useState("hoverEnabled"), m = n.useState("modal"), N = n.useState("disabled"), L = n.useState("lastOpenChangeReason"), v = n.useState("parent"), j = n.useState("activeIndex"), Q = n.useState("payload"), ne = n.useState("floatingParentNodeId"), K = t.useRef(null), W = ne != null;
+  let X;
+  process.env.NODE_ENV !== "production" && v.type !== void 0 && r !== void 0 && console.warn("Base UI: The `modal` prop is not supported on nested menus. It will be ignored."), n.useSyncedValues({
+    disabled: R,
+    modal: v.type === void 0 ? r : void 0,
+    rootId: pt()
+  });
+  const {
+    openMethod: T,
+    triggerProps: te,
+    reset: $
+  } = mn(p);
+  On(n);
+  const {
+    forceUnmount: oe
+  } = kn(p, n, () => {
+    n.update({
+      allowMouseEnter: !1,
+      stickIfOpen: !0
+    }), $();
+  }), se = t.useRef(v.type !== "context-menu"), ie = Me();
+  t.useEffect(() => {
+    if (p || (K.current = null), v.type === "context-menu") {
+      if (!p) {
+        ie.clear(), se.current = !1;
+        return;
+      }
+      ie.start(500, () => {
+        se.current = !0;
+      });
+    }
+  }, [ie, p, v.type]), gn(p && m && L !== xe && T !== "touch", w), Te(() => {
+    !p && !x && n.set("hoverEnabled", !0);
+  }, [p, x, n]);
+  const Z = t.useRef(!0), F = Me(), V = le((M, S) => {
+    const B = S.reason;
+    if (p === M && S.trigger === G || (S.preventUnmountOnClose = () => {
+      n.set("preventUnmountingOnClose", !0);
+    }, !M && S.trigger == null && (S.trigger = G ?? void 0), C?.(M, S), S.isCanceled))
+      return;
+    const Yt = {
+      open: M,
+      nativeEvent: S.event,
+      reason: S.reason,
+      nested: W
+    };
+    X?.emit("openchange", Yt);
+    const ge = S.event;
+    if (M === !1 && ge?.type === "click" && ge.pointerType === "touch" && !Z.current)
+      return;
+    if (!M && j !== null) {
+      const ae = n.context.itemDomElements.current[j];
+      queueMicrotask(() => {
+        ae?.setAttribute("tabindex", "-1");
+      });
+    }
+    M && B === et ? (Z.current = !1, F.start(300, () => {
+      Z.current = !0;
+    })) : (Z.current = !0, F.clear());
+    const Je = (B === ft || B === be) && ge.detail === 0 && ge?.isTrusted, Kt = !M && (B === yn || B == null);
+    function Qe() {
+      const ae = {
+        open: M,
+        openChangeReason: B
+      };
+      K.current = S.event ?? null;
+      const Ze = S.trigger?.id ?? null;
+      (Ze || M) && (ae.activeTriggerId = Ze, ae.activeTriggerElement = S.trigger ?? null), n.update(ae);
+    }
+    B === xe ? ln.flushSync(Qe) : Qe(), v.type === "menubar" && (B === et || B === En || B === xe || B === In || B === ue) ? n.set("instantType", "group") : Je || Kt ? n.set("instantType", Je ? "click" : "dismiss") : n.set("instantType", void 0);
+  }), me = t.useCallback((M) => {
+    const S = z(M);
+    return S.preventUnmountOnClose = () => {
+      n.set("preventUnmountingOnClose", !0);
+    }, S;
+  }, [n]), Ke = t.useCallback(() => {
+    n.setOpen(!1, me(Nn));
+  }, [n, me]);
+  t.useImperativeHandle(g, () => ({
+    unmount: oe,
+    close: Ke
+  }), [oe, Ke]);
+  let Pe;
+  v.type === "context-menu" && (Pe = v.context), t.useImperativeHandle(Pe?.positionerRef, () => w, [w]), t.useImperativeHandle(Pe?.actionsRef, () => ({
+    setOpen: V
+  }), [V]);
+  const re = _n({
+    popupStore: n,
+    onOpenChange: V
+  });
+  X = re.context.events, t.useEffect(() => {
+    const M = ({
+      open: S,
+      eventDetails: B
+    }) => V(S, B);
+    return X.on("setOpen", M), () => {
+      X?.off("setOpen", M);
+    };
+  }, [X, V]);
+  const kt = Zt(re, {
+    enabled: !N,
+    bubbles: b && v.type === "menu",
+    outsidePress() {
+      return v.type !== "context-menu" || K.current?.type === "contextmenu" ? !0 : se.current;
+    },
+    externalTree: W ? A : void 0
+  }), _t = Dn(re, {
+    role: "menu"
+  }), wt = bn(), Dt = t.useCallback((M) => {
+    n.select("activeIndex") !== M && n.set("activeIndex", M);
+  }, [n]), Vt = Vn(re, {
+    enabled: !N,
+    listRef: n.context.itemDomElements,
+    activeIndex: j,
+    nested: v.type !== void 0,
+    loopFocus: a,
+    orientation: f,
+    parentOrientation: v.type === "menubar" ? v.context.orientation : void 0,
+    rtl: wt === "rtl",
+    disabledIndices: cn,
+    onNavigate: Dt,
+    openOnArrowKeyDown: v.type !== "context-menu",
+    externalTree: W ? A : void 0,
+    focusItemOnHover: l
+  }), At = t.useCallback((M) => {
+    n.context.typingRef.current = M;
+  }, [n]), Ut = An(re, {
+    listRef: n.context.itemLabels,
+    activeIndex: j,
+    resetMs: Rn,
+    onMatch: (M) => {
+      p && M !== j && n.set("activeIndex", M);
+    },
+    onTypingChange: At
+  }), {
+    getReferenceProps: We,
+    getFloatingProps: Xe,
+    getItemProps: je,
+    getTriggerProps: $e
+  } = at([kt, _t, Vt, Ut]), Lt = t.useMemo(() => {
+    const M = Se(We(), {
+      onMouseEnter() {
+        n.set("hoverEnabled", !0);
+      },
+      onMouseMove() {
+        n.set("allowMouseEnter", !0);
+      }
+    }, te);
+    return delete M.role, M;
+  }, [We, n, te]), Ft = t.useMemo(() => {
+    const M = $e();
+    if (!M)
+      return M;
+    const S = Se(M, te);
+    return delete S.role, delete S["aria-controls"], S;
+  }, [$e, te]), qe = dn(), Gt = t.useMemo(() => Xe({
+    onMouseEnter() {
+      v.type === "menu" && qe.request(() => n.set("hoverEnabled", !1));
+    },
+    onMouseMove() {
+      n.set("allowMouseEnter", !0);
+    },
+    onClick() {
+      n.select("hoverEnabled") && n.set("hoverEnabled", !1);
+    },
+    onKeyDown(M) {
+      const S = n.select("keyboardEventRelay");
+      S && !M.isPropagationStopped() && S(M);
+    }
+  }), [Xe, v.type, qe, n]), Bt = t.useMemo(() => je(), [je]);
+  n.useSyncedValues({
+    floatingRootContext: re,
+    activeTriggerProps: Lt,
+    inactiveTriggerProps: Ft,
+    popupProps: Gt,
+    itemProps: Bt
+  });
+  const Ht = t.useMemo(() => ({
+    store: n,
+    parent: O
+  }), [n, O]), ze = /* @__PURE__ */ c(Ie.Provider, {
+    value: Ht,
+    children: typeof o == "function" ? o({
+      payload: Q
+    }) : o
+  });
+  return v.type === void 0 || v.type === "context-menu" ? /* @__PURE__ */ c(en, {
+    externalTree: A,
+    children: ze
+  }) : ze;
+}
+function io(e) {
+  const o = q().store, i = t.useMemo(() => ({
+    parentMenu: o
+  }), [o]);
+  return /* @__PURE__ */ c(Ye.Provider, {
+    value: i,
+    children: /* @__PURE__ */ c(Nt, {
+      ...e
+    })
+  });
+}
+function Pt(e) {
+  if (Un(e) && e.hasAttribute("data-rootownerid"))
+    return e.getAttribute("data-rootownerid") ?? void 0;
+  if (!Ln(e))
+    return Pt(Fn(e));
+}
+const St = /* @__PURE__ */ t.forwardRef(function(o, i) {
+  const {
+    render: C,
+    className: E,
+    label: d,
+    id: R,
+    nativeButton: r = !1,
+    openOnHover: a = !0,
+    delay: f = 100,
+    closeDelay: g = 0,
+    disabled: b = !1,
+    ...I
+  } = o, P = ve(), k = fe(), {
+    store: l
+  } = q(), h = pe(R), u = l.useState("open"), s = l.useState("floatingRootContext"), _ = l.useState("floatingTreeRoot"), O = wn(h, l), n = t.useCallback(($) => {
+    const oe = O($);
+    return $ !== null && l.select("open") && l.select("activeTriggerId") == null && l.update({
+      activeTriggerId: h,
+      activeTriggerElement: $,
+      closeDelay: g
+    }), oe;
+  }, [O, g, l, h]), A = t.useRef(null), y = t.useCallback(($) => {
+    A.current = $, l.set("activeTriggerElement", $);
+  }, [l]), D = yt();
+  if (!D?.parentMenu)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: <Menu.SubmenuTrigger> must be placed in <Menu.SubmenuRoot>." : J(37));
+  l.useSyncedValue("closeDelay", g);
+  const p = D.parentMenu, G = p.useState("itemProps"), w = p.useState("isActive", P.index), x = t.useMemo(() => ({
+    type: "submenu-trigger",
+    setActive: () => p.set("activeIndex", P.index)
+  }), [p, P.index]), m = l.useState("disabled"), N = b || m, {
+    getItemProps: L,
+    itemRef: v
+  } = ye({
+    closeOnClick: !1,
+    disabled: N,
+    highlighted: w,
+    id: h,
+    store: l,
+    nativeButton: r,
+    itemMetadata: x,
+    nodeId: k?.nodeId
+  }), j = l.useState("hoverEnabled"), Q = l.useState("allowMouseEnter"), ne = $n(s, {
+    enabled: j && a && !N && Q,
+    handleClose: qn({
+      blockPointerEvents: !0
+    }),
+    mouseOnly: !0,
+    move: !0,
+    restMs: f,
+    delay: {
+      open: f,
+      close: g
+    },
+    triggerElementRef: A,
+    externalTree: _
+  }), K = hn(s, {
+    enabled: !N,
+    event: "mousedown",
+    toggle: !a,
+    ignoreMouse: a,
+    stickIfOpen: !1
+  }), W = at([K]), X = l.useState("triggerProps", !0);
+  delete X.id;
+  const T = t.useMemo(() => ({
+    disabled: N,
+    highlighted: w,
+    open: u
+  }), [N, w, u]);
+  return Y("div", o, {
+    state: T,
+    stateAttributesMapping: tn,
+    props: [W.getReferenceProps(), ne, X, G, {
+      tabIndex: u || w ? 0 : -1,
+      onBlur() {
+        w && p.set("activeIndex", null);
+      }
+    }, I, L],
+    ref: [i, P.ref, v, n, y]
+  });
+});
+process.env.NODE_ENV !== "production" && (St.displayName = "MenuSubmenuTrigger");
+function ao(e) {
+  const [o, i] = t.useState({
+    getBoundingClientRect() {
+      return DOMRect.fromRect({
+        width: 0,
+        height: 0,
+        x: 0,
+        y: 0
+      });
+    }
+  }), C = t.useRef(null), E = t.useRef(null), d = t.useRef(null), R = t.useRef(null), r = t.useRef(!0), a = t.useRef(null), f = pt(), g = t.useMemo(() => ({
+    anchor: o,
+    setAnchor: i,
+    actionsRef: d,
+    backdropRef: C,
+    internalBackdropRef: E,
+    positionerRef: R,
+    allowMouseUpTriggerRef: r,
+    initialCursorPointRef: a,
+    rootId: f
+  }), [o, f]);
+  return /* @__PURE__ */ c(ke.Provider, {
+    value: g,
+    children: /* @__PURE__ */ c(Ie.Provider, {
+      value: void 0,
+      children: /* @__PURE__ */ c(Nt, {
+        ...e
+      })
+    })
+  });
+}
+const rt = 500, Tt = /* @__PURE__ */ t.forwardRef(function(o, i) {
+  const {
+    render: C,
+    className: E,
+    ...d
+  } = o, {
+    setAnchor: R,
+    actionsRef: r,
+    internalBackdropRef: a,
+    backdropRef: f,
+    positionerRef: g,
+    allowMouseUpTriggerRef: b,
+    initialCursorPointRef: I,
+    rootId: P
+  } = Ee(!1), {
+    store: k
+  } = q(!1), l = k.useState("open"), h = t.useRef(null), u = t.useRef(null), s = Me(), _ = Me(), O = t.useRef(!1);
+  function n(x, m, N) {
+    const L = N.type.startsWith("touch");
+    I.current = {
+      x,
+      y: m
+    }, R({
+      getBoundingClientRect() {
+        return DOMRect.fromRect({
+          width: L ? 10 : 0,
+          height: L ? 10 : 0,
+          x,
+          y: m
+        });
+      }
+    }), O.current = !1, r.current?.setOpen(!0, z(ft, N)), _.start(rt, () => {
+      O.current = !0;
+    });
+  }
+  function A(x) {
+    b.current = !0, Gn(x), n(x.clientX, x.clientY, x.nativeEvent), tt(h.current).addEventListener("mouseup", (N) => {
+      if (b.current = !1, !O.current)
+        return;
+      _.clear(), O.current = !1;
+      const L = nt(N);
+      he(g.current, L) || P && L && Pt(L) === P || r.current?.setOpen(!1, z(Pn, N));
+    }, {
+      once: !0
+    });
+  }
+  function y(x) {
+    if (b.current = !1, x.touches.length === 1) {
+      x.stopPropagation();
+      const m = x.touches[0];
+      u.current = {
+        x: m.clientX,
+        y: m.clientY
+      }, s.start(rt, () => {
+        u.current && n(u.current.x, u.current.y, x.nativeEvent);
+      });
+    }
+  }
+  function D(x) {
+    if (s.isStarted() && u.current && x.touches.length === 1) {
+      const m = x.touches[0], N = 10, L = Math.abs(m.clientX - u.current.x), v = Math.abs(m.clientY - u.current.y);
+      (L > N || v > N) && s.clear();
+    }
+  }
+  function p() {
+    s.clear(), u.current = null;
+  }
+  t.useEffect(() => {
+    function x(N) {
+      const v = nt(N);
+      (he(h.current, v) || he(a.current, v) || he(f.current, v)) && N.preventDefault();
+    }
+    const m = tt(h.current);
+    return m.addEventListener("contextmenu", x), () => {
+      m.removeEventListener("contextmenu", x);
+    };
+  }, [f, a]);
+  const G = t.useMemo(() => ({
+    open: l
+  }), [l]);
+  return Y("div", o, {
+    state: G,
+    ref: [h, i],
+    props: [{
+      onContextMenu: A,
+      onTouchStart: y,
+      onTouchMove: D,
+      onTouchEnd: p,
+      onTouchCancel: p,
+      style: {
+        WebkitTouchCallout: "none"
+      }
+    }, d],
+    stateAttributesMapping: nn
+  });
+});
+process.env.NODE_ENV !== "production" && (Tt.displayName = "ContextMenuTrigger");
+const H = {
+  "context-menu": "_context-menu_ct7eh_2",
+  "context-menu__item": "_context-menu__item_ct7eh_11",
+  "context-menu__item-icon": "_context-menu__item-icon_ct7eh_23",
+  "context-menu__item-shortcut": "_context-menu__item-shortcut_ct7eh_30",
+  "context-menu__label": "_context-menu__label_ct7eh_35"
+}, Ot = Wt("root");
+function uo({
+  trigger: e,
+  background: o = "root",
+  className: i,
+  children: C,
+  style: E,
+  ...d
+}) {
+  return /* @__PURE__ */ c(Ot.Provider, { value: o, children: /* @__PURE__ */ ee(ao, { ...d, children: [
+    e ? /* @__PURE__ */ c(Tt, { render: e }) : null,
+    /* @__PURE__ */ c(Le, { children: /* @__PURE__ */ c(Fe, { children: /* @__PURE__ */ c(
+      Ae,
+      {
+        render: /* @__PURE__ */ c(ct, { background: o }),
+        className: de(
+          H["context-menu"],
+          ut["transition_fade-out"],
+          i
+        ),
+        style: E,
+        children: C
+      }
+    ) }) })
+  ] }) });
+}
+function co({
+  icon: e,
+  shortcut: o,
+  className: i,
+  children: C,
+  ...E
+}) {
+  return /* @__PURE__ */ ee(
+    Re,
+    {
+      render: /* @__PURE__ */ c(Rt, { ...E }),
+      interactive: "list-item",
+      className: de(H["context-menu__item"], i),
+      children: [
+        e ? /* @__PURE__ */ c(ce, { name: e, className: H["context-menu__item-icon"] }) : null,
+        Ce(C),
+        o ? /* @__PURE__ */ c(
+          lt,
+          {
+            className: H["context-menu__item-shortcut"],
+            color: "dimmest",
+            size: "sm",
+            children: o
+          }
+        ) : null
+      ]
+    }
+  );
+}
+function lo(e) {
+  return /* @__PURE__ */ c(on, { render: /* @__PURE__ */ c(rn, {}), ...e });
+}
+function po({
+  label: e,
+  children: o,
+  ...i
+}) {
+  return /* @__PURE__ */ ee(Mt, { ...i, children: [
+    e ? /* @__PURE__ */ c(
+      lt,
+      {
+        render: /* @__PURE__ */ c(Ct, {}),
+        className: H["context-menu__label"],
+        color: "dimmest",
+        size: "sm",
+        children: e
+      }
+    ) : null,
+    o
+  ] });
+}
+const fo = bt;
+function mo({
+  className: e,
+  children: o,
+  ...i
+}) {
+  return /* @__PURE__ */ ee(
+    Re,
+    {
+      interactive: "list-item",
+      render: /* @__PURE__ */ c(vt, { ...i }),
+      className: de(H["context-menu__item"], e),
+      children: [
+        /* @__PURE__ */ c(
+          Et,
+          {
+            className: H["context-menu__item-icon"],
+            children: /* @__PURE__ */ c(ce, { name: "checkbox-circle-line", color: st.primaryDefault })
+          }
+        ),
+        Ce(o)
+      ]
+    }
+  );
+}
+function go({
+  className: e,
+  children: o,
+  ...i
+}) {
+  return /* @__PURE__ */ ee(
+    Re,
+    {
+      interactive: "list-item",
+      render: /* @__PURE__ */ c(ht, { ...i }),
+      className: de(H["context-menu__item"], e),
+      children: [
+        /* @__PURE__ */ c(
+          xt,
+          {
+            className: H["context-menu__item-icon"],
+            children: /* @__PURE__ */ c(ce, { name: "check-line", color: st.primaryDefault })
+          }
+        ),
+        Ce(o)
+      ]
+    }
+  );
+}
+function ho({
+  label: e,
+  icon: o,
+  children: i,
+  className: C,
+  style: E,
+  ...d
+}) {
+  const R = Xt(Ot);
+  return /* @__PURE__ */ ee(io, { ...d, children: [
+    /* @__PURE__ */ ee(
+      Re,
+      {
+        render: /* @__PURE__ */ c(St, {}),
+        className: H["context-menu__item"],
+        children: [
+          o ? /* @__PURE__ */ c(ce, { name: o, className: H["context-menu__item-icon"] }) : null,
+          Ce(e),
+          /* @__PURE__ */ c(
+            ce,
+            {
+              name: "arrow-right-line",
+              className: H["context-menu__item-shortcut"]
+            }
+          )
+        ]
+      }
+    ),
+    /* @__PURE__ */ c(Le, { children: /* @__PURE__ */ c(Fe, { alignOffset: -4, sideOffset: -4, children: /* @__PURE__ */ c(
+      Ae,
+      {
+        render: /* @__PURE__ */ c(ct, { background: R }),
+        className: de(
+          H["context-menu"],
+          ut.transition_scale,
+          C
+        ),
+        style: E,
+        children: i
+      }
+    ) }) })
+  ] });
+}
+const or = Object.assign(uo, {
+  Item: co,
+  Separator: lo,
+  Group: po,
+  RadioGroup: fo,
+  RadioItem: mo,
+  CheckboxItem: go,
+  More: ho
+});
+export {
+  or as ContextMenu
+};