@kbach/react-native 1.0.0-beta.3 → 1.0.0-beta.30

package/dist/index.js

@@ -21,456 +21,1992 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   ThemeProvider: () => ThemeProvider,
-  defaultTheme: () => defaultTheme,
-  getGlobalDarkMode: () => getGlobalDarkMode,
-  getGlobalThemeMode: () => getGlobalThemeMode,
-  getTheme: () => getTheme,
+  applyKbachConfig: () => applyKbachConfig,
+  clsx: () => clsx,
+  defaultTheme: () => import_theme4.defaultTheme,
+  deleteDynamicToken: () => import_dynamicTokens2.deleteDynamicToken,
+  getDynamicToken: () => import_dynamicTokens2.getDynamicToken,
+  getGlobalDarkMode: () => import_darkModeStore5.getGlobalDarkMode,
+  getGlobalThemeMode: () => import_darkModeStore5.getGlobalThemeMode,
+  getTheme: () => import_theme4.getTheme,
+  resolveKbachConfig: () => resolveKbachConfig,
   resolveStyle: () => resolveStyle,
-  setGlobalThemeMode: () => setGlobalThemeMode,
-  setTheme: () => setTheme,
-  subscribeGlobalDarkMode: () => subscribeGlobalDarkMode,
-  toggleGlobalDarkMode: () => toggleGlobalDarkMode,
-  useGlobalDarkMode: () => useGlobalDarkMode,
+  setDynamicToken: () => import_dynamicTokens2.setDynamicToken,
+  setGlobalThemeMode: () => import_darkModeStore5.setGlobalThemeMode,
+  setTheme: () => import_theme4.setTheme,
+  subscribeDynamicTokens: () => import_dynamicTokens2.subscribeDynamicTokens,
+  subscribeGlobalDarkMode: () => import_darkModeStore5.subscribeGlobalDarkMode,
+  toggleGlobalDarkMode: () => import_darkModeStore5.toggleGlobalDarkMode,
+  useColors: () => useColors,
+  useDynamicToken: () => useDynamicToken,
   useTheme: () => useTheme
 });
 module.exports = __toCommonJS(src_exports);
+var import_theme4 = require("./theme");
 
-// src/generatedPalette.ts
-var PALETTE = {
-  "amber-1": "#fffbeb",
-  "amber-10": "#78350f",
-  "amber-11": "#451a03",
-  "amber-12": "#291002",
-  "amber-2": "#fef3c7",
-  "amber-3": "#fde68a",
-  "amber-4": "#fcd34d",
-  "amber-5": "#fbbf24",
-  "amber-6": "#f59e0b",
-  "amber-7": "#d97706",
-  "amber-8": "#b45309",
-  "amber-9": "#92400e",
-  "black": "#000000",
-  "blue-1": "#eff6ff",
-  "blue-10": "#1e3a8a",
-  "blue-11": "#172554",
-  "blue-12": "#0d1633",
-  "blue-2": "#dbeafe",
-  "blue-3": "#bfdbfe",
-  "blue-4": "#93c5fd",
-  "blue-5": "#60a5fa",
-  "blue-6": "#3b82f6",
-  "blue-7": "#2563eb",
-  "blue-8": "#1d4ed8",
-  "blue-9": "#1e40af",
-  "bronze": "#cd7f32",
-  "coal": "#1c1c1c",
-  "copper": "#b87333",
-  "current": "currentColor",
-  "cyan-1": "#ecfeff",
-  "cyan-10": "#164e63",
-  "cyan-11": "#083344",
-  "cyan-12": "#041e28",
-  "cyan-2": "#cffafe",
-  "cyan-3": "#a5f3fc",
-  "cyan-4": "#67e8f9",
-  "cyan-5": "#22d3ee",
-  "cyan-6": "#06b6d4",
-  "cyan-7": "#0891b2",
-  "cyan-8": "#0e7490",
-  "cyan-9": "#155e75",
-  "emerald-1": "#ecfdf5",
-  "emerald-10": "#064e3b",
-  "emerald-11": "#022c22",
-  "emerald-12": "#011a14",
-  "emerald-2": "#d1fae5",
-  "emerald-3": "#a7f3d0",
-  "emerald-4": "#6ee7b7",
-  "emerald-5": "#34d399",
-  "emerald-6": "#10b981",
-  "emerald-7": "#059669",
-  "emerald-8": "#047857",
-  "emerald-9": "#065f46",
-  "fuchsia-1": "#fdf4ff",
-  "fuchsia-10": "#701a75",
-  "fuchsia-11": "#4a044e",
-  "fuchsia-12": "#2d022f",
-  "fuchsia-2": "#fae8ff",
-  "fuchsia-3": "#f5d0fe",
-  "fuchsia-4": "#f0abfc",
-  "fuchsia-5": "#e879f9",
-  "fuchsia-6": "#d946ef",
-  "fuchsia-7": "#c026d3",
-  "fuchsia-8": "#a21caf",
-  "fuchsia-9": "#86198f",
-  "gold": "#d4af37",
-  "gray-1": "#f9fafb",
-  "gray-10": "#111827",
-  "gray-11": "#030712",
-  "gray-12": "#020409",
-  "gray-2": "#f3f4f6",
-  "gray-3": "#e5e7eb",
-  "gray-4": "#d1d5db",
-  "gray-5": "#9ca3af",
-  "gray-6": "#6b7280",
-  "gray-7": "#4b5563",
-  "gray-8": "#374151",
-  "gray-9": "#1f2937",
-  "green-1": "#f0fdf4",
-  "green-10": "#14532d",
-  "green-11": "#052e16",
-  "green-12": "#031b0d",
-  "green-2": "#dcfce7",
-  "green-3": "#bbf7d0",
-  "green-4": "#86efac",
-  "green-5": "#4ade80",
-  "green-6": "#22c55e",
-  "green-7": "#16a34a",
-  "green-8": "#15803d",
-  "green-9": "#166534",
-  "indigo-1": "#eef2ff",
-  "indigo-10": "#312e81",
-  "indigo-11": "#1e1b4b",
-  "indigo-12": "#12102d",
-  "indigo-2": "#e0e7ff",
-  "indigo-3": "#c7d2fe",
-  "indigo-4": "#a5b4fc",
-  "indigo-5": "#818cf8",
-  "indigo-6": "#6366f1",
-  "indigo-7": "#4f46e5",
-  "indigo-8": "#4338ca",
-  "indigo-9": "#3730a3",
-  "lime-1": "#f7fee7",
-  "lime-10": "#365314",
-  "lime-11": "#1a2e05",
-  "lime-12": "#0f1b03",
-  "lime-2": "#ecfccb",
-  "lime-3": "#d9f99d",
-  "lime-4": "#bef264",
-  "lime-5": "#a3e635",
-  "lime-6": "#84cc16",
-  "lime-7": "#65a30d",
-  "lime-8": "#4d7c0f",
-  "lime-9": "#3f6212",
-  "neutral-1": "#fafafa",
-  "neutral-10": "#171717",
-  "neutral-11": "#0a0a0a",
-  "neutral-12": "#050505",
-  "neutral-2": "#f5f5f5",
-  "neutral-3": "#e5e5e5",
-  "neutral-4": "#d4d4d4",
-  "neutral-5": "#a3a3a3",
-  "neutral-6": "#737373",
-  "neutral-7": "#525252",
-  "neutral-8": "#404040",
-  "neutral-9": "#262626",
-  "orange-1": "#fff7ed",
-  "orange-10": "#7c2d12",
-  "orange-11": "#431407",
-  "orange-12": "#270c04",
-  "orange-2": "#ffedd5",
-  "orange-3": "#fed7aa",
-  "orange-4": "#fdba74",
-  "orange-5": "#fb923c",
-  "orange-6": "#f97316",
-  "orange-7": "#ea580c",
-  "orange-8": "#c2410c",
-  "orange-9": "#9a3412",
-  "pink-1": "#fdf2f8",
-  "pink-10": "#831843",
-  "pink-11": "#500724",
-  "pink-12": "#300415",
-  "pink-2": "#fce7f3",
-  "pink-3": "#fbcfe8",
-  "pink-4": "#f9a8d4",
-  "pink-5": "#f472b6",
-  "pink-6": "#ec4899",
-  "pink-7": "#db2777",
-  "pink-8": "#be185d",
-  "pink-9": "#9d174d",
-  "purple-1": "#faf5ff",
-  "purple-10": "#581c87",
-  "purple-11": "#3b0764",
-  "purple-12": "#23043c",
-  "purple-2": "#f3e8ff",
-  "purple-3": "#e9d5ff",
-  "purple-4": "#d8b4fe",
-  "purple-5": "#c084fc",
-  "purple-6": "#a855f7",
-  "purple-7": "#9333ea",
-  "purple-8": "#7e22ce",
-  "purple-9": "#6b21a8",
-  "red-1": "#fef2f2",
-  "red-10": "#7f1d1d",
-  "red-11": "#450a0a",
-  "red-12": "#280606",
-  "red-2": "#fee2e2",
-  "red-3": "#fecaca",
-  "red-4": "#fca5a5",
-  "red-5": "#f87171",
-  "red-6": "#ef4444",
-  "red-7": "#dc2626",
-  "red-8": "#b91c1c",
-  "red-9": "#991b1b",
-  "rose-1": "#fff1f2",
-  "rose-10": "#881337",
-  "rose-11": "#4c0519",
-  "rose-12": "#2d030e",
-  "rose-2": "#ffe4e6",
-  "rose-3": "#fecdd3",
-  "rose-4": "#fda4af",
-  "rose-5": "#fb7185",
-  "rose-6": "#f43f5e",
-  "rose-7": "#e11d48",
-  "rose-8": "#be123c",
-  "rose-9": "#9f1239",
-  "silver": "#c0c0c0",
-  "sky-1": "#f0f9ff",
-  "sky-10": "#0c4a6e",
-  "sky-11": "#082f49",
-  "sky-12": "#041b2b",
-  "sky-2": "#e0f2fe",
-  "sky-3": "#bae6fd",
-  "sky-4": "#7dd3fc",
-  "sky-5": "#38bdf8",
-  "sky-6": "#0ea5e9",
-  "sky-7": "#0284c7",
-  "sky-8": "#0369a1",
-  "sky-9": "#075985",
-  "slate-1": "#f8fafc",
-  "slate-10": "#0f172a",
-  "slate-11": "#020617",
-  "slate-12": "#01020a",
-  "slate-2": "#f1f5f9",
-  "slate-3": "#e2e8f0",
-  "slate-4": "#cbd5e1",
-  "slate-5": "#94a3b8",
-  "slate-6": "#64748b",
-  "slate-7": "#475569",
-  "slate-8": "#334155",
-  "slate-9": "#1e293b",
-  "stone-1": "#fafaf9",
-  "stone-10": "#1c1917",
-  "stone-11": "#0c0a09",
-  "stone-12": "#070605",
-  "stone-2": "#f5f5f4",
-  "stone-3": "#e7e5e4",
-  "stone-4": "#d6d3d1",
-  "stone-5": "#a8a29e",
-  "stone-6": "#78716c",
-  "stone-7": "#57534e",
-  "stone-8": "#44403c",
-  "stone-9": "#292524",
-  "teal-1": "#f0fdfa",
-  "teal-10": "#134e4a",
-  "teal-11": "#042f2e",
-  "teal-12": "#021c1b",
-  "teal-2": "#ccfbf1",
-  "teal-3": "#99f6e4",
-  "teal-4": "#5eead4",
-  "teal-5": "#2dd4bf",
-  "teal-6": "#14b8a6",
-  "teal-7": "#0d9488",
-  "teal-8": "#0f766e",
-  "teal-9": "#115e59",
-  "transparent": "transparent",
-  "violet-1": "#f5f3ff",
-  "violet-10": "#4c1d95",
-  "violet-11": "#2e1065",
-  "violet-12": "#1c0a3d",
-  "violet-2": "#ede9fe",
-  "violet-3": "#ddd6fe",
-  "violet-4": "#c4b5fd",
-  "violet-5": "#a78bfa",
-  "violet-6": "#8b5cf6",
-  "violet-7": "#7c3aed",
-  "violet-8": "#6d28d9",
-  "violet-9": "#5b21b6",
-  "white": "#ffffff",
-  "yellow-1": "#fefce8",
-  "yellow-10": "#713f12",
-  "yellow-11": "#422006",
-  "yellow-12": "#271304",
-  "yellow-2": "#fef9c3",
-  "yellow-3": "#fef08a",
-  "yellow-4": "#fde047",
-  "yellow-5": "#facc15",
-  "yellow-6": "#eab308",
-  "yellow-7": "#ca8a04",
-  "yellow-8": "#a16207",
-  "yellow-9": "#854d0e",
-  "zinc-1": "#fafafa",
-  "zinc-10": "#18181b",
-  "zinc-11": "#09090b",
-  "zinc-12": "#050506",
-  "zinc-2": "#f4f4f5",
-  "zinc-3": "#e4e4e7",
-  "zinc-4": "#d4d4d8",
-  "zinc-5": "#a1a1aa",
-  "zinc-6": "#71717a",
-  "zinc-7": "#52525b",
-  "zinc-8": "#3f3f46",
-  "zinc-9": "#27272a"
-};
+// src/nativeBridge.ts
+var import_react_native = require("react-native");
+var import_theme = require("./theme");
+var import_darkModeStore = require("./darkModeStore");
 
