astralis-ui 0.1.0

package/dist/components/layout/flex/flex-item.js

@@ -0,0 +1,35 @@
+"use client";
+import { jsx as x } from "react/jsx-runtime";
+import { forwardRef as I } from "react";
+import { astralisMerge as V } from "../../../utils/astralis-merge.js";
+import { resolveStyleProps as i } from "../../../utils/responsive.js";
+import { flexItemVariantMap as m, flexItemVariants as d } from "./flex.style.js";
+import { boxVariantMap as u, boxVariants as v } from "../box/box.styles.js";
+import { BOX_VARIANT_KEYS as y } from "../box/box.js";
+const b = Object.keys(m), P = I(
+  ({ children: n, as: l, className: f, ...e }, p) => {
+    const c = l || "div", o = {}, a = {}, s = {};
+    for (const t in e)
+      if (Object.prototype.hasOwnProperty.call(e, t)) {
+        const r = e[t];
+        b.includes(t) ? o[t] = r : y.includes(t) ? a[t] = r : s[t] = r;
+      }
+    return /* @__PURE__ */ x(
+      c,
+      {
+        className: V(
+          i(a, { maps: u, variants: v }),
+          i(o, { maps: m, variants: d }),
+          f
+        ),
+        ref: p,
+        ...s,
+        children: n
+      }
+    );
+  }
+);
+P.displayName = "Flex.Item";
+export {
+  P as default
+};

package/dist/components/layout/flex/flex.js

@@ -0,0 +1,32 @@
+"use client";
+import { jsx as p } from "react/jsx-runtime";
+import { forwardRef as x } from "react";
+import { astralisMerge as V } from "../../../utils/astralis-merge.js";
+import { resolveStyleProps as s } from "../../../utils/responsive.js";
+import { flexVariantMap as i, flexVariants as d } from "./flex.style.js";
+import { boxVariantMap as y, boxVariants as b } from "../box/box.styles.js";
+import { BOX_VARIANT_KEYS as u } from "../box/box.js";
+const v = Object.keys(i), P = x(
+  ({ children: n, as: m, className: l, ...r }, f) => {
+    const c = m || "div", o = {}, a = {}, e = {};
+    for (const t in r)
+      Object.prototype.hasOwnProperty.call(r, t) && (v.includes(t) ? o[t] = r[t] : u.includes(t) ? a[t] = r[t] : e[t] = r[t]);
+    return /* @__PURE__ */ p(
+      c,
+      {
+        className: V(
+          s(a, { maps: y, variants: b }),
+          s(o, { maps: i, variants: d }),
+          l
+        ),
+        ref: f,
+        ...e,
+        children: n
+      }
+    );
+  }
+);
+P.displayName = "Flex";
+export {
+  P as default
+};

package/dist/components/layout/flex/flex.style.js

@@ -0,0 +1,42 @@
+"use client";
+import { cva as e } from "class-variance-authority";
+import { columnGapTypes as t, rowGapTypes as a, gapTypes as n, flexWrapTypes as s, placeContentTypes as r, alignContentTypes as p, alignItemsTypes as i, justifyContentTypes as o, flexDirectionTypes as l, alignSelfTypes as f, orderTypes as y, flexShrinkTypes as T, flexGrowTypes as c, flexTypes as x, flexBasisTypes as m } from "../../../const/layout-mappings.js";
+const g = {
+  direction: l,
+  // Container alignment valid in flexbox: justify-content (main axis),
+  // align-items (cross axis), align-content (wrapped lines), place-content
+  // (shorthand of the two). justify-items / place-items are NO-OPs in flex.
+  justifyContent: o,
+  alignItems: i,
+  alignContent: p,
+  placeContent: r,
+  wrap: s,
+  gap: n,
+  rowGap: a,
+  columnGap: t
+}, d = e("astralis:flex", {
+  variants: g,
+  defaultVariants: {
+    direction: "row",
+    alignItems: "start",
+    justifyContent: "start",
+    wrap: "nowrap"
+  }
+}), w = {
+  basis: m,
+  flex: x,
+  grow: c,
+  shrink: T,
+  order: y,
+  // Only align-self has effect on a flex item; justify-self / place-self are
+  // NO-OPs in flex (main-axis positioning is done via margins / justify-content).
+  alignSelf: f
+}, G = e("", {
+  variants: w
+});
+export {
+  w as flexItemVariantMap,
+  G as flexItemVariants,
+  g as flexVariantMap,
+  d as flexVariants
+};

