nuvox 0.1.4 → 0.1.6

package/dist/chunk-HAMPWL7I.js

@@ -0,0 +1,2457 @@
+// src/tokens/contract.ts
+function defineTheme(tokens) {
+  return tokens;
+}
+var TOKEN_CATEGORIES = [
+  "meta",
+  "color",
+  "radius",
+  "spacing",
+  "typography",
+  "shadow",
+  "elevation",
+  "motion",
+  "border",
+  "effects"
+];
+var REQUIRED_TOKEN_PATHS = [
+  "meta.name",
+  "meta.label",
+  "meta.description",
+  ...["0", "50", "100", "200", "300", "400", "500", "600", "700", "800", "900", "950"].map((k) => `color.neutral.${k}`),
+  ...["success", "danger", "warning", "info"].flatMap(
+    (c) => ["light", "subtle", "base", "dark", "deeper"].map((k) => `color.${c}.${k}`)
+  ),
+  "color.background",
+  "color.surface",
+  "color.surfaceRaised",
+  "color.border",
+  "color.borderFocus",
+  "color.text",
+  "color.textMuted",
+  "color.textInverse",
+  "radius.sm",
+  "radius.md",
+  "radius.lg",
+  "radius.xl",
+  "radius.2xl",
+  "radius.full",
+  "spacing.xs",
+  "spacing.sm",
+  "spacing.md",
+  "spacing.lg",
+  "spacing.xl",
+  "spacing.2xl",
+  "typography.fontSans",
+  "typography.fontMono",
+  "typography.sizeXs",
+  "typography.sizeSm",
+  "typography.sizeMd",
+  "typography.sizeLg",
+  "typography.sizeXl",
+  "typography.weightNormal",
+  "typography.weightMedium",
+  "typography.weightBold",
+  "typography.lineHeightTight",
+  "typography.lineHeightNormal",
+  "shadow.xs",
+  "shadow.sm",
+  "shadow.md",
+  "shadow.lg",
+  "shadow.xl",
+  "shadow.2xl",
+  "shadow.inner",
+  "elevation.dropdown",
+  "elevation.popover",
+  "elevation.modal",
+  "elevation.toast",
+  "elevation.tooltip",
+  "motion.durationFast",
+  "motion.durationNormal",
+  "motion.durationSlow",
+  "motion.easeStandard",
+  "motion.easeEmphasized",
+  "motion.durationInstant",
+  "border.widthThin",
+  "border.widthMedium",
+  "border.widthThick",
+  "border.style",
+  "effects.backdropBlur"
+];
+function getAtPath(obj, path) {
+  return path.split(".").reduce((acc, key) => {
+    if (acc === null || typeof acc !== "object") return void 0;
+    return acc[key];
+  }, obj);
+}
+function findMissingTokenPaths(theme) {
+  return REQUIRED_TOKEN_PATHS.filter((path) => {
+    const value = getAtPath(theme, path);
+    return value === null || value === void 0 || value === "";
+  });
+}
+
+// src/tokens/themes/light.ts
+var light = defineTheme({
+  meta: {
+    name: "light",
+    label: "Light",
+    description: "Default, neutral, high-legibility surface."
+  },
+  color: {
+    neutral: {
+      0: "#ffffff",
+      50: "#f9fafb",
+      100: "#f3f4f6",
+      200: "#e5e7eb",
+      300: "#d1d5db",
+      400: "#9ca3af",
+      500: "#6b7280",
+      600: "#4b5563",
+      700: "#374151",
+      800: "#1f2937",
+      900: "#111827",
+      950: "#030712"
+    },
+    success: { light: "#d1fae5", subtle: "#a7f3d0", base: "#10b981", dark: "#059669", deeper: "#064e3b" },
+    danger: { light: "#fee2e2", subtle: "#fecaca", base: "#ef4444", dark: "#dc2626", deeper: "#7f1d1d" },
+    warning: { light: "#fef3c7", subtle: "#fde68a", base: "#f59e0b", dark: "#d97706", deeper: "#78350f" },
+    info: { light: "#dbeafe", subtle: "#bfdbfe", base: "#3b82f6", dark: "#2563eb", deeper: "#1e3a5f" },
+    background: "#ffffff",
+    surface: "#ffffff",
+    surfaceRaised: "#ffffff",
+    border: "#e5e7eb",
+    // Neutral, not brand-tied — the actual focus-ring color
+    // interactive components use is the picked accent
+    // (--color-brand-500/600), not this. This exists for
+    // non-branded emphasis borders.
+    borderFocus: "#9ca3af",
+    text: "#111827",
+    textMuted: "#6b7280",
+    textInverse: "#ffffff"
+  },
+  radius: { sm: "6px", md: "10px", lg: "14px", xl: "18px", "2xl": "24px", full: "9999px" },
+  spacing: { xs: "4px", sm: "8px", md: "12px", lg: "16px", xl: "24px", "2xl": "32px" },
+  typography: {
+    fontSans: "'Inter', system-ui, sans-serif",
+    fontMono: "'JetBrains Mono', monospace",
+    sizeXs: "12px",
+    sizeSm: "14px",
+    sizeMd: "16px",
+    sizeLg: "18px",
+    sizeXl: "22px",
+    weightNormal: "400",
+    weightMedium: "500",
+    weightBold: "700",
+    lineHeightTight: "1.2",
+    lineHeightNormal: "1.5"
+  },
+  shadow: {
+    xs: "0 1px 2px rgba(0,0,0,0.05)",
+    sm: "0 2px 6px rgba(0,0,0,0.06)",
+    md: "0 4px 12px rgba(0,0,0,0.08)",
+    lg: "0 10px 24px rgba(0,0,0,0.10)",
+    xl: "0 20px 40px rgba(0,0,0,0.12)",
+    "2xl": "0 28px 56px rgba(0,0,0,0.16)",
+    inner: "inset 0 1px 2px rgba(0,0,0,0.05)"
+  },
+  elevation: { dropdown: 1050, popover: 1060, modal: 1e3, toast: 1200, tooltip: 1100 },
+  motion: {
+    durationFast: "120ms",
+    durationNormal: "200ms",
+    durationSlow: "320ms",
+    easeStandard: "cubic-bezier(0.4, 0, 0.2, 1)",
+    easeEmphasized: "cubic-bezier(0.2, 0, 0, 1)",
+    durationInstant: "0ms"
+  },
+  border: { widthThin: "1px", widthMedium: "1.5px", widthThick: "2px", style: "solid" },
+  effects: { backdropBlur: "0px" }
+});
+
+// src/tokens/themes/dark.ts
+var dark = defineTheme({
+  meta: {
+    name: "dark",
+    label: "Dark",
+    description: "Low-glare surface for extended use."
+  },
+  color: {
+    neutral: {
+      0: "#030712",
+      50: "#111827",
+      100: "#1f2937",
+      200: "#374151",
+      300: "#4b5563",
+      400: "#6b7280",
+      500: "#9ca3af",
+      600: "#d1d5db",
+      700: "#e5e7eb",
+      800: "#f3f4f6",
+      900: "#f9fafb",
+      950: "#ffffff"
+    },
+    success: { light: "#064e3b", subtle: "#065f46", base: "#34d399", dark: "#6ee7b7", deeper: "#d1fae5" },
+    danger: { light: "#7f1d1d", subtle: "#991b1b", base: "#f87171", dark: "#fca5a5", deeper: "#fee2e2" },
+    warning: { light: "#78350f", subtle: "#92400e", base: "#fbbf24", dark: "#fcd34d", deeper: "#fef3c7" },
+    info: { light: "#1e3a5f", subtle: "#1e40af", base: "#60a5fa", dark: "#93c5fd", deeper: "#dbeafe" },
+    background: "#0b0f19",
+    surface: "#131826",
+    surfaceRaised: "#1c2333",
+    border: "#2a3143",
+    borderFocus: "#6b7280",
+    text: "#f3f4f6",
+    textMuted: "#9ca3af",
+    textInverse: "#111827"
+  },
+  radius: { sm: "6px", md: "10px", lg: "14px", xl: "18px", "2xl": "24px", full: "9999px" },
+  spacing: { xs: "4px", sm: "8px", md: "12px", lg: "16px", xl: "24px", "2xl": "32px" },
+  typography: {
+    fontSans: "'Inter', system-ui, sans-serif",
+    fontMono: "'JetBrains Mono', monospace",
+    sizeXs: "12px",
+    sizeSm: "14px",
+    sizeMd: "16px",
+    sizeLg: "18px",
+    sizeXl: "22px",
+    weightNormal: "400",
+    weightMedium: "500",
+    weightBold: "700",
+    lineHeightTight: "1.2",
+    lineHeightNormal: "1.5"
+  },
+  shadow: {
+    xs: "0 1px 2px rgba(0,0,0,0.4)",
+    sm: "0 2px 6px rgba(0,0,0,0.45)",
+    md: "0 4px 12px rgba(0,0,0,0.5)",
+    lg: "0 10px 24px rgba(0,0,0,0.55)",
+    xl: "0 20px 40px rgba(0,0,0,0.6)",
+    "2xl": "0 28px 56px rgba(0,0,0,0.65)",
+    inner: "inset 0 1px 2px rgba(0,0,0,0.4)"
+  },
+  elevation: { dropdown: 1050, popover: 1060, modal: 1e3, toast: 1200, tooltip: 1100 },
+  motion: {
+    durationFast: "120ms",
+    durationNormal: "200ms",
+    durationSlow: "320ms",
+    easeStandard: "cubic-bezier(0.4, 0, 0.2, 1)",
+    easeEmphasized: "cubic-bezier(0.2, 0, 0, 1)",
+    durationInstant: "0ms"
+  },
+  border: { widthThin: "1px", widthMedium: "1.5px", widthThick: "2px", style: "solid" },
+  effects: { backdropBlur: "0px" }
+});
+
+// src/tokens/themes/glass.ts
+var glass = defineTheme({
+  meta: {
+    name: "glass",
+    label: "Glass",
+    description: "Translucent, softly rounded, floating surfaces. Needs a rich background behind it."
+  },
+  color: {
+    neutral: {
+      0: "#ffffff",
+      50: "#f9fafb",
+      100: "#f3f4f6",
+      200: "#e5e7eb",
+      300: "#d1d5db",
+      400: "#9ca3af",
+      500: "#6b7280",
+      600: "#4b5563",
+      700: "#374151",
+      800: "#1f2937",
+      900: "#111827",
+      950: "#030712"
+    },
+    success: { light: "#d1fae5", subtle: "#a7f3d0", base: "#10b981", dark: "#059669", deeper: "#064e3b" },
+    danger: { light: "#fee2e2", subtle: "#fecaca", base: "#ef4444", dark: "#dc2626", deeper: "#7f1d1d" },
+    warning: { light: "#fef3c7", subtle: "#fde68a", base: "#f59e0b", dark: "#d97706", deeper: "#78350f" },
+    info: { light: "#dbeafe", subtle: "#bfdbfe", base: "#3b82f6", dark: "#2563eb", deeper: "#1e3a5f" },
+    background: "transparent",
+    surface: "rgba(255,255,255,0.55)",
+    surfaceRaised: "rgba(255,255,255,0.75)",
+    // Was rgba(255,255,255,0.35) — translucent WHITE. Composited on
+    // a plain white page (the theme's own meta.description admits it
+    // "needs a rich background behind it," but most consumers won't
+    // add one), that resolves to literal #ffffff — a 1.0:1 contrast
+    // ratio, i.e. actually invisible, which is the reported vanished
+    // Progress-track border. A neutral slate tint stays visible
+    // against both a plain white AND a plain black fallback backdrop
+    // (measured ~2.1-2.3:1 either way) — short of full 3:1 UI-contrast
+    // on both extremes at once, but a large improvement over 1.0, and
+    // still reads as a soft glass edge over an actual rich backdrop.
+    border: "rgba(100,116,139,0.6)",
+    borderFocus: "#9ca3af",
+    text: "#111827",
+    textMuted: "rgba(17,24,39,0.65)",
+    textInverse: "#ffffff"
+  },
+  // Notably rounder than light/dark — this is a shape difference, not just color.
+  radius: { sm: "10px", md: "16px", lg: "22px", xl: "28px", "2xl": "36px", full: "9999px" },
+  spacing: { xs: "4px", sm: "8px", md: "12px", lg: "16px", xl: "24px", "2xl": "32px" },
+  typography: {
+    fontSans: "'Inter', system-ui, sans-serif",
+    fontMono: "'JetBrains Mono', monospace",
+    sizeXs: "12px",
+    sizeSm: "14px",
+    sizeMd: "16px",
+    sizeLg: "18px",
+    sizeXl: "22px",
+    weightNormal: "400",
+    weightMedium: "500",
+    weightBold: "700",
+    lineHeightTight: "1.2",
+    lineHeightNormal: "1.5"
+  },
+  shadow: {
+    xs: "0 2px 8px rgba(0,0,0,0.06)",
+    sm: "0 4px 16px rgba(0,0,0,0.08)",
+    md: "0 8px 32px rgba(0,0,0,0.10)",
+    lg: "0 16px 48px rgba(0,0,0,0.12)",
+    xl: "0 24px 64px rgba(0,0,0,0.14)",
+    "2xl": "0 32px 80px rgba(0,0,0,0.18)",
+    inner: "inset 0 1px 0 rgba(255,255,255,0.4)"
+  },
+  elevation: { dropdown: 1050, popover: 1060, modal: 1e3, toast: 1200, tooltip: 1100 },
+  motion: {
+    // Slightly slower/softer than light/dark — matches "everything floats".
+    durationFast: "160ms",
+    durationNormal: "260ms",
+    durationSlow: "400ms",
+    easeStandard: "cubic-bezier(0.25, 0.1, 0.25, 1)",
+    easeEmphasized: "cubic-bezier(0.16, 1, 0.3, 1)",
+    durationInstant: "0ms"
+  },
+  border: { widthThin: "1px", widthMedium: "1px", widthThick: "1.5px", style: "solid" },
+  effects: { backdropBlur: "16px" }
+});
+
+// src/tokens/themes/dark-glass.ts
+var darkGlass = defineTheme({
+  ...dark,
+  meta: {
+    name: "dark-glass",
+    label: "Dark Glass",
+    description: "Translucent glass panels floating over a dark background."
+  },
+  color: {
+    ...dark.color,
+    background: "#05070d",
+    surface: "rgba(255,255,255,0.06)",
+    surfaceRaised: "rgba(255,255,255,0.10)",
+    border: "rgba(255,255,255,0.12)"
+  },
+  radius: { sm: "10px", md: "16px", lg: "22px", xl: "28px", "2xl": "36px", full: "9999px" },
+  shadow: {
+    xs: "0 2px 8px rgba(0,0,0,0.5)",
+    sm: "0 4px 16px rgba(0,0,0,0.55)",
+    md: "0 8px 32px rgba(0,0,0,0.6)",
+    lg: "0 16px 48px rgba(0,0,0,0.65)",
+    xl: "0 24px 64px rgba(0,0,0,0.7)",
+    "2xl": "0 32px 80px rgba(0,0,0,0.75)",
+    inner: "inset 0 1px 0 rgba(255,255,255,0.08)"
+  },
+  motion: { ...dark.motion, durationFast: "160ms", durationNormal: "260ms", durationSlow: "400ms" },
+  effects: { backdropBlur: "18px" }
+});
+
+// src/tokens/themes/minimalism.ts
+var minimalism = defineTheme({
+  ...light,
+  meta: {
+    name: "minimalism",
+    label: "Minimalism",
+    description: "Reduced to essentials \u2014 thin borders, flat surfaces, no shadow, tight radius."
+  },
+  color: {
+    ...light.color,
+    border: "#e2e2e2",
+    surface: "#ffffff",
+    surfaceRaised: "#ffffff"
+  },
+  radius: { sm: "2px", md: "3px", lg: "4px", xl: "6px", "2xl": "8px", full: "9999px" },
+  shadow: { xs: "none", sm: "none", md: "none", lg: "none", xl: "none", "2xl": "none", inner: "none" },
+  border: { widthThin: "1px", widthMedium: "1px", widthThick: "1px", style: "solid" },
+  effects: { backdropBlur: "0px" }
+});
+
+// src/tokens/themes/brutalism.ts
+var brutalism = defineTheme({
+  ...light,
+  meta: {
+    name: "brutalism",
+    label: "Brutalism",
+    description: "Raw, unstyled web aesthetic \u2014 square corners, zero shadow, monospace type."
+  },
+  color: {
+    ...light.color,
+    background: "#ffffff",
+    surface: "#ffffff",
+    surfaceRaised: "#ffffff",
+    border: "#000000",
+    borderFocus: "#ff0000",
+    text: "#000000"
+  },
+  radius: { sm: "0px", md: "0px", lg: "0px", xl: "0px", "2xl": "0px", full: "0px" },
+  typography: { ...light.typography, fontSans: "'Courier New', monospace", fontMono: "'Courier New', monospace" },
+  shadow: { xs: "none", sm: "none", md: "none", lg: "none", xl: "none", "2xl": "none", inner: "none" },
+  border: { widthThin: "1px", widthMedium: "2px", widthThick: "3px", style: "solid" },
+  motion: { ...light.motion, durationFast: "0ms", durationNormal: "0ms", durationSlow: "0ms" },
+  effects: { backdropBlur: "0px" }
+});
+
+// src/tokens/themes/neobrutalism.ts
+var neobrutalism = defineTheme({
+  ...light,
+  meta: {
+    name: "neobrutalism",
+    label: "Neo Brutalism",
+    description: "Bold black borders, flat offset shadows, saturated color blocks."
+  },
+  color: {
+    ...light.color,
+    background: "#fef3c7",
+    surface: "#ffffff",
+    surfaceRaised: "#ffffff",
+    border: "#000000",
+    borderFocus: "#000000",
+    // light.color.warning.light (#fef3c7) is identical to this
+    // theme's own background — every warning Alert/Badge/etc. was
+    // rendering invisibly on the page. Bumped to the next step in
+    // the same warm-amber family (matches light.color.warning.subtle)
+    // so it stays on-theme but is actually visible against the page.
+    warning: { ...light.color.warning, light: "#fde68a" }
+  },
+  radius: { sm: "4px", md: "6px", lg: "8px", xl: "10px", "2xl": "12px", full: "9999px" },
+  shadow: {
+    xs: "2px 2px 0 #000000",
+    sm: "3px 3px 0 #000000",
+    md: "4px 4px 0 #000000",
+    lg: "6px 6px 0 #000000",
+    xl: "8px 8px 0 #000000",
+    "2xl": "10px 10px 0 #000000",
+    inner: "inset 2px 2px 0 #000000"
+  },
+  border: { widthThin: "2px", widthMedium: "3px", widthThick: "4px", style: "solid" },
+  motion: { ...light.motion, durationFast: "80ms", durationNormal: "140ms", durationSlow: "200ms", easeStandard: "linear", easeEmphasized: "linear" },
+  effects: { backdropBlur: "0px" }
+});
+
+// src/tokens/themes/cyberpunk.ts
+var cyberpunk = defineTheme({
+  ...dark,
+  meta: {
+    name: "cyberpunk",
+    label: "Cyberpunk",
+    description: "Neon-on-black, glowing edges, high-saturation magenta/cyan accents."
+  },
+  color: {
+    ...dark.color,
+    background: "#0a0014",
+    surface: "#12001f",
+    surfaceRaised: "#1a0230",
+    border: "#ff2bd6",
+    borderFocus: "#00f0ff",
+    text: "#e8faff",
+    textMuted: "#9a8cc9"
+  },
+  radius: { sm: "2px", md: "4px", lg: "6px", xl: "8px", "2xl": "10px", full: "9999px" },
+  shadow: {
+    xs: "0 0 6px rgba(255,43,214,0.5)",
+    sm: "0 0 12px rgba(255,43,214,0.55)",
+    md: "0 0 20px rgba(0,240,255,0.5)",
+    lg: "0 0 32px rgba(0,240,255,0.55)",
+    xl: "0 0 48px rgba(255,43,214,0.6)",
+    "2xl": "0 0 64px rgba(0,240,255,0.65)",
+    inner: "inset 0 0 8px rgba(255,43,214,0.4)"
+  },
+  border: { widthThin: "1px", widthMedium: "1.5px", widthThick: "2px", style: "solid" },
+  motion: { ...dark.motion, easeStandard: "cubic-bezier(0.83,0,0.17,1)", easeEmphasized: "cubic-bezier(0.9,0,0.1,1)" },
+  effects: { backdropBlur: "0px" }
+});
+
+// src/tokens/themes/gradient.ts
+var gradient = defineTheme({
+  ...light,
+  meta: {
+    name: "gradient",
+    label: "Gradient",
+    description: "Vibrant, colorful transitions across surfaces and accents."
+  },
+  color: {
+    ...light.color,
+    background: "linear-gradient(135deg, #667eea 0%, #764ba2 100%)",
+    surface: "linear-gradient(135deg, rgba(255,255,255,0.92), rgba(255,255,255,0.75))",
+    surfaceRaised: "#ffffff",
+    border: "rgba(118,75,162,0.25)",
+    borderFocus: "#764ba2",
+    // text/textMuted were still light theme's values (#111827 /
+    // #6b7280) — fine on the near-white `surface`, but components
+    // that render straight on `background` (Timeline, Pagination,
+    // Tabs — all used with no wrapping surface in this library's own
+    // docs examples) sat directly on the purple gradient instead.
+    // Measured contrast against the gradient's darker stop
+    // (#764ba2): text 2.79:1, textMuted a barely-there 1.32:1 — the
+    // reported "nearly invisible" text. Darkened both; textMuted
+    // still can't clear 4.5:1 against the darkest point of this
+    // specific gradient with a single flat color (nothing dark
+    // enough to do that stays legible as "muted" against the near-
+    // white surface too), so this is the best available compromise
+    // within a single global text/textMuted pair, not a full fix —
+    // worth knowing if it still reads as low-contrast on the
+    // darkest corner of the gradient.
+    text: "#000000",
+    textMuted: "#2e2440"
+  },
+  radius: { sm: "12px", md: "18px", lg: "24px", xl: "32px", "2xl": "40px", full: "9999px" },
+  shadow: {
+    xs: "0 2px 10px rgba(118,75,162,0.15)",
+    sm: "0 4px 20px rgba(118,75,162,0.18)",
+    md: "0 8px 30px rgba(118,75,162,0.22)",
+    lg: "0 16px 40px rgba(118,75,162,0.26)",
+    xl: "0 24px 56px rgba(118,75,162,0.3)",
+    "2xl": "0 32px 72px rgba(118,75,162,0.35)",
+    inner: "inset 0 1px 0 rgba(255,255,255,0.5)"
+  },
+  motion: { ...light.motion, durationNormal: "240ms", durationSlow: "380ms" },
+  effects: { backdropBlur: "0px" }
+});
+
+// src/tokens/themes/material.ts
+var material = defineTheme({
+  ...light,
+  meta: {
+    name: "material",
+    label: "Material",
+    description: "Google Material Design-inspired elevation shadows and motion curves."
+  },
+  color: {
+    ...light.color,
+    surface: "#ffffff",
+    background: "#fafafa"
+  },
+  radius: { sm: "4px", md: "8px", lg: "12px", xl: "16px", "2xl": "28px", full: "9999px" },
+  typography: { ...light.typography, fontSans: "'Roboto', system-ui, sans-serif" },
+  shadow: {
+    xs: "0 1px 2px rgba(0,0,0,0.24)",
+    sm: "0 1px 4px rgba(0,0,0,0.2), 0 1px 2px rgba(0,0,0,0.12)",
+    md: "0 3px 6px rgba(0,0,0,0.16), 0 3px 6px rgba(0,0,0,0.23)",
+    lg: "0 10px 20px rgba(0,0,0,0.19), 0 6px 6px rgba(0,0,0,0.23)",
+    xl: "0 14px 28px rgba(0,0,0,0.25), 0 10px 10px rgba(0,0,0,0.22)",
+    "2xl": "0 19px 38px rgba(0,0,0,0.3), 0 15px 12px rgba(0,0,0,0.22)",
+    inner: "inset 0 1px 2px rgba(0,0,0,0.12)"
+  },
+  motion: { ...light.motion, easeStandard: "cubic-bezier(0.4,0,0.2,1)", easeEmphasized: "cubic-bezier(0.0,0,0.2,1)" },
+  effects: { backdropBlur: "0px" }
+});
+
+// src/tokens/themes/skeuomorphism.ts
+var skeuomorphism = defineTheme({
+  ...light,
+  meta: {
+    name: "skeuomorphism",
+    label: "Skeuomorphism",
+    description: "Realistic depth \u2014 soft embossed surfaces mimicking physical material."
+  },
+  color: {
+    ...light.color,
+    background: "#e8e4da",
+    surface: "#f0ece2",
+    surfaceRaised: "#f7f4ec",
+    border: "#c9c2b0",
+    text: "#3a3226"
+  },
+  radius: { sm: "8px", md: "12px", lg: "18px", xl: "24px", "2xl": "32px", full: "9999px" },
+  shadow: {
+    xs: "inset 0 1px 1px rgba(255,255,255,0.8), 0 1px 3px rgba(58,50,38,0.25)",
+    sm: "inset 0 1px 1px rgba(255,255,255,0.8), 0 2px 6px rgba(58,50,38,0.28)",
+    md: "inset 0 1px 1px rgba(255,255,255,0.8), 0 4px 10px rgba(58,50,38,0.3)",
+    lg: "inset 0 1px 1px rgba(255,255,255,0.8), 0 8px 18px rgba(58,50,38,0.32)",
+    xl: "inset 0 1px 1px rgba(255,255,255,0.8), 0 14px 28px rgba(58,50,38,0.35)",
+    "2xl": "inset 0 1px 1px rgba(255,255,255,0.8), 0 20px 40px rgba(58,50,38,0.38)",
+    inner: "inset 0 2px 4px rgba(58,50,38,0.3)"
+  },
+  motion: { ...light.motion, durationNormal: "220ms", easeStandard: "cubic-bezier(0.34,1.56,0.64,1)" },
+  effects: { backdropBlur: "0px" }
+});
+
+// src/tokens/registry.ts
+var registry = /* @__PURE__ */ new Map();
+function assertComplete(theme) {
+  const missing = findMissingTokenPaths(theme);
+  if (missing.length > 0) {
+    throw new Error(
+      `Theme "${theme.meta?.name ?? "unknown"}" is missing/empty required token(s): ${missing.join(", ")}`
+    );
+  }
+}
+function registerTheme(theme) {
+  assertComplete(theme);
+  registry.set(theme.meta.name, theme);
+}
+function getTheme(name) {
+  return registry.get(name);
+}
+function listThemes() {
+  return Array.from(registry.values());
+}
+registerTheme(light);
+registerTheme(dark);
+registerTheme(glass);
+registerTheme(darkGlass);
+registerTheme(minimalism);
+registerTheme(brutalism);
+registerTheme(neobrutalism);
+registerTheme(cyberpunk);
+registerTheme(gradient);
+registerTheme(material);
+registerTheme(skeuomorphism);
+
+// src/tokens/accents/indigo.ts
+var indigo = {
+  name: "indigo",
+  label: "Indigo",
+  scale: {
+    50: "#f0f4ff",
+    100: "#e0e8ff",
+    200: "#c7d5fe",
+    300: "#a5b4fc",
+    400: "#818cf8",
+    500: "#6366f1",
+    600: "#4f46e5",
+    700: "#4338ca",
+    800: "#3730a3",
+    900: "#312e81"
+  }
+};
+
+// src/tokens/accents/violet.ts
+var violet = {
+  name: "violet",
+  label: "Violet",
+  scale: {
+    50: "#faf5ff",
+    100: "#f3e8ff",
+    200: "#e9d5ff",
+    300: "#d8b4fe",
+    400: "#c084fc",
+    500: "#a855f7",
+    600: "#9333ea",
+    700: "#7e22ce",
+    800: "#6b21a8",
+    900: "#581c87"
+  }
+};
+
+// src/tokens/accents/teal.ts
+var teal = {
+  name: "teal",
+  label: "Teal",
+  scale: {
+    50: "#f0fdfa",
+    100: "#ccfbf1",
+    200: "#99f6e4",
+    300: "#5eead4",
+    400: "#2dd4bf",
+    500: "#14b8a6",
+    600: "#0d9488",
+    700: "#0f766e",
+    800: "#115e59",
+    900: "#134e4a"
+  }
+};
+
+// src/tokens/accents/rose.ts
+var rose = {
+  name: "rose",
+  label: "Rose",
+  scale: {
+    50: "#fff1f2",
+    100: "#ffe4e6",
+    200: "#fecdd3",
+    300: "#fda4af",
+    400: "#fb7185",
+    500: "#f43f5e",
+    600: "#e11d48",
+    700: "#be123c",
+    800: "#9f1239",
+    900: "#881337"
+  }
+};
+
+// src/tokens/accents/amber.ts
+var amber = {
+  name: "amber",
+  label: "Amber",
+  scale: {
+    50: "#fffbeb",
+    100: "#fef3c7",
+    200: "#fde68a",
+    300: "#fcd34d",
+    400: "#fbbf24",
+    500: "#f59e0b",
+    600: "#d97706",
+    700: "#b45309",
+    800: "#92400e",
+    900: "#78350f"
+  }
+};
+
+// src/tokens/accents/emerald.ts
+var emerald = {
+  name: "emerald",
+  label: "Emerald",
+  scale: {
+    50: "#ecfdf5",
+    100: "#d1fae5",
+    200: "#a7f3d0",
+    300: "#6ee7b7",
+    400: "#34d399",
+    500: "#10b981",
+    600: "#059669",
+    700: "#047857",
+    800: "#065f46",
+    900: "#064e3b"
+  }
+};
+
+// src/tokens/accents/copper.ts
+var copper = {
+  name: "copper",
+  label: "Copper",
+  scale: {
+    50: "#fdf6ec",
+    100: "#faebd2",
+    200: "#f3d3a0",
+    300: "#e9b56b",
+    400: "#d99a45",
+    500: "#b9752c",
+    600: "#9c5d24",
+    700: "#7d4a1f",
+    800: "#623a1c",
+    900: "#4e2f19"
+  }
+};
+
+// src/tokens/accents/graphite.ts
+var graphite = {
+  name: "graphite",
+  label: "Graphite",
+  scale: {
+    50: "#fafafa",
+    100: "#f0f0f0",
+    200: "#e0e0e0",
+    300: "#c7c7c7",
+    400: "#a3a3a3",
+    500: "#525252",
+    600: "#404040",
+    700: "#262626",
+    800: "#171717",
+    900: "#0a0a0a"
+  }
+};
+
+// src/tokens/accents/magenta.ts
+var magenta = {
+  name: "magenta",
+  label: "Magenta",
+  scale: {
+    50: "#ffe0fb",
+    100: "#ffb3f5",
+    200: "#ff80ee",
+    300: "#ff4de6",
+    400: "#ff26e0",
+    500: "#ff00d9",
+    600: "#e600c4",
+    700: "#cc00af",
+    800: "#b3009a",
+    900: "#800070"
+  }
+};
+
+// src/tokens/accents.ts
+var registry2 = /* @__PURE__ */ new Map();
+function assertCompleteScale(def) {
+  const missing = ["50", "100", "200", "300", "400", "500", "600", "700", "800", "900"].filter(
+    (k) => !def.scale[k]
+  );
+  if (missing.length > 0) {
+    throw new Error(`Accent "${def.name}" is missing scale step(s): ${missing.join(", ")}`);
+  }
+}
+function registerAccent(def) {
+  assertCompleteScale(def);
+  registry2.set(def.name, def);
+}
+function getAccent(name) {
+  return registry2.get(name);
+}
+function listAccents() {
+  return Array.from(registry2.values());
+}
+registerAccent(indigo);
+registerAccent(violet);
+registerAccent(teal);
+registerAccent(rose);
+registerAccent(amber);
+registerAccent(emerald);
+registerAccent(copper);
+registerAccent(graphite);
+registerAccent(magenta);
+var DEFAULT_ACCENT = "indigo";
+
+// src/core/field.ts
+function resolveFieldState(props) {
+  return {
+    // ?? throughout, never || (CONTRACT.md Rule 3) — `error={false}`
+    // or `disabled={false}` must not be silently discarded.
+    isDisabled: props.disabled ?? false,
+    isRequired: props.required ?? false,
+    isInvalid: props.error ?? false,
+    size: props.size ?? "md"
+  };
+}
+function getFieldAriaProps(state, describedBy) {
+  return {
+    "aria-invalid": state.isInvalid ? true : void 0,
+    "aria-required": state.isRequired ? true : void 0,
+    "aria-describedby": describedBy
+  };
+}
+
+// src/core/colorpicker.ts
+var DEFAULT_PRESETS = [
+  "#ef4444",
+  "#f97316",
+  "#f59e0b",
+  "#eab308",
+  "#84cc16",
+  "#22c55e",
+  "#10b981",
+  "#14b8a6",
+  "#06b6d4",
+  "#3b82f6",
+  "#6366f1",
+  "#8b5cf6",
+  "#a855f7",
+  "#d946ef",
+  "#ec4899",
+  "#6b7280",
+  "#171717",
+  "#ffffff"
+];
+function resolveColorPickerState(props) {
+  return {
+    ...resolveFieldState(props),
+    presets: props.presets ?? DEFAULT_PRESETS,
+    variant: props.variant ?? "both"
+  };
+}
+var HEX_RE = /^#?([0-9a-f]{3}|[0-9a-f]{6})$/i;
+function normalizeHex(text) {
+  const trimmed = text.trim();
+  const match = trimmed.match(HEX_RE);
+  if (!match) return null;
+  let hex = match[1].toLowerCase();
+  if (hex.length === 3) {
+    hex = hex.split("").map((c) => c + c).join("");
+  }
+  return `#${hex}`;
+}
+function isSameColor(a, b) {
+  if (!a || !b) return a === b;
+  const na = normalizeHex(a);
+  const nb = normalizeHex(b);
+  return na !== null && na === nb;
+}
+function getSwatchClasses(input) {
+  return [
+    "nx-colorpicker__swatch-option",
+    input.isSelected && "nx-colorpicker__swatch-option--selected",
+    input.isActive && "nx-colorpicker__swatch-option--active"
+  ].filter(Boolean).join(" ");
+}
+function getSwatchGridAriaProps(label) {
+  return { role: "listbox", "aria-label": label };
+}
+function getSwatchAriaProps(input) {
+  return {
+    role: "option",
+    "aria-selected": input.isSelected,
+    "aria-label": input.label,
+    tabIndex: input.isFocusable ? 0 : -1
+  };
+}
+function getFieldTriggerAriaProps(state, describedBy) {
+  return getFieldAriaProps(state, describedBy);
+}
+var COLOR_FORMATS = ["hex", "rgb", "hsl"];
+function clampNum(n, min, max) {
+  return Math.min(Math.max(n, min), max);
+}
+function hexToRgb(hex) {
+  const normalized = normalizeHex(hex);
+  if (!normalized) return null;
+  return {
+    r: parseInt(normalized.slice(1, 3), 16),
+    g: parseInt(normalized.slice(3, 5), 16),
+    b: parseInt(normalized.slice(5, 7), 16)
+  };
+}
+function rgbToHex({ r, g, b }) {
+  const channel = (n) => clampNum(Math.round(n), 0, 255).toString(16).padStart(2, "0");
+  return `#${channel(r)}${channel(g)}${channel(b)}`;
+}
+function rgbToHsv({ r, g, b }) {
+  const rn = r / 255, gn = g / 255, bn = b / 255;
+  const max = Math.max(rn, gn, bn), min = Math.min(rn, gn, bn);
+  const d = max - min;
+  let h = 0;
+  if (d !== 0) {
+    if (max === rn) h = (gn - bn) / d % 6;
+    else if (max === gn) h = (bn - rn) / d + 2;
+    else h = (rn - gn) / d + 4;
+    h *= 60;
+    if (h < 0) h += 360;
+  }
+  const s = max === 0 ? 0 : d / max;
+  return { h, s: s * 100, v: max * 100 };
+}
+function hsvToRgb({ h, s, v }) {
+  const s1 = clampNum(s, 0, 100) / 100;
+  const v1 = clampNum(v, 0, 100) / 100;
+  const hh = (h % 360 + 360) % 360 / 60;
+  const c = v1 * s1;
+  const x = c * (1 - Math.abs(hh % 2 - 1));
+  const m = v1 - c;
+  let [r1, g1, b1] = [0, 0, 0];
+  if (hh < 1) [r1, g1, b1] = [c, x, 0];
+  else if (hh < 2) [r1, g1, b1] = [x, c, 0];
+  else if (hh < 3) [r1, g1, b1] = [0, c, x];
+  else if (hh < 4) [r1, g1, b1] = [0, x, c];
+  else if (hh < 5) [r1, g1, b1] = [x, 0, c];
+  else [r1, g1, b1] = [c, 0, x];
+  return { r: (r1 + m) * 255, g: (g1 + m) * 255, b: (b1 + m) * 255 };
+}
+function rgbToHsl({ r, g, b }) {
+  const rn = r / 255, gn = g / 255, bn = b / 255;
+  const max = Math.max(rn, gn, bn), min = Math.min(rn, gn, bn);
+  const l = (max + min) / 2;
+  const d = max - min;
+  let h = 0, s = 0;
+  if (d !== 0) {
+    s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+    if (max === rn) h = (gn - bn) / d % 6;
+    else if (max === gn) h = (bn - rn) / d + 2;
+    else h = (rn - gn) / d + 4;
+    h *= 60;
+    if (h < 0) h += 360;
+  }
+  return { h, s: s * 100, l: l * 100 };
+}
+function hslToRgb({ h, s, l }) {
+  const s1 = clampNum(s, 0, 100) / 100;
+  const l1 = clampNum(l, 0, 100) / 100;
+  const c = (1 - Math.abs(2 * l1 - 1)) * s1;
+  const hh = (h % 360 + 360) % 360 / 60;
+  const x = c * (1 - Math.abs(hh % 2 - 1));
+  const m = l1 - c / 2;
+  let [r1, g1, b1] = [0, 0, 0];
+  if (hh < 1) [r1, g1, b1] = [c, x, 0];
+  else if (hh < 2) [r1, g1, b1] = [x, c, 0];
+  else if (hh < 3) [r1, g1, b1] = [0, c, x];
+  else if (hh < 4) [r1, g1, b1] = [0, x, c];
+  else if (hh < 5) [r1, g1, b1] = [x, 0, c];
+  else [r1, g1, b1] = [c, 0, x];
+  return { r: (r1 + m) * 255, g: (g1 + m) * 255, b: (b1 + m) * 255 };
+}
+function hexToHsv(hex) {
+  const rgb = hexToRgb(hex);
+  return rgb ? rgbToHsv(rgb) : null;
+}
+function hsvToHex(hsv) {
+  return rgbToHex(hsvToRgb(hsv));
+}
+function hslToHex(hsl) {
+  return rgbToHex(hslToRgb(hsl));
+}
+var RGB_FUNCTION_RE = /^rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*(?:,\s*[\d.]+\s*)?\)$/i;
+var HSL_FUNCTION_RE = /^hsla?\(\s*(-?\d{1,3})\s*,\s*(\d{1,3})%\s*,\s*(\d{1,3})%\s*(?:,\s*[\d.]+\s*)?\)$/i;
+function parseColorInput(text) {
+  const trimmed = text.trim();
+  const hex = normalizeHex(trimmed);
+  if (hex) return hex;
+  const rgbMatch = trimmed.match(RGB_FUNCTION_RE);
+  if (rgbMatch) {
+    const [, r, g, b] = rgbMatch;
+    return rgbToHex({ r: clampNum(Number(r), 0, 255), g: clampNum(Number(g), 0, 255), b: clampNum(Number(b), 0, 255) });
+  }
+  const hslMatch = trimmed.match(HSL_FUNCTION_RE);
+  if (hslMatch) {
+    const [, h, s, l] = hslMatch;
+    return hslToHex({ h: clampNum(Number(h), 0, 360), s: clampNum(Number(s), 0, 100), l: clampNum(Number(l), 0, 100) });
+  }
+  return null;
+}
+function formatColorValue(hex, format) {
+  if (format === "hex") return hex;
+  const rgb = hexToRgb(hex);
+  if (!rgb) return hex;
+  if (format === "rgb") return `rgb(${Math.round(rgb.r)}, ${Math.round(rgb.g)}, ${Math.round(rgb.b)})`;
+  const hsl = rgbToHsl(rgb);
+  return `hsl(${Math.round(hsl.h)}, ${Math.round(hsl.s)}%, ${Math.round(hsl.l)}%)`;
+}
+function getSvKeyboardDelta(key, coarse) {
+  const step = coarse ? 10 : 2;
+  switch (key) {
+    case "ArrowLeft":
+      return { ds: -step, dv: 0 };
+    case "ArrowRight":
+      return { ds: step, dv: 0 };
+    case "ArrowUp":
+      return { ds: 0, dv: step };
+    case "ArrowDown":
+      return { ds: 0, dv: -step };
+    default:
+      return null;
+  }
+}
+function clampPercent(n) {
+  return clampNum(n, 0, 100);
+}
+function getFormatTabClasses(isActive) {
+  return ["nx-colorpicker__format-tab", isActive && "nx-colorpicker__format-tab--active"].filter(Boolean).join(" ");
+}
+function getFormatTablistAriaProps(label) {
+  return { role: "tablist", "aria-label": label };
+}
+function getFormatTabAriaProps(isActive) {
+  return { role: "tab", "aria-selected": isActive, tabIndex: isActive ? 0 : -1 };
+}
+function getSvThumbAriaProps(saturation, value) {
+  return {
+    role: "slider",
+    "aria-label": "Color saturation and brightness",
+    "aria-valuetext": `Saturation ${Math.round(saturation)}%, brightness ${Math.round(value)}%`,
+    tabIndex: 0
+  };
+}
+
+// src/core/table.ts
+function resolveTableState(props) {
+  return {
+    size: props.size ?? "md",
+    striped: props.striped ?? false,
+    bordered: props.bordered ?? false,
+    stickyHeader: props.stickyHeader ?? false
+  };
+}
+function getWrapperClasses(className) {
+  return ["nx-table-wrapper", className].filter(Boolean).join(" ");
+}
+function getTableClasses(state, className) {
+  return [
+    "nx-table",
+    `nx-table--${state.size}`,
+    state.striped && "nx-table--striped",
+    state.bordered && "nx-table--bordered",
+    state.stickyHeader && "nx-table--sticky-header",
+    className
+  ].filter(Boolean).join(" ");
+}
+function getRowClasses(selected, clickable, className) {
+  return [
+    "nx-table__row",
+    selected && "nx-table__row--selected",
+    clickable && "nx-table__row--clickable",
+    className
+  ].filter(Boolean).join(" ");
+}
+function getHeadCellClasses(sortable, className) {
+  return ["nx-table__head-cell", sortable && "nx-table__head-cell--sortable", className].filter(Boolean).join(" ");
+}
+function getCellClasses(className) {
+  return ["nx-table__cell", className].filter(Boolean).join(" ");
+}
+function getNextSortDirection(current) {
+  if (current === null) return "asc";
+  if (current === "asc") return "desc";
+  return null;
+}
+function getSortAriaProps(direction) {
+  return {
+    "aria-sort": direction === "asc" ? "ascending" : direction === "desc" ? "descending" : "none"
+  };
+}
+function getSelectAllState(totalCount, selectedCount) {
+  if (totalCount <= 0 || selectedCount <= 0) return "none";
+  if (selectedCount >= totalCount) return "all";
+  return "some";
+}
+
+// src/core/kanban.ts
+var DRAG_START_THRESHOLD_PX = 4;
+function resolveKanbanState(props) {
+  return { compact: props.compact ?? false };
+}
+function getBoardClasses(state, className) {
+  return ["nx-kanban", state.compact && "nx-kanban--compact", className].filter(Boolean).join(" ");
+}
+function getColumnClasses(isDropTarget, isDragging, className) {
+  return [
+    "nx-kanban__column",
+    isDropTarget && "nx-kanban__column--drop-target",
+    isDragging && "nx-kanban__column--dragging",
+    className
+  ].filter(Boolean).join(" ");
+}
+function getColumnCountClasses(overLimit) {
+  return ["nx-kanban__column-count", overLimit && "nx-kanban__column-count--over-limit"].filter(Boolean).join(" ");
+}
+function getCardWrapperClasses(opts, className) {
+  return [
+    "nx-kanban__card",
+    opts.isPointerDragging && "nx-kanban__card--dragging",
+    opts.isPickedUp && "nx-kanban__card--picked-up",
+    opts.disabled && "nx-kanban__card--disabled",
+    className
+  ].filter(Boolean).join(" ");
+}
+function findCardLocation(value, cardId) {
+  for (const column of value.columns) {
+    const index = column.cardIds.indexOf(cardId);
+    if (index !== -1) return { columnId: column.id, index };
+  }
+  return null;
+}
+function removeCard(value, cardId) {
+  const location = findCardLocation(value, cardId);
+  if (!location) return value;
+  return {
+    columns: value.columns.map(
+      (column) => column.id === location.columnId ? { ...column, cardIds: column.cardIds.filter((id) => id !== cardId) } : column
+    )
+  };
+}
+function moveCard(value, target) {
+  const location = findCardLocation(value, target.cardId);
+  const destExists = value.columns.some((column) => column.id === target.toColumnId);
+  if (!location || !destExists) return value;
+  const withoutCard = value.columns.map(
+    (column) => column.cardIds.includes(target.cardId) ? { ...column, cardIds: column.cardIds.filter((id) => id !== target.cardId) } : column
+  );
+  return {
+    columns: withoutCard.map((column) => {
+      if (column.id !== target.toColumnId) return column;
+      const clampedIndex = Math.max(0, Math.min(target.toIndex, column.cardIds.length));
+      const cardIds = [...column.cardIds];
+      cardIds.splice(clampedIndex, 0, target.cardId);
+      return { ...column, cardIds };
+    })
+  };
+}
+function getAdjacentColumnId(value, columnId, direction) {
+  const index = value.columns.findIndex((column) => column.id === columnId);
+  if (index === -1) return null;
+  return value.columns[index + direction]?.id ?? null;
+}
+function getKeyboardMoveTarget(value, cardId, direction) {
+  const location = findCardLocation(value, cardId);
+  if (!location) return null;
+  const column = value.columns.find((c) => c.id === location.columnId);
+  if (!column) return null;
+  if (direction === "up" || direction === "down") {
+    const toIndex2 = direction === "up" ? location.index - 1 : location.index + 1;
+    if (toIndex2 < 0 || toIndex2 > column.cardIds.length - 1) return null;
+    return { cardId, toColumnId: location.columnId, toIndex: toIndex2 };
+  }
+  const adjacentColumnId = getAdjacentColumnId(value, location.columnId, direction === "prev" ? -1 : 1);
+  if (!adjacentColumnId) return null;
+  const destColumn = value.columns.find((c) => c.id === adjacentColumnId);
+  if (!destColumn) return null;
+  const toIndex = Math.min(location.index, destColumn.cardIds.length);
+  return { cardId, toColumnId: adjacentColumnId, toIndex };
+}
+function computeDropIndex(pointerY, cardRects) {
+  for (let i = 0; i < cardRects.length; i++) {
+    const midpoint = (cardRects[i].top + cardRects[i].bottom) / 2;
+    if (pointerY < midpoint) return i;
+  }
+  return cardRects.length;
+}
+function computeDropColumn(pointerX, pointerY, columns) {
+  for (const column of columns) {
+    if (pointerX >= column.left && pointerX <= column.right && pointerY >= column.top && pointerY <= column.bottom) {
+      return column.id;
+    }
+  }
+  return null;
+}
+function moveColumn(value, target) {
+  const fromIndex = value.columns.findIndex((c) => c.id === target.columnId);
+  if (fromIndex === -1) return value;
+  const columns = [...value.columns];
+  const [moved] = columns.splice(fromIndex, 1);
+  const clampedIndex = Math.max(0, Math.min(target.toIndex, columns.length));
+  columns.splice(clampedIndex, 0, moved);
+  return { columns };
+}
+function removeColumn(value, columnId) {
+  if (!value.columns.some((c) => c.id === columnId)) return value;
+  return { columns: value.columns.filter((c) => c.id !== columnId) };
+}
+function getColumnKeyboardMoveTarget(value, columnId, direction) {
+  const fromIndex = value.columns.findIndex((c) => c.id === columnId);
+  if (fromIndex === -1) return null;
+  const toIndex = direction === "prev" ? fromIndex - 1 : fromIndex + 1;
+  if (toIndex < 0 || toIndex > value.columns.length - 1) return null;
+  return { columnId, toIndex };
+}
+function computeColumnDropIndex(pointerX, columnRects) {
+  for (let i = 0; i < columnRects.length; i++) {
+    const midpoint = (columnRects[i].left + columnRects[i].right) / 2;
+    if (pointerX < midpoint) return i;
+  }
+  return columnRects.length;
+}
+
+// src/core/code-highlight.ts
+function tokenizeFlat(source, grammar) {
+  const tokens = [];
+  const n = source.length;
+  let i = 0;
+  outer: while (i < n) {
+    for (const rule of grammar.rules) {
+      if (rule.pattern) {
+        rule.pattern.lastIndex = i;
+        const m = rule.pattern.exec(source);
+        if (m && m.index === i && m[0].length > 0) {
+          tokens.push({ type: rule.type, content: m[0] });
+          i += m[0].length;
+          continue outer;
+        }
+      } else if (rule.match) {
+        const result = rule.match(source, i, tokens);
+        if (result && result.length > 0) {
+          tokens.push(...result.tokens);
+          i += result.length;
+          continue outer;
+        }
+      }
+    }
+    const ch = source[i];
+    const last = tokens[tokens.length - 1];
+    if (last && last.type === "plain") last.content += ch;
+    else tokens.push({ type: "plain", content: ch });
+    i++;
+  }
+  return tokens;
+}
+function splitIntoLines(tokens) {
+  const lines = [[]];
+  for (const tok of tokens) {
+    const parts = tok.content.split("\n");
+    parts.forEach((part, idx) => {
+      if (part.length > 0) lines[lines.length - 1].push({ type: tok.type, content: part });
+      if (idx < parts.length - 1) lines.push([]);
+    });
+  }
+  return lines;
+}
+var KEYWORD = (words) => new RegExp(`\\b(?:${words})\\b`, "y");
+function matchTemplateLiteral(source, start, jsGrammar2) {
+  if (source[start] !== "`") return null;
+  const tokens = [{ type: "string", content: "`" }];
+  let i = start + 1;
+  let buf = "";
+  const flush = () => {
+    if (buf) {
+      tokens.push({ type: "string", content: buf });
+      buf = "";
+    }
+  };
+  while (i < source.length) {
+    const ch = source[i];
+    if (ch === "\\" && i + 1 < source.length) {
+      buf += ch + source[i + 1];
+      i += 2;
+      continue;
+    }
+    if (ch === "`") {
+      flush();
+      tokens.push({ type: "string", content: "`" });
+      i++;
+      return { length: i - start, tokens };
+    }
+    if (ch === "$" && source[i + 1] === "{") {
+      flush();
+      tokens.push({ type: "punctuation", content: "${" });
+      i += 2;
+      const exprStart = i;
+      let depth = 1;
+      while (i < source.length && depth > 0) {
+        if (source[i] === "{") depth++;
+        else if (source[i] === "}") depth--;
+        if (depth > 0) i++;
+      }
+      const exprSource = source.slice(exprStart, i);
+      tokens.push(...tokenizeFlat(exprSource, jsGrammar2));
+      if (i < source.length) {
+        tokens.push({ type: "punctuation", content: "}" });
+        i++;
+      }
+      continue;
+    }
+    buf += ch;
+    i++;
+  }
+  flush();
+  return { length: i - start, tokens };
+}
+var REGEX_EXPRESSION_KEYWORDS = /* @__PURE__ */ new Set([
+  "return",
+  "typeof",
+  "instanceof",
+  "in",
+  "of",
+  "new",
+  "delete",
+  "void",
+  "throw",
+  "case",
+  "do",
+  "else",
+  "yield",
+  "await"
+]);
+function matchRegexLiteral(source, start) {
+  if (source[start] !== "/" || source[start + 1] === "/" || source[start + 1] === "*") return null;
+  let j = start - 1;
+  while (j >= 0 && /\s/.test(source[j])) j--;
+  if (j >= 0) {
+    const prevChar = source[j];
+    const looksLikeValueEnd = /[)\]}\w$]/.test(prevChar) || prevChar === '"' || prevChar === "'" || prevChar === "`";
+    if (looksLikeValueEnd) {
+      const wordBefore = source.slice(0, j + 1).match(/([A-Za-z_$][\w$]*)$/)?.[1];
+      if (!(wordBefore && REGEX_EXPRESSION_KEYWORDS.has(wordBefore))) return null;
+    }
+  }
+  let i = start + 1;
+  let inClass = false;
+  while (i < source.length) {
+    const ch = source[i];
+    if (ch === "\\") {
+      i += 2;
+      continue;
+    }
+    if (ch === "\n") return null;
+    if (ch === "[") inClass = true;
+    else if (ch === "]") inClass = false;
+    else if (ch === "/" && !inClass) {
+      i++;
+      break;
+    }
+    i++;
+  }
+  if (source[i - 1] !== "/") return null;
+  while (i < source.length && /[a-z]/i.test(source[i])) i++;
+  return { length: i - start, tokens: [{ type: "regex", content: source.slice(start, i) }] };
+}
+function buildJsGrammar(withTags) {
+  const grammar = { rules: [] };
+  const rules = grammar.rules;
+  if (withTags) {
+    rules.push({ type: "tag", pattern: /<\/?[A-Za-z][\w.-]*/y });
+  }
+  rules.push(
+    { type: "comment", pattern: /\/\/[^\n]*|\/\*[\s\S]*?\*\//y },
+    { type: "string", pattern: /"(?:[^"\\\n]|\\.)*"|'(?:[^'\\\n]|\\.)*'/y },
+    { type: "custom-template", match: (src, idx) => matchTemplateLiteral(src, idx, grammar) },
+    { type: "custom-regex", match: (src, idx) => matchRegexLiteral(src, idx) },
+    { type: "decorator", pattern: /@[A-Za-z_$][\w$]*/y },
+    { type: "boolean", pattern: KEYWORD("true|false|null|undefined") },
+    {
+      type: "keyword",
+      pattern: KEYWORD(
+        "const|let|var|function|return|if|else|for|while|do|switch|case|default|break|continue|class|extends|super|new|this|typeof|instanceof|in|of|try|catch|finally|throw|async|await|yield|import|export|from|as|void|delete|static|get|set|interface|type|enum|implements|public|private|protected|readonly|namespace|declare|abstract|is|keyof|infer|satisfies"
+      )
+    },
+    {
+      type: "builtin",
+      pattern: KEYWORD(
+        "console|Math|JSON|Promise|Array|Object|Map|Set|WeakMap|WeakSet|String|Number|Boolean|Symbol|Error|Date|RegExp|Reflect|Proxy|globalThis|Infinity|NaN|BigInt|fetch|localStorage|sessionStorage"
+      )
+    },
+    { type: "number", pattern: /\b0[xX][0-9a-fA-F]+\b|\b\d+\.?\d*(?:[eE][+-]?\d+)?n?\b/y },
+    { type: "function", pattern: /[A-Za-z_$][\w$]*(?=\s*\()/y },
+    { type: "punctuation", pattern: /[{}()[\];,.:?]/y }
+  );
+  return grammar;
+}
+var jsGrammar = buildJsGrammar(false);
+var jsxGrammar = buildJsGrammar(true);
+var jsonGrammar = {
+  rules: [
+    { type: "string", pattern: /"(?:[^"\\\n]|\\.)*"/y },
+    { type: "boolean", pattern: KEYWORD("true|false|null") },
+    { type: "number", pattern: /-?\b\d+\.?\d*(?:[eE][+-]?\d+)?\b/y },
+    { type: "punctuation", pattern: /[{}[\]:,]/y }
+  ]
+};
+var cssGrammar = {
+  rules: [
+    { type: "comment", pattern: /\/\*[\s\S]*?\*\//y },
+    { type: "string", pattern: /"(?:[^"\\\n]|\\.)*"|'(?:[^'\\\n]|\\.)*'/y },
+    { type: "keyword", pattern: /!important\b/y },
+    { type: "atrule", pattern: /@[a-zA-Z-]+/y },
+    // Custom-property declarations/usage (--brand-color, var(--x)) —
+    // checked before the generic hex-color/selector rules below.
+    { type: "variable", pattern: /--[a-zA-Z_][\w-]*/y },
+    { type: "function", pattern: /\b(?:var|calc|rgba?|hsla?|clamp|minmax|repeat|url|translate[XYZ]?|rotate[XYZ]?|scale[XYZ]?|linear-gradient|radial-gradient)(?=\()/y },
+    // Pseudo-classes/elements (:hover, ::before) before the plain ":" punctuation.
+    { type: "pseudo", pattern: /::?[a-zA-Z-]+/y },
+    // Hex colors before the generic "#name" id-selector pattern below.
+    { type: "builtin", pattern: /#[0-9a-fA-F]{3,8}\b/y },
+    { type: "selector", pattern: /[.#][a-zA-Z_-][\w-]*/y },
+    { type: "property", pattern: /[a-zA-Z-]+(?=\s*:)/y },
+    { type: "number", pattern: /-?\d+\.?\d*(?:px|em|rem|%|vh|vw|s|ms|deg|fr)?\b/y },
+    { type: "punctuation", pattern: /[{}:;,()]/y }
+  ]
+};
+var htmlGrammar = {
+  rules: [
+    { type: "comment", pattern: /<!--[\s\S]*?-->/y },
+    { type: "keyword", pattern: /<!DOCTYPE[^>]*>/iy },
+    { type: "tag", pattern: /<\/?[a-zA-Z][\w:-]*/y },
+    { type: "attrName", pattern: /[a-zA-Z-]+(?=\s*=)/y },
+    { type: "string", pattern: /"(?:[^"\\\n]|\\.)*"|'(?:[^'\\\n]|\\.)*'/y },
+    { type: "builtin", pattern: /&[a-zA-Z#0-9]+;/y },
+    { type: "punctuation", pattern: /[<>=/]/y }
+  ]
+};
+var bashGrammar = {
+  rules: [
+    { type: "comment", pattern: /#[^\n]*/y },
+    { type: "string", pattern: /"(?:[^"\\\n]|\\.)*"|'[^'\n]*'/y },
+    { type: "variable", pattern: /\$\{?\w+\}?/y },
+    {
+      type: "keyword",
+      pattern: KEYWORD(
+        "if|then|else|elif|fi|for|do|done|while|case|esac|function|return|exit|export|local|echo|cd|sudo|npm|yarn|pnpm|git|mkdir|rm|cp|mv|cat|grep|sed|awk"
+      )
+    },
+    { type: "number", pattern: /\b\d+\b/y },
+    { type: "function", pattern: /(?<=^|\s)--?[a-zA-Z][\w-]*/y },
+    { type: "punctuation", pattern: /[|&;()]/y }
+  ]
+};
+var pythonGrammar = {
+  rules: [
+    { type: "comment", pattern: /#[^\n]*/y },
+    { type: "decorator", pattern: /@[A-Za-z_][\w.]*/y },
+    {
+      // f/r/b/u string prefixes (f"...", rb'...', etc.) before plain strings.
+      type: "string",
+      pattern: /[rRbBfFuU]{0,2}(?:"""[\s\S]*?"""|'''[\s\S]*?'''|"(?:[^"\\\n]|\\.)*"|'(?:[^'\\\n]|\\.)*')/y
+    },
+    { type: "boolean", pattern: KEYWORD("True|False|None") },
+    {
+      type: "keyword",
+      pattern: KEYWORD(
+        "def|return|if|elif|else|for|while|in|not|and|or|is|import|from|as|class|try|except|finally|raise|with|lambda|yield|pass|break|continue|global|nonlocal|assert|del|async|await|self"
+      )
+    },
+    { type: "builtin", pattern: KEYWORD("print|len|range|str|int|float|list|dict|set|tuple|type|isinstance|super|open|input|enumerate|zip|map|filter|sorted|sum|min|max|any|all") },
+    { type: "number", pattern: /\b\d+\.?\d*\b/y },
+    { type: "function", pattern: /[A-Za-z_]\w*(?=\s*\()/y },
+    { type: "punctuation", pattern: /[:,.()[\]{}]/y }
+  ]
+};
+var markdownGrammar = {
+  rules: [
+    { type: "comment", pattern: /```[\s\S]*?```/y },
+    { type: "keyword", pattern: /^#{1,6}[^\n]*/my },
+    { type: "punctuation", pattern: /^(?:-{3,}|\*{3,}|_{3,})$/my },
+    { type: "function", pattern: /`[^`\n]+`/y },
+    { type: "builtin", pattern: /\*\*[^*\n]+\*\*/y },
+    { type: "variable", pattern: /~~[^~\n]+~~/y },
+    { type: "string", pattern: /\*[^*\n]+\*/y },
+    { type: "tag", pattern: /!?\[[^\]\n]*\]\([^)\n]*\)/y },
+    { type: "punctuation", pattern: /^[-*+]\s|^\d+\.\s/my }
+  ]
+};
+var yamlGrammar = {
+  rules: [
+    { type: "comment", pattern: /#[^\n]*/y },
+    { type: "property", pattern: /^[ \t]*[\w.-]+(?=\s*:)/my },
+    { type: "string", pattern: /"(?:[^"\\\n]|\\.)*"|'[^'\n]*'/y },
+    { type: "boolean", pattern: KEYWORD("true|false|null|yes|no|on|off|True|False|Null") },
+    { type: "number", pattern: /-?\b\d+\.?\d*\b/y },
+    { type: "variable", pattern: /[&*][\w-]+/y },
+    { type: "punctuation", pattern: /[:\-[\]{},]/y }
+  ]
+};
+var sqlGrammar = {
+  rules: [
+    { type: "comment", pattern: /--[^\n]*|\/\*[\s\S]*?\*\//y },
+    { type: "string", pattern: /'(?:[^'\\\n]|\\.)*'/y },
+    {
+      type: "keyword",
+      pattern: new RegExp(
+        "\\b(?:SELECT|FROM|WHERE|INSERT|INTO|VALUES|UPDATE|SET|DELETE|CREATE|TABLE|ALTER|DROP|JOIN|INNER|LEFT|RIGHT|OUTER|ON|GROUP|BY|ORDER|HAVING|LIMIT|OFFSET|AS|AND|OR|NOT|NULL|IS|IN|LIKE|BETWEEN|DISTINCT|UNION|ALL|EXISTS|CASE|WHEN|THEN|ELSE|END|PRIMARY|KEY|FOREIGN|REFERENCES|DEFAULT|CONSTRAINT|INDEX|VIEW|WITH)\\b",
+        "iy"
+      )
+    },
+    { type: "number", pattern: /\b\d+\.?\d*\b/y },
+    { type: "function", pattern: /\b[A-Za-z_]\w*(?=\s*\()/y },
+    { type: "punctuation", pattern: /[(),;.*=<>!]/y }
+  ]
+};
+var GRAMMARS = {
+  javascript: jsGrammar,
+  typescript: jsGrammar,
+  jsx: jsxGrammar,
+  tsx: jsxGrammar,
+  json: jsonGrammar,
+  css: cssGrammar,
+  html: htmlGrammar,
+  bash: bashGrammar,
+  python: pythonGrammar,
+  markdown: markdownGrammar,
+  yaml: yamlGrammar,
+  sql: sqlGrammar
+};
+var ALIASES = {
+  js: "javascript",
+  mjs: "javascript",
+  cjs: "javascript",
+  ts: "typescript",
+  sh: "bash",
+  shell: "bash",
+  zsh: "bash",
+  py: "python",
+  md: "markdown",
+  htm: "html",
+  yml: "yaml"
+};
+var LANGUAGE_LABELS = {
+  javascript: "JavaScript",
+  typescript: "TypeScript",
+  jsx: "JSX",
+  tsx: "TSX",
+  json: "JSON",
+  css: "CSS",
+  html: "HTML",
+  bash: "Shell",
+  python: "Python",
+  markdown: "Markdown",
+  yaml: "YAML",
+  sql: "SQL",
+  plaintext: "Plain text"
+};
+function normalizeLanguage(language) {
+  const lower = language.trim().toLowerCase();
+  return ALIASES[lower] ?? lower;
+}
+var nuvoxHighlight = (code, language) => {
+  const key = normalizeLanguage(language ?? "plaintext");
+  const grammar = GRAMMARS[key];
+  if (!grammar) return splitIntoLines([{ type: "plain", content: code }]);
+  try {
+    return splitIntoLines(tokenizeFlat(code, grammar));
+  } catch {
+    return splitIntoLines([{ type: "plain", content: code }]);
+  }
+};
+
+// src/core/rich-text.ts
+var MARK_TAGS = {
+  bold: "STRONG",
+  italic: "EM",
+  underline: "U",
+  strike: "S",
+  code: "CODE"
+};
+var BLOCK_TAGS = {
+  paragraph: "P",
+  h1: "H1",
+  h2: "H2",
+  h3: "H3",
+  blockquote: "BLOCKQUOTE",
+  bulletList: "UL",
+  orderedList: "OL"
+};
+var BLOCK_TAG_NAMES = /* @__PURE__ */ new Set(["P", "H1", "H2", "H3", "BLOCKQUOTE", "DIV"]);
+function isMark(command) {
+  return command in MARK_TAGS;
+}
+function isBlock(command) {
+  return command in BLOCK_TAGS;
+}
+function isCommandActive(ancestorTags, command) {
+  if (command === "link") return ancestorTags.includes("A");
+  if (command === "unlink") return false;
+  if (isMark(command)) return ancestorTags.includes(MARK_TAGS[command]);
+  if (isBlock(command)) return ancestorTags.includes(BLOCK_TAGS[command]);
+  return false;
+}
+function closestWithinRoot(node, tag, root) {
+  let n = node;
+  while (n && n !== root) {
+    if (n.nodeType === Node.ELEMENT_NODE && n.tagName === tag) return n;
+    n = n.parentNode;
+  }
+  return null;
+}
+function closestBlock(node, root) {
+  let n = node && node.nodeType === Node.ELEMENT_NODE ? node : node?.parentNode ?? null;
+  while (n && n !== root) {
+    if (n.nodeType === Node.ELEMENT_NODE && BLOCK_TAG_NAMES.has(n.tagName)) return n;
+    n = n.parentNode;
+  }
+  return null;
+}
+function unwrapElement(el) {
+  const parent = el.parentNode;
+  if (!parent) return;
+  while (el.firstChild) parent.insertBefore(el.firstChild, el);
+  parent.removeChild(el);
+}
+function replaceTag(el, tag) {
+  const next = document.createElement(tag);
+  while (el.firstChild) next.appendChild(el.firstChild);
+  el.parentNode?.replaceChild(next, el);
+  return next;
+}
+function selectNodeContents(node, collapseToEnd = false) {
+  const sel = window.getSelection();
+  if (!sel) return;
+  const range = document.createRange();
+  range.selectNodeContents(node);
+  if (collapseToEnd) range.collapse(false);
+  sel.removeAllRanges();
+  sel.addRange(range);
+}
+var ZERO_WIDTH_SPACE = "\u200B";
+function selectAtMarker(sel, marker, offset) {
+  const range = document.createRange();
+  range.setStart(marker, offset);
+  range.collapse(true);
+  sel.removeAllRanges();
+  sel.addRange(range);
+}
+function togglePendingMark(root, tag) {
+  const sel = window.getSelection();
+  if (!sel || sel.rangeCount === 0) return;
+  const range = sel.getRangeAt(0);
+  const existing = closestWithinRoot(range.startContainer, tag, root);
+  if (existing) {
+    const marker2 = document.createTextNode(ZERO_WIDTH_SPACE);
+    existing.parentNode?.insertBefore(marker2, existing.nextSibling);
+    selectAtMarker(sel, marker2, 1);
+    return;
+  }
+  const wrapper = document.createElement(tag);
+  const marker = document.createTextNode(ZERO_WIDTH_SPACE);
+  wrapper.appendChild(marker);
+  range.insertNode(wrapper);
+  selectAtMarker(sel, marker, 1);
+}
+function toggleMark(root, tag) {
+  const sel = window.getSelection();
+  if (!sel || sel.rangeCount === 0) return;
+  if (sel.isCollapsed) {
+    togglePendingMark(root, tag);
+    return;
+  }
+  const range = sel.getRangeAt(0);
+  const existing = closestWithinRoot(range.commonAncestorContainer, tag, root);
+  if (existing) {
+    unwrapElement(existing);
+    return;
+  }
+  const wrapper = document.createElement(tag);
+  wrapper.appendChild(range.extractContents());
+  range.insertNode(wrapper);
+  selectNodeContents(wrapper);
+}
+function restoreSelection(range) {
+  const sel = window.getSelection();
+  if (!sel) return;
+  sel.removeAllRanges();
+  sel.addRange(range);
+}
+function stripEmptyMarkers(root) {
+  const isRootFocused = typeof document !== "undefined" && root.contains(document.activeElement);
+  const sel = isRootFocused ? window.getSelection() : null;
+  const caretNode = sel && sel.rangeCount > 0 ? sel.getRangeAt(0).startContainer : null;
+  const candidateTags = [...Object.values(MARK_TAGS), "SPAN"];
+  let changed = false;
+  for (const tag of candidateTags) {
+    for (const el of Array.from(root.getElementsByTagName(tag))) {
+      if (el.textContent === ZERO_WIDTH_SPACE && !(caretNode && el.contains(caretNode))) {
+        el.remove();
+        changed = true;
+      }
+    }
+  }
+  return changed;
+}
+function setBlockTag(root, targetTag) {
+  const sel = window.getSelection();
+  if (!sel || sel.rangeCount === 0) return;
+  const block = closestBlock(sel.getRangeAt(0).startContainer, root);
+  if (!block) return;
+  const next = replaceTag(block, block.tagName === targetTag ? "P" : targetTag);
+  selectNodeContents(next, true);
+}
+function toggleList(root, listTag) {
+  const sel = window.getSelection();
+  if (!sel || sel.rangeCount === 0) return;
+  const range = sel.getRangeAt(0);
+  const li = closestWithinRoot(range.startContainer, "LI", root);
+  if (li && li.parentElement?.tagName === listTag) {
+    const list2 = li.parentElement;
+    const p = document.createElement("P");
+    while (li.firstChild) p.appendChild(li.firstChild);
+    list2.parentNode?.replaceChild(p, list2);
+    selectNodeContents(p, true);
+    return;
+  }
+  const block = closestBlock(range.startContainer, root);
+  if (!block) return;
+  const list = document.createElement(listTag);
+  const item = document.createElement("LI");
+  while (block.firstChild) item.appendChild(block.firstChild);
+  list.appendChild(item);
+  block.parentNode?.replaceChild(list, block);
+  selectNodeContents(item, true);
+}
+function setLink(root, url) {
+  const sel = window.getSelection();
+  if (!sel || sel.rangeCount === 0 || sel.isCollapsed) return;
+  const range = sel.getRangeAt(0);
+  const existing = closestWithinRoot(range.commonAncestorContainer, "A", root);
+  if (existing) {
+    existing.setAttribute("href", url);
+    return;
+  }
+  const a = document.createElement("A");
+  a.setAttribute("href", url);
+  a.setAttribute("rel", "noopener noreferrer");
+  a.appendChild(range.extractContents());
+  range.insertNode(a);
+  selectNodeContents(a);
+}
+function unlink(root) {
+  const sel = window.getSelection();
+  if (!sel || sel.rangeCount === 0) return;
+  const a = closestWithinRoot(sel.getRangeAt(0).commonAncestorContainer, "A", root);
+  if (a) unwrapElement(a);
+}
+function findStyledSpanWithinRoot(node, property, root) {
+  let n = node;
+  while (n && n !== root) {
+    if (n.nodeType === Node.ELEMENT_NODE) {
+      const el = n;
+      if (el.tagName === "SPAN" && el.style.getPropertyValue(property)) return el;
+    }
+    n = n.parentNode;
+  }
+  return null;
+}
+function setInlineStyle(root, property, value) {
+  const sel = window.getSelection();
+  if (!sel || sel.rangeCount === 0) return;
+  const range = sel.getRangeAt(0);
+  if (sel.isCollapsed) {
+    const existing2 = findStyledSpanWithinRoot(range.startContainer, property, root);
+    if (existing2) {
+      existing2.style.setProperty(property, value);
+      return;
+    }
+    const wrapper2 = document.createElement("span");
+    wrapper2.style.setProperty(property, value);
+    const marker = document.createTextNode(ZERO_WIDTH_SPACE);
+    wrapper2.appendChild(marker);
+    range.insertNode(wrapper2);
+    selectAtMarker(sel, marker, 1);
+    return;
+  }
+  const existing = findStyledSpanWithinRoot(range.commonAncestorContainer, property, root);
+  if (existing) {
+    existing.style.setProperty(property, value);
+    return;
+  }
+  const wrapper = document.createElement("span");
+  wrapper.style.setProperty(property, value);
+  wrapper.appendChild(range.extractContents());
+  range.insertNode(wrapper);
+  selectNodeContents(wrapper);
+}
+function clearInlineStyle(root, property) {
+  const sel = window.getSelection();
+  if (!sel || sel.rangeCount === 0) return;
+  const el = findStyledSpanWithinRoot(sel.getRangeAt(0).commonAncestorContainer, property, root);
+  if (!el) return;
+  el.style.removeProperty(property);
+  if (!el.getAttribute("style")) unwrapElement(el);
+}
+function execRichTextCommand(root, command, value) {
+  if (isMark(command)) toggleMark(root, MARK_TAGS[command]);
+  else if (command === "bulletList") toggleList(root, "UL");
+  else if (command === "orderedList") toggleList(root, "OL");
+  else if (isBlock(command)) setBlockTag(root, BLOCK_TAGS[command]);
+  else if (command === "link" && value) setLink(root, value);
+  else if (command === "unlink") unlink(root);
+  else if (command === "textColor" && value) setInlineStyle(root, "color", value);
+  else if (command === "clearTextColor") clearInlineStyle(root, "color");
+  else if (command === "highlight" && value) setInlineStyle(root, "background-color", value);
+  else if (command === "clearHighlight") clearInlineStyle(root, "background-color");
+}
+function getActiveCommands(root) {
+  const result = /* @__PURE__ */ new Set();
+  if (typeof window === "undefined") return result;
+  const sel = window.getSelection();
+  if (!sel || sel.rangeCount === 0) return result;
+  const tags = [];
+  let node = sel.anchorNode;
+  while (node && node !== root) {
+    if (node.nodeType === Node.ELEMENT_NODE) tags.push(node.tagName);
+    node = node.parentNode;
+  }
+  const commands = [...Object.keys(MARK_TAGS), ...Object.keys(BLOCK_TAGS), "link"];
+  for (const command of commands) {
+    if (isCommandActive(tags, command)) result.add(command);
+  }
+  return result;
+}
+var ALLOWED_TAGS = /* @__PURE__ */ new Set([
+  "P",
+  "BR",
+  "STRONG",
+  "B",
+  "EM",
+  "I",
+  "U",
+  "S",
+  "STRIKE",
+  "CODE",
+  "A",
+  "H1",
+  "H2",
+  "H3",
+  "BLOCKQUOTE",
+  "UL",
+  "OL",
+  "LI",
+  "SPAN"
+]);
+var ALLOWED_ATTRS = {
+  A: ["href"],
+  SPAN: ["style"]
+};
+var ALLOWED_STYLE_PROPS = /* @__PURE__ */ new Set(["color", "background-color"]);
+var SAFE_COLOR_VALUE = /^(#[0-9a-fA-F]{3,8}|rgb\(\s*\d+\s*,\s*\d+\s*,\s*\d+\s*\)|rgba\(\s*\d+\s*,\s*\d+\s*,\s*\d+\s*,\s*[\d.]+\s*\)|hsl\([^();]*\)|hsla\([^();]*\)|[a-zA-Z]+)$/;
+function sanitizeStyleAttr(value) {
+  const out = [];
+  for (const decl of value.split(";")) {
+    const colon = decl.indexOf(":");
+    if (colon === -1) continue;
+    const prop = decl.slice(0, colon).trim().toLowerCase();
+    const val = decl.slice(colon + 1).trim();
+    if (ALLOWED_STYLE_PROPS.has(prop) && SAFE_COLOR_VALUE.test(val)) {
+      out.push(`${prop}: ${val}`);
+    }
+  }
+  return out.join("; ");
+}
+var STRIP_ENTIRELY = /* @__PURE__ */ new Set(["SCRIPT", "STYLE", "IFRAME", "OBJECT", "EMBED"]);
+function sanitizeElement(el) {
+  for (const child of Array.from(el.childNodes)) {
+    if (child.nodeType === Node.TEXT_NODE) continue;
+    if (child.nodeType !== Node.ELEMENT_NODE) {
+      child.parentNode?.removeChild(child);
+      continue;
+    }
+    const childEl = child;
+    if (STRIP_ENTIRELY.has(childEl.tagName)) {
+      childEl.parentNode?.removeChild(childEl);
+      continue;
+    }
+    if (!ALLOWED_TAGS.has(childEl.tagName)) {
+      sanitizeElement(childEl);
+      const parent = childEl.parentNode;
+      while (childEl.firstChild) parent?.insertBefore(childEl.firstChild, childEl);
+      parent?.removeChild(childEl);
+      continue;
+    }
+    const allowedAttrs = ALLOWED_ATTRS[childEl.tagName] ?? [];
+    for (const attr of Array.from(childEl.attributes)) {
+      const name = attr.name.toLowerCase();
+      if (!allowedAttrs.includes(name)) {
+        childEl.removeAttribute(attr.name);
+        continue;
+      }
+      if (name === "style") {
+        const cleaned = sanitizeStyleAttr(attr.value);
+        if (cleaned) childEl.setAttribute("style", cleaned);
+        else childEl.removeAttribute("style");
+      }
+    }
+    if (childEl.tagName === "A") {
+      const href = childEl.getAttribute("href") ?? "";
+      const safe = /^https?:\/\//i.test(href) || href.startsWith("/") || href.startsWith("#") || href.startsWith("mailto:");
+      if (!safe) childEl.removeAttribute("href");
+      childEl.setAttribute("rel", "noopener noreferrer");
+      childEl.setAttribute("target", "_blank");
+    }
+    sanitizeElement(childEl);
+  }
+}
+function sanitizeHtml(html) {
+  if (typeof DOMParser === "undefined") return "";
+  const doc = new DOMParser().parseFromString(html, "text/html");
+  sanitizeElement(doc.body);
+  return doc.body.innerHTML;
+}
+var HISTORY_LIMIT = 100;
+function createHistory() {
+  return { past: [], future: [] };
+}
+function pushHistory(history, previousValue) {
+  return { past: [...history.past, previousValue].slice(-HISTORY_LIMIT), future: [] };
+}
+function undoHistory(history, currentValue) {
+  if (history.past.length === 0) return null;
+  const value = history.past[history.past.length - 1];
+  return {
+    history: { past: history.past.slice(0, -1), future: [currentValue, ...history.future] },
+    value
+  };
+}
+function redoHistory(history, currentValue) {
+  if (history.future.length === 0) return null;
+  const value = history.future[0];
+  return {
+    history: { past: [...history.past, currentValue], future: history.future.slice(1) },
+    value
+  };
+}
+function resolveRichTextEditorState(props) {
+  return {
+    isDisabled: props.disabled ?? false,
+    isReadOnly: props.readOnly ?? false,
+    placeholder: props.placeholder ?? "",
+    size: props.size ?? "md"
+  };
+}
+function getRichTextEditorClasses(state) {
+  return [
+    "nx-rich-text",
+    `nx-rich-text--${state.size}`,
+    state.isDisabled && "nx-rich-text--disabled",
+    state.isReadOnly && "nx-rich-text--readonly"
+  ].filter(Boolean).join(" ");
+}
+
+// src/core/gallery.ts
+function resolveGalleryState(props) {
+  return {
+    layout: props.layout ?? "grid",
+    columns: props.columns ?? 3,
+    gap: props.gap,
+    targetRowHeight: props.targetRowHeight ?? 220
+  };
+}
+function getGalleryClasses(state, className) {
+  return ["nx-gallery", `nx-gallery--${state.layout}`, className].filter(Boolean).join(" ");
+}
+function getGalleryStyle(state) {
+  const style = {};
+  if (state.gap) style.gap = state.gap;
+  if (state.layout === "grid" || state.layout === "masonry") {
+    style["--nx-gallery-columns"] = String(state.columns);
+  }
+  return style;
+}
+function aspectRatioFromDims(width, height) {
+  if (!width || !height || width <= 0 || height <= 0) return 1;
+  return width / height;
+}
+function computeJustifiedRows(aspectRatios, containerWidth, targetRowHeight, gap) {
+  if (aspectRatios.length === 0 || containerWidth <= 0 || targetRowHeight <= 0) return [];
+  const rows = [];
+  let rowIndices = [];
+  let rowNaturalWidths = [];
+  let rowWidthSum = 0;
+  function flushRow(scale) {
+    if (rowIndices.length === 0) return;
+    const gapsWidth = gap * (rowIndices.length - 1);
+    const availableWidth = containerWidth - gapsWidth;
+    const naturalTotal = rowWidthSum;
+    const scaleFactor = scale ? availableWidth / naturalTotal : 1;
+    rows.push({
+      indices: rowIndices,
+      height: targetRowHeight * scaleFactor,
+      widths: rowNaturalWidths.map((w) => w * scaleFactor)
+    });
+    rowIndices = [];
+    rowNaturalWidths = [];
+    rowWidthSum = 0;
+  }
+  for (let i = 0; i < aspectRatios.length; i++) {
+    const naturalWidth = aspectRatios[i] * targetRowHeight;
+    const gapsWidth = gap * rowIndices.length;
+    if (rowIndices.length > 0 && rowWidthSum + naturalWidth + gapsWidth > containerWidth) {
+      flushRow(true);
+    }
+    rowIndices.push(i);
+    rowNaturalWidths.push(naturalWidth);
+    rowWidthSum += naturalWidth;
+  }
+  const finalGapsWidth = gap * (rowIndices.length - 1);
+  const overflows = rowWidthSum + finalGapsWidth > containerWidth;
+  flushRow(overflows);
+  return rows;
+}
+
+// src/core/slider.ts
+function isRangeValue(value) {
+  return Array.isArray(value);
+}
+function toThumbs(value) {
+  return isRangeValue(value) ? [value[0], value[1]] : [value];
+}
+function fromThumbs(thumbs, like) {
+  return isRangeValue(like) ? [thumbs[0], thumbs[1]] : thumbs[0];
+}
+function resolveSliderState(props) {
+  return {
+    // ?? not || (CONTRACT.md Rule 3) — an explicit min={0} must not
+    // be discarded (it already is the default, but a future
+    // negative-range default would make this the exact bug Rule 3
+    // guards against).
+    min: props.min ?? 0,
+    max: props.max ?? 100,
+    step: props.step ?? 1,
+    isDisabled: props.disabled ?? false,
+    size: props.size ?? "md"
+  };
+}
+function clampAndSnap(value, state) {
+  const { min, max, step } = state;
+  const clamped = Math.min(Math.max(value, min), max);
+  if (step <= 0) return clamped;
+  const steps = Math.round((clamped - min) / step);
+  const snapped = min + steps * step;
+  return Math.min(Math.max(snapped, min), max);
+}
+function valueToPercent(value, min, max) {
+  if (max === min) return 0;
+  return (value - min) / (max - min) * 100;
+}
+function percentToValue(percent, min, max) {
+  return min + percent / 100 * (max - min);
+}
+function clampRangeThumb(thumbs, index, next, minGap = 0) {
+  if (index === 0) return Math.min(next, thumbs[1] - minGap);
+  return Math.max(next, thumbs[0] + minGap);
+}
+function nearestThumbIndex(thumbs, targetValue) {
+  const distLow = Math.abs(thumbs[0] - targetValue);
+  const distHigh = Math.abs(thumbs[1] - targetValue);
+  return distHigh < distLow ? 1 : 0;
+}
+var STEP_KEYS_UP = /* @__PURE__ */ new Set(["ArrowRight", "ArrowUp"]);
+var STEP_KEYS_DOWN = /* @__PURE__ */ new Set(["ArrowLeft", "ArrowDown"]);
+function getKeyboardValue(key, current, state) {
+  const bigStep = Math.min(state.step * 10, state.max - state.min);
+  if (STEP_KEYS_UP.has(key)) return clampAndSnap(current + state.step, state);
+  if (STEP_KEYS_DOWN.has(key)) return clampAndSnap(current - state.step, state);
+  if (key === "PageUp") return clampAndSnap(current + bigStep, state);
+  if (key === "PageDown") return clampAndSnap(current - bigStep, state);
+  if (key === "Home") return state.min;
+  if (key === "End") return state.max;
+  return null;
+}
+function getRootClasses(state, isRange, showValueLabel, className) {
+  return [
+    "nx-slider",
+    `nx-slider--${state.size}`,
+    isRange && "nx-slider--range",
+    state.isDisabled && "nx-slider--disabled",
+    // The value-label bubble floats above the thumb (see
+    // Slider.css) — with no room reserved for it, it overflows
+    // .nx-slider's own box and lands on whatever's above it in
+    // .nx-field, which for a slider with a `label` is the label
+    // text itself. This adds the top margin the bubble actually
+    // needs instead of relying on .nx-field's generic 4px gap.
+    showValueLabel && "nx-slider--with-value-label",
+    className
+  ].filter(Boolean).join(" ");
+}
+function getThumbAriaProps(input) {
+  return {
+    role: "slider",
+    "aria-valuemin": input.min,
+    "aria-valuemax": input.max,
+    "aria-valuenow": input.value,
+    "aria-valuetext": input.valueText,
+    "aria-orientation": "horizontal",
+    "aria-disabled": input.isDisabled || void 0,
+    "aria-labelledby": input.labelledBy,
+    tabIndex: input.isDisabled ? -1 : 0
+  };
+}
+
+// src/core/media.ts
+var PLAYBACK_RATES = [0.5, 0.75, 1, 1.25, 1.5, 1.75, 2];
+function formatMediaTime(seconds) {
+  if (!Number.isFinite(seconds) || seconds < 0) return "0:00";
+  const total = Math.floor(seconds);
+  const h = Math.floor(total / 3600);
+  const m = Math.floor(total % 3600 / 60);
+  const s = total % 60;
+  const paddedS = String(s).padStart(2, "0");
+  if (h > 0) return `${h}:${String(m).padStart(2, "0")}:${paddedS}`;
+  return `${m}:${paddedS}`;
+}
+function clampVolume(volume) {
+  return clampAndSnap(volume, { min: 0, max: 1, step: 0 });
+}
+function positionToTime(clientX, trackRect, duration) {
+  if (trackRect.width <= 0 || !Number.isFinite(duration) || duration <= 0) return 0;
+  const rawPercent = (clientX - trackRect.left) / trackRect.width * 100;
+  const percent = clampAndSnap(rawPercent, { min: 0, max: 100, step: 0 });
+  return percentToValue(percent, 0, duration);
+}
+function positionToRatio(clientX, trackRect) {
+  return clampVolume(positionToTime(clientX, trackRect, 1));
+}
+function getBufferedPercent(bufferedEnd, duration) {
+  if (!Number.isFinite(duration) || duration <= 0) return 0;
+  return clampAndSnap(bufferedEnd / duration * 100, { min: 0, max: 100, step: 0 });
+}
+function getProgressPercent(currentTime, duration) {
+  return getBufferedPercent(currentTime, duration);
+}
+function recoverDuration(media, restoreTo, onDuration, giveUpMs = 4e3, pollMs = 100) {
+  function isKnown(duration) {
+    return Number.isFinite(duration) && duration > 0;
+  }
+  if (isKnown(media.duration)) {
+    onDuration(media.duration);
+    return () => {
+    };
+  }
+  let settled = false;
+  let pollHandle;
+  let giveUpHandle;
+  function cleanup() {
+    media.removeEventListener("timeupdate", handleResolved);
+    media.removeEventListener("seeked", handleResolved);
+    media.removeEventListener("durationchange", handleResolved);
+    media.removeEventListener("error", handleError);
+    if (pollHandle !== void 0) clearInterval(pollHandle);
+    if (giveUpHandle !== void 0) clearTimeout(giveUpHandle);
+  }
+  function finish(resolvedDuration, restore) {
+    if (settled) return;
+    settled = true;
+    cleanup();
+    if (restore) media.currentTime = restoreTo;
+    onDuration(resolvedDuration);
+  }
+  function handleResolved() {
+    if (isKnown(media.duration)) finish(media.duration, true);
+  }
+  function handleError() {
+    finish(0, false);
+  }
+  media.addEventListener("timeupdate", handleResolved);
+  media.addEventListener("seeked", handleResolved);
+  media.addEventListener("durationchange", handleResolved);
+  media.addEventListener("error", handleError);
+  pollHandle = setInterval(() => {
+    if (isKnown(media.duration)) finish(media.duration, true);
+  }, pollMs);
+  giveUpHandle = setTimeout(() => finish(0, false), giveUpMs);
+  media.currentTime = 1e101;
+  return cleanup;
+}
+function getSeekAriaProps(currentTime, duration) {
+  return {
+    role: "slider",
+    "aria-label": "Seek",
+    "aria-valuemin": 0,
+    "aria-valuemax": Math.max(duration, 0),
+    "aria-valuenow": Math.min(Math.max(currentTime, 0), Math.max(duration, 0)),
+    "aria-valuetext": formatMediaTime(currentTime)
+  };
+}
+function getVolumeAriaProps(volume, muted) {
+  const pct = Math.round(clampVolume(volume) * 100);
+  return {
+    role: "slider",
+    "aria-label": "Volume",
+    "aria-valuemin": 0,
+    "aria-valuemax": 100,
+    "aria-valuenow": muted ? 0 : pct,
+    "aria-valuetext": muted ? "Muted" : `${pct}%`
+  };
+}
+function getPlayButtonAriaProps(isPlaying) {
+  return { "aria-label": isPlaying ? "Pause" : "Play" };
+}
+function getMuteButtonAriaProps(isMuted) {
+  return { "aria-label": isMuted ? "Unmute" : "Mute", "aria-pressed": isMuted };
+}
+function isEffectivelyMuted(volume, muted) {
+  return muted || volume <= 0;
+}
+var SKIP_SECONDS = 10;
+var LABELED_SKIP_SECONDS = [5, 10, 15, 30];
+function hasLabeledSkipIcon(seconds) {
+  return LABELED_SKIP_SECONDS.includes(seconds);
+}
+function resolveSkipSeconds(skipSeconds) {
+  if (skipSeconds === void 0) return SKIP_SECONDS;
+  if (!Number.isFinite(skipSeconds) || skipSeconds <= 0) return SKIP_SECONDS;
+  return skipSeconds;
+}
+function skipTime(currentTime, duration, deltaSeconds) {
+  const max = Number.isFinite(duration) && duration > 0 ? duration : Infinity;
+  return Math.min(Math.max(currentTime + deltaSeconds, 0), max);
+}
+function getSkipButtonAriaProps(deltaSeconds) {
+  return { "aria-label": deltaSeconds < 0 ? `Back ${Math.abs(deltaSeconds)} seconds` : `Forward ${deltaSeconds} seconds` };
+}
+function resolveMediaTransport(props) {
+  const showNext = props.onNext !== void 0;
+  const showPrevious = props.onPrevious !== void 0;
+  return {
+    skipSeconds: resolveSkipSeconds(props.skipSeconds),
+    showNext,
+    showPrevious,
+    nextDisabled: showNext && (props.hasNext ?? true) === false,
+    previousDisabled: showPrevious && (props.hasPrevious ?? true) === false
+  };
+}
+function getTrackButtonAriaProps(direction) {
+  return { "aria-label": direction === "next" ? "Next track" : "Previous track" };
+}
+function getMediaKeyAction(key) {
+  switch (key) {
+    case " ":
+    case "Spacebar":
+      return "toggle-play";
+    case "ArrowLeft":
+      return "seek-back";
+    case "ArrowRight":
+      return "seek-forward";
+    case "ArrowUp":
+      return "volume-up";
+    case "ArrowDown":
+      return "volume-down";
+    default:
+      return null;
+  }
+}
+
+// src/core/pdf-viewer.ts
+function resolvePdfViewerState(props) {
+  return {
+    initialPage: props.initialPage ?? 1,
+    initialScale: props.initialScale ?? "auto",
+    minScale: props.minScale ?? 0.5,
+    maxScale: props.maxScale ?? 3,
+    scaleStep: props.scaleStep ?? 0.25
+  };
+}
+function getPdfViewerClasses(className) {
+  return ["nx-pdf-viewer", className].filter(Boolean).join(" ");
+}
+function clampPage(page) {
+  return Math.max(Math.round(page), 1);
+}
+function clampScale(scale, min, max) {
+  return Math.min(Math.max(scale, min), max);
+}
+function resolveZoomBase(scale, fitScale) {
+  return scale === "auto" ? fitScale : scale;
+}
+function zoomIn(scale, step, max, fitScale = 1) {
+  return clampScale(resolveZoomBase(scale, fitScale) + step, 0, max);
+}
+function zoomOut(scale, step, min, fitScale = 1) {
+  return clampScale(resolveZoomBase(scale, fitScale) - step, min, Infinity);
+}
+function isZoomAtMin(scale, min) {
+  return scale !== "auto" && scale <= min;
+}
+function isZoomAtMax(scale, max) {
+  return scale !== "auto" && scale >= max;
+}
+function estimateFitScale(iframeWidthPx, pageWidthPt = 612) {
+  if (iframeWidthPx <= 0 || pageWidthPt <= 0) return 1;
+  const pageWidthPx = pageWidthPt * (96 / 72);
+  return iframeWidthPx / pageWidthPx;
+}
+function formatZoomPercent(scale) {
+  return scale === "auto" ? "Fit" : `${Math.round(scale * 100)}%`;
+}
+function buildPdfSrc(src, page, scale) {
+  const base = src.split("#")[0];
+  const zoomParam = scale === "auto" ? "page-width" : Math.round(scale * 100);
+  return `${base}#page=${clampPage(page)}&zoom=${zoomParam}`;
+}
+
+export {
+  defineTheme,
+  TOKEN_CATEGORIES,
+  REQUIRED_TOKEN_PATHS,
+  findMissingTokenPaths,
+  light,
+  dark,
+  glass,
+  darkGlass,
+  minimalism,
+  brutalism,
+  neobrutalism,
+  cyberpunk,
+  gradient,
+  material,
+  skeuomorphism,
+  registerTheme,
+  getTheme,
+  listThemes,
+  indigo,
+  violet,
+  teal,
+  rose,
+  amber,
+  emerald,
+  copper,
+  graphite,
+  magenta,
+  registerAccent,
+  getAccent,
+  listAccents,
+  DEFAULT_ACCENT,
+  resolveFieldState,
+  getFieldAriaProps,
+  DEFAULT_PRESETS,
+  resolveColorPickerState,
+  normalizeHex,
+  isSameColor,
+  getSwatchClasses,
+  getSwatchGridAriaProps,
+  getSwatchAriaProps,
+  getFieldTriggerAriaProps,
+  COLOR_FORMATS,
+  hexToRgb,
+  rgbToHex,
+  rgbToHsl,
+  hexToHsv,
+  hsvToHex,
+  hslToHex,
+  parseColorInput,
+  formatColorValue,
+  getSvKeyboardDelta,
+  clampPercent,
+  getFormatTabClasses,
+  getFormatTablistAriaProps,
+  getFormatTabAriaProps,
+  getSvThumbAriaProps,
+  resolveTableState,
+  getWrapperClasses,
+  getTableClasses,
+  getRowClasses,
+  getHeadCellClasses,
+  getCellClasses,
+  getNextSortDirection,
+  getSortAriaProps,
+  getSelectAllState,
+  DRAG_START_THRESHOLD_PX,
+  resolveKanbanState,
+  getBoardClasses,
+  getColumnClasses,
+  getColumnCountClasses,
+  getCardWrapperClasses,
+  findCardLocation,
+  removeCard,
+  moveCard,
+  getAdjacentColumnId,
+  getKeyboardMoveTarget,
+  computeDropIndex,
+  computeDropColumn,
+  moveColumn,
+  removeColumn,
+  getColumnKeyboardMoveTarget,
+  computeColumnDropIndex,
+  LANGUAGE_LABELS,
+  normalizeLanguage,
+  nuvoxHighlight,
+  restoreSelection,
+  stripEmptyMarkers,
+  execRichTextCommand,
+  getActiveCommands,
+  sanitizeHtml,
+  createHistory,
+  pushHistory,
+  undoHistory,
+  redoHistory,
+  resolveRichTextEditorState,
+  getRichTextEditorClasses,
+  resolveGalleryState,
+  getGalleryClasses,
+  getGalleryStyle,
+  aspectRatioFromDims,
+  computeJustifiedRows,
+  isRangeValue,
+  toThumbs,
+  fromThumbs,
+  resolveSliderState,
+  clampAndSnap,
+  valueToPercent,
+  percentToValue,
+  clampRangeThumb,
+  nearestThumbIndex,
+  getKeyboardValue,
+  getRootClasses,
+  getThumbAriaProps,
+  PLAYBACK_RATES,
+  formatMediaTime,
+  clampVolume,
+  positionToTime,
+  positionToRatio,
+  getBufferedPercent,
+  getProgressPercent,
+  recoverDuration,
+  getSeekAriaProps,
+  getVolumeAriaProps,
+  getPlayButtonAriaProps,
+  getMuteButtonAriaProps,
+  isEffectivelyMuted,
+  SKIP_SECONDS,
+  LABELED_SKIP_SECONDS,
+  hasLabeledSkipIcon,
+  resolveSkipSeconds,
+  skipTime,
+  getSkipButtonAriaProps,
+  resolveMediaTransport,
+  getTrackButtonAriaProps,
+  getMediaKeyAction,
+  resolvePdfViewerState,
+  getPdfViewerClasses,
+  clampPage,
+  zoomIn,
+  zoomOut,
+  isZoomAtMin,
+  isZoomAtMax,
+  estimateFitScale,
+  formatZoomPercent,
+  buildPdfSrc
+};
+//# sourceMappingURL=chunk-HAMPWL7I.js.map