@kbach/react-native 1.0.0-beta.1 → 1.0.0-beta.11

package/dist/jsx-runtime.js

@@ -25,13 +25,15 @@ __export(jsx_runtime_exports, {
   jsxs: () => jsxs
 });
 module.exports = __toCommonJS(jsx_runtime_exports);
+
+// src/jsxRuntimeCore.ts
 var import_jsx_runtime = require("react/jsx-runtime");
 var import_react = require("react");
-var import_react_native3 = require("react-native");
-
-// src/nativeBridge.ts
 var import_react_native2 = require("react-native");
 
+// src/darkModeStore.ts
+var import_react_native = require("react-native");
+
 // src/generatedPalette.ts
 var PALETTE = {
   "amber-1": "#fffbeb",
@@ -312,27 +314,84 @@ var PALETTE = {
 // src/theme.ts
 var defaultTheme = {
   colors: PALETTE,
+  // Real Tailwind's default spacing scale in full — every step is exactly
+  // `n * 4px`, including the fractional `.5` steps (`1.5` -> 6px, `2.5` ->
+  // 10px, `3.5` -> 14px) and the "px" literal (a bare 1px). Only the
+  // "usual stops", though — `jsEngine/shared.ts`'s `spacingPx` (and the
+  // native Rust dispatcher's own `spacing_px`) falls back to Tailwind v4's
+  // live `n * 4px` formula for any bare numeric step not listed here
+  // (`p-0.25`, `w-13`, ...), so this table names the common values and
+  // gives a theme override something to target, not the full resolvable
+  // set. Mirrors @kbach/react's theme.ts exactly.
   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,
+    "px": 1,
+    "0.5": 2,
     "1": 4,
+    "1.5": 6,
     "2": 8,
+    "2.5": 10,
+    "3": 12,
+    "3.5": 14,
     "4": 16,
+    "5": 20,
     "6": 24,
-    "8": 32
+    "7": 28,
+    "8": 32,
+    "9": 36,
+    "10": 40,
+    "11": 44,
+    "12": 48,
+    "14": 56,
+    "16": 64,
+    "20": 80,
+    "24": 96,
+    "28": 112,
+    "32": 128,
+    "36": 144,
+    "40": 160,
+    "44": 176,
+    "48": 192,
+    "52": 208,
+    "56": 224,
+    "60": 240,
+    "64": 256,
+    "72": 288,
+    "80": 320,
+    "96": 384
+  },
+  screens: {
+    sm: 640,
+    md: 768,
+    lg: 1024,
+    xl: 1280,
+    "2xl": 1536
+  },
+  // Byte-for-byte the same three stacks
+  // packages/core-engine/src/resolvers/typography.rs's `font_family_value`
+  // falls back to. On native these three still effectively no-op (see
+  // `first_font_name`'s own doc comment for why a generic CSS keyword
+  // isn't a real loadable font) — only a caller-configured custom name
+  // changes native rendering; Expo Web uses the full stack as-is.
+  fontFamily: {
+    sans: 'ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji"',
+    serif: 'ui-serif, Georgia, Cambria, "Times New Roman", Times, serif',
+    mono: 'ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace'
   },
-  screens: {},
-  darkMode: "attribute"
+  darkMode: "attribute",
+  // Empty by default, matching real Tailwind's own defaults.
+  container: {}
 };
+var activeTheme = defaultTheme;
 var activeThemeJson = JSON.stringify(defaultTheme);
+function getTheme() {
+  return activeTheme;
+}
 function getThemeJson() {
   return activeThemeJson;
 }
 
 // src/darkModeStore.ts
-var import_react_native = require("react-native");
 var listeners = /* @__PURE__ */ new Set();
 function systemPrefersDark() {
   return import_react_native.Appearance.getColorScheme() === "dark";
@@ -340,11 +399,24 @@ function systemPrefersDark() {
 function resolveIsDark(m) {
   return m === "system" ? systemPrefersDark() : m === "dark";
 }
+function applyToDom(dark) {
+  if (typeof document === "undefined") return;
+  const root = document.documentElement;
+  const strategy = getTheme().darkMode;
+  if (strategy === "class") {
+    root.classList.toggle("dark", dark);
+    root.classList.toggle("light", !dark);
+  } else if (strategy === "attribute") {
+    root.setAttribute("data-theme", dark ? "dark" : "light");
+  }
+}
 var mode = "system";
 var isDark = resolveIsDark(mode);
+applyToDom(isDark);
 var subscription = import_react_native.Appearance.addChangeListener(({ colorScheme }) => {
   if (mode !== "system") return;
   isDark = colorScheme === "dark";
+  applyToDom(isDark);
   notify();
 });
 function notify() {
@@ -354,20 +426,12 @@ function getGlobalDarkMode() {
   return isDark;
 }
 
-// src/nativeBridge.ts
-function resolveStyle(classString, pressed = false) {
-  const KbachModule = import_react_native2.TurboModuleRegistry.getEnforcing("KbachModule");
-  const colorScheme = getGlobalDarkMode() ? "dark" : "light";
-  const json = KbachModule.resolveStyle(classString, getThemeJson(), colorScheme, pressed);
-  return JSON.parse(json);
-}
-
-// src/jsx-runtime.tsx
+// src/jsxRuntimeCore.ts
 function makeElement(isStaticChildren, type, props, key) {
   return (isStaticChildren ? import_jsx_runtime.jsxs : import_jsx_runtime.jsx)(type, props, key);
 }
-function resolvedStyleFor(classStrRaw, userStyle, pressed) {
-  const resolved = resolveStyle(classStrRaw, pressed);
+function resolvedStyleFor(resolveStyle2, classStrRaw, userStyle, pressed) {
+  const resolved = resolveStyle2(classStrRaw, pressed);
   if (userStyle === void 0) {
     return resolved;
   }
@@ -376,7 +440,11 @@ function resolvedStyleFor(classStrRaw, userStyle, pressed) {
   }
   return [resolved, userStyle];
 }
-function processElement(type, rawProps, key, isStaticChildren) {
+var DARK_MODIFIER_RE = /(^|\s)dark:/;
+function darkModeKeySuffix(classStrRaw) {
+  return DARK_MODIFIER_RE.test(classStrRaw) ? `:kb-dark-${getGlobalDarkMode()}` : "";
+}
+function processElement(resolveStyle2, type, rawProps, key, isStaticChildren) {
   if (type === null || typeof type === "symbol" || !rawProps) {
     return makeElement(isStaticChildren, type, rawProps ?? {}, key);
   }
@@ -384,15 +452,1223 @@ function processElement(type, rawProps, key, isStaticChildren) {
   if (typeof classStrRaw !== "string") {
     return makeElement(isStaticChildren, type, rawProps, key);
   }
-  const finalStyle = type === import_react_native3.Pressable ? (state) => resolvedStyleFor(classStrRaw, userStyle, state.pressed) : resolvedStyleFor(classStrRaw, userStyle, false);
-  return makeElement(isStaticChildren, type, { ...rest, style: finalStyle }, key);
+  const finalStyle = type === import_react_native2.Pressable ? (state) => resolvedStyleFor(resolveStyle2, classStrRaw, userStyle, state.pressed) : resolvedStyleFor(resolveStyle2, classStrRaw, userStyle, false);
+  const suffix = darkModeKeySuffix(classStrRaw);
+  const finalKey = suffix ? `${key ?? ""}${suffix}` : key;
+  return makeElement(isStaticChildren, type, { ...rest, style: finalStyle }, finalKey);
+}
+function createJsxFunctions(resolveStyle2) {
+  function jsx2(type, props, key) {
+    return processElement(resolveStyle2, type, props, key, false);
+  }
+  function jsxs2(type, props, key) {
+    return processElement(resolveStyle2, type, props, key, true);
+  }
+  return { jsx: jsx2, jsxs: jsxs2 };
+}
+
+// src/nativeBridge.ts
+var import_react_native3 = require("react-native");
+
+// 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-",
+  "top-",
+  "right-",
+  "bottom-",
+  "left-",
+  "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-",
+  "rotate-",
+  "translate-x-",
+  "translate-y-",
+  "skew-x-",
+  "skew-y-",
+  "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 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 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/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) return null;
+  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`;
+}
+
+// src/jsEngine/resolvers/layout.ts
+function negateRaw(value, negative) {
+  return negative ? `-${value}` : value;
+}
+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 "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 "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") — see resolveNegatableLength's own doc comment.
+    case "top": {
+      const v = resolveNegatableLength(theme, parsed);
+      return v === null ? null : [decl("top", v)];
+    }
+    case "right": {
+      const v = resolveNegatableLength(theme, parsed);
+      return v === null ? null : [decl("right", v)];
+    }
+    case "bottom": {
+      const v = resolveNegatableLength(theme, parsed);
+      return v === null ? null : [decl("bottom", v)];
+    }
+    case "left": {
+      const v = resolveNegatableLength(theme, parsed);
+      return v === null ? null : [decl("left", v)];
+    }
+    case "inset": {
+      const v = resolveNegatableLength(theme, parsed);
+      return v === null ? null : [decl("inset", v)];
+    }
+    case "aspect-square":
+      return [decl("aspect-ratio", "1 / 1")];
+    case "aspect-video":
+      return [decl("aspect-ratio", "16 / 9")];
+    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;
+  }
+}
+
+// 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 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 cssSizeKeyword(key) {
+  switch (key) {
+    case "min":
+      return "min-content";
+    case "max":
+      return "max-content";
+    case "fit":
+      return "fit-content";
+    default:
+      return null;
+  }
+}
+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/jsEngine/resolvers/color.ts
+function lookupHex(theme, key) {
+  const entry = theme.colors[key];
+  return typeof entry === "string" ? entry : null;
+}
+
+// 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 hex = lookupHex(theme, value);
+  return hex === null ? null : [decl("border-color", hex)];
+}
+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 hex = lookupHex(theme, value);
+  return hex === null ? null : [decl(`${sideProperty}-color`, hex)];
+}
+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 hex = lookupHex(theme, value);
+  return hex === null ? null : [decl(`${sideA}-color`, hex), decl(`${sideB}-color`, hex)];
+}
+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 hex = lookupHex(theme, value);
+  return hex === null ? null : [decl("outline-color", hex)];
+}
+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)];
 }
-function jsx(type, props, key) {
-  return processElement(type, props, key, false);
+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 jsxs(type, props, key) {
-  return processElement(type, props, key, true);
+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 = parsed.isArbitrary ? value : lookupHex(theme, value);
+  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 = parsed.isArbitrary ? value : lookupHex(theme, value);
+  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/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";
+    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";
+    default:
+      return null;
+  }
+}
+function fontWeight(key) {
+  switch (key) {
+    case "thin":
+      return "100";
+    case "normal":
+      return "400";
+    case "medium":
+      return "500";
+    case "semibold":
+      return "600";
+    case "bold":
+      return "700";
+    case "extrabold":
+      return "800";
+    default:
+      return null;
+  }
+}
+
+// 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/resolveUtilityNative.ts
+function resolveTypographyNative(parsed) {
+  switch (parsed.utility) {
+    case "font": {
+      if (parsed.value === null) return null;
+      const w = fontWeight(parsed.value);
+      return w === null ? null : [decl("font-weight", w)];
+    }
+    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) {
+  const value = parsed.value;
+  if (value === null) return null;
+  return parsed.isArbitrary ? value : lookupHex(theme, value);
+}
+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 resolveUtilityNative(parsed, theme) {
+  return resolveFlex(parsed, false) ?? resolve(parsed, theme) ?? resolve2(parsed, theme) ?? resolve3(parsed, theme) ?? resolveColorNative(parsed, theme) ?? resolveLeadingTrackingNative(parsed) ?? resolveTypographyNative(parsed) ?? nativeShadowDeclarations(parsed);
+}
+
+// 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",
+  // 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"
+]);
+function rnStyleValue(property, value) {
+  if (NUMERIC_LENGTH_PROPS.has(property)) {
+    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 px;
+  }
+  return value;
+}
+function resolveStyleJs(classString, theme, colorScheme, pressed, width) {
+  const style = {};
+  let shadowOffset = null;
+  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;
+      }
+      style[kebabToCamel(d.property)] = rnStyleValue(d.property, d.value);
+    }
+  }
+  if (shadowOffset !== null) {
+    style.shadowOffset = { width: shadowOffset.width ?? 0, height: shadowOffset.height ?? 0 };
+  }
+  return style;
+}
+
+// src/nativeBridge.ts
+function resolveStyle(classString, pressed = false) {
+  const colorScheme = getGlobalDarkMode() ? "dark" : "light";
+  const width = import_react_native3.Dimensions.get("window").width;
+  const KbachModule = import_react_native3.TurboModuleRegistry.get("KbachModule");
+  if (!KbachModule) {
+    return resolveStyleJs(classString, getTheme(), colorScheme, pressed, width);
+  }
+  const json = KbachModule.resolveStyle(classString, getThemeJson(), colorScheme, pressed, width);
+  return JSON.parse(json);
+}
+
+// src/jsx-runtime.tsx
+var { jsx, jsxs } = createJsxFunctions(resolveStyle);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Fragment,