package/dist/components/layout/flex/index.js

@@ -0,0 +1,11 @@
+"use client";
+import e from "./flex.js";
+import t from "./flex-item.js";
+const l = Object.assign(e, {
+  Item: t
+});
+export {
+  l as Flex,
+  t as FlexItem,
+  l as default
+};

package/dist/components/layout/float/float.js

@@ -0,0 +1,32 @@
+"use client";
+import { jsx as p } from "react/jsx-runtime";
+import { forwardRef as V } from "react";
+import { astralisMerge as d } from "../../../utils/astralis-merge.js";
+import { resolveStyleProps as e } from "../../../utils/responsive.js";
+import { floatVariantMap as i, floatVariants as y } from "./float.styles.js";
+import { boxVariantMap as b, boxVariants as u } from "../box/box.styles.js";
+import { BOX_VARIANT_KEYS as v } from "../box/box.js";
+const x = Object.keys(i), P = V(
+  ({ children: n, as: m, className: l, ...a }, f) => {
+    const c = m || "div", o = {}, r = {}, s = {};
+    for (const t in a)
+      Object.prototype.hasOwnProperty.call(a, t) && (x.includes(t) ? o[t] = a[t] : v.includes(t) ? r[t] = a[t] : s[t] = a[t]);
+    return /* @__PURE__ */ p(
+      c,
+      {
+        className: d(
+          e(r, { maps: b, variants: u }),
+          e(o, { maps: i, variants: y }),
+          l
+        ),
+        ref: f,
+        ...s,
+        children: n
+      }
+    );
+  }
+);
+P.displayName = "Float";
+export {
+  P as default
+};

package/dist/components/layout/float/float.styles.js

@@ -0,0 +1,29 @@
+"use client";
+import { cva as t } from "class-variance-authority";
+const a = {
+  placement: {
+    // Every placement declares ALL FOUR insets (auto for the unused sides).
+    // Responsive overrides only ADD breakpoint classes on top of the base
+    // value's classes, so without the auto-counters a base `top-start`
+    // overridden to `md:bottom-end` would keep top-0/left-0 pinned as well.
+    "top-start": "astralis:top-0 astralis:bottom-auto astralis:left-0 astralis:right-auto astralis:-translate-x-1/2 astralis:-translate-y-1/2",
+    "top-center": "astralis:top-0 astralis:bottom-auto astralis:left-1/2 astralis:right-auto astralis:-translate-x-1/2 astralis:-translate-y-1/2",
+    "top-end": "astralis:top-0 astralis:bottom-auto astralis:right-0 astralis:left-auto astralis:translate-x-1/2 astralis:-translate-y-1/2",
+    "middle-start": "astralis:top-1/2 astralis:bottom-auto astralis:left-0 astralis:right-auto astralis:-translate-x-1/2 astralis:-translate-y-1/2",
+    "middle-center": "astralis:top-1/2 astralis:bottom-auto astralis:left-1/2 astralis:right-auto astralis:-translate-x-1/2 astralis:-translate-y-1/2",
+    "middle-end": "astralis:top-1/2 astralis:bottom-auto astralis:right-0 astralis:left-auto astralis:translate-x-1/2 astralis:-translate-y-1/2",
+    "bottom-start": "astralis:bottom-0 astralis:top-auto astralis:left-0 astralis:right-auto astralis:-translate-x-1/2 astralis:translate-y-1/2",
+    "bottom-center": "astralis:bottom-0 astralis:top-auto astralis:left-1/2 astralis:right-auto astralis:-translate-x-1/2 astralis:translate-y-1/2",
+    "bottom-end": "astralis:bottom-0 astralis:top-auto astralis:right-0 astralis:left-auto astralis:translate-x-1/2 astralis:translate-y-1/2"
+  }
+}, r = t(
+  "astralis:absolute astralis:z-lower astralis:inline-flex astralis:items-center astralis:justify-center",
+  {
+    variants: a,
+    defaultVariants: { placement: "top-end" }
+  }
+);
+export {
+  a as floatVariantMap,
+  r as floatVariants
+};

