@farm.js/core 0.1.51-beta.2 → 0.1.60

package/dist/chunk-NHD7BAKD.mjs

@@ -0,0 +1,1457 @@
+// src/mobile/native-theme.ts
+var FARM_NATIVE_THEME = {
+  spacing: 4,
+  colors: {
+    "red-50": "#fef2f2",
+    "red-100": "#ffe2e2",
+    "red-200": "#ffc9c9",
+    "red-300": "#ffa2a2",
+    "red-400": "#ff6467",
+    "red-500": "#fb2c36",
+    "red-600": "#e7000b",
+    "red-700": "#c10007",
+    "red-800": "#9f0712",
+    "red-900": "#82181a",
+    "red-950": "#460809",
+    "orange-50": "#fff7ed",
+    "orange-100": "#ffedd4",
+    "orange-200": "#ffd6a7",
+    "orange-300": "#ffb86a",
+    "orange-400": "#ff8904",
+    "orange-500": "#ff6900",
+    "orange-600": "#f54900",
+    "orange-700": "#ca3500",
+    "orange-800": "#9f2d00",
+    "orange-900": "#7e2a0c",
+    "orange-950": "#441306",
+    "amber-50": "#fffbeb",
+    "amber-100": "#fef3c6",
+    "amber-200": "#fee685",
+    "amber-300": "#ffd230",
+    "amber-400": "#ffb900",
+    "amber-500": "#fe9a00",
+    "amber-600": "#e17100",
+    "amber-700": "#bb4d00",
+    "amber-800": "#973c00",
+    "amber-900": "#7b3306",
+    "amber-950": "#461901",
+    "yellow-50": "#fefce8",
+    "yellow-100": "#fef9c2",
+    "yellow-200": "#fff085",
+    "yellow-300": "#ffdf20",
+    "yellow-400": "#fdc700",
+    "yellow-500": "#f0b100",
+    "yellow-600": "#d08700",
+    "yellow-700": "#a65f00",
+    "yellow-800": "#894b00",
+    "yellow-900": "#733e0a",
+    "yellow-950": "#432004",
+    "lime-50": "#f7fee7",
+    "lime-100": "#ecfcca",
+    "lime-200": "#d8f999",
+    "lime-300": "#bbf451",
+    "lime-400": "#9ae600",
+    "lime-500": "#7ccf00",
+    "lime-600": "#5ea500",
+    "lime-700": "#497d00",
+    "lime-800": "#3c6300",
+    "lime-900": "#35530e",
+    "lime-950": "#192e03",
+    "green-50": "#f0fdf4",
+    "green-100": "#dcfce7",
+    "green-200": "#b9f8cf",
+    "green-300": "#7bf1a8",
+    "green-400": "#05df72",
+    "green-500": "#00c950",
+    "green-600": "#00a63e",
+    "green-700": "#008236",
+    "green-800": "#016630",
+    "green-900": "#0d542b",
+    "green-950": "#032e15",
+    "emerald-50": "#ecfdf5",
+    "emerald-100": "#d0fae5",
+    "emerald-200": "#a4f4cf",
+    "emerald-300": "#5ee9b5",
+    "emerald-400": "#00d492",
+    "emerald-500": "#00bc7d",
+    "emerald-600": "#009966",
+    "emerald-700": "#007a55",
+    "emerald-800": "#006045",
+    "emerald-900": "#004f3b",
+    "emerald-950": "#002c22",
+    "teal-50": "#f0fdfa",
+    "teal-100": "#cbfbf1",
+    "teal-200": "#96f7e4",
+    "teal-300": "#46ecd5",
+    "teal-400": "#00d5be",
+    "teal-500": "#00bba7",
+    "teal-600": "#009689",
+    "teal-700": "#00786f",
+    "teal-800": "#005f5a",
+    "teal-900": "#0b4f4a",
+    "teal-950": "#022f2e",
+    "cyan-50": "#ecfeff",
+    "cyan-100": "#cefafe",
+    "cyan-200": "#a2f4fd",
+    "cyan-300": "#53eafd",
+    "cyan-400": "#00d3f2",
+    "cyan-500": "#00b8db",
+    "cyan-600": "#0092b8",
+    "cyan-700": "#007595",
+    "cyan-800": "#005f78",
+    "cyan-900": "#104e64",
+    "cyan-950": "#053345",
+    "sky-50": "#f0f9ff",
+    "sky-100": "#dff2fe",
+    "sky-200": "#b8e6fe",
+    "sky-300": "#74d4ff",
+    "sky-400": "#00bcff",
+    "sky-500": "#00a6f4",
+    "sky-600": "#0084d1",
+    "sky-700": "#0069a8",
+    "sky-800": "#00598a",
+    "sky-900": "#024a70",
+    "sky-950": "#052f4a",
+    "blue-50": "#eff6ff",
+    "blue-100": "#dbeafe",
+    "blue-200": "#bedbff",
+    "blue-300": "#8ec5ff",
+    "blue-400": "#51a2ff",
+    "blue-500": "#2b7fff",
+    "blue-600": "#155dfc",
+    "blue-700": "#1447e6",
+    "blue-800": "#193cb8",
+    "blue-900": "#1c398e",
+    "blue-950": "#162456",
+    "indigo-50": "#eef2ff",
+    "indigo-100": "#e0e7ff",
+    "indigo-200": "#c6d2ff",
+    "indigo-300": "#a3b3ff",
+    "indigo-400": "#7c86ff",
+    "indigo-500": "#615fff",
+    "indigo-600": "#4f39f6",
+    "indigo-700": "#432dd7",
+    "indigo-800": "#372aac",
+    "indigo-900": "#312c85",
+    "indigo-950": "#1e1a4d",
+    "violet-50": "#f5f3ff",
+    "violet-100": "#ede9fe",
+    "violet-200": "#ddd6ff",
+    "violet-300": "#c4b4ff",
+    "violet-400": "#a684ff",
+    "violet-500": "#8e51ff",
+    "violet-600": "#7f22fe",
+    "violet-700": "#7008e7",
+    "violet-800": "#5d0ec0",
+    "violet-900": "#4d179a",
+    "violet-950": "#2f0d68",
+    "purple-50": "#faf5ff",
+    "purple-100": "#f3e8ff",
+    "purple-200": "#e9d4ff",
+    "purple-300": "#dab2ff",
+    "purple-400": "#c27aff",
+    "purple-500": "#ad46ff",
+    "purple-600": "#9810fa",
+    "purple-700": "#8200db",
+    "purple-800": "#6e11b0",
+    "purple-900": "#59168b",
+    "purple-950": "#3c0366",
+    "fuchsia-50": "#fdf4ff",
+    "fuchsia-100": "#fae8ff",
+    "fuchsia-200": "#f6cfff",
+    "fuchsia-300": "#f4a8ff",
+    "fuchsia-400": "#ed6aff",
+    "fuchsia-500": "#e12afb",
+    "fuchsia-600": "#c800de",
+    "fuchsia-700": "#a800b7",
+    "fuchsia-800": "#8a0194",
+    "fuchsia-900": "#721378",
+    "fuchsia-950": "#4b004f",
+    "pink-50": "#fdf2f8",
+    "pink-100": "#fce7f3",
+    "pink-200": "#fccee8",
+    "pink-300": "#fda5d5",
+    "pink-400": "#fb64b6",
+    "pink-500": "#f6339a",
+    "pink-600": "#e60076",
+    "pink-700": "#c6005c",
+    "pink-800": "#a3004c",
+    "pink-900": "#861043",
+    "pink-950": "#510424",
+    "rose-50": "#fff1f2",
+    "rose-100": "#ffe4e6",
+    "rose-200": "#ffccd3",
+    "rose-300": "#ffa1ad",
+    "rose-400": "#ff637e",
+    "rose-500": "#ff2056",
+    "rose-600": "#ec003f",
+    "rose-700": "#c70036",
+    "rose-800": "#a50036",
+    "rose-900": "#8b0836",
+    "rose-950": "#4d0218",
+    "slate-50": "#f8fafc",
+    "slate-100": "#f1f5f9",
+    "slate-200": "#e2e8f0",
+    "slate-300": "#cad5e2",
+    "slate-400": "#90a1b9",
+    "slate-500": "#62748e",
+    "slate-600": "#45556c",
+    "slate-700": "#314158",
+    "slate-800": "#1d293d",
+    "slate-900": "#0f172b",
+    "slate-950": "#020618",
+    "gray-50": "#f9fafb",
+    "gray-100": "#f3f4f6",
+    "gray-200": "#e5e7eb",
+    "gray-300": "#d1d5dc",
+    "gray-400": "#99a1af",
+    "gray-500": "#6a7282",
+    "gray-600": "#4a5565",
+    "gray-700": "#364153",
+    "gray-800": "#1e2939",
+    "gray-900": "#101828",
+    "gray-950": "#030712",
+    "zinc-50": "#fafafa",
+    "zinc-100": "#f4f4f5",
+    "zinc-200": "#e4e4e7",
+    "zinc-300": "#d4d4d8",
+    "zinc-400": "#9f9fa9",
+    "zinc-500": "#71717b",
+    "zinc-600": "#52525c",
+    "zinc-700": "#3f3f46",
+    "zinc-800": "#27272a",
+    "zinc-900": "#18181b",
+    "zinc-950": "#09090b",
+    "neutral-50": "#fafafa",
+    "neutral-100": "#f5f5f5",
+    "neutral-200": "#e5e5e5",
+    "neutral-300": "#d4d4d4",
+    "neutral-400": "#a1a1a1",
+    "neutral-500": "#737373",
+    "neutral-600": "#525252",
+    "neutral-700": "#404040",
+    "neutral-800": "#262626",
+    "neutral-900": "#171717",
+    "neutral-950": "#0a0a0a",
+    "stone-50": "#fafaf9",
+    "stone-100": "#f5f5f4",
+    "stone-200": "#e7e5e4",
+    "stone-300": "#d6d3d1",
+    "stone-400": "#a6a09b",
+    "stone-500": "#79716b",
+    "stone-600": "#57534d",
+    "stone-700": "#44403b",
+    "stone-800": "#292524",
+    "stone-900": "#1c1917",
+    "stone-950": "#0c0a09",
+    "mauve-50": "#fafafa",
+    "mauve-100": "#f3f1f3",
+    "mauve-200": "#e7e4e7",
+    "mauve-300": "#d7d0d7",
+    "mauve-400": "#a89ea9",
+    "mauve-500": "#79697b",
+    "mauve-600": "#594c5b",
+    "mauve-700": "#463947",
+    "mauve-800": "#2a212c",
+    "mauve-900": "#1d161e",
+    "mauve-950": "#0c090c",
+    "olive-50": "#fbfbf9",
+    "olive-100": "#f4f4f0",
+    "olive-200": "#e8e8e3",
+    "olive-300": "#d8d8d0",
+    "olive-400": "#abab9c",
+    "olive-500": "#7c7c67",
+    "olive-600": "#5b5b4b",
+    "olive-700": "#474739",
+    "olive-800": "#2b2b22",
+    "olive-900": "#1d1d16",
+    "olive-950": "#0c0c09",
+    "mist-50": "#f9fbfb",
+    "mist-100": "#f1f3f3",
+    "mist-200": "#e3e7e8",
+    "mist-300": "#d0d6d8",
+    "mist-400": "#9ca8ab",
+    "mist-500": "#67787c",
+    "mist-600": "#4b585b",
+    "mist-700": "#394447",
+    "mist-800": "#22292b",
+    "mist-900": "#161b1d",
+    "mist-950": "#090b0c",
+    "taupe-50": "#fbfaf9",
+    "taupe-100": "#f3f1f1",
+    "taupe-200": "#e8e4e3",
+    "taupe-300": "#d8d2d0",
+    "taupe-400": "#aba09c",
+    "taupe-500": "#7c6d67",
+    "taupe-600": "#5b4f4b",
+    "taupe-700": "#473c39",
+    "taupe-800": "#2b2422",
+    "taupe-900": "#1d1816",
+    "taupe-950": "#0c0a09",
+    black: "#000000",
+    white: "#ffffff"
+  },
+  text: {
+    xs: [12, 16],
+    sm: [14, 20],
+    base: [16, 24],
+    lg: [18, 28],
+    xl: [20, 28],
+    "2xl": [24, 32],
+    "3xl": [30, 36],
+    "4xl": [36, 40],
+    "5xl": [48, 48],
+    "6xl": [60, 60],
+    "7xl": [72, 72],
+    "8xl": [96, 96],
+    "9xl": [128, 128]
+  },
+  fontWeight: {
+    thin: 100,
+    extralight: 200,
+    light: 300,
+    normal: 400,
+    medium: 500,
+    semibold: 600,
+    bold: 700,
+    extrabold: 800,
+    black: 900
+  },
+  tracking: { tighter: -0.05, tight: -0.025, normal: 0, wide: 0.025, wider: 0.05, widest: 0.1 },
+  leading: { tight: 1.25, snug: 1.375, normal: 1.5, relaxed: 1.625, loose: 2 },
+  radius: { xs: 2, sm: 4, md: 6, lg: 8, xl: 12, "2xl": 16, "3xl": 24, "4xl": 32 },
+  container: {
+    "3xs": 256,
+    "2xs": 288,
+    xs: 320,
+    sm: 384,
+    md: 448,
+    lg: 512,
+    xl: 576,
+    "2xl": 672,
+    "3xl": 768,
+    "4xl": 896,
+    "5xl": 1024,
+    "6xl": 1152,
+    "7xl": 1280
+  }
+};
+
+// src/mobile/native-style.ts
+var FARM_NATIVE_TEXT_KEYS = /* @__PURE__ */ new Set([
+  "color",
+  "fontSize",
+  "lineHeight",
+  "fontWeight",
+  "fontStyle",
+  "fontFamily",
+  "textAlign",
+  "letterSpacing",
+  "textTransform",
+  "textDecorationLine",
+  // `leading-*`: a multiple of the font size, or a fixed height. Either wins over the line
+  // height a `text-*` size sets, as in Tailwind.
+  "lineHeightScale",
+  "lineHeightPx"
+]);
+var ALL_SIDES = ["Top", "Right", "Bottom", "Left"];
+var ALL_CORNERS = ["TopLeft", "TopRight", "BottomRight", "BottomLeft"];
+var each = (keys, value) => Object.fromEntries(keys.map((key) => [key, value]));
+var SIDES = {
+  t: ["Top"],
+  r: ["Right"],
+  b: ["Bottom"],
+  l: ["Left"],
+  x: ["Left", "Right"],
+  y: ["Top", "Bottom"],
+  s: ["Left"],
+  e: ["Right"]
+};
+var CORNERS = {
+  t: ["TopLeft", "TopRight"],
+  r: ["TopRight", "BottomRight"],
+  b: ["BottomLeft", "BottomRight"],
+  l: ["TopLeft", "BottomLeft"],
+  tl: ["TopLeft"],
+  tr: ["TopRight"],
+  br: ["BottomRight"],
+  bl: ["BottomLeft"]
+};
+var ALIGN = {
+  start: "flex-start",
+  end: "flex-end",
+  center: "center",
+  between: "space-between",
+  around: "space-around",
+  evenly: "space-evenly",
+  stretch: "stretch",
+  baseline: "baseline",
+  auto: "auto"
+};
+var DROPPED = /^(?:relative|cursor-.+|select-.+|outline-.+|pointer-events-.+)$/;
+var DEFAULT_THEME = FARM_NATIVE_THEME;
+var THEME = DEFAULT_THEME;
+function withTheme(theme, run) {
+  const previous = THEME;
+  THEME = theme ?? DEFAULT_THEME;
+  try {
+    return run();
+  } finally {
+    THEME = previous;
+  }
+}
+function spacing(value) {
+  if (value === "px") return 1;
+  if (value === "auto") return "auto";
+  if (!/^\d+(?:\.5)?$/.test(value)) return void 0;
+  return Number(value) * THEME.spacing;
+}
+function size(value) {
+  if (value === "full") return "100%";
+  const fraction = /^(\d+)\/(\d+)$/.exec(value);
+  if (fraction) return `${Math.round(Number(fraction[1]) / Number(fraction[2]) * 1e4) / 100}%`;
+  return spacing(value);
+}
+function color(value) {
+  const [name, alpha] = value.split("/");
+  if (name === "transparent") return "transparent";
+  if (name === "current" || name === "inherit") return "currentColor";
+  const hex = THEME.colors[name];
+  if (!hex) return void 0;
+  if (alpha === void 0) return hex;
+  if (!/^\d{1,3}$/.test(alpha) || Number(alpha) > 100) return void 0;
+  return `${hex}${Math.round(Number(alpha) / 100 * 255).toString(16).padStart(2, "0")}`;
+}
+function utility(token) {
+  if (DROPPED.test(token)) return {};
+  switch (token) {
+    case "flex":
+      return { display: "flex", flexDirection: "row" };
+    case "flex-row":
+      return { flexDirection: "row" };
+    case "flex-col":
+      return { flexDirection: "column" };
+    case "flex-1":
+      return { flexGrow: 1, flexShrink: 1, flexBasis: 0 };
+    case "flex-auto":
+      return { flexGrow: 1, flexShrink: 1 };
+    case "flex-initial":
+      return { flexGrow: 0, flexShrink: 1 };
+    case "flex-none":
+      return { flexGrow: 0, flexShrink: 0 };
+    case "grow":
+      return { flexGrow: 1 };
+    case "grow-0":
+      return { flexGrow: 0 };
+    case "shrink":
+      return { flexShrink: 1 };
+    case "shrink-0":
+      return { flexShrink: 0 };
+    case "flex-nowrap":
+      return {};
+    case "flex-wrap":
+      return { flexWrap: "wrap" };
+    case "hidden":
+      return { display: "none" };
+    case "overflow-hidden":
+      return { overflow: "hidden" };
+    case "overflow-visible":
+      return { overflow: "visible" };
+    case "italic":
+      return { fontStyle: "italic" };
+    case "not-italic":
+      return { fontStyle: "normal" };
+    case "underline":
+      return { textDecorationLine: "underline" };
+    case "line-through":
+      return { textDecorationLine: "line-through" };
+    case "no-underline":
+      return { textDecorationLine: "none" };
+    case "uppercase":
+    case "lowercase":
+    case "capitalize":
+      return { textTransform: token };
+    case "normal-case":
+      return { textTransform: "none" };
+    case "text-left":
+    case "text-center":
+    case "text-right":
+    case "text-justify":
+      return { textAlign: token.slice(5) };
+    case "rounded":
+      return each(
+        ALL_CORNERS.map((corner) => `border${corner}Radius`),
+        THEME.radius.sm
+      );
+    case "border":
+      return {
+        ...each(
+          ALL_SIDES.map((side) => `border${side}Width`),
+          1
+        ),
+        ...each(
+          ALL_SIDES.map((side) => `border${side}Color`),
+          "currentColor"
+        )
+      };
+    case "border-solid":
+    case "border-dashed":
+    case "border-dotted":
+      return { borderStyle: token.slice(7) };
+    case "border-none":
+      return { borderStyle: "none" };
+  }
+  let match = /^(items|justify|self)-([a-z]+)$/.exec(token);
+  if (match) {
+    const value = ALIGN[match[2]];
+    if (!value) return void 0;
+    const key = { items: "alignItems", justify: "justifyContent", self: "alignSelf" }[match[1]];
+    return { [key]: value };
+  }
+  match = /^(-?)(p|m)([trblxyse]?)-(.+)$/.exec(token);
+  if (match) {
+    const value = spacing(match[4]);
+    if (value === void 0 || match[2] === "p" && (value === "auto" || match[1]))
+      return void 0;
+    const signed = match[1] && typeof value === "number" ? -value : value;
+    const property = match[2] === "p" ? "padding" : "margin";
+    const sides2 = match[3] ? SIDES[match[3]] : ALL_SIDES;
+    return each(
+      sides2.map((side) => `${property}${side}`),
+      signed
+    );
+  }
+  match = /^gap(-[xy])?-(.+)$/.exec(token);
+  if (match) {
+    const value = spacing(match[2]);
+    if (typeof value !== "number") return void 0;
+    if (match[1] === "-x") return { columnGap: value };
+    if (match[1] === "-y") return { rowGap: value };
+    return { rowGap: value, columnGap: value };
+  }
+  match = /^(w|h|size|min-w|min-h|max-h)-(.+)$/.exec(token);
+  if (match) {
+    const value = size(match[2]);
+    if (value === void 0 || value === "auto" && match[1].includes("-")) return void 0;
+    if (match[1] === "size") return { width: value, height: value };
+    const key = {
+      w: "width",
+      h: "height",
+      "min-w": "minWidth",
+      "min-h": "minHeight",
+      "max-h": "maxHeight"
+    }[match[1]];
+    return value === "auto" ? {} : { [key]: value };
+  }
+  match = /^max-w-(.+)$/.exec(token);
+  if (match) {
+    if (match[1] === "none") return {};
+    if (match[1] === "full") return { maxWidth: "100%" };
+    const value = THEME.container[match[1]];
+    return value === void 0 ? void 0 : { maxWidth: value };
+  }
+  match = /^text-(.+)$/.exec(token);
+  if (match) {
+    const text = THEME.text[match[1]];
+    if (text) {
+      return Number.isFinite(text[1]) ? { fontSize: text[0], lineHeight: text[1] } : { fontSize: text[0] };
+    }
+    const value = color(match[1]);
+    return value === void 0 ? void 0 : { color: value };
+  }
+  match = /^font-(.+)$/.exec(token);
+  if (match) {
+    if (match[1] === "sans" || match[1] === "serif" || match[1] === "mono") {
+      return { fontFamily: match[1] };
+    }
+    const weight = THEME.fontWeight[match[1]];
+    return weight === void 0 ? void 0 : { fontWeight: weight };
+  }
+  match = /^leading-(.+)$/.exec(token);
+  if (match) {
+    if (match[1] === "none") return { lineHeightScale: 1 };
+    const scale = THEME.leading[match[1]];
+    if (scale !== void 0) return { lineHeightScale: scale };
+    const value = spacing(match[1]);
+    return typeof value === "number" ? { lineHeightPx: value } : void 0;
+  }
+  match = /^tracking-(.+)$/.exec(token);
+  if (match) {
+    const value = THEME.tracking[match[1]];
+    return value === void 0 ? void 0 : { letterSpacing: value };
+  }
+  match = /^bg-(.+)$/.exec(token);
+  if (match) {
+    const value = color(match[1]);
+    return value === void 0 ? void 0 : { backgroundColor: value };
+  }
+  match = /^border-([trblxy])$/.exec(token);
+  if (match) {
+    return each(
+      SIDES[match[1]].map((side) => `border${side}Width`),
+      1
+    );
+  }
+  match = /^border(?:-([trblxy]))?-(.+)$/.exec(token);
+  if (match) {
+    const sides2 = match[1] ? SIDES[match[1]] : ALL_SIDES;
+    if (/^(?:0|2|4|8)$/.test(match[2])) {
+      return Object.fromEntries(sides2.map((side) => [`border${side}Width`, Number(match[2])]));
+    }
+    const value = color(match[2]);
+    if (value === void 0) return void 0;
+    return Object.fromEntries(sides2.map((side) => [`border${side}Color`, value]));
+  }
+  match = /^rounded(?:-([trbl]{1,2}))?(?:-([a-z0-9]+))?$/.exec(token);
+  if (match) {
+    const radius = match[2] === void 0 ? THEME.radius.sm : match[2] === "none" ? 0 : match[2] === "full" ? 9999 : THEME.radius[match[2]];
+    if (radius === void 0) return void 0;
+    const corners = match[1] ? CORNERS[match[1]] : [...ALL_CORNERS];
+    if (!corners) return void 0;
+    return Object.fromEntries(corners.map((corner) => [`border${corner}Radius`, radius]));
+  }
+  match = /^opacity-(\d{1,3})$/.exec(token);
+  if (match && Number(match[1]) <= 100) return { opacity: Number(match[1]) / 100 };
+  return void 0;
+}
+function farmNativeClassProblem(token, theme) {
+  return withTheme(theme, () => classProblem(token));
+}
+function classProblem(token) {
+  const parts = token.split(":");
+  const base = parts.pop().replace(/^!/, "");
+  if (parts.some((variant) => variant !== "dark")) {
+    return `"${token}" needs a variant the native tier cannot apply`;
+  }
+  if (base.includes("[")) return `"${token}" is an arbitrary value`;
+  return utility(base) === void 0 ? `class "${token}" has no native-tier style` : void 0;
+}
+function resolveFarmNativeClasses(className, theme) {
+  return withTheme(theme, () => resolveClasses(className));
+}
+function resolveClasses(className) {
+  const light = [];
+  const darkParts = [];
+  const themedDark = [];
+  const darkTheme = THEME.darkColors ? { ...THEME, colors: { ...THEME.colors, ...THEME.darkColors } } : void 0;
+  const unsupported = [];
+  for (const token of className.split(/\s+/)) {
+    if (!token) continue;
+    if (classProblem(token)) {
+      unsupported.push(token);
+      continue;
+    }
+    const parts = token.split(":");
+    const base = parts.pop().replace(/^!/, "");
+    const resolved = utility(base);
+    (parts.length > 0 ? darkParts : light).push(resolved);
+    if (parts.length === 0 && darkTheme) {
+      const lightTheme = THEME;
+      THEME = darkTheme;
+      const dark2 = utility(base);
+      THEME = lightTheme;
+      if (dark2 && JSON.stringify(dark2) !== JSON.stringify(resolved)) themedDark.push(dark2);
+    }
+  }
+  const merge = (parts) => Object.assign(
+    {},
+    ...parts.sort((left, right) => Object.keys(right).length - Object.keys(left).length)
+  );
+  const style = merge(light);
+  const dark = { ...merge(themedDark), ...merge(darkParts) };
+  return { style, ...Object.keys(dark).length > 0 ? { dark } : {}, unsupported };
+}
+function longhands(style) {
+  const [[key, value]] = Object.entries(style);
+  if (key === "gap") return { rowGap: value, columnGap: value };
+  if (key === "borderWidth")
+    return each(
+      ALL_SIDES.map((side) => `border${side}Width`),
+      value
+    );
+  if (key === "borderColor")
+    return each(
+      ALL_SIDES.map((side) => `border${side}Color`),
+      value
+    );
+  if (key === "borderRadius") {
+    return each(
+      ALL_CORNERS.map((corner) => `border${corner}Radius`),
+      value
+    );
+  }
+  return style;
+}
+var PX = /^(-?\d*\.?\d+)px$/;
+function cssLength(value) {
+  if (value === "0") return 0;
+  if (value === "auto") return "auto";
+  const px = PX.exec(value);
+  if (px) return Number(px[1]);
+  if (/^-?\d*\.?\d+%$/.test(value)) return value;
+  const rem = /^(-?\d*\.?\d+)rem$/.exec(value);
+  return rem ? Number(rem[1]) * 16 : void 0;
+}
+var CSS_LENGTHS = new Set(
+  "gap row-gap column-gap padding-top padding-right padding-bottom padding-left margin-top margin-right margin-bottom margin-left width height min-width min-height max-width max-height border-width border-top-width border-right-width border-bottom-width border-left-width border-radius font-size line-height letter-spacing flex-basis".split(" ")
+);
+var CSS_KEYWORDS = {
+  display: /* @__PURE__ */ new Set(["flex", "none"]),
+  "flex-direction": /* @__PURE__ */ new Set(["row", "column"]),
+  "align-items": /* @__PURE__ */ new Set(["flex-start", "flex-end", "center", "stretch", "baseline"]),
+  "align-self": /* @__PURE__ */ new Set(["auto", "flex-start", "flex-end", "center", "stretch", "baseline"]),
+  "justify-content": /* @__PURE__ */ new Set([
+    "flex-start",
+    "flex-end",
+    "center",
+    "space-between",
+    "space-around",
+    "space-evenly"
+  ]),
+  "font-style": /* @__PURE__ */ new Set(["normal", "italic"]),
+  "text-align": /* @__PURE__ */ new Set(["left", "center", "right", "justify"]),
+  "text-transform": /* @__PURE__ */ new Set(["none", "uppercase", "lowercase", "capitalize"]),
+  "text-decoration-line": /* @__PURE__ */ new Set(["none", "underline", "line-through"]),
+  "border-style": /* @__PURE__ */ new Set(["solid", "dashed", "dotted", "none"]),
+  overflow: /* @__PURE__ */ new Set(["hidden", "visible"])
+};
+var CSS_COLORS = /* @__PURE__ */ new Set(["color", "background-color", "border-color"]);
+var CSS_NUMBERS = /* @__PURE__ */ new Set(["opacity", "flex-grow", "flex-shrink", "font-weight"]);
+var SHORTHAND_SIDES = ["Top", "Right", "Bottom", "Left"];
+var FARM_NATIVE_STYLE_PROPERTIES = new Set(
+  [
+    ...CSS_LENGTHS,
+    ...CSS_COLORS,
+    ...CSS_NUMBERS,
+    ...Object.keys(CSS_KEYWORDS),
+    "padding",
+    "margin",
+    "flex",
+    "flex-wrap"
+  ].map((property) => property.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase()))
+);
+function camel(property) {
+  return property.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+function cssColor(value) {
+  if (/^#(?:[0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/i.test(value)) return value.toLowerCase();
+  if (value === "transparent" || value === "currentcolor") {
+    return value === "currentcolor" ? "currentColor" : value;
+  }
+  const rgb = /^rgba?\((\d{1,3})[ ,]+(\d{1,3})[ ,]+(\d{1,3})(?:[ ,/]+([\d.]+%?))?\)$/i.exec(value);
+  if (!rgb) return value === "white" ? "#ffffff" : value === "black" ? "#000000" : void 0;
+  const hex = rgb.slice(1, 4).map((channel) => Math.min(255, Number(channel)).toString(16).padStart(2, "0")).join("");
+  if (rgb[4] === void 0) return `#${hex}`;
+  const alpha = rgb[4].endsWith("%") ? Number(rgb[4].slice(0, -1)) / 100 : Number(rgb[4]);
+  return `#${hex}${Math.round(Math.min(1, alpha) * 255).toString(16).padStart(2, "0")}`;
+}
+var IGNORED_PROPERTIES = /* @__PURE__ */ new Set([
+  // No effect on a static, touch-only screen, or the shell owns it.
+  "cursor",
+  "outline",
+  "outline-offset",
+  "user-select",
+  "-webkit-user-select",
+  "-webkit-tap-highlight-color",
+  "pointer-events",
+  "box-sizing",
+  "color-scheme",
+  "appearance",
+  "-webkit-appearance",
+  "transition",
+  "transition-property",
+  "transition-duration",
+  "transition-timing-function",
+  "will-change",
+  "-webkit-font-smoothing",
+  "-moz-osx-font-smoothing",
+  "text-rendering"
+]);
+var BORDER_STYLES = /* @__PURE__ */ new Set(["solid", "dashed", "dotted", "none"]);
+function sides(property, values) {
+  const [top, right = top, bottom = top, left = right] = values;
+  const ordered = [top, right, bottom, left];
+  return Object.fromEntries(
+    SHORTHAND_SIDES.map((side, index) => [property.replace("*", side), ordered[index]])
+  );
+}
+function border(value, side) {
+  const keys = side ? [side] : SHORTHAND_SIDES;
+  if (value === "none" || value === "0")
+    return each(
+      keys.map((key) => `border${key}Width`),
+      0
+    );
+  let width;
+  let style;
+  let color2;
+  for (const part of value.split(/\s+(?![^(]*\))/)) {
+    if (BORDER_STYLES.has(part)) style = part;
+    else if (cssLength(part) !== void 0 && width === void 0) width = cssLength(part);
+    else if (part === "thin") width = 1;
+    else if (cssColor(part)) color2 = cssColor(part);
+    else return void 0;
+  }
+  return {
+    ...each(
+      keys.map((key) => `border${key}Width`),
+      style === "none" ? 0 : width ?? 3
+    ),
+    ...color2 ? each(
+      keys.map((key) => `border${key}Color`),
+      color2
+    ) : {},
+    ...style ? { borderStyle: style } : {}
+  };
+}
+function resolveFarmNativeDeclaration(property, value) {
+  if (IGNORED_PROPERTIES.has(property) || value === "inherit" || value === "unset") return null;
+  switch (property) {
+    case "padding":
+    case "margin": {
+      const parts = value.split(/\s+/).map(cssLength);
+      if (parts.length > 4 || parts.some((part) => part === void 0)) return void 0;
+      if (property === "padding" && parts.includes("auto")) return void 0;
+      return sides(`${property}*`, parts);
+    }
+    case "gap": {
+      const parts = value.split(/\s+/).map(cssLength);
+      if (parts.length > 2 || parts.some((part) => typeof part !== "number")) return void 0;
+      return { rowGap: parts[0], columnGap: parts[1] ?? parts[0] };
+    }
+    case "border-radius": {
+      const parts = value.split(/\s+/).map(cssLength);
+      if (parts.length > 4 || parts.some((part) => typeof part !== "number")) return void 0;
+      const [a, b = a, c = a, d = b] = parts;
+      return {
+        borderTopLeftRadius: a,
+        borderTopRightRadius: b,
+        borderBottomRightRadius: c,
+        borderBottomLeftRadius: d
+      };
+    }
+    case "border":
+      return border(value, "");
+    case "border-top":
+    case "border-right":
+    case "border-bottom":
+    case "border-left":
+      return border(value, property[7].toUpperCase() + property.slice(8));
+    case "background-color": {
+      const parsed = cssColor(value);
+      return parsed ? { backgroundColor: parsed } : void 0;
+    }
+    case "background": {
+      const parsed = cssColor(value);
+      if (parsed) return { backgroundColor: parsed };
+      return value.split(/\s+/).every((part) => /^(?:none|0(?:%|px)?)$/.test(part)) ? { backgroundColor: "transparent" } : void 0;
+    }
+    case "display":
+      if (value === "flex" || value === "inline-flex") return { display: "flex" };
+      if (value === "block" || value === "flow-root") return {};
+      return value === "none" ? { display: "none" } : void 0;
+    case "flex-wrap":
+      return value === "nowrap" ? {} : value === "wrap" ? { flexWrap: "wrap" } : void 0;
+    case "flex":
+      if (/^\d+$/.test(value)) return { flexGrow: Number(value), flexShrink: 1, flexBasis: 0 };
+      if (value === "none") return { flexGrow: 0, flexShrink: 0 };
+      if (value === "auto") return { flexGrow: 1, flexShrink: 1 };
+      return void 0;
+    case "font":
+      return void 0;
+    case "font-family":
+      return {
+        fontFamily: /mono/.test(value) ? "mono" : /(?:^|,\s*)serif\b|georgia|times/.test(value) ? "serif" : "sans"
+      };
+    case "font-weight":
+      if (value === "bold") return { fontWeight: 700 };
+      if (value === "normal") return { fontWeight: 400 };
+      return /^\d{3}$/.test(value) ? { fontWeight: Number(value) } : void 0;
+    case "line-height":
+      if (/^\d*\.?\d+$/.test(value)) return { lineHeightScale: Number(value) };
+      if (value === "normal") return null;
+      return typeof cssLength(value) === "number" ? { lineHeightPx: cssLength(value) } : void 0;
+    case "text-decoration":
+    case "text-decoration-line":
+      return CSS_KEYWORDS["text-decoration-line"].has(value) ? { textDecorationLine: value } : void 0;
+    case "list-style":
+    case "list-style-type":
+      return value === "none" ? null : void 0;
+    case "align-items":
+    case "align-self":
+    case "justify-content":
+      value = value === "start" ? "flex-start" : value === "end" ? "flex-end" : value;
+      break;
+    case "text-align":
+      value = value === "start" ? "left" : value === "end" ? "right" : value;
+      break;
+  }
+  if (CSS_LENGTHS.has(property)) {
+    const length = cssLength(value);
+    return length === void 0 ? void 0 : longhands({ [camel(property)]: length });
+  }
+  if (CSS_COLORS.has(property)) {
+    const parsed = cssColor(value);
+    return parsed ? longhands({ [camel(property)]: parsed }) : void 0;
+  }
+  if (CSS_NUMBERS.has(property)) {
+    return /^\d*\.?\d+$/.test(value) ? { [camel(property)]: Number(value) } : void 0;
+  }
+  if (CSS_KEYWORDS[property]?.has(value)) return { [camel(property)]: value };
+  return void 0;
+}
+function splitFarmCssDeclarations(css) {
+  const out = [];
+  let depth = 0;
+  let start = 0;
+  const push = (end) => {
+    const text = css.slice(start, end);
+    const colon = text.indexOf(":");
+    if (colon > 0) {
+      out.push([
+        text.slice(0, colon).trim().toLowerCase(),
+        text.slice(colon + 1).replace(/\s*!important\s*$/i, "").trim()
+      ]);
+    }
+  };
+  for (let index = 0; index < css.length; index += 1) {
+    const char = css[index];
+    if (char === "(") depth += 1;
+    else if (char === ")") depth = Math.max(0, depth - 1);
+    else if (char === ";" && depth === 0) {
+      push(index);
+      start = index + 1;
+    }
+  }
+  push(css.length);
+  return out;
+}
+function resolveFarmNativeInlineStyle(css) {
+  const style = {};
+  const unsupported = [];
+  for (const [property, raw] of splitFarmCssDeclarations(css)) {
+    const value = raw.toLowerCase();
+    if (!property) continue;
+    const resolved = resolveFarmNativeDeclaration(property, value);
+    if (resolved) Object.assign(style, resolved);
+    else if (resolved === void 0) unsupported.push(`${property}: ${value}`);
+  }
+  return { style, unsupported };
+}
+function oklchToHex(value) {
+  const match = /^oklch\(\s*([\d.]+)(%?)\s+([\d.]+)\s+([\d.]+|none)(?:deg)?\s*(?:\/\s*([\d.]+)(%?))?\s*\)$/.exec(
+    value
+  );
+  if (!match) return void 0;
+  const l = Number(match[1]) / (match[2] ? 100 : 1);
+  const c = Number(match[3]);
+  const h = (match[4] === "none" ? 0 : Number(match[4])) * Math.PI / 180;
+  const a = c * Math.cos(h);
+  const b = c * Math.sin(h);
+  const l_ = (l + 0.3963377774 * a + 0.2158037573 * b) ** 3;
+  const m_ = (l - 0.1055613458 * a - 0.0638541728 * b) ** 3;
+  const s_ = (l - 0.0894841775 * a - 1.291485548 * b) ** 3;
+  const linear = [
+    4.0767416621 * l_ - 3.3077115913 * m_ + 0.2309699292 * s_,
+    -1.2684380046 * l_ + 2.6097574011 * m_ - 0.3413193965 * s_,
+    -0.0041960863 * l_ - 0.7034186147 * m_ + 1.707614701 * s_
+  ];
+  const hex = linear.map((channel) => {
+    const clamped = Math.min(1, Math.max(0, channel));
+    const gamma = clamped <= 31308e-7 ? 12.92 * clamped : 1.055 * clamped ** (1 / 2.4) - 0.055;
+    return Math.round(gamma * 255).toString(16).padStart(2, "0");
+  }).join("");
+  if (match[5] === void 0) return `#${hex}`;
+  const alpha = Number(match[5]) / (match[6] ? 100 : 1);
+  return `#${hex}${Math.round(Math.min(1, alpha) * 255).toString(16).padStart(2, "0")}`;
+}
+function themeColor(value) {
+  const parsed = cssColor(value.toLowerCase());
+  if (parsed && parsed !== "currentColor") return parsed;
+  return oklchToHex(value.toLowerCase());
+}
+function themeLength(value) {
+  const length = cssLength(value.trim());
+  return typeof length === "number" ? length : void 0;
+}
+function createFarmNativeTheme(declarations, vars = {
+  light: {},
+  dark: {}
+}) {
+  const theme = {
+    spacing: DEFAULT_THEME.spacing,
+    colors: { ...DEFAULT_THEME.colors },
+    darkColors: {},
+    text: { ...DEFAULT_THEME.text },
+    fontWeight: { ...DEFAULT_THEME.fontWeight },
+    tracking: { ...DEFAULT_THEME.tracking },
+    leading: { ...DEFAULT_THEME.leading },
+    radius: { ...DEFAULT_THEME.radius },
+    container: { ...DEFAULT_THEME.container }
+  };
+  const namespaces = [
+    ["color-", "colors"],
+    ["text-", "text"],
+    ["font-weight-", "fontWeight"],
+    ["tracking-", "tracking"],
+    ["leading-", "leading"],
+    ["radius-", "radius"],
+    ["container-", "container"]
+  ];
+  const resolve = (value, scheme, depth = 0) => {
+    const reference = /^var\(\s*(--[\w-]+)\s*(?:,\s*(.+))?\)$/.exec(value.trim());
+    if (!reference) return value.trim();
+    if (depth > 8) return void 0;
+    const name = reference[1];
+    const next = (scheme === "dark" ? vars.dark[name] ?? vars.light[name] : vars.light[name]) ?? reference[2];
+    return next === void 0 ? void 0 : resolve(next, scheme, depth + 1);
+  };
+  const lineHeights = [];
+  for (const [rawName, value] of declarations) {
+    const name = rawName.replace(/^--/, "");
+    if (value.trim() === "initial") {
+      if (name === "*") {
+        for (const [, key] of namespaces) theme[key] = {};
+        continue;
+      }
+      for (const [prefix, key] of namespaces) {
+        if (!name.startsWith(prefix)) continue;
+        const rest2 = name.slice(prefix.length);
+        const values = theme[key];
+        if (rest2.endsWith("*")) {
+          for (const entry of Object.keys(values)) {
+            if (entry.startsWith(rest2.slice(0, -1))) delete values[entry];
+          }
+        } else delete values[rest2];
+      }
+      continue;
+    }
+    const light = resolve(value, "light");
+    if (name === "spacing") {
+      const px = light === void 0 ? void 0 : themeLength(light);
+      if (px !== void 0) theme.spacing = px;
+      continue;
+    }
+    if (name.startsWith("color-")) {
+      const key = name.slice(6);
+      const color2 = light === void 0 ? void 0 : themeColor(light);
+      const darkValue = resolve(value, "dark");
+      const dark = darkValue === void 0 ? void 0 : themeColor(darkValue);
+      delete theme.colors[key];
+      delete theme.darkColors[key];
+      if (color2) theme.colors[key] = color2;
+      if (color2 && dark && dark !== color2) theme.darkColors[key] = dark;
+      continue;
+    }
+    const lineHeight = /^text-(.+)--line-height$/.exec(name);
+    if (lineHeight) {
+      if (light !== void 0) lineHeights.push([lineHeight[1], light]);
+      continue;
+    }
+    if (name.startsWith("text-") && !name.includes("--")) {
+      const px = light === void 0 ? void 0 : themeLength(light);
+      const key = name.slice(5);
+      if (px === void 0) delete theme.text[key];
+      else theme.text[key] = [px, theme.text[key]?.[1] ?? Number.NaN];
+      continue;
+    }
+    const numeric = [
+      ["font-weight-", "fontWeight"],
+      ["leading-", "leading"]
+    ];
+    const number = numeric.find(([prefix]) => name.startsWith(prefix));
+    if (number) {
+      const parsed = light === void 0 ? Number.NaN : Number(light);
+      const key = name.slice(number[0].length);
+      if (Number.isFinite(parsed)) theme[number[1]][key] = parsed;
+      else delete theme[number[1]][key];
+      continue;
+    }
+    if (name.startsWith("tracking-")) {
+      const em = light === void 0 ? void 0 : /^(-?[\d.]+)em$/.exec(light.trim());
+      const key = name.slice(9);
+      if (em) theme.tracking[key] = Number(em[1]);
+      else delete theme.tracking[key];
+      continue;
+    }
+    for (const [prefix, key] of [
+      ["radius-", "radius"],
+      ["container-", "container"]
+    ]) {
+      if (!name.startsWith(prefix)) continue;
+      const px = light === void 0 ? void 0 : themeLength(light);
+      if (px === void 0) delete theme[key][name.slice(prefix.length)];
+      else theme[key][name.slice(prefix.length)] = px;
+    }
+  }
+  for (const [size2, value] of lineHeights) {
+    const text = theme.text[size2];
+    if (!text) continue;
+    const calc = /^calc\(\s*([\d.]+)\s*\/\s*([\d.]+)\s*\)$/.exec(value.trim());
+    const ratio = calc ? Number(calc[1]) / Number(calc[2]) : Number(value);
+    const px = Number.isFinite(ratio) ? Math.round(ratio * text[0] * 1e3) / 1e3 : themeLength(value);
+    if (px !== void 0) theme.text[size2] = [text[0], px];
+  }
+  const { darkColors, ...rest } = theme;
+  return Object.keys(darkColors).length > 0 ? { ...rest, darkColors } : rest;
+}
+
+// src/mobile/native-css.ts
+var IGNORED_PSEUDO = /^:(?:hover|focus|focus-visible|focus-within|active|visited|target|checked|placeholder-shown|disabled|enabled|empty)$/;
+var DROPPED_AT_RULES = /^@(?:font-face|keyframes|-webkit-keyframes|property|page|import|charset|namespace|tailwind|config|plugin|source|custom-variant|variant|utility|theme)\b/;
+function stripComments(css) {
+  return css.replace(/\/\*[\s\S]*?\*\//g, "");
+}
+function splitList(text) {
+  const parts = [];
+  let depth = 0;
+  let start = 0;
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+    if (char === "(" || char === "[") depth += 1;
+    else if (char === ")" || char === "]") depth -= 1;
+    else if (char === "," && depth === 0) {
+      parts.push(text.slice(start, index).trim());
+      start = index + 1;
+    }
+  }
+  parts.push(text.slice(start).trim());
+  return parts.filter(Boolean);
+}
+function parseCompound(text) {
+  const compound = { classes: [], attributes: [], positions: [] };
+  const token = /([a-zA-Z][\w-]*|\*)|#([\w-]+)|\.([\w-]+)|\[([\w-]+)(?:([~|^$*]?=)["']?([^"'\]]*)["']?)?\]|(::?[\w-]+)(\([^)]*\))?/gy;
+  let match;
+  let index = 0;
+  while (index < text.length) {
+    token.lastIndex = index;
+    match = token.exec(text);
+    if (!match) return void 0;
+    index = token.lastIndex;
+    if (match[1]) {
+      if (match[1] !== "*") compound.tag = match[1].toLowerCase();
+    } else if (match[2]) compound.id = match[2];
+    else if (match[3]) compound.classes.push(match[3]);
+    else if (match[4]) {
+      if (match[5] && match[5] !== "=") return void 0;
+      compound.attributes.push({ name: match[4].toLowerCase(), value: match[6] });
+    } else if (match[7]) {
+      if (match[8]) return void 0;
+      if (match[7] === ":first-child" || match[7] === ":last-child") {
+        compound.positions.push(match[7].slice(1));
+      } else if (match[7] === ":root") compound.tag = "html";
+      else if (IGNORED_PSEUDO.test(match[7])) return null;
+      else return void 0;
+    }
+  }
+  return compound;
+}
+function parseSelector(text) {
+  const steps = [];
+  let specificity = 0;
+  const parts = text.replace(/\s*([>+~])\s*/g, " $1 ").trim().split(/\s+/);
+  let combinator;
+  for (let index = parts.length - 1; index >= 0; index -= 1) {
+    const part = parts[index];
+    if (part === ">" || part === "+" || part === "~") {
+      combinator = part;
+      continue;
+    }
+    const compound = parseCompound(part);
+    if (compound === null) return null;
+    if (compound === void 0) return void 0;
+    if (steps.length > 0) steps[steps.length - 1].combinator = combinator ?? " ";
+    steps.push({ compound });
+    combinator = void 0;
+    specificity += (compound.id ? 1e4 : 0) + (compound.classes.length + compound.attributes.length + compound.positions.length) * 100 + (compound.tag ? 1 : 0);
+  }
+  return steps.length > 0 ? { steps, specificity } : void 0;
+}
+function parseFarmNativeStylesheet(css) {
+  const sheet = {
+    rules: [],
+    unknown: [],
+    vars: { light: {}, dark: {} },
+    layered: /* @__PURE__ */ new Set()
+  };
+  let order = 0;
+  const walk = (text, context) => {
+    let index = 0;
+    while (index < text.length) {
+      const open = text.indexOf("{", index);
+      const semicolon = text.indexOf(";", index);
+      if (open < 0) break;
+      if (semicolon >= 0 && semicolon < open) {
+        index = semicolon + 1;
+        continue;
+      }
+      const prelude = text.slice(index, open).trim();
+      let depth = 1;
+      let close = open + 1;
+      while (close < text.length && depth > 0) {
+        if (text[close] === "{") depth += 1;
+        else if (text[close] === "}") depth -= 1;
+        close += 1;
+      }
+      const body = text.slice(open + 1, close - 1);
+      index = close;
+      if (prelude.startsWith("@")) {
+        if (DROPPED_AT_RULES.test(prelude)) continue;
+        if (/^@layer\b/.test(prelude)) {
+          walk(body, { ...context, layered: true });
+        } else if (/^@media\b/.test(prelude)) {
+          const query = prelude.slice(6).trim();
+          if (/^\(\s*prefers-color-scheme:\s*dark\s*\)$/.test(query))
+            walk(body, { ...context, dark: true });
+          else if (/^\(\s*prefers-color-scheme:\s*light\s*\)$/.test(query))
+            walk(body, { ...context, light: true });
+          else walk(body, { ...context, unknownMedia: prelude });
+        } else if (/^@supports\b/.test(prelude)) {
+          walk(body, context);
+        } else {
+          walk(body, { ...context, unknownMedia: prelude });
+        }
+        continue;
+      }
+      const declarations = splitFarmCssDeclarations(body);
+      const applies = /@apply\b/.test(body);
+      for (const text2 of splitList(prelude)) {
+        const selector = parseSelector(text2);
+        if (selector === null) continue;
+        const subject = selector?.steps[0].compound;
+        if (context.layered) {
+          for (const name of subject?.classes ?? []) sheet.layered.add(name);
+          continue;
+        }
+        if (selector && selector.steps.length === 1 && subject?.tag === "html" && !subject.classes.length) {
+          for (const [property, value] of declarations) {
+            if (property.startsWith("--")) {
+              (context.dark ? sheet.vars.dark : sheet.vars.light)[property] = value;
+            }
+          }
+        }
+        if (!selector || context.unknownMedia || applies) {
+          const fallback = /(?:^|[\s>+~])([a-zA-Z][\w-]*)?((?:[.#:[][^\s>+~]*)?)$/.exec(text2);
+          sheet.unknown.push({
+            classes: [...(fallback?.[2] ?? "").matchAll(/\.([\w-]+)/g)].map((match) => match[1]),
+            tag: fallback?.[1]?.toLowerCase(),
+            text: context.unknownMedia ? `${context.unknownMedia} ${text2}` : applies ? `${text2} { @apply }` : text2
+          });
+          continue;
+        }
+        if (context.light) continue;
+        const own = declarations.filter(([property]) => !property.startsWith("--"));
+        if (own.length > 0) {
+          sheet.rules.push({
+            selector,
+            text: text2,
+            declarations: own,
+            dark: context.dark,
+            order: order++
+          });
+        }
+      }
+    }
+  };
+  walk(stripComments(css), {});
+  return sheet;
+}
+function classesOf(element) {
+  return (element.attributes.class ?? "").split(/\s+/).filter(Boolean);
+}
+function matchesCompound(compound, element) {
+  if (compound.tag && compound.tag !== element.tag) return false;
+  if (compound.id && element.attributes.id !== compound.id) return false;
+  if (compound.classes.length > 0) {
+    const classes = classesOf(element);
+    if (!compound.classes.every((name) => classes.includes(name))) return false;
+  }
+  for (const attribute of compound.attributes) {
+    const value = attribute.name === "data-farm-shell" && element.tag === "html" ? element.attributes[attribute.name] ?? "android" : element.attributes[attribute.name];
+    if (value === void 0) return false;
+    if (attribute.value !== void 0 && value !== attribute.value) return false;
+  }
+  for (const position of compound.positions) {
+    if (position === "first-child" && element.previous) return false;
+    if (position === "last-child" && !element.last) return false;
+  }
+  return true;
+}
+function matches(selector, element) {
+  const step = (index, target) => {
+    if (!target) return false;
+    const { compound, combinator } = selector.steps[index];
+    if (!matchesCompound(compound, target)) return false;
+    if (index === selector.steps.length - 1) return true;
+    switch (combinator) {
+      case ">":
+        return step(index + 1, target.parent);
+      case "+":
+        return step(index + 1, target.previous);
+      case "~":
+        for (let sibling = target.previous; sibling; sibling = sibling.previous) {
+          if (step(index + 1, sibling)) return true;
+        }
+        return false;
+      default:
+        for (let ancestor = target.parent; ancestor; ancestor = ancestor.parent) {
+          if (step(index + 1, ancestor)) return true;
+        }
+        return false;
+    }
+  };
+  return step(0, element);
+}
+function substitute(value, vars, depth = 0) {
+  if (!value.includes("var(")) return value;
+  if (depth > 8) return void 0;
+  let missing = false;
+  const replaced = value.replace(
+    /var\(\s*(--[\w-]+)\s*(?:,\s*([^()]*(?:\([^()]*\))?[^()]*))?\)/g,
+    (_, name, fallback) => {
+      const resolved = vars[name] ?? fallback?.trim();
+      if (resolved === void 0) {
+        missing = true;
+        return "";
+      }
+      return resolved;
+    }
+  );
+  return missing ? void 0 : substitute(replaced, vars, depth + 1);
+}
+function cascadeFarmNativeStylesheets(sheets, element) {
+  const style = {};
+  const dark = {};
+  const unsupported = [];
+  const classes = classesOf(element);
+  const matched = [];
+  sheets.forEach((sheet, index) => {
+    for (const rule of sheet.rules) {
+      if (matches(rule.selector, element)) matched.push({ rule, sheet, index });
+    }
+    for (const unknown of sheet.unknown) {
+      const touches = unknown.classes.some((name) => classes.includes(name)) || unknown.classes.length === 0 && unknown.tag === element.tag;
+      if (touches) unsupported.push(`selector "${unknown.text}"`);
+    }
+  });
+  matched.sort(
+    (left, right) => left.rule.selector.specificity - right.rule.selector.specificity || left.index - right.index || left.rule.order - right.rule.order
+  );
+  for (const { rule, sheet } of matched) {
+    for (const [property, raw] of rule.declarations) {
+      const themes = rule.dark ? [dark] : [style, dark];
+      for (const target of themes) {
+        const vars = target === dark ? { ...sheet.vars.light, ...sheet.vars.dark } : sheet.vars.light;
+        const value = substitute(raw, vars);
+        const resolved = value === void 0 ? void 0 : resolveFarmNativeDeclaration(property, value.toLowerCase().trim());
+        if (resolved === void 0) {
+          const message = `${property}: ${raw}`;
+          if (!unsupported.includes(message)) unsupported.push(message);
+          break;
+        }
+        if (resolved) Object.assign(target, resolved);
+      }
+    }
+  }
+  for (const key of Object.keys(dark)) {
+    if (dark[key] === style[key]) delete dark[key];
+  }
+  const layered = classes.filter((name) => sheets.some((sheet) => sheet.layered.has(name)));
+  return { style, dark, unsupported, layered };
+}
+function inspectFarmNativeStylesheets(sheets, target) {
+  const problems = [];
+  let styled = false;
+  const touches = (compound, subject) => "class" in target ? compound.classes.includes(target.class) : subject && compound.tag === target.tag && compound.classes.length === 0;
+  for (const sheet of sheets) {
+    for (const rule of sheet.rules) {
+      if (!rule.selector.steps.some((step, index) => touches(step.compound, index === 0))) continue;
+      styled = true;
+      for (const [property, raw] of rule.declarations) {
+        for (const vars of [sheet.vars.light, { ...sheet.vars.light, ...sheet.vars.dark }]) {
+          const value = substitute(raw, vars);
+          if (value === void 0 || resolveFarmNativeDeclaration(property, value.toLowerCase().trim()) === void 0) {
+            const message = `"${rule.text} { ${property}: ${raw} }" has no native-tier style`;
+            if (!problems.includes(message)) problems.push(message);
+            break;
+          }
+        }
+      }
+    }
+    for (const unknown of sheet.unknown) {
+      const hit = "class" in target ? unknown.classes.includes(target.class) : unknown.classes.length === 0 && unknown.tag === target.tag;
+      if (hit) {
+        styled = true;
+        problems.push(`"${unknown.text}" is CSS the native tier cannot apply`);
+      }
+    }
+  }
+  return { styled, problems };
+}
+function cascadeFarmNativeStylesheetsForElement(sheets, element, contextClasses = /* @__PURE__ */ new Set()) {
+  const { tag, classes = [] } = element;
+  const problems = [];
+  const inherit = /* @__PURE__ */ new Set();
+  const problem = (message) => {
+    if (!problems.includes(message)) problems.push(message);
+  };
+  for (const sheet of sheets) {
+    for (const rule of sheet.rules) {
+      const [subject, ...context] = rule.selector.steps;
+      const compound = subject.compound;
+      if (compound.tag && compound.tag !== tag || compound.classes.some((name) => !classes.includes(name))) {
+        continue;
+      }
+      const unreachable = context.some(
+        (step) => step.compound.classes.length > 0 && step.compound.classes.some((name) => !contextClasses.has(name))
+      );
+      if (unreachable) continue;
+      const shellOnly = tag === "html" && compound.attributes.every((attribute) => attribute.name === "data-farm-shell");
+      if (context.length > 0 || compound.id || compound.positions.length > 0 || compound.attributes.length > 0 && !shellOnly) {
+        problem(`"${rule.text}" depends on where <${tag}> renders`);
+        continue;
+      }
+      for (const [property, value] of rule.declarations) {
+        if (value.trim().toLowerCase() !== "inherit") continue;
+        for (const key of INHERITABLE[property] ?? []) inherit.add(key);
+      }
+    }
+    for (const unknown of sheet.unknown) {
+      const touches = unknown.classes.length > 0 ? unknown.classes.some((name) => classes.includes(name)) : !unknown.tag || unknown.tag === tag;
+      if (touches) problem(`"${unknown.text}" is CSS a port cannot apply`);
+    }
+  }
+  const { style, dark, unsupported } = cascadeFarmNativeStylesheets(sheets, {
+    tag,
+    attributes: {
+      ...tag === "html" ? { "data-farm-shell": "" } : {},
+      ...classes.length > 0 ? { class: classes.join(" ") } : {}
+    }
+  });
+  for (const message of unsupported) problem(`<${tag}> ${message}`);
+  return { style, dark, inherit: [...inherit].sort(), problems };
+}
+var INHERITABLE = {
+  font: ["fontFamily", "fontSize", "fontStyle", "fontWeight", "lineHeight"],
+  "font-family": ["fontFamily"],
+  "font-size": ["fontSize"],
+  "font-style": ["fontStyle"],
+  "font-weight": ["fontWeight"],
+  "line-height": ["lineHeight"],
+  "letter-spacing": ["letterSpacing"],
+  color: ["color"],
+  "text-align": ["textAlign"]
+};
+
+export {
+  FARM_NATIVE_TEXT_KEYS,
+  farmNativeClassProblem,
+  resolveFarmNativeClasses,
+  FARM_NATIVE_STYLE_PROPERTIES,
+  resolveFarmNativeInlineStyle,
+  createFarmNativeTheme,
+  parseFarmNativeStylesheet,
+  cascadeFarmNativeStylesheets,
+  inspectFarmNativeStylesheets,
+  cascadeFarmNativeStylesheetsForElement
+};