-// src/theme.ts
-var defaultTheme = {
-  colors: PALETTE,
-  spacing: {
-    // "0" is always a hardcoded zero in real Tailwind's own scale too,
-    // regardless of the base spacing unit — needed for `p-0`/`m-0`/etc.
-    // Mirrors the identical fix in @kbach/react's theme.ts.
-    "0": 0,
-    "1": 4,
-    "2": 8,
-    "4": 16,
-    "6": 24,
-    "8": 32
-  },
-  screens: {
-    sm: 640,
-    md: 768,
-    lg: 1024,
-    xl: 1280,
-    "2xl": 1536
-  },
-  darkMode: "attribute"
-};
-var activeTheme = defaultTheme;
-var activeThemeJson = JSON.stringify(defaultTheme);
-function setTheme(theme) {
-  activeTheme = theme;
-  activeThemeJson = JSON.stringify(theme);
+// src/jsEngine/parser.ts
+var VALUE_PREFIXES = [
+  "bg-opacity-",
+  "text-opacity-",
+  "bg-blend-",
+  "text-shadow-",
+  "bg-",
+  "text-",
+  "border-x-",
+  "border-y-",
+  "border-t-",
+  "border-r-",
+  "border-b-",
+  "border-l-",
+  "border-",
+  "caret-",
+  "accent-",
+  "fill-",
+  "stroke-width-",
+  "stroke-",
+  "resize-",
+  "touch-",
+  "will-change-",
+  "scroll-mx-",
+  "scroll-my-",
+  "scroll-mt-",
+  "scroll-mr-",
+  "scroll-mb-",
+  "scroll-ml-",
+  "scroll-m-",
+  "scroll-px-",
+  "scroll-py-",
+  "scroll-pt-",
+  "scroll-pr-",
+  "scroll-pb-",
+  "scroll-pl-",
+  "scroll-p-",
+  "px-",
+  "py-",
+  "pt-",
+  "pr-",
+  "pb-",
+  "pl-",
+  "p-",
+  "mx-",
+  "my-",
+  "mt-",
+  "mr-",
+  "mb-",
+  "ml-",
+  "m-",
+  "gap-x-",
+  "gap-y-",
+  "gap-",
+  "min-w-",
+  "max-w-",
+  "w-",
+  "min-h-",
+  "max-h-",
+  "h-",
+  "size-",
+  "basis-",
+  "rounded-tl-",
+  "rounded-tr-",
+  "rounded-br-",
+  "rounded-bl-",
+  "rounded-t-",
+  "rounded-r-",
+  "rounded-b-",
+  "rounded-l-",
+  "rounded-",
+  "ring-offset-",
+  "ring-",
+  "outline-offset-",
+  "outline-",
+  "shadow-",
+  "opacity-",
+  "duration-",
+  "delay-",
+  "ease-",
+  "cursor-",
+  "mix-blend-",
+  "animate-",
+  "leading-",
+  "tracking-",
+  "font-",
+  "z-",
+  "inset-x-",
+  "inset-y-",
+  "inset-",
+  "top-",
+  "right-",
+  "bottom-",
+  "left-",
+  "start-",
+  "end-",
+  "overflow-x-",
+  "overflow-y-",
+  "overscroll-x-",
+  "overscroll-y-",
+  "overscroll-",
+  "aspect-",
+  "divide-color-",
+  "space-x-",
+  "space-y-",
+  "flex-",
+  "grow-",
+  "shrink-",
+  "order-",
+  "grid-cols-",
+  "grid-rows-",
+  "grid-flow-",
+  "auto-cols-",
+  "auto-rows-",
+  "col-span-",
+  "col-start-",
+  "col-end-",
+  "col-",
+  "row-span-",
+  "row-start-",
+  "row-end-",
+  "row-",
+  "place-items-",
+  "place-content-",
+  "place-self-",
+  "justify-items-",
+  "justify-self-",
+  "scale-x-",
+  "scale-y-",
+  "scale-z-",
+  "scale-",
+  "rotate-x-",
+  "rotate-y-",
+  "rotate-z-",
+  "rotate-",
+  "translate-x-",
+  "translate-y-",
+  "translate-z-",
+  "skew-x-",
+  "skew-y-",
+  "perspective-origin-",
+  "perspective-",
+  "origin-",
+  "blur-",
+  "brightness-",
+  "contrast-",
+  "grayscale-",
+  "hue-rotate-",
+  "invert-",
+  "saturate-",
+  "sepia-",
+  "drop-shadow-",
+  "filter-",
+  "backdrop-blur-",
+  "backdrop-brightness-",
+  "backdrop-contrast-",
+  "backdrop-grayscale-",
+  "backdrop-hue-rotate-",
+  "backdrop-invert-",
+  "backdrop-opacity-",
+  "backdrop-saturate-",
+  "backdrop-sepia-",
+  "backdrop-filter-",
+  "decoration-",
+  "underline-offset-",
+  "indent-",
+  "from-",
+  "via-",
+  "to-"
+];
+var ARBITRARY_PROPERTY_SENTINEL = "[arbitrary-property]";
+function isSafeArbitraryValue(value) {
+  return !value.includes("{") && !value.includes("}") && !value.includes(";");
 }
-function getTheme() {
-  return activeTheme;
+function splitRespectingBrackets(token) {
+  const parts = [];
+  let depth = 0;
+  let start = 0;
+  for (let i = 0; i < token.length; i++) {
+    const ch = token[i];
+    if (ch === "[") depth += 1;
+    else if (ch === "]") depth -= 1;
+    else if (ch === ":" && depth <= 0) {
+      parts.push(token.slice(start, i));
+      start = i + 1;
+    }
+  }
+  parts.push(token.slice(start));
+  return parts;
 }
-function getThemeJson() {
-  return activeThemeJson;
+function parseClass(token) {
+  const parts = splitRespectingBrackets(token);
+  let base = parts.pop() ?? token;
+  const modifiers = parts;
+  const important = base.startsWith("!");
+  if (important) {
+    base = base.slice(1);
+  }
+  const negative = base.startsWith("-");
+  if (negative) {
+    base = base.slice(1);
+  }
+  if (base.length >= 2 && base.startsWith("[") && base.endsWith("]")) {
+    const raw = base.slice(1, -1);
+    const colonIdx = raw.indexOf(":");
+    if (colonIdx !== -1) {
+      const property = raw.slice(0, colonIdx);
+      const rawValue = raw.slice(colonIdx + 1);
+      if (property !== "" && rawValue !== "" && isSafeArbitraryValue(raw)) {
+        const value = rawValue.replace(/_/g, " ");
+        return {
+          modifiers,
+          utility: ARBITRARY_PROPERTY_SENTINEL,
+          value: `${property}:${value}`,
+          isArbitrary: true,
+          important,
+          negative,
+          original: token
+        };
+      }
+    }
+  }
+  for (const prefix of VALUE_PREFIXES) {
+    if (!base.startsWith(prefix)) continue;
+    const value = base.slice(prefix.length);
+    if (value === "") continue;
+    if (value.length >= 2 && value.startsWith("[") && value.endsWith("]")) {
+      const raw = value.slice(1, -1);
+      if (!isSafeArbitraryValue(raw)) {
+        continue;
+      }
+      const spaced = raw.replace(/_/g, " ");
+      return {
+        modifiers,
+        utility: prefix.slice(0, -1),
+        value: spaced,
+        isArbitrary: true,
+        important,
+        negative,
+        original: token
+      };
+    }
+    return {
+      modifiers,
+      utility: prefix.slice(0, -1),
+      value,
+      isArbitrary: false,
+      important,
+      negative,
+      original: token
+    };
+  }
+  return {
+    modifiers,
+    utility: base,
+    value: null,
+    isArbitrary: false,
+    important,
+    negative,
+    original: token
+  };
 }
 
-// src/nativeBridge.ts
-var import_react_native2 = require("react-native");
+// src/jsEngine/shared.ts
+function decl(property, value) {
+  return { property, value };
+}
+function spacingPx(theme, value) {
+  const fromTable = theme.spacing[value];
+  if (fromTable !== void 0) return fromTable;
+  const n = Number(value);
+  return Number.isFinite(n) && value.trim() !== "" ? n * 4 : void 0;
+}
+function resolveLength(theme, parsed) {
+  if (parsed.negative) return null;
+  const value = parsed.value;
+  if (value === null) return null;
+  if (parsed.isArbitrary) return value;
+  if (value === "full") return "100%";
+  if (value === "auto") return "auto";
+  const px = spacingPx(theme, value);
+  return px === void 0 ? null : `${px}px`;
+}
+function resolveNegatableLength(theme, parsed) {
+  if (!parsed.negative) return resolveLength(theme, parsed);
+  if (parsed.isArbitrary) {
+    const value2 = parsed.value;
+    return value2 === null ? null : `calc(${value2} * -1)`;
+  }
+  const value = parsed.value;
+  if (value === null) return null;
+  const px = spacingPx(theme, value);
+  if (px === void 0) return null;
+  if (px === 0) return "0px";
+  return `-${px}px`;
+}
+function fractionPercent(value) {
+  const slashIdx = value.indexOf("/");
+  if (slashIdx === -1) return null;
+  const numStr = value.slice(0, slashIdx);
+  const denStr = value.slice(slashIdx + 1);
+  const num = Number(numStr);
+  const den = Number(denStr);
+  if (!Number.isFinite(num) || !Number.isFinite(den) || numStr.trim() === "" || denStr.trim() === "") return null;
+  if (den === 0) return null;
+  const pct = num / den * 100;
+  const formatted = pct.toFixed(6);
+  const trimmed = formatted.replace(/0+$/, "").replace(/\.$/, "");
+  return `${trimmed}%`;
+}
+function resolveNegatableSize(theme, parsed) {
+  if (!parsed.isArbitrary && parsed.value !== null) {
+    const pct = fractionPercent(parsed.value);
+    if (pct !== null) return parsed.negative ? `-${pct}` : pct;
+  }
+  return resolveNegatableLength(theme, parsed);
+}
+function resolvePercent(parsed) {
+  if (parsed.negative) return null;
+  const value = parsed.value;
+  if (value === null) return null;
+  if (parsed.isArbitrary) return value;
+  const pct = Number(value);
+  if (!Number.isFinite(pct) || value.trim() === "") return null;
+  return String(pct / 100);
+}
 
-// src/darkModeStore.ts
-var import_react_native = require("react-native");
-var listeners = /* @__PURE__ */ new Set();
-function systemPrefersDark() {
-  return import_react_native.Appearance.getColorScheme() === "dark";
-}
-function resolveIsDark(m) {
-  return m === "system" ? systemPrefersDark() : m === "dark";
-}
-var mode = "system";
-var isDark = resolveIsDark(mode);
-var hasExplicitChoice = false;
-var subscription = import_react_native.Appearance.addChangeListener(({ colorScheme }) => {
-  if (mode !== "system") return;
-  isDark = colorScheme === "dark";
-  notify();
-});
-function notify() {
-  for (const listener of listeners) listener();
+// src/jsEngine/resolvers/layout.ts
+function negateRaw(value, negative) {
+  return negative ? `-${value}` : value;
 }
-function getGlobalDarkMode() {
-  return isDark;
+function overflowAxisValue(property, value) {
+  switch (value) {
+    case "auto":
+    case "hidden":
+    case "clip":
+    case "visible":
+    case "scroll":
+      return [decl(property, value)];
+    default:
+      return null;
+  }
 }
-function getGlobalThemeMode() {
-  return mode;
+function overscrollValue(property, value) {
+  switch (value) {
+    case "auto":
+    case "contain":
+    case "none":
+      return [decl(property, value)];
+    default:
+      return null;
+  }
 }
-function setGlobalThemeMode(nextMode) {
-  mode = nextMode;
-  isDark = resolveIsDark(nextMode);
-  hasExplicitChoice = true;
-  notify();
+function resolve(parsed, theme) {
+  switch (parsed.utility) {
+    case "flex":
+      return parsed.value === null ? [decl("display", "flex")] : null;
+    case "grid":
+      return [decl("display", "grid")];
+    case "block":
+      return [decl("display", "block")];
+    case "inline-block":
+      return [decl("display", "inline-block")];
+    case "inline":
+      return [decl("display", "inline")];
+    case "inline-flex":
+      return [decl("display", "inline-flex")];
+    case "inline-grid":
+      return [decl("display", "inline-grid")];
+    case "contents":
+      return [decl("display", "contents")];
+    case "flow-root":
+      return [decl("display", "flow-root")];
+    case "hidden":
+      return [decl("display", "none")];
+    case "@container":
+      return [decl("container-type", "inline-size")];
+    case "items-center":
+      return [decl("align-items", "center")];
+    case "items-start":
+      return [decl("align-items", "flex-start")];
+    case "items-end":
+      return [decl("align-items", "flex-end")];
+    case "items-baseline":
+      return [decl("align-items", "baseline")];
+    case "items-stretch":
+      return [decl("align-items", "stretch")];
+    case "justify-center":
+      return [decl("justify-content", "center")];
+    case "justify-start":
+      return [decl("justify-content", "flex-start")];
+    case "justify-end":
+      return [decl("justify-content", "flex-end")];
+    case "justify-between":
+      return [decl("justify-content", "space-between")];
+    case "justify-around":
+      return [decl("justify-content", "space-around")];
+    case "justify-evenly":
+      return [decl("justify-content", "space-evenly")];
+    case "justify-normal":
+      return [decl("justify-content", "normal")];
+    case "justify-stretch":
+      return [decl("justify-content", "stretch")];
+    case "content-normal":
+      return [decl("align-content", "normal")];
+    case "content-start":
+      return [decl("align-content", "flex-start")];
+    case "content-end":
+      return [decl("align-content", "flex-end")];
+    case "content-center":
+      return [decl("align-content", "center")];
+    case "content-between":
+      return [decl("align-content", "space-between")];
+    case "content-around":
+      return [decl("align-content", "space-around")];
+    case "content-evenly":
+      return [decl("align-content", "space-evenly")];
+    case "content-stretch":
+      return [decl("align-content", "stretch")];
+    case "self-auto":
+      return [decl("align-self", "auto")];
+    case "self-center":
+      return [decl("align-self", "center")];
+    case "self-start":
+      return [decl("align-self", "flex-start")];
+    case "self-end":
+      return [decl("align-self", "flex-end")];
+    case "self-stretch":
+      return [decl("align-self", "stretch")];
+    case "self-baseline":
+      return [decl("align-self", "baseline")];
+    case "overflow-hidden":
+      return [decl("overflow", "hidden")];
+    case "overflow-auto":
+      return [decl("overflow", "auto")];
+    case "overflow-scroll":
+      return [decl("overflow", "scroll")];
+    case "overflow-visible":
+      return [decl("overflow", "visible")];
+    case "overflow-clip":
+      return [decl("overflow", "clip")];
+    case "overflow-x":
+      return parsed.value === null ? null : overflowAxisValue("overflow-x", parsed.value);
+    case "overflow-y":
+      return parsed.value === null ? null : overflowAxisValue("overflow-y", parsed.value);
+    case "overscroll":
+      return parsed.value === null ? null : overscrollValue("overscroll-behavior", parsed.value);
+    case "overscroll-x":
+      return parsed.value === null ? null : overscrollValue("overscroll-behavior-x", parsed.value);
+    case "overscroll-y":
+      return parsed.value === null ? null : overscrollValue("overscroll-behavior-y", parsed.value);
+    case "static":
+      return [decl("position", "static")];
+    case "relative":
+      return [decl("position", "relative")];
+    case "absolute":
+      return [decl("position", "absolute")];
+    case "fixed":
+      return [decl("position", "fixed")];
+    case "sticky":
+      return [decl("position", "sticky")];
+    case "z":
+      return parsed.value === null ? null : [decl("z-index", negateRaw(parsed.value, parsed.negative))];
+    case "order":
+      return parsed.value === null ? null : [decl("order", negateRaw(parsed.value, parsed.negative))];
+    case "grow":
+      return [decl("flex-grow", parsed.value ?? "1")];
+    case "shrink":
+      return [decl("flex-shrink", parsed.value ?? "1")];
+    // top/right/bottom/left/inset support real Tailwind's negative-value
+    // convention ("-top-4") AND its percentage-fraction scale ("top-1/2",
+    // "-inset-1/3") — see resolveNegatableSize's own doc comment.
+    case "top": {
+      const v = resolveNegatableSize(theme, parsed);
+      return v === null ? null : [decl("top", v)];
+    }
+    case "right": {
+      const v = resolveNegatableSize(theme, parsed);
+      return v === null ? null : [decl("right", v)];
+    }
+    case "bottom": {
+      const v = resolveNegatableSize(theme, parsed);
+      return v === null ? null : [decl("bottom", v)];
+    }
+    case "left": {
+      const v = resolveNegatableSize(theme, parsed);
+      return v === null ? null : [decl("left", v)];
+    }
+    case "inset": {
+      const v = resolveNegatableSize(theme, parsed);
+      return v === null ? null : [decl("inset", v)];
+    }
+    case "inset-x": {
+      const v = resolveNegatableSize(theme, parsed);
+      return v === null ? null : [decl("left", v), decl("right", v)];
+    }
+    case "inset-y": {
+      const v = resolveNegatableSize(theme, parsed);
+      return v === null ? null : [decl("top", v), decl("bottom", v)];
+    }
+    // Logical inset — just a different CSS property name, same reasoning
+    // as Rust's layout.rs (no direction-tracking logic needed here).
+    case "start": {
+      const v = resolveNegatableSize(theme, parsed);
+      return v === null ? null : [decl("inset-inline-start", v)];
+    }
+    case "end": {
+      const v = resolveNegatableSize(theme, parsed);
+      return v === null ? null : [decl("inset-inline-end", v)];
+    }
+    // "aspect-" is a registered VALUE_PREFIXES entry (parser.ts), so
+    // "aspect-square"/"aspect-video"/"aspect-auto"/arbitrary all arrive
+    // here as utility="aspect" + a value, mirroring layout.rs's own
+    // "aspect" arm.
+    case "aspect": {
+      const value = parsed.value;
+      if (value === null) return null;
+      if (parsed.isArbitrary) return [decl("aspect-ratio", value)];
+      switch (value) {
+        case "square":
+          return [decl("aspect-ratio", "1 / 1")];
+        case "video":
+          return [decl("aspect-ratio", "16 / 9")];
+        case "auto":
+          return [decl("aspect-ratio", "auto")];
+        default:
+          return null;
+      }
+    }
+    default:
+      return null;
+  }
+}
+function resolveFlex(parsed, web) {
+  if (parsed.utility !== "flex") return null;
+  const value = parsed.value;
+  if (value === null) return null;
+  if (parsed.isArbitrary) return [decl("flex", value)];
+  switch (value) {
+    case "row":
+      return [decl("flex-direction", "row")];
+    case "col":
+      return [decl("flex-direction", "column")];
+    case "row-reverse":
+      return [decl("flex-direction", "row-reverse")];
+    case "col-reverse":
+      return [decl("flex-direction", "column-reverse")];
+    case "wrap":
+      return [decl("flex-wrap", "wrap")];
+    case "wrap-reverse":
+      return [decl("flex-wrap", "wrap-reverse")];
+    case "nowrap":
+      return [decl("flex-wrap", "nowrap")];
+    case "1":
+      return [decl("flex", "1")];
+    case "auto":
+      return [decl("flex", web ? "auto" : "1")];
+    case "initial":
+      return [decl("flex", web ? "initial" : "1")];
+    case "none":
+      return [decl("flex", web ? "none" : "0")];
+    case "grow":
+      return [decl("flex-grow", "1")];
+    case "grow-0":
+      return [decl("flex-grow", "0")];
+    case "shrink":
+      return [decl("flex-shrink", "1")];
+    case "shrink-0":
+      return [decl("flex-shrink", "0")];
+    default:
+      return null;
+  }
 }
-function toggleGlobalDarkMode() {
-  setGlobalThemeMode(isDark ? "light" : "dark");
+
+// src/jsEngine/resolvers/spacing.ts
+function namedSize(key) {
+  switch (key) {
+    case "sm":
+      return "24rem";
+    case "md":
+      return "28rem";
+    case "lg":
+      return "32rem";
+    case "xl":
+      return "36rem";
+    case "2xl":
+      return "42rem";
+    case "3xl":
+      return "48rem";
+    case "4xl":
+      return "56rem";
+    case "5xl":
+      return "64rem";
+    case "6xl":
+      return "72rem";
+    case "7xl":
+      return "80rem";
+    case "8xl":
+      return "88rem";
+    case "9xl":
+      return "96rem";
+    default:
+      return null;
+  }
 }
-function subscribeGlobalDarkMode(listener) {
-  listeners.add(listener);
-  return () => listeners.delete(listener);
+function cssSizeKeyword(key) {
+  switch (key) {
+    case "min":
+      return "min-content";
+    case "max":
+      return "max-content";
+    case "fit":
+      return "fit-content";
+    default:
+      return null;
+  }
 }
-function seedDefaultMode(fallback) {
-  if (hasExplicitChoice || mode === fallback) return;
-  mode = fallback;
-  isDark = resolveIsDark(fallback);
-  notify();
+function resolveSize(theme, parsed) {
+  if (!parsed.isArbitrary && parsed.value !== null) {
+    const named = namedSize(parsed.value);
+    if (named !== null) return named;
+    const kw = cssSizeKeyword(parsed.value);
+    if (kw !== null) return kw;
+    const fraction = fractionPercent(parsed.value);
+    if (fraction !== null) return fraction;
+  }
+  return resolveLength(theme, parsed);
+}
+function resolve2(parsed, theme) {
+  const length = () => resolveLength(theme, parsed);
+  const size = () => resolveSize(theme, parsed);
+  const negatableLength = () => resolveNegatableLength(theme, parsed);
+  switch (parsed.utility) {
+    case "p": {
+      const v = length();
+      return v === null ? null : [decl("padding", v)];
+    }
+    case "px": {
+      const v = length();
+      return v === null ? null : [decl("padding-left", v), decl("padding-right", v)];
+    }
+    case "py": {
+      const v = length();
+      return v === null ? null : [decl("padding-top", v), decl("padding-bottom", v)];
+    }
+    case "pt": {
+      const v = length();
+      return v === null ? null : [decl("padding-top", v)];
+    }
+    case "pr": {
+      const v = length();
+      return v === null ? null : [decl("padding-right", v)];
+    }
+    case "pb": {
+      const v = length();
+      return v === null ? null : [decl("padding-bottom", v)];
+    }
+    case "pl": {
+      const v = length();
+      return v === null ? null : [decl("padding-left", v)];
+    }
+    case "m": {
+      const v = negatableLength();
+      return v === null ? null : [decl("margin", v)];
+    }
+    case "mx": {
+      const v = negatableLength();
+      return v === null ? null : [decl("margin-left", v), decl("margin-right", v)];
+    }
+    case "my": {
+      const v = negatableLength();
+      return v === null ? null : [decl("margin-top", v), decl("margin-bottom", v)];
+    }
+    case "mt": {
+      const v = negatableLength();
+      return v === null ? null : [decl("margin-top", v)];
+    }
+    case "mr": {
+      const v = negatableLength();
+      return v === null ? null : [decl("margin-right", v)];
+    }
+    case "mb": {
+      const v = negatableLength();
+      return v === null ? null : [decl("margin-bottom", v)];
+    }
+    case "ml": {
+      const v = negatableLength();
+      return v === null ? null : [decl("margin-left", v)];
+    }
+    case "gap": {
+      const v = length();
+      return v === null ? null : [decl("gap", v)];
+    }
+    case "gap-x": {
+      const v = length();
+      return v === null ? null : [decl("column-gap", v)];
+    }
+    case "gap-y": {
+      const v = length();
+      return v === null ? null : [decl("row-gap", v)];
+    }
+    case "w": {
+      const v = size();
+      return v === null ? null : [decl("width", v)];
+    }
+    case "h": {
+      const v = size();
+      return v === null ? null : [decl("height", v)];
+    }
+    case "min-w": {
+      const v = size();
+      return v === null ? null : [decl("min-width", v)];
+    }
+    case "max-w": {
+      const v = size();
+      return v === null ? null : [decl("max-width", v)];
+    }
+    case "min-h": {
+      const v = size();
+      return v === null ? null : [decl("min-height", v)];
+    }
+    case "max-h": {
+      const v = size();
+      return v === null ? null : [decl("max-height", v)];
+    }
+    case "size": {
+      const v = size();
+      return v === null ? null : [decl("width", v), decl("height", v)];
+    }
+    case "basis": {
+      const v = size();
+      return v === null ? null : [decl("flex-basis", v)];
+    }
+    default:
+      return null;
+  }
 }
 
-// src/nativeBridge.ts
-function resolveStyle(classString, pressed = false) {
-  const KbachModule = import_react_native2.TurboModuleRegistry.getEnforcing("KbachModule");
-  const colorScheme = getGlobalDarkMode() ? "dark" : "light";
-  const width = import_react_native2.Dimensions.get("window").width;
-  const json = KbachModule.resolveStyle(classString, getThemeJson(), colorScheme, pressed, width);
-  return JSON.parse(json);
+// src/jsEngine/resolvers/color.ts
+function lookupHex(theme, key) {
+  const entry = theme.colors[key];
+  return typeof entry === "string" ? entry : null;
+}
+function hexToRgb(hex) {
+  const m = /^#([0-9a-f]{3}|[0-9a-f]{6})$/i.exec(hex.trim());
+  if (!m) return null;
+  let h = m[1];
+  if (h.length === 3) h = h.split("").map((c) => c + c).join("");
+  const n = parseInt(h, 16);
+  return [n >> 16 & 255, n >> 8 & 255, n & 255];
+}
+function splitOpacity(value) {
+  const slash = value.lastIndexOf("/");
+  if (slash === -1) return [value, null];
+  const opacityText = value.slice(slash + 1);
+  const n = Number(opacityText);
+  if (opacityText !== "" && Number.isInteger(n) && n >= 0 && n <= 100) {
+    return [value.slice(0, slash), n];
+  }
+  return [value, null];
+}
+function colorValue(theme, parsed) {
+  const value = parsed.value;
+  if (value === null) return null;
+  if (parsed.isArbitrary) return value;
+  const [name, opacity] = splitOpacity(value);
+  const hex = lookupHex(theme, name);
+  if (hex === null) return null;
+  if (opacity === null) return hex;
+  const rgb = hexToRgb(hex);
+  if (rgb === null) return hex;
+  return `rgba(${rgb.join(",")},${opacity / 100})`;
 }
 
-// src/useGlobalDarkMode.ts
-var import_react = require("react");
-function useGlobalDarkMode() {
-  return (0, import_react.useSyncExternalStore)(subscribeGlobalDarkMode, getGlobalDarkMode);
+// src/jsEngine/resolvers/border.ts
+function radiusSize(key) {
+  switch (key) {
+    case "none":
+      return "0px";
+    case "sm":
+      return "0.125rem";
+    case "md":
+      return "0.375rem";
+    case "lg":
+      return "0.5rem";
+    case "xl":
+      return "0.75rem";
+    case "2xl":
+      return "1rem";
+    case "3xl":
+      return "1.5rem";
+    case "full":
+      return "9999px";
+    default:
+      return null;
+  }
+}
+function borderSideProperty(side) {
+  switch (side) {
+    case "t":
+      return "border-top";
+    case "r":
+      return "border-right";
+    case "b":
+      return "border-bottom";
+    case "l":
+      return "border-left";
+    default:
+      return null;
+  }
+}
+function borderValue(theme, parsed) {
+  const value = parsed.value;
+  if (value === null) return null;
+  if (!parsed.isArbitrary) {
+    const side = borderSideProperty(value);
+    if (side !== null) {
+      return [decl(`${side}-width`, "1px"), decl(`${side}-style`, "solid")];
+    }
+    if (value === "collapse") return [decl("border-collapse", "collapse")];
+    if (value === "separate") return [decl("border-collapse", "separate")];
+  }
+  if (parsed.isArbitrary) {
+    return [decl("border-width", value)];
+  }
+  if (Number.isFinite(Number(value)) && value.trim() !== "") {
+    const v = resolveLength(theme, parsed);
+    return v === null ? null : [decl("border-width", v)];
+  }
+  if (value === "solid" || value === "dashed" || value === "dotted" || value === "double" || value === "hidden" || value === "none") {
+    return [decl("border-style", value)];
+  }
+  const color = colorValue(theme, parsed);
+  return color === null ? null : [decl("border-color", color)];
+}
+function borderSideValue(theme, parsed, sideProperty) {
+  const value = parsed.value;
+  if (value === null) return null;
+  if (parsed.isArbitrary) return [decl(`${sideProperty}-width`, value)];
+  if (Number.isFinite(Number(value)) && value.trim() !== "") {
+    const v = resolveLength(theme, parsed);
+    return v === null ? null : [decl(`${sideProperty}-width`, v)];
+  }
+  if (value === "solid" || value === "dashed" || value === "dotted" || value === "double" || value === "hidden" || value === "none") {
+    return [decl(`${sideProperty}-style`, value)];
+  }
+  const color = colorValue(theme, parsed);
+  return color === null ? null : [decl(`${sideProperty}-color`, color)];
+}
+function borderAxisValue(theme, parsed, sideA, sideB) {
+  const value = parsed.value;
+  if (value === null) return null;
+  if (parsed.isArbitrary) return [decl(`${sideA}-width`, value), decl(`${sideB}-width`, value)];
+  if (Number.isFinite(Number(value)) && value.trim() !== "") {
+    const v = resolveLength(theme, parsed);
+    return v === null ? null : [decl(`${sideA}-width`, v), decl(`${sideB}-width`, v)];
+  }
+  if (value === "solid" || value === "dashed" || value === "dotted" || value === "double" || value === "hidden" || value === "none") {
+    return [decl(`${sideA}-style`, value), decl(`${sideB}-style`, value)];
+  }
+  const color = colorValue(theme, parsed);
+  return color === null ? null : [decl(`${sideA}-color`, color), decl(`${sideB}-color`, color)];
+}
+function radiusProperties(side) {
+  switch (side) {
+    case "t":
+      return ["border-top-left-radius", "border-top-right-radius"];
+    case "r":
+      return ["border-top-right-radius", "border-bottom-right-radius"];
+    case "b":
+      return ["border-bottom-right-radius", "border-bottom-left-radius"];
+    case "l":
+      return ["border-top-left-radius", "border-bottom-left-radius"];
+    case "tl":
+      return ["border-top-left-radius"];
+    case "tr":
+      return ["border-top-right-radius"];
+    case "br":
+      return ["border-bottom-right-radius"];
+    case "bl":
+      return ["border-bottom-left-radius"];
+    default:
+      return null;
+  }
+}
+function resolveRadiusValue(theme, parsed) {
+  if (!parsed.isArbitrary && parsed.value !== null) {
+    const size = radiusSize(parsed.value);
+    if (size !== null) return size;
+  }
+  return resolveLength(theme, parsed);
+}
+function resolveRadiusSide(theme, parsed, side) {
+  const properties = radiusProperties(side);
+  if (properties === null) return null;
+  const value = resolveRadiusValue(theme, parsed);
+  if (value === null) return null;
+  return properties.map((p) => decl(p, value));
+}
+var OUTLINE_STYLES = ["solid", "dashed", "dotted", "double"];
+function outlineWidthValue(key) {
+  switch (key) {
+    case "0":
+      return "0px";
+    case "1":
+      return "1px";
+    case "2":
+      return "2px";
+    case "4":
+      return "4px";
+    case "8":
+      return "8px";
+    default:
+      return null;
+  }
+}
+function outlineValue(theme, parsed) {
+  const value = parsed.value;
+  if (value === null) return null;
+  if (parsed.isArbitrary) return [decl("outline-width", value)];
+  const w = outlineWidthValue(value);
+  if (w !== null) return [decl("outline-width", w)];
+  if (OUTLINE_STYLES.includes(value)) return [decl("outline-style", value)];
+  const color = colorValue(theme, parsed);
+  return color === null ? null : [decl("outline-color", color)];
+}
+function outlineOffsetValue(parsed) {
+  const value = parsed.value;
+  if (value === null) return null;
+  if (parsed.isArbitrary) return [decl("outline-offset", value)];
+  const w = outlineWidthValue(value);
+  return w === null ? null : [decl("outline-offset", w)];
+}
+var RING_BOX_SHADOW = "var(--kb-ring-inset,) 0 0 0 var(--kb-ring-offset-width, 0px) var(--kb-ring-offset-color, #fff), var(--kb-ring-inset,) 0 0 0 calc(var(--kb-ring-width, 0px) + var(--kb-ring-offset-width, 0px)) var(--kb-ring-color, rgba(59,130,246,0.5))";
+function ringWidth(key) {
+  switch (key) {
+    case "0":
+      return "0px";
+    case "1":
+      return "1px";
+    case "2":
+      return "2px";
+    case "4":
+      return "4px";
+    case "8":
+      return "8px";
+    default:
+      return null;
+  }
+}
+function ringValue(theme, parsed) {
+  const value = parsed.value;
+  if (value === null) return null;
+  if (value === "inset") {
+    return [decl("--kb-ring-inset", "inset"), decl("box-shadow", RING_BOX_SHADOW)];
+  }
+  if (!parsed.isArbitrary) {
+    const w = ringWidth(value);
+    if (w !== null) return [decl("--kb-ring-width", w), decl("box-shadow", RING_BOX_SHADOW)];
+  }
+  const color = colorValue(theme, parsed);
+  if (color === null) return null;
+  return [decl("--kb-ring-color", color), decl("box-shadow", RING_BOX_SHADOW)];
+}
+function ringOffsetValue(theme, parsed) {
+  const value = parsed.value;
+  if (value === null) return null;
+  if (!parsed.isArbitrary) {
+    const w = ringWidth(value);
+    if (w !== null) return [decl("--kb-ring-offset-width", w), decl("box-shadow", RING_BOX_SHADOW)];
+  }
+  const color = colorValue(theme, parsed);
+  if (color === null) return null;
+  return [decl("--kb-ring-offset-color", color), decl("box-shadow", RING_BOX_SHADOW)];
+}
+var RADIUS_SIDES = /* @__PURE__ */ new Set(["t", "r", "b", "l", "tl", "tr", "br", "bl"]);
+function resolve3(parsed, theme) {
+  switch (parsed.utility) {
+    case "border":
+      if (parsed.value === null) return [decl("border-width", "1px"), decl("border-style", "solid")];
+      return borderValue(theme, parsed);
+    case "border-t":
+      return borderSideValue(theme, parsed, "border-top");
+    case "border-r":
+      return borderSideValue(theme, parsed, "border-right");
+    case "border-b":
+      return borderSideValue(theme, parsed, "border-bottom");
+    case "border-l":
+      return borderSideValue(theme, parsed, "border-left");
+    case "border-x":
+      return borderAxisValue(theme, parsed, "border-left", "border-right");
+    case "border-y":
+      return borderAxisValue(theme, parsed, "border-top", "border-bottom");
+    case "rounded": {
+      if (parsed.value === null) return [decl("border-radius", "0.25rem")];
+      const value = parsed.value;
+      if (!parsed.isArbitrary) {
+        const size = radiusSize(value);
+        if (size !== null) return [decl("border-radius", size)];
+      }
+      const v = resolveLength(theme, parsed);
+      return v === null ? null : [decl("border-radius", v)];
+    }
+    case "ring":
+      if (parsed.value === null) return [decl("--kb-ring-width", "3px"), decl("box-shadow", RING_BOX_SHADOW)];
+      return ringValue(theme, parsed);
+    case "ring-offset":
+      return ringOffsetValue(theme, parsed);
+    case "outline":
+      if (parsed.value === null) return [decl("outline-style", "solid")];
+      if (parsed.value === "none") return [decl("outline", "none")];
+      return outlineValue(theme, parsed);
+    case "outline-offset":
+      return outlineOffsetValue(parsed);
+    default:
+      if (parsed.utility.startsWith("rounded-") && RADIUS_SIDES.has(parsed.utility.slice("rounded-".length))) {
+        return resolveRadiusSide(theme, parsed, parsed.utility.slice("rounded-".length));
+      }
+      return null;
+  }
 }
 
-// src/ThemeProvider.tsx
-var import_react3 = require("react");
+// src/jsEngine/resolvers/typography.ts
+function textSize(key) {
+  switch (key) {
+    case "xs":
+      return "0.75rem";
+    case "sm":
+      return "0.875rem";
+    case "base":
+      return "1rem";
+    case "lg":
+      return "1.125rem";
+    case "xl":
+      return "1.25rem";
+    case "2xl":
+      return "1.5rem";
+    case "3xl":
+      return "1.875rem";
+    case "4xl":
+      return "2.25rem";
+    case "5xl":
+      return "3rem";
+    case "6xl":
+      return "3.75rem";
+    case "7xl":
+      return "4.5rem";
+    case "8xl":
+      return "6rem";
+    case "9xl":
+      return "8rem";
+    default:
+      return null;
+  }
+}
+function lineHeightSize(key) {
+  switch (key) {
+    case "3":
+      return "0.75rem";
+    case "4":
+      return "1rem";
+    case "5":
+      return "1.25rem";
+    case "6":
+      return "1.5rem";
+    case "7":
+      return "1.75rem";
+    case "8":
+      return "2rem";
+    case "9":
+      return "2.25rem";
+    case "10":
+      return "2.5rem";
+    default:
+      return null;
+  }
+}
+function textAlign(key) {
+  switch (key) {
+    case "left":
+      return "left";
+    case "center":
+      return "center";
+    case "right":
+      return "right";
+    case "justify":
+      return "justify";
+    // Logical alignment — same "no direction-tracking logic needed" reasoning
+    // as layout.rs's start/end inset properties.
+    case "start":
+      return "start";
+    case "end":
+      return "end";
+    default:
+      return null;
+  }
+}
+function fontWeight(key) {
+  switch (key) {
+    case "thin":
+      return "100";
+    case "extralight":
+      return "200";
+    case "light":
+      return "300";
+    case "normal":
+      return "400";
+    case "medium":
+      return "500";
+    case "semibold":
+      return "600";
+    case "bold":
+      return "700";
+    case "extrabold":
+      return "800";
+    case "black":
+      return "900";
+    default:
+      return null;
+  }
+}
+function fontFamilyValue(theme, key) {
+  const fromTheme = theme.fontFamily?.[key];
+  if (fromTheme !== void 0) return fromTheme;
+  switch (key) {
+    case "sans":
+      return 'ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji"';
+    case "serif":
+      return 'ui-serif, Georgia, Cambria, "Times New Roman", Times, serif';
+    case "mono":
+      return 'ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace';
+    default:
+      return null;
+  }
+}
 
-// src/ThemeContext.tsx
-var import_react2 = require("react");
-var ThemeContext = (0, import_react2.createContext)(null);
-function useTheme() {
-  const ctx = (0, import_react2.useContext)(ThemeContext);
-  if (!ctx) {
-    throw new Error(
-      'useTheme() must be called within a <ThemeProvider>. For dark-mode state without a provider, use useGlobalDarkMode() (read) or toggleGlobalDarkMode()/setGlobalThemeMode() (write) from "@kbach/react-native" instead.'
+// src/jsEngine/resolvers/effects.ts
+function nativeShadowValue(key) {
+  switch (key) {
+    case "sm":
+      return { offsetY: 1, radius: 2, opacity: 0.05, elevation: 1 };
+    case "DEFAULT":
+      return { offsetY: 1, radius: 3, opacity: 0.1, elevation: 2 };
+    case "md":
+      return { offsetY: 4, radius: 6, opacity: 0.1, elevation: 4 };
+    case "lg":
+      return { offsetY: 10, radius: 15, opacity: 0.1, elevation: 8 };
+    case "xl":
+      return { offsetY: 20, radius: 25, opacity: 0.1, elevation: 12 };
+    case "2xl":
+      return { offsetY: 25, radius: 50, opacity: 0.25, elevation: 16 };
+    case "none":
+      return { offsetY: 0, radius: 0, opacity: 0, elevation: 0 };
+    default:
+      return null;
+  }
+}
+function nativeShadowDeclarations(parsed) {
+  if (parsed.utility !== "shadow" || parsed.isArbitrary) return null;
+  const key = parsed.value ?? "DEFAULT";
+  const s = nativeShadowValue(key);
+  if (s === null) return null;
+  return [
+    decl("shadow-color", "#000000"),
+    decl("shadow-offset-x", "0"),
+    decl("shadow-offset-y", String(s.offsetY)),
+    decl("shadow-opacity", String(s.opacity)),
+    decl("shadow-radius", String(s.radius)),
+    decl("elevation", String(s.elevation))
+  ];
+}
+
+// src/jsEngine/resolvers/transform.ts
+function scaleFactor(parsed) {
+  if (parsed.value === null) return null;
+  const n = Number(parsed.value);
+  if (!Number.isFinite(n)) return null;
+  return parsed.isArbitrary ? n : n / 100;
+}
+function angle(parsed) {
+  if (parsed.value === null) return null;
+  if (parsed.isArbitrary) return parsed.value;
+  const n = Number(parsed.value);
+  if (!Number.isFinite(n)) return null;
+  return `${parsed.negative ? -n : n}deg`;
+}
+function resolveNative(parsed, theme) {
+  switch (parsed.utility) {
+    case "transform-none":
+      return [decl("transform-op-none", "1")];
+    case "backface-visible":
+      return [decl("backface-visibility", "visible")];
+    case "backface-hidden":
+      return [decl("backface-visibility", "hidden")];
+    case "translate-x": {
+      const v = resolveNegatableSize(theme, parsed);
+      return v === null ? null : [decl("transform-op-translate-x", v)];
+    }
+    case "translate-y": {
+      const v = resolveNegatableSize(theme, parsed);
+      return v === null ? null : [decl("transform-op-translate-y", v)];
+    }
+    case "scale": {
+      const n = scaleFactor(parsed);
+      return n === null ? null : [decl("transform-op-scale-x", `${n}`), decl("transform-op-scale-y", `${n}`)];
+    }
+    case "scale-x": {
+      const n = scaleFactor(parsed);
+      return n === null ? null : [decl("transform-op-scale-x", `${n}`)];
+    }
+    case "scale-y": {
+      const n = scaleFactor(parsed);
+      return n === null ? null : [decl("transform-op-scale-y", `${n}`)];
+    }
+    case "rotate": {
+      const deg = angle(parsed);
+      return deg === null ? null : [decl("transform-op-rotate", deg)];
+    }
+    case "rotate-x": {
+      const deg = angle(parsed);
+      return deg === null ? null : [decl("transform-op-rotate-x", deg)];
+    }
+    case "rotate-y": {
+      const deg = angle(parsed);
+      return deg === null ? null : [decl("transform-op-rotate-y", deg)];
+    }
+    case "rotate-z": {
+      const deg = angle(parsed);
+      return deg === null ? null : [decl("transform-op-rotate-z", deg)];
+    }
+    case "skew-x": {
+      const deg = angle(parsed);
+      return deg === null ? null : [decl("transform-op-skew-x", deg)];
+    }
+    case "skew-y": {
+      const deg = angle(parsed);
+      return deg === null ? null : [decl("transform-op-skew-y", deg)];
+    }
+    default:
+      return null;
+  }
+}
+
+// src/jsEngine/resolveUtilityNative.ts
+function firstFontName(stack) {
+  const first = stack.split(",")[0] ?? stack;
+  return first.trim().replace(/^["']|["']$/g, "");
+}
+function resolveTypographyNative(parsed, theme) {
+  switch (parsed.utility) {
+    case "font": {
+      if (parsed.value === null) return null;
+      if (parsed.isArbitrary) {
+        return [decl("font-family", firstFontName(parsed.value))];
+      }
+      const w = fontWeight(parsed.value);
+      if (w !== null) return [decl("font-weight", w)];
+      const family = fontFamilyValue(theme, parsed.value);
+      return family === null ? null : [decl("font-family", firstFontName(family))];
+    }
+    case "uppercase":
+      return [decl("text-transform", "uppercase")];
+    case "lowercase":
+      return [decl("text-transform", "lowercase")];
+    case "capitalize":
+      return [decl("text-transform", "capitalize")];
+    case "underline":
+      return [decl("text-decoration-line", "underline")];
+    case "line-through":
+      return [decl("text-decoration-line", "line-through")];
+    case "no-underline":
+      return [decl("text-decoration-line", "none")];
+    case "italic":
+      return [decl("font-style", "italic")];
+    case "not-italic":
+      return [decl("font-style", "normal")];
+    default:
+      return null;
+  }
+}
+function resolveLeadingTrackingNative(parsed) {
+  const value = parsed.value;
+  if (value === null) return null;
+  if (parsed.utility === "leading") {
+    if (parsed.isArbitrary) return [decl("line-height", value)];
+    const v = lineHeightSize(value);
+    return v === null ? null : [decl("line-height", v)];
+  }
+  if (parsed.utility === "tracking" && parsed.isArbitrary) {
+    return [decl("letter-spacing", value)];
+  }
+  return null;
+}
+function nativeHexColor(parsed, theme) {
+  return colorValue(theme, parsed);
+}
+function resolveTextNative(parsed, theme) {
+  if (!parsed.isArbitrary && parsed.value !== null) {
+    const size = textSize(parsed.value);
+    if (size !== null) return [decl("font-size", size)];
+    const align = textAlign(parsed.value);
+    if (align !== null) return [decl("text-align", align)];
+  }
+  const hex = nativeHexColor(parsed, theme);
+  return hex === null ? null : [decl("color", hex)];
+}
+function resolveColorNative(parsed, theme) {
+  switch (parsed.utility) {
+    case "bg": {
+      const hex = nativeHexColor(parsed, theme);
+      return hex === null ? null : [decl("background-color", hex)];
+    }
+    case "text":
+      return resolveTextNative(parsed, theme);
+    default:
+      return null;
+  }
+}
+function resolveOpacityNative(parsed) {
+  if (parsed.utility !== "opacity") return null;
+  const v = resolvePercent(parsed);
+  return v === null ? null : [decl("opacity", v)];
+}
+function resolveUtilityNative(parsed, theme) {
+  return resolveFlex(parsed, false) ?? resolve(parsed, theme) ?? resolve2(parsed, theme) ?? resolve3(parsed, theme) ?? resolveColorNative(parsed, theme) ?? resolveLeadingTrackingNative(parsed) ?? resolveTypographyNative(parsed, theme) ?? resolveOpacityNative(parsed) ?? nativeShadowDeclarations(parsed) ?? resolveNative(parsed, theme);
+}
+
+// src/jsEngine/calc.ts
+function reduceConstantMath(raw) {
+  const trimmed = raw.trim();
+  const calc = stripCall(trimmed, "calc");
+  if (calc !== null) {
+    return new Evaluator(calc).parseExprToEnd();
+  }
+  const clamp = stripCall(trimmed, "clamp");
+  if (clamp !== null) {
+    const args = splitTopLevelCommas(clamp);
+    if (args.length !== 3) return null;
+    const [min2, preferred, max2] = args.map((a) => new Evaluator(a).parseExprToEnd());
+    if (min2 === null || preferred === null || max2 === null) return null;
+    return Math.max(min2, Math.min(preferred, max2));
+  }
+  const min = stripCall(trimmed, "min");
+  if (min !== null) {
+    const values = splitTopLevelCommas(min).map((a) => new Evaluator(a).parseExprToEnd());
+    return values.some((v) => v === null) ? null : Math.min(...values);
+  }
+  const max = stripCall(trimmed, "max");
+  if (max !== null) {
+    const values = splitTopLevelCommas(max).map((a) => new Evaluator(a).parseExprToEnd());
+    return values.some((v) => v === null) ? null : Math.max(...values);
+  }
+  return null;
+}
+function stripCall(raw, name) {
+  if (!raw.startsWith(name)) return null;
+  const afterName = raw.slice(name.length).trimStart();
+  if (!afterName.startsWith("(") || !afterName.endsWith(")")) return null;
+  return afterName.slice(1, -1);
+}
+function splitTopLevelCommas(s) {
+  const parts = [];
+  let depth = 0;
+  let start = 0;
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i];
+    if (ch === "(") depth++;
+    else if (ch === ")") depth--;
+    else if (ch === "," && depth === 0) {
+      parts.push(s.slice(start, i).trim());
+      start = i + 1;
+    }
+  }
+  parts.push(s.slice(start).trim());
+  return parts;
+}
+var Evaluator = class {
+  constructor(s) {
+    this.pos = 0;
+    this.s = s;
+  }
+  parseExprToEnd() {
+    const value = this.expr();
+    if (value === null) return null;
+    this.skipWs();
+    return this.pos === this.s.length ? value : null;
+  }
+  skipWs() {
+    while (this.pos < this.s.length && /\s/.test(this.s[this.pos])) this.pos++;
+  }
+  peek() {
+    this.skipWs();
+    return this.s[this.pos];
+  }
+  expr() {
+    let value = this.term();
+    if (value === null) return null;
+    for (; ; ) {
+      const ch = this.peek();
+      if (ch === "+") {
+        this.pos++;
+        const rhs = this.term();
+        if (rhs === null) return null;
+        value += rhs;
+      } else if (ch === "-") {
+        this.pos++;
+        const rhs = this.term();
+        if (rhs === null) return null;
+        value -= rhs;
+      } else {
+        return value;
+      }
+    }
+  }
+  term() {
+    let value = this.factor();
+    if (value === null) return null;
+    for (; ; ) {
+      const ch = this.peek();
+      if (ch === "*") {
+        this.pos++;
+        const rhs = this.factor();
+        if (rhs === null) return null;
+        value *= rhs;
+      } else if (ch === "/") {
+        this.pos++;
+        const divisor = this.factor();
+        if (divisor === null || divisor === 0) return null;
+        value /= divisor;
+      } else {
+        return value;
+      }
+    }
+  }
+  factor() {
+    const ch = this.peek();
+    if (ch === void 0) return null;
+    if (ch === "(") {
+      this.pos++;
+      const value = this.expr();
+      if (value === null || this.peek() !== ")") return null;
+      this.pos++;
+      return value;
+    }
+    if (ch === "-") {
+      this.pos++;
+      const value = this.factor();
+      return value === null ? null : -value;
+    }
+    return this.numberWithUnit();
+  }
+  numberWithUnit() {
+    this.skipWs();
+    const start = this.pos;
+    while (this.pos < this.s.length && (/[0-9]/.test(this.s[this.pos]) || this.s[this.pos] === ".")) this.pos++;
+    if (this.pos === start) return null;
+    const n = Number(this.s.slice(start, this.pos));
+    if (!Number.isFinite(n)) return null;
+    const unitStart = this.pos;
+    while (this.pos < this.s.length && /[a-zA-Z]/.test(this.s[this.pos])) this.pos++;
+    const unit = this.s.slice(unitStart, this.pos);
+    switch (unit) {
+      case "":
+        return n;
+      case "px":
+        return n;
+      case "rem":
+        return n * 16;
+      default:
+        return null;
+    }
+  }
+};
+
+// src/jsEngine/resolveStyle.ts
+var RESPONSIVE_BREAKPOINTS = /* @__PURE__ */ new Set(["sm", "md", "lg", "xl", "2xl"]);
+function nativeModifierState(modifier, theme, colorScheme, pressed, width) {
+  if (modifier === "dark") return colorScheme === "dark";
+  if (modifier === "active") return pressed;
+  if (RESPONSIVE_BREAKPOINTS.has(modifier)) {
+    const minWidth = theme.screens[modifier];
+    if (minWidth === void 0) return null;
+    return width >= minWidth;
+  }
+  return null;
+}
+function kebabToCamel(s) {
+  return s.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+var NUMERIC_LENGTH_PROPS = /* @__PURE__ */ new Set([
+  "padding",
+  "padding-top",
+  "padding-right",
+  "padding-bottom",
+  "padding-left",
+  "margin",
+  "margin-top",
+  "margin-right",
+  "margin-bottom",
+  "margin-left",
+  "gap",
+  "column-gap",
+  "row-gap",
+  "width",
+  "height",
+  "min-width",
+  "max-width",
+  "min-height",
+  "max-height",
+  "top",
+  "right",
+  "bottom",
+  "left",
+  "inset",
+  "border-radius",
+  "border-width",
+  "font-size",
+  "z-index",
+  "line-height",
+  "letter-spacing",
+  "flex",
+  "flex-grow",
+  "flex-shrink",
+  "order",
+  "flex-basis",
+  "shadow-opacity",
+  "shadow-radius",
+  "elevation",
+  "opacity",
+  // Per-side border width + per-corner radius — see resolvers/border.ts's
+  // new borderSideValue/borderAxisValue/resolveRadiusSide additions; RN's
+  // style system wants plain numbers for these exactly like the generic
+  // "border-width"/"border-radius" forms above.
+  "border-top-width",
+  "border-right-width",
+  "border-bottom-width",
+  "border-left-width",
+  "border-top-left-radius",
+  "border-top-right-radius",
+  "border-bottom-right-radius",
+  "border-bottom-left-radius",
+  "outline-width",
+  "outline-offset",
+  // The transform ops whose RN value is a plain JS number — translate takes
+  // a length (px/percentage, same as top/left/etc. above) and scale takes a
+  // bare decimal factor (parsed by the same "raw value" fallback branch
+  // below). transform-op-rotate*/transform-op-skew* stay OUT of this set on
+  // purpose, since RN wants those as literal "45deg"-shaped strings, not
+  // numbers. See the transform-ops accumulator below for how these markers
+  // get collected into the final array.
+  "transform-op-translate-x",
+  "transform-op-translate-y",
+  "transform-op-scale-x",
+  "transform-op-scale-y"
+]);
+var TRANSFORM_OP_KEYS = /* @__PURE__ */ new Map([
+  ["transform-op-translate-x", "translateX"],
+  ["transform-op-translate-y", "translateY"],
+  ["transform-op-rotate", "rotate"],
+  ["transform-op-rotate-x", "rotateX"],
+  ["transform-op-rotate-y", "rotateY"],
+  ["transform-op-rotate-z", "rotateZ"],
+  ["transform-op-skew-x", "skewX"],
+  ["transform-op-skew-y", "skewY"],
+  ["transform-op-scale-x", "scaleX"],
+  ["transform-op-scale-y", "scaleY"]
+]);
+var TRANSFORM_OP_ORDER = ["translateX", "translateY", "rotate", "rotateX", "rotateY", "rotateZ", "skewX", "skewY", "scaleX", "scaleY"];
+function isPlainPercentage(value) {
+  if (!value.endsWith("%")) return false;
+  let digits = value.slice(0, -1);
+  if (digits.startsWith("-")) digits = digits.slice(1);
+  return digits.length > 0 && /^[0-9.]+$/.test(digits);
+}
+function rnStyleValue(property, value) {
+  if (!NUMERIC_LENGTH_PROPS.has(property)) {
+    return { value, warning: null };
+  }
+  let px = null;
+  if (value.endsWith("px")) {
+    const n = Number(value.slice(0, -2));
+    px = Number.isFinite(n) ? n : null;
+  } else if (value.endsWith("rem")) {
+    const n = Number(value.slice(0, -3));
+    px = Number.isFinite(n) ? n * 16 : null;
+  } else {
+    const n = Number(value);
+    px = value.trim() !== "" && Number.isFinite(n) ? n : null;
+  }
+  if (px !== null) return { value: px, warning: null };
+  if (isPlainPercentage(value)) {
+    return { value, warning: null };
+  }
+  const reduced = reduceConstantMath(value);
+  if (reduced !== null) {
+    return { value: reduced, warning: null };
+  }
+  const warning = `[Kbach] "${value}" isn't a valid native value for "${property}" \u2014 dropped.
+calc()/min()/max()/clamp() only resolve on native when every operand is a constant px/rem length (no %, vw, vh, var(), or other viewport/CSS-variable units \u2014 those need real layout/DOM, which doesn't exist on native at paint time).
+Fix: use a plain px/rem calc, a fraction utility (e.g. w-1/2), or resolve this value in JS instead.`;
+  return { value: null, warning };
+}
+function resolveStyleJsWithWarnings(classString, theme, colorScheme, pressed, width) {
+  const style = {};
+  const warnings = [];
+  let shadowOffset = null;
+  const transformOps = /* @__PURE__ */ new Map();
+  for (const token of classString.split(/\s+/).filter(Boolean)) {
+    const parsed = parseClass(token);
+    const allModifiersHold = parsed.modifiers.every(
+      (m) => nativeModifierState(m, theme, colorScheme, pressed, width) === true
     );
+    if (!allModifiersHold) continue;
+    const decls = resolveUtilityNative(parsed, theme);
+    if (decls === null) continue;
+    for (const d of decls) {
+      if (d.property.startsWith("__")) {
+        continue;
+      }
+      if (d.property === "shadow-offset-x" || d.property === "shadow-offset-y") {
+        const n = Number(d.value);
+        if (!Number.isFinite(n)) continue;
+        if (shadowOffset === null) shadowOffset = {};
+        shadowOffset[d.property === "shadow-offset-x" ? "width" : "height"] = n;
+        continue;
+      }
+      if (d.property === "transform-op-none") {
+        transformOps.clear();
+        continue;
+      }
+      const opKey = TRANSFORM_OP_KEYS.get(d.property);
+      if (opKey !== void 0) {
+        const { value: value2, warning: warning2 } = rnStyleValue(d.property, d.value);
+        if (warning2 !== null) warnings.push(warning2);
+        if (value2 !== null) transformOps.set(opKey, value2);
+        continue;
+      }
+      const { value, warning } = rnStyleValue(d.property, d.value);
+      if (warning !== null) warnings.push(warning);
+      if (value !== null) style[kebabToCamel(d.property)] = value;
+    }
+  }
+  if (shadowOffset !== null) {
+    style.shadowOffset = { width: shadowOffset.width ?? 0, height: shadowOffset.height ?? 0 };
+  }
+  if (transformOps.size > 0) {
+    style.transform = TRANSFORM_OP_ORDER.filter((key) => transformOps.has(key)).map((key) => ({
+      [key]: transformOps.get(key)
+    }));
+  }
+  return { style, warnings };
+}
+
+// src/nativeBridge.ts
+var RESOLVE_STYLE_CACHE_MAX = 500;
+var resolveStyleCache = /* @__PURE__ */ new Map();
+var cachedForThemeJson = null;
+function resolveStyle(classString, pressed = false) {
+  const colorScheme = (0, import_darkModeStore.getGlobalDarkMode)() ? "dark" : "light";
+  const width = import_react_native.Dimensions.get("window").width;
+  const themeJson = (0, import_theme.getThemeJson)();
+  if (themeJson !== cachedForThemeJson) {
+    resolveStyleCache.clear();
+    cachedForThemeJson = themeJson;
+  }
+  const cacheKey = `${classString}\0${pressed}\0${colorScheme}\0${width}`;
+  const cached = resolveStyleCache.get(cacheKey);
+  if (cached !== void 0) return { ...cached };
+  const style = resolveStyleUncached(classString, pressed, colorScheme, width, themeJson);
+  if (resolveStyleCache.size >= RESOLVE_STYLE_CACHE_MAX) resolveStyleCache.clear();
+  resolveStyleCache.set(cacheKey, style);
+  return { ...style };
+}
+function resolveStyleUncached(classString, pressed, colorScheme, width, themeJson) {
+  const KbachModule = import_react_native.TurboModuleRegistry.get("KbachModule");
+  if (!KbachModule) {
+    const { style: style2, warnings: warnings2 } = resolveStyleJsWithWarnings(classString, (0, import_theme.getTheme)(), colorScheme, pressed, width);
+    warnIfDev(classString, warnings2);
+    return style2;
+  }
+  const json = KbachModule.resolveStyle(classString, themeJson, colorScheme, pressed, width);
+  const style = JSON.parse(json);
+  const warnings = style.__kbachWarnings;
+  if (warnings !== void 0) {
+    delete style.__kbachWarnings;
+    warnIfDev(classString, warnings);
+  }
+  return style;
+}
+var warnedMessages = /* @__PURE__ */ new Set();
+function warnIfDev(classString, warnings) {
+  if (warnings.length === 0) return;
+  if (typeof __DEV__ !== "undefined" && !__DEV__) return;
+  for (const warning of warnings) {
+    const message = `${warning}
+From className: "${classString}"`;
+    if (warnedMessages.has(message)) continue;
+    warnedMessages.add(message);
+    console.warn(message);
+  }
+}
+
+// src/config.ts
+var import_theme2 = require("./theme");
+var import_darkModeStore2 = require("./darkModeStore");
+function parseHexRgb(hex) {
+  const m = /^#([0-9a-f]{3}|[0-9a-f]{6})$/i.exec(hex.trim());
+  if (!m) return null;
+  let h = m[1];
+  if (h.length === 3) h = h.split("").map((c) => c + c).join("");
+  const n = parseInt(h, 16);
+  return [n >> 16 & 255, n >> 8 & 255, n & 255];
+}
+function applyOpacityToHex(hex, opacityText) {
+  const rgb = parseHexRgb(hex);
+  if (!rgb) return hex;
+  const a = Number(opacityText) / 100;
+  const clamped = Number.isFinite(a) ? Math.min(1, Math.max(0, a)) : 1;
+  return `rgba(${rgb.join(",")},${clamped})`;
+}
+function resolveColorEntry(value, lookup) {
+  const slash = value.indexOf("/");
+  const name = slash === -1 ? value : value.slice(0, slash);
+  const opacity = slash === -1 ? void 0 : value.slice(slash + 1);
+  const base = lookup(name);
+  if (base === void 0) return value;
+  return opacity === void 0 ? base : applyOpacityToHex(base, opacity);
+}
+function resolveColors(extend, existing) {
+  const resolved = {};
+  const lookup = (name) => {
+    const found = resolved[name] ?? existing[name];
+    return typeof found === "string" ? found : void 0;
+  };
+  for (const [name, value] of Object.entries(extend)) {
+    resolved[name] = resolveColorEntry(value, lookup);
+  }
+  return resolved;
+}
+function resolveKbachConfig(config) {
+  let theme = { ...import_theme2.defaultTheme, ...config.theme };
+  if (config.extend?.colors) {
+    theme = { ...theme, colors: { ...theme.colors, ...resolveColors(config.extend.colors, theme.colors) } };
+  }
+  if (config.extend?.spacing) {
+    theme = { ...theme, spacing: { ...theme.spacing, ...config.extend.spacing } };
   }
-  return ctx;
+  if (config.extend?.screens) {
+    theme = { ...theme, screens: { ...theme.screens, ...config.extend.screens } };
+  }
+  if (config.extend?.fontFamily) {
+    theme = { ...theme, fontFamily: { ...theme.fontFamily, ...config.extend.fontFamily } };
+  }
+  if (config.extend?.container) {
+    theme = { ...theme, container: { ...theme.container, ...config.extend.container } };
+  }
+  if (config.darkMode) {
+    theme = { ...theme, darkMode: config.darkMode };
+  }
+  return theme;
+}
+function applyKbachConfig(config) {
+  const theme = resolveKbachConfig(config);
+  (0, import_theme2.setTheme)(theme);
+  (0, import_darkModeStore2.resyncDomWithActiveTheme)();
+  return theme;
+}
+
+// src/useTheme.ts
+var import_react = require("react");
+var import_darkModeStore3 = require("./darkModeStore");
+function useTheme() {
+  const isDark = (0, import_react.useSyncExternalStore)(import_darkModeStore3.subscribeGlobalDarkMode, import_darkModeStore3.getGlobalDarkMode);
+  const mode = (0, import_react.useSyncExternalStore)(import_darkModeStore3.subscribeGlobalDarkMode, import_darkModeStore3.getGlobalThemeMode);
+  return (0, import_react.useMemo)(
+    () => ({ mode, isDark, setMode: import_darkModeStore3.setGlobalThemeMode, toggle: import_darkModeStore3.toggleGlobalDarkMode }),
+    [mode, isDark]
+  );
 }
 
 // src/ThemeProvider.tsx
+var import_react2 = require("react");
+var import_darkModeStore4 = require("./darkModeStore");
 var import_jsx_runtime = require("react/jsx-runtime");
+var PERSIST_STORAGE_KEY = "kbach-theme";
+function isThemeMode(value) {
+  return value === "light" || value === "dark" || value === "system";
+}
 var mountedProviderCount = 0;
 var warnedMultipleProviders = false;
-function ThemeProvider({ children, defaultMode = "system" }) {
-  (0, import_react3.useEffect)(() => {
+function ThemeProvider({ children, defaultMode = "system", persist = false }) {
+  (0, import_react2.useEffect)(() => {
     mountedProviderCount++;
     if (mountedProviderCount > 1 && !warnedMultipleProviders) {
       warnedMultipleProviders = true;
       console.warn(
-        "[kbach] Multiple <ThemeProvider> instances are mounted at once. Dark-mode state is one global store (the same one useGlobalDarkMode()/toggleGlobalDarkMode() read and write), not scoped per-provider, so they will fight over the same state instead of each getting their own."
+        "[Kbach] Multiple <ThemeProvider> instances are mounted at once.\nDark mode is one global store \u2014 useTheme() reads it everywhere, not scoped per provider \u2014 so their defaultMode/persist seeds will fight over the same state.\nMount exactly one <ThemeProvider>, as high in the tree as convenient."
       );
     }
     return () => {
       mountedProviderCount--;
     };
   }, []);
-  const seeded = (0, import_react3.useRef)(false);
-  (0, import_react3.useEffect)(() => {
+  const seeded = (0, import_react2.useRef)(false);
+  (0, import_react2.useEffect)(() => {
     if (seeded.current) return;
     seeded.current = true;
-    seedDefaultMode(defaultMode);
+    if (!persist) {
+      (0, import_darkModeStore4.seedDefaultMode)(defaultMode);
+      return;
+    }
+    let cancelled = false;
+    persist.getItem(PERSIST_STORAGE_KEY).then((stored) => {
+      if (cancelled) return;
+      if (isThemeMode(stored)) (0, import_darkModeStore4.seedDefaultMode)(stored);
+      else (0, import_darkModeStore4.seedDefaultMode)(defaultMode);
+    }).catch(() => {
+      if (!cancelled) (0, import_darkModeStore4.seedDefaultMode)(defaultMode);
+    });
+    return () => {
+      cancelled = true;
+    };
   }, []);
-  const isDark2 = (0, import_react3.useSyncExternalStore)(subscribeGlobalDarkMode, getGlobalDarkMode);
-  const mode2 = (0, import_react3.useSyncExternalStore)(subscribeGlobalDarkMode, getGlobalThemeMode);
-  const value = (0, import_react3.useMemo)(
-    () => ({ mode: mode2, isDark: isDark2, setMode: setGlobalThemeMode, toggle: toggleGlobalDarkMode }),
-    [mode2, isDark2]
-  );
-  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ThemeContext.Provider, { value, children });
+  (0, import_react2.useEffect)(() => {
+    if (!persist) return;
+    return (0, import_darkModeStore4.subscribeGlobalDarkMode)(() => {
+      persist.setItem(PERSIST_STORAGE_KEY, (0, import_darkModeStore4.getGlobalThemeMode)()).catch(() => {
+      });
+    });
+  }, [persist]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children });
+}
+
+// src/index.ts
+var import_darkModeStore5 = require("./darkModeStore");
+
+// src/useColors.ts
+var import_react3 = require("react");
+var import_theme3 = require("./theme");
+function parseHexRgb2(hex) {
+  const m = /^#([0-9a-f]{3}|[0-9a-f]{6})$/i.exec(hex.trim());
+  if (!m) return null;
+  let h = m[1];
+  if (h.length === 3) h = h.split("").map((c) => c + c).join("");
+  const n = parseInt(h, 16);
+  return [n >> 16 & 255, n >> 8 & 255, n & 255];
+}
+function applyOpacity(color, opacity) {
+  const a = Math.max(0, Math.min(1, opacity / 100));
+  if (color.startsWith("#")) {
+    const rgb = parseHexRgb2(color);
+    return rgb ? `rgba(${rgb.join(",")},${a})` : color;
+  }
+  if (color.startsWith("rgb(")) return color.replace("rgb(", "rgba(").replace(")", `,${a})`);
+  if (color.startsWith("rgba(")) return color.replace(/,\s*[\d.]+\)$/, `,${a})`);
+  return color;
+}
+function resolveEntry(entry, isDark) {
+  return typeof entry === "string" ? entry : isDark ? entry.dark : entry.light;
+}
+function makeColorsProxy(theme, isDark) {
+  const alpha = (color, opacity) => opacity === void 0 ? color : applyOpacity(color, opacity);
+  const cache = /* @__PURE__ */ new Map();
+  function resolveNamed(key) {
+    let name = key;
+    let opacity;
+    if (key.includes("/")) {
+      const slash = key.indexOf("/");
+      name = key.slice(0, slash);
+      opacity = Number(key.slice(slash + 1));
+    }
+    const entry = theme.colors[name];
+    if (entry === void 0) return void 0;
+    const value = resolveEntry(entry, isDark);
+    return opacity === void 0 ? value : applyOpacity(value, opacity);
+  }
+  function makeFamilyProxy(family) {
+    return new Proxy({}, {
+      get(_, prop) {
+        const key = String(prop);
+        if (key === "then") return void 0;
+        return resolveNamed(`${family}-${key}`);
+      }
+    });
+  }
+  return new Proxy({ alpha }, {
+    get(_, prop) {
+      const key = String(prop);
+      if (key === "then") return void 0;
+      if (key === "alpha") return alpha;
+      const direct = resolveNamed(key);
+      if (direct !== void 0) return direct;
+      if (!cache.has(key)) cache.set(key, makeFamilyProxy(key));
+      return cache.get(key);
+    }
+  });
+}
+function useColors() {
+  const { isDark } = useTheme();
+  const theme = (0, import_theme3.getTheme)();
+  return (0, import_react3.useMemo)(() => makeColorsProxy(theme, isDark), [theme, isDark]);
+}
+
+// src/index.ts
+var import_dynamicTokens2 = require("./dynamicTokens");
+
+// src/useDynamicToken.ts
+var import_react4 = require("react");
+var import_dynamicTokens = require("./dynamicTokens");
+function useDynamicToken(name) {
+  return (0, import_react4.useSyncExternalStore)(import_dynamicTokens.subscribeDynamicTokens, () => (0, import_dynamicTokens.getDynamicToken)(name));
+}
+
+// src/clsx.ts
+function clsx(...inputs) {
+  let out = "";
+  for (const input of inputs) {
+    const piece = resolveClassValue(input);
+    if (piece) out = out ? `${out} ${piece}` : piece;
+  }
+  return out;
+}
+function resolveClassValue(value) {
+  if (!value) return "";
+  const type = typeof value;
+  if (type === "string" || type === "number" || type === "bigint") return String(value);
+  if (Array.isArray(value)) return clsx(...value);
+  if (type === "object") {
+    let out = "";
+    for (const key in value) {
+      if (Object.prototype.hasOwnProperty.call(value, key) && value[key]) {
+        out = out ? `${out} ${key}` : key;
+      }
+    }
+    return out;
+  }
+  return "";
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ThemeProvider,
+  applyKbachConfig,
+  clsx,
   defaultTheme,
+  deleteDynamicToken,
+  getDynamicToken,
   getGlobalDarkMode,
   getGlobalThemeMode,
   getTheme,
+  resolveKbachConfig,
   resolveStyle,
+  setDynamicToken,
   setGlobalThemeMode,
   setTheme,
+  subscribeDynamicTokens,
   subscribeGlobalDarkMode,
   toggleGlobalDarkMode,
-  useGlobalDarkMode,
+  useColors,
+  useDynamicToken,
   useTheme
 });