package/dist/components/layout/grid/grid-item.js

@@ -0,0 +1,36 @@
+"use client";
+import { jsx as V } from "react/jsx-runtime";
+import { forwardRef as u } from "react";
+import { astralisMerge as v } from "../../../utils/astralis-merge.js";
+import { resolveStyleProps as n } from "../../../utils/responsive.js";
+import { gridItemVariantMap as l, gridItemVariants as y } from "./grid.styles.js";
+import { boxVariantMap as b, boxVariants as x } from "../box/box.styles.js";
+import { BOX_VARIANT_KEYS as A } from "../box/box.js";
+const P = Object.keys(l), g = u(
+  ({ children: p, as: c, className: f, area: e, style: a, ...t }, d) => {
+    const I = c || "div", s = {}, i = {}, m = {};
+    for (const r in t)
+      if (Object.prototype.hasOwnProperty.call(t, r)) {
+        const o = t[r];
+        P.includes(r) ? s[r] = o : A.includes(r) ? i[r] = o : m[r] = o;
+      }
+    return /* @__PURE__ */ V(
+      I,
+      {
+        className: v(
+          n(i, { maps: b, variants: x }),
+          n(s, { maps: l, variants: y }),
+          f
+        ),
+        ref: d,
+        style: e ? { gridArea: e, ...a } : a,
+        ...m,
+        children: p
+      }
+    );
+  }
+);
+g.displayName = "Grid.Item";
+export {
+  g as default
+};

package/dist/components/layout/grid/grid.js

@@ -0,0 +1,47 @@
+"use client";
+import { jsx as v } from "react/jsx-runtime";
+import { forwardRef as b } from "react";
+import { astralisMerge as x } from "../../../utils/astralis-merge.js";
+import { resolveStyleProps as d } from "../../../utils/responsive.js";
+import { gridVariantMap as f, gridVariants as P } from "./grid.styles.js";
+import { boxVariantMap as T, boxVariants as u } from "../box/box.styles.js";
+import { BOX_VARIANT_KEYS as N } from "../box/box.js";
+const O = Object.keys(f), S = b(
+  ({
+    children: l,
+    as: p,
+    className: y,
+    templateColumns: o,
+    templateRows: t,
+    templateAreas: a,
+    style: s,
+    ...i
+  }, V) => {
+    const g = p || "div", e = {}, n = {}, m = {};
+    for (const r in i)
+      Object.prototype.hasOwnProperty.call(i, r) && (O.includes(r) ? e[r] = i[r] : N.includes(r) ? n[r] = i[r] : m[r] = i[r]);
+    const c = o || t || a ? {
+      ...o ? { gridTemplateColumns: o } : {},
+      ...t ? { gridTemplateRows: t } : {},
+      ...a ? { gridTemplateAreas: a } : {}
+    } : void 0;
+    return /* @__PURE__ */ v(
+      g,
+      {
+        className: x(
+          d(n, { maps: T, variants: u }),
+          d(e, { maps: f, variants: P }),
+          y
+        ),
+        ref: V,
+        style: c ? { ...c, ...s } : s,
+        ...m,
+        children: l
+      }
+    );
+  }
+);
+S.displayName = "Grid";
+export {
+  S as default
+};

package/dist/components/layout/grid/grid.styles.js

@@ -0,0 +1,43 @@
+"use client";
+import { cva as t } from "class-variance-authority";
+import { columnGapTypes as e, rowGapTypes as s, gapTypes as a, placeItemsTypes as o, placeContentTypes as r, alignContentTypes as n, justifyContentTypes as p, alignItemsTypes as i, gridJustifyItemsTypes as l, gridAutoRowsTypes as y, gridAutoColumnsTypes as g, gridAutoFlow as d, gridTemplateRows as T, gridTemplateColumns as m, placeSelfTypes as u, justifySelfTypes as c, alignSelfTypes as f, orderTypes as w, gridRowEndTypes as S, gridRowStartTypes as C, gridRowSpanTypes as I, gridColEndTypes as R, gridColStartTypes as j, gridColSpanTypes as V } from "../../../const/layout-mappings.js";
+const E = {
+  columns: m,
+  rows: T,
+  flow: d,
+  autoColumns: g,
+  autoRows: y,
+  justifyItems: l,
+  alignItems: i,
+  justifyContent: p,
+  alignContent: n,
+  placeContent: r,
+  placeItems: o,
+  gap: a,
+  rowGap: s,
+  columnGap: e
+}, M = t("astralis:grid", {
+  variants: E,
+  defaultVariants: {
+    flow: "row"
+  }
+}), G = {
+  colSpan: V,
+  colStart: j,
+  colEnd: R,
+  rowSpan: I,
+  rowStart: C,
+  rowEnd: S,
+  order: w,
+  alignSelf: f,
+  justifySelf: c,
+  placeSelf: u
+}, x = t("", {
+  variants: G
+});
+export {
+  G as gridItemVariantMap,
+  x as gridItemVariants,
+  E as gridVariantMap,
+  M as gridVariants
+};

package/dist/components/layout/grid/index.js

@@ -0,0 +1,10 @@
+"use client";
+import t from "./grid.js";
+import o from "./grid-item.js";
+const e = Object.assign(t, {
+  Item: o
+});
+export {
+  e as Grid,
+  o as GridItem
+};

package/dist/components/layout/separator/separator.js

@@ -0,0 +1,33 @@
+"use client";
+import { jsx as d } from "react/jsx-runtime";
+import { forwardRef as y } from "react";
+import { astralisMerge as V } from "../../../utils/astralis-merge.js";
+import { resolveStyleProps as n } from "../../../utils/responsive.js";
+import { separatorVariantMap as s, separatorVariants as v } from "./separator.styles.js";
+import { boxVariantMap as b, boxVariants as u } from "../box/box.styles.js";
+import { BOX_VARIANT_KEYS as x } from "../box/box.js";
+const O = Object.keys(s), P = y(
+  ({ as: m, className: l, ...r }, c) => {
+    const p = m || "div", a = r.orientation ?? "horizontal", f = typeof a == "string" ? a : void 0, o = {}, e = {}, i = {};
+    for (const t in r)
+      Object.prototype.hasOwnProperty.call(r, t) && (O.includes(t) ? o[t] = r[t] : x.includes(t) ? e[t] = r[t] : i[t] = r[t]);
+    return /* @__PURE__ */ d(
+      p,
+      {
+        role: "separator",
+        "aria-orientation": f,
+        className: V(
+          n(o, { maps: s, variants: v }),
+          n(e, { maps: b, variants: u }),
+          l
+        ),
+        ref: c,
+        ...i
+      }
+    );
+  }
+);
+P.displayName = "Separator";
+export {
+  P as default
+};

package/dist/components/layout/separator/separator.styles.js

@@ -0,0 +1,29 @@
+"use client";
+import { cva as a } from "class-variance-authority";
+const r = {
+  orientation: {
+    // Each value RESETS the other orientation's properties. Responsive
+    // overrides only ADD breakpoint classes — the base value's classes stay
+    // applied — so without the explicit zero/auto counters, a
+    // `{ base: "horizontal", md: "vertical" }` separator at md would keep the
+    // base's top border and full width on top of the vertical styles.
+    horizontal: "astralis:w-full astralis:h-auto astralis:border-t astralis:border-l-0",
+    vertical: "astralis:w-auto astralis:h-full astralis:self-stretch astralis:border-l astralis:border-t-0"
+  },
+  variant: {
+    solid: "astralis:border-solid",
+    dashed: "astralis:border-dashed",
+    dotted: "astralis:border-dotted"
+  }
+}, s = a(
+  // Default colour comes from the muted stroke token; overridable via `borderColor`.
+  "astralis:border-stroke-muted astralis:shrink-0",
+  {
+    variants: r,
+    defaultVariants: { orientation: "horizontal", variant: "solid" }
+  }
+);
+export {
+  r as separatorVariantMap,
+  s as separatorVariants
+};

package/dist/components/layout/stack/stack.js

@@ -0,0 +1,24 @@
+"use client";
+import { jsx as i } from "react/jsx-runtime";
+import { forwardRef as r } from "react";
+import { Flex as l } from "../flex/index.js";
+const c = r(({ direction: t = "vertical", as: e, children: o, ...a }, n) => /* @__PURE__ */ i(
+  l,
+  {
+    ref: n,
+    as: e,
+    direction: t === "vertical" ? "column" : "row",
+    ...a,
+    children: o
+  }
+));
+c.displayName = "Stack";
+const m = r((t, e) => /* @__PURE__ */ i(c, { ref: e, alignItems: "center", ...t, direction: "horizontal" }));
+m.displayName = "HStack";
+const s = r((t, e) => /* @__PURE__ */ i(c, { ref: e, ...t, direction: "vertical" }));
+s.displayName = "VStack";
+export {
+  m as HStack,
+  s as VStack,
+  c as default
+};

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

@@ -0,0 +1,62 @@
+"use client";
+import { jsx as m } from "react/jsx-runtime";
+import { useMemo as h, useEffect as x } from "react";
+import { Portal as T } from "../../overlay/portal.js";
+import { useMenu as I } from "../menu.context.js";
+import { astralisMerge as N } from "../../../utils/astralis-merge.js";
+import { usePresence as P } from "../../../hooks/use-presence.js";
+import { useAnchorPosition as b } from "../../../hooks/use-anchor-position.js";
+import { useDismiss as w } from "../../../hooks/use-dismiss.js";
+import { useRovingFocus as A } from "../../../hooks/use-roving-focus.js";
+import { menuMotionClasses as F, menuContentClasses as K } from "../menu.styles.js";
+const a = 160;
+function O({ className: u = "", children: f, onKeyDown: c, ...l }) {
+  const { open: t, close: i, triggerRef: o, contentRef: r, contentId: d, side: p, align: R, sideOffset: g } = I(), { mounted: s, state: y } = P(t, a), { x: v, y: M, side: C } = b({
+    open: s,
+    anchorRef: o,
+    floatingRef: r,
+    side: p,
+    align: R,
+    sideOffset: g
+  }), D = h(() => [o, r], [o, r]);
+  w(t, i, { refs: D });
+  const n = A({
+    itemSelector: "[data-astralis-menu-item]",
+    orientation: "vertical",
+    typeahead: !0
+  });
+  return x(() => {
+    if (!t) return;
+    const e = setTimeout(() => n.focusFirst(), 0);
+    return () => {
+      clearTimeout(e), o.current?.focus();
+    };
+  }, [t]), s ? /* @__PURE__ */ m(T, { children: /* @__PURE__ */ m(
+    "div",
+    {
+      ref: (e) => {
+        r.current = e, n.containerRef.current = e;
+      },
+      id: d,
+      role: "menu",
+      "aria-orientation": "vertical",
+      tabIndex: -1,
+      "data-side": C,
+      style: { left: v, top: M, transitionDuration: `${a}ms` },
+      onKeyDown: (e) => {
+        if (c?.(e), e.key === "Tab") {
+          i();
+          return;
+        }
+        n.onKeyDown(e);
+      },
+      className: N(K, F(y), u),
+      ...l,
+      children: f
+    }
+  ) }) : null;
+}
+O.displayName = "Menu.Content";
+export {
+  O as MenuContent
+};

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

@@ -0,0 +1,81 @@
+"use client";
+import { jsx as o, jsxs as g } from "react/jsx-runtime";
+import { cloneElement as y } from "react";
+import { useMenu as p } from "../menu.context.js";
+import { astralisMerge as u } from "../../../utils/astralis-merge.js";
+import { menuSeparatorClasses as N, menuLabelClasses as v, menuIconSlotClasses as C, menuShortcutClasses as h, menuItemDangerClasses as k, menuItemClasses as D } from "../menu.styles.js";
+function I({ children: n }) {
+  const { toggle: e, open: a, triggerRef: i, contentId: l } = p(), s = n;
+  return y(s, {
+    ref: i,
+    onClick: (r) => {
+      s.props.onClick?.(r), e();
+    },
+    // ArrowDown on a closed trigger opens the menu (APG menu-button pattern).
+    onKeyDown: (r) => {
+      s.props.onKeyDown?.(r), !a && (r.key === "ArrowDown" || r.key === "ArrowUp") && (r.preventDefault(), e());
+    },
+    "aria-haspopup": "menu",
+    "aria-expanded": a,
+    "aria-controls": a ? l : void 0
+  });
+}
+I.displayName = "Menu.Trigger";
+function w({
+  onSelect: n,
+  disabled: e = !1,
+  danger: a = !1,
+  icon: i,
+  shortcut: l,
+  closeOnSelect: s,
+  className: r = "",
+  children: f,
+  ...d
+}) {
+  const m = p(), M = s ?? m.closeOnSelect, c = () => {
+    e || (n?.(), M && m.close());
+  };
+  return /* @__PURE__ */ g(
+    "div",
+    {
+      role: "menuitem",
+      tabIndex: -1,
+      "aria-disabled": e || void 0,
+      "data-astralis-menu-item": "",
+      onClick: c,
+      onKeyDown: (t) => {
+        (t.key === "Enter" || t.key === " ") && (t.preventDefault(), c());
+      },
+      onPointerMove: (t) => {
+        e || t.currentTarget.focus();
+      },
+      className: u(D, a && k, r),
+      ...d,
+      children: [
+        i && /* @__PURE__ */ o("span", { "aria-hidden": "true", className: C, children: i }),
+        /* @__PURE__ */ o("span", { className: "astralis:flex-1 astralis:truncate", children: f }),
+        l && /* @__PURE__ */ o("span", { className: h, children: l })
+      ]
+    }
+  );
+}
+w.displayName = "Menu.Item";
+function x({ className: n = "", children: e, ...a }) {
+  return /* @__PURE__ */ o("div", { className: u(v, n), ...a, children: e });
+}
+x.displayName = "Menu.Label";
+function S({ className: n = "", ...e }) {
+  return /* @__PURE__ */ o("div", { role: "separator", "aria-orientation": "horizontal", className: u(N, n), ...e });
+}
+S.displayName = "Menu.Separator";
+function b({ className: n = "", children: e, ...a }) {
+  return /* @__PURE__ */ o("div", { role: "group", className: n || void 0, ...a, children: e });
+}
+b.displayName = "Menu.Group";
+export {
+  b as MenuGroup,
+  w as MenuItem,
+  x as MenuLabel,
+  S as MenuSeparator,
+  I as MenuTrigger
+};

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

@@ -0,0 +1,36 @@
+"use client";
+import { jsx as b } from "react/jsx-runtime";
+import { useId as d, useRef as a, useCallback as m, useMemo as v } from "react";
+import { MenuContext as M } from "../menu.context.js";
+import { useControllableState as I } from "../../../hooks/use-controllable-state.js";
+function V({
+  children: f,
+  open: p,
+  defaultOpen: i = !1,
+  onOpenChange: g,
+  side: e = "bottom",
+  align: n = "start",
+  sideOffset: r = 6,
+  closeOnSelect: u = !0
+}) {
+  const [o, t] = I({ value: p, defaultValue: i, onChange: g }), l = d(), x = a(null), C = a(null), s = m(() => t(!1), [t]), c = m(() => t(!o), [t, o]), R = v(
+    () => ({
+      open: o,
+      setOpen: t,
+      toggle: c,
+      close: s,
+      triggerRef: x,
+      contentRef: C,
+      contentId: `${l}-menu`,
+      side: e,
+      align: n,
+      sideOffset: r,
+      closeOnSelect: u
+    }),
+    [o, t, c, s, l, e, n, r, u]
+  );
+  return /* @__PURE__ */ b(M.Provider, { value: R, children: f });
+}
+export {
+  V as MenuRoot
+};

package/dist/components/menu/index.js

@@ -0,0 +1,15 @@
+"use client";
+import { MenuRoot as e } from "./components/menu-root.js";
+import { MenuContent as r } from "./components/menu-content.js";
+import { MenuGroup as o, MenuSeparator as t, MenuLabel as n, MenuItem as u, MenuTrigger as m } from "./components/menu-parts.js";
+const i = Object.assign(e, {
+  Trigger: m,
+  Content: r,
+  Item: u,
+  Label: n,
+  Separator: t,
+  Group: o
+});
+export {
+  i as Menu
+};

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

@@ -0,0 +1,12 @@
+"use client";
+import { createContext as t, useContext as n } from "react";
+const o = t(null);
+function r() {
+  const e = n(o);
+  if (!e) throw new Error("Menu sub-components must be used within <Menu>");
+  return e;
+}
+export {
+  o as MenuContext,
+  r as useMenu
+};

package/dist/components/menu/menu.styles.js

@@ -0,0 +1,12 @@
+"use client";
+const a = "astralis:fixed astralis:z-higher astralis:min-w-44 astralis:max-w-72 astralis:rounded-xl astralis:border-normal astralis:border-stroke-subtle astralis:bg-surface-panel astralis:shadow-lg astralis:p-1 astralis:outline-none astralis:transition-all astralis:duration-fast", t = (s) => s === "open" ? "astralis:opacity-100 astralis:scale-100" : "astralis:opacity-0 astralis:scale-95", l = "astralis:flex astralis:w-full astralis:cursor-pointer astralis:select-none astralis:items-center astralis:gap-2 astralis:rounded-lg astralis:px-2.5 astralis:py-1.5 astralis:text-sm astralis:text-label-base astralis:outline-none astralis:transition-colors astralis:focus:bg-surface-subtle astralis:aria-disabled:opacity-moderate astralis:aria-disabled:pointer-events-none", r = "astralis:text-label-error astralis:focus:bg-surface-error", e = "astralis:px-2.5 astralis:py-1.5 astralis:text-xs astralis:font-medium astralis:text-label-subtle", i = "astralis:my-1 astralis:h-px astralis:bg-stroke-subtle", n = "astralis:h-4 astralis:w-4 astralis:shrink-0 astralis:text-label-muted", o = "astralis:ml-auto astralis:pl-4 astralis:text-xs astralis:text-label-subtle";
+export {
+  a as menuContentClasses,
+  n as menuIconSlotClasses,
+  l as menuItemClasses,
+  r as menuItemDangerClasses,
+  e as menuLabelClasses,
+  t as menuMotionClasses,
+  i as menuSeparatorClasses,
+  o as menuShortcutClasses
+};