@csszyx/cli 0.9.8 → 0.9.10

package/dist/shared/cli.dDkXlxD_.mjs

@@ -0,0 +1,3428 @@
+import { resolve, dirname } from 'node:path';
+import { existsSync, writeFileSync } from 'node:fs';
+import { mkdir } from 'node:fs/promises';
+import { pathToFileURL } from 'node:url';
+import resolveConfig from 'tailwindcss/resolveConfig.js';
+import { parse } from '@babel/parser';
+import * as t from '@babel/types';
+
+const CONFIG_FILES = [
+  "tailwind.config.ts",
+  "tailwind.config.js",
+  "tailwind.config.cjs",
+  "tailwind.config.mjs"
+];
+function findConfigFile(cwd) {
+  for (const fileName of CONFIG_FILES) {
+    const configPath = resolve(cwd, fileName);
+    if (existsSync(configPath)) {
+      return configPath;
+    }
+  }
+  return null;
+}
+async function scanTailwindConfig(configPath) {
+  const absolutePath = resolve(configPath);
+  if (!existsSync(absolutePath)) {
+    throw new Error(`Tailwind config not found: ${absolutePath}`);
+  }
+  let userConfig;
+  try {
+    const fileUrl = pathToFileURL(absolutePath).href;
+    const module = await import(fileUrl);
+    userConfig = module.default || module;
+  } catch (error) {
+    throw new Error(
+      `Failed to load Tailwind config: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  const resolvedConfig = resolveConfig(userConfig);
+  const theme = resolvedConfig.theme;
+  const hasCustomColors = Boolean(userConfig.theme?.colors || userConfig.theme?.extend?.colors);
+  const hasCustomSpacing = Boolean(
+    userConfig.theme?.spacing || userConfig.theme?.extend?.spacing
+  );
+  return {
+    theme,
+    configPath: absolutePath,
+    hasCustomColors,
+    hasCustomSpacing
+  };
+}
+function flattenColors(colors) {
+  const result = [];
+  for (const [key, value] of Object.entries(colors)) {
+    if (key === "inherit" || key === "current" || key === "transparent") {
+      result.push(key);
+      continue;
+    }
+    if (typeof value === "string") {
+      result.push(key);
+    } else if (typeof value === "object" && value !== null) {
+      for (const shade of Object.keys(value)) {
+        if (shade === "DEFAULT") {
+          result.push(key);
+        } else {
+          result.push(`${key}-${shade}`);
+        }
+      }
+    }
+  }
+  return result.sort();
+}
+function extractSpacingKeys(spacing) {
+  return Object.keys(spacing).sort((a, b) => {
+    const aNum = parseFloat(a);
+    const bNum = parseFloat(b);
+    if (!Number.isNaN(aNum) && !Number.isNaN(bNum)) {
+      return aNum - bNum;
+    }
+    if (!Number.isNaN(aNum)) {
+      return -1;
+    }
+    if (!Number.isNaN(bNum)) {
+      return 1;
+    }
+    return a.localeCompare(b);
+  });
+}
+function extractScreenKeys(screens) {
+  return Object.keys(screens);
+}
+
+const PROPERTY_MAPPINGS = [
+  // Layout
+  {
+    prop: "display",
+    prefix: "",
+    valueType: "display",
+    description: "CSS display property"
+  },
+  {
+    prop: "position",
+    prefix: "",
+    valueType: "position",
+    description: "CSS position property"
+  },
+  {
+    prop: "overflow",
+    prefix: "overflow",
+    valueType: "overflow",
+    description: "CSS overflow property"
+  },
+  {
+    prop: "z",
+    prefix: "z",
+    valueType: "zIndex",
+    description: "CSS z-index property"
+  },
+  // Flexbox & Grid
+  {
+    prop: "flex",
+    prefix: "flex",
+    valueType: "flex",
+    description: "Flex shorthand"
+  },
+  {
+    prop: "flexDir",
+    prefix: "flex",
+    valueType: "flexDirection",
+    description: "Flex direction"
+  },
+  {
+    prop: "justify",
+    prefix: "justify",
+    valueType: "justify",
+    description: "Justify content"
+  },
+  {
+    prop: "items",
+    prefix: "items",
+    valueType: "items",
+    description: "Align items"
+  },
+  {
+    prop: "gap",
+    prefix: "gap",
+    valueType: "spacing",
+    description: "Gap between flex/grid items"
+  },
+  {
+    prop: "grid",
+    prefix: "grid",
+    valueType: "grid",
+    description: "Grid shorthand"
+  },
+  {
+    prop: "gridCols",
+    prefix: "grid-cols",
+    valueType: "gridCols",
+    description: "Grid template columns"
+  },
+  {
+    prop: "gridRows",
+    prefix: "grid-rows",
+    valueType: "gridRows",
+    description: "Grid template rows"
+  },
+  {
+    prop: "col",
+    prefix: "col",
+    valueType: "col",
+    description: "Grid column span"
+  },
+  {
+    prop: "row",
+    prefix: "row",
+    valueType: "row",
+    description: "Grid row span"
+  },
+  // Spacing
+  {
+    prop: "p",
+    prefix: "p",
+    valueType: "spacing",
+    responsive: true,
+    description: "Padding (all sides)"
+  },
+  {
+    prop: "px",
+    prefix: "px",
+    valueType: "spacing",
+    responsive: true,
+    description: "Padding horizontal"
+  },
+  {
+    prop: "py",
+    prefix: "py",
+    valueType: "spacing",
+    responsive: true,
+    description: "Padding vertical"
+  },
+  {
+    prop: "pt",
+    prefix: "pt",
+    valueType: "spacing",
+    responsive: true,
+    description: "Padding top"
+  },
+  {
+    prop: "pr",
+    prefix: "pr",
+    valueType: "spacing",
+    responsive: true,
+    description: "Padding right"
+  },
+  {
+    prop: "pb",
+    prefix: "pb",
+    valueType: "spacing",
+    responsive: true,
+    description: "Padding bottom"
+  },
+  {
+    prop: "pl",
+    prefix: "pl",
+    valueType: "spacing",
+    responsive: true,
+    description: "Padding left"
+  },
+  {
+    prop: "m",
+    prefix: "m",
+    valueType: "spacing",
+    responsive: true,
+    description: "Margin (all sides)"
+  },
+  {
+    prop: "mx",
+    prefix: "mx",
+    valueType: "spacing",
+    responsive: true,
+    description: "Margin horizontal"
+  },
+  {
+    prop: "my",
+    prefix: "my",
+    valueType: "spacing",
+    responsive: true,
+    description: "Margin vertical"
+  },
+  {
+    prop: "mt",
+    prefix: "mt",
+    valueType: "spacing",
+    responsive: true,
+    description: "Margin top"
+  },
+  {
+    prop: "mr",
+    prefix: "mr",
+    valueType: "spacing",
+    responsive: true,
+    description: "Margin right"
+  },
+  {
+    prop: "mb",
+    prefix: "mb",
+    valueType: "spacing",
+    responsive: true,
+    description: "Margin bottom"
+  },
+  {
+    prop: "ml",
+    prefix: "ml",
+    valueType: "spacing",
+    responsive: true,
+    description: "Margin left"
+  },
+  // Sizing
+  {
+    prop: "w",
+    prefix: "w",
+    valueType: "sizing",
+    responsive: true,
+    description: "Width"
+  },
+  {
+    prop: "h",
+    prefix: "h",
+    valueType: "sizing",
+    responsive: true,
+    description: "Height"
+  },
+  {
+    prop: "minW",
+    prefix: "min-w",
+    valueType: "minWidth",
+    description: "Minimum width"
+  },
+  {
+    prop: "maxW",
+    prefix: "max-w",
+    valueType: "maxWidth",
+    description: "Maximum width"
+  },
+  {
+    prop: "minH",
+    prefix: "min-h",
+    valueType: "minHeight",
+    description: "Minimum height"
+  },
+  {
+    prop: "maxH",
+    prefix: "max-h",
+    valueType: "maxHeight",
+    description: "Maximum height"
+  },
+  // Colors
+  {
+    prop: "bg",
+    prefix: "bg",
+    valueType: "colors",
+    stateful: true,
+    description: "Background color"
+  },
+  {
+    prop: "text",
+    prefix: "text",
+    valueType: "colors",
+    stateful: true,
+    description: "Text color"
+  },
+  {
+    prop: "border",
+    prefix: "border",
+    valueType: "colors",
+    stateful: true,
+    description: "Border color"
+  },
+  {
+    prop: "ring",
+    prefix: "ring",
+    valueType: "colors",
+    stateful: true,
+    description: "Ring color"
+  },
+  {
+    prop: "fill",
+    prefix: "fill",
+    valueType: "colors",
+    description: "SVG fill color"
+  },
+  {
+    prop: "stroke",
+    prefix: "stroke",
+    valueType: "colors",
+    description: "SVG stroke color"
+  },
+  // Typography
+  {
+    prop: "font",
+    prefix: "font",
+    valueType: "fontWeight",
+    description: "Font weight"
+  },
+  {
+    prop: "fontFamily",
+    prefix: "font",
+    valueType: "fontFamily",
+    description: "Font family"
+  },
+  {
+    prop: "fontSize",
+    prefix: "text",
+    valueType: "fontSize",
+    description: "Font size"
+  },
+  {
+    prop: "leading",
+    prefix: "leading",
+    valueType: "lineHeight",
+    description: "Line height"
+  },
+  {
+    prop: "tracking",
+    prefix: "tracking",
+    valueType: "letterSpacing",
+    description: "Letter spacing"
+  },
+  {
+    prop: "textAlign",
+    prefix: "text",
+    valueType: "textAlign",
+    description: "Text alignment"
+  },
+  // Borders
+  {
+    prop: "rounded",
+    prefix: "rounded",
+    valueType: "borderRadius",
+    description: "Border radius"
+  },
+  {
+    prop: "borderW",
+    prefix: "border",
+    valueType: "borderWidth",
+    description: "Border width"
+  },
+  // Effects
+  {
+    prop: "shadow",
+    prefix: "shadow",
+    valueType: "boxShadow",
+    description: "Box shadow"
+  },
+  {
+    prop: "opacity",
+    prefix: "opacity",
+    valueType: "opacity",
+    description: "Opacity"
+  },
+  // Transforms
+  {
+    prop: "scale",
+    prefix: "scale",
+    valueType: "scale",
+    description: "Scale transform"
+  },
+  {
+    prop: "rotate",
+    prefix: "rotate",
+    valueType: "rotate",
+    description: "Rotate transform"
+  },
+  {
+    prop: "translate",
+    prefix: "translate",
+    valueType: "translate",
+    description: "Translate transform"
+  },
+  // Transitions
+  {
+    prop: "transition",
+    prefix: "transition",
+    valueType: "transition",
+    description: "Transition property"
+  },
+  {
+    prop: "duration",
+    prefix: "duration",
+    valueType: "duration",
+    description: "Transition duration"
+  },
+  {
+    prop: "ease",
+    prefix: "ease",
+    valueType: "ease",
+    description: "Transition timing function"
+  }
+];
+const STATIC_VALUE_TYPES = {
+  display: [
+    "block",
+    "inline-block",
+    "inline",
+    "flex",
+    "inline-flex",
+    "grid",
+    "inline-grid",
+    "hidden",
+    "contents",
+    "flow-root"
+  ],
+  position: ["static", "fixed", "absolute", "relative", "sticky"],
+  overflow: [
+    "auto",
+    "hidden",
+    "clip",
+    "visible",
+    "scroll",
+    "x-auto",
+    "y-auto",
+    "x-hidden",
+    "y-hidden",
+    "x-clip",
+    "y-clip",
+    "x-visible",
+    "y-visible",
+    "x-scroll",
+    "y-scroll"
+  ],
+  flexDirection: ["row", "row-reverse", "col", "col-reverse"],
+  justify: ["normal", "start", "end", "center", "between", "around", "evenly", "stretch"],
+  items: ["start", "end", "center", "baseline", "stretch"],
+  flex: ["1", "auto", "initial", "none"],
+  grid: ["flow-row", "flow-col", "flow-dense", "flow-row-dense", "flow-col-dense"],
+  gridCols: ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "none", "subgrid"],
+  gridRows: ["1", "2", "3", "4", "5", "6", "none", "subgrid"],
+  col: [
+    "auto",
+    "span-1",
+    "span-2",
+    "span-3",
+    "span-4",
+    "span-5",
+    "span-6",
+    "span-7",
+    "span-8",
+    "span-9",
+    "span-10",
+    "span-11",
+    "span-12",
+    "span-full",
+    "start-1",
+    "start-2",
+    "start-3",
+    "start-4",
+    "start-5",
+    "start-6",
+    "start-7",
+    "start-8",
+    "start-9",
+    "start-10",
+    "start-11",
+    "start-12",
+    "start-13",
+    "start-auto",
+    "end-1",
+    "end-2",
+    "end-3",
+    "end-4",
+    "end-5",
+    "end-6",
+    "end-7",
+    "end-8",
+    "end-9",
+    "end-10",
+    "end-11",
+    "end-12",
+    "end-13",
+    "end-auto"
+  ],
+  row: [
+    "auto",
+    "span-1",
+    "span-2",
+    "span-3",
+    "span-4",
+    "span-5",
+    "span-6",
+    "span-full",
+    "start-1",
+    "start-2",
+    "start-3",
+    "start-4",
+    "start-5",
+    "start-6",
+    "start-7",
+    "start-auto",
+    "end-1",
+    "end-2",
+    "end-3",
+    "end-4",
+    "end-5",
+    "end-6",
+    "end-7",
+    "end-auto"
+  ],
+  textAlign: ["left", "center", "right", "justify", "start", "end"],
+  fontWeight: [
+    "thin",
+    "extralight",
+    "light",
+    "normal",
+    "medium",
+    "semibold",
+    "bold",
+    "extrabold",
+    "black"
+  ],
+  transition: ["none", "all", "colors", "opacity", "shadow", "transform"],
+  ease: ["linear", "in", "out", "in-out"]
+};
+function generateUnionType(values) {
+  if (values.length === 0) {
+    return "string";
+  }
+  return values.map((v) => `'${v}'`).join(" | ");
+}
+function generateTypeDeclarations(theme, options = {}) {
+  const { includeComments = true } = options;
+  const colors = flattenColors(theme.colors || {});
+  const spacing = extractSpacingKeys(theme.spacing || {});
+  const screens = extractScreenKeys(theme.screens || {});
+  const sizing = [
+    ...spacing,
+    "auto",
+    "full",
+    "screen",
+    "svw",
+    "lvw",
+    "dvw",
+    "min",
+    "max",
+    "fit",
+    "1/2",
+    "1/3",
+    "2/3",
+    "1/4",
+    "2/4",
+    "3/4",
+    "1/5",
+    "2/5",
+    "3/5",
+    "4/5",
+    "1/6",
+    "5/6"
+  ];
+  const valueTypeMap = {
+    colors,
+    spacing,
+    sizing,
+    screens,
+    ...STATIC_VALUE_TYPES,
+    // Extract from theme if available
+    zIndex: theme.zIndex ? Object.keys(theme.zIndex) : ["0", "10", "20", "30", "40", "50", "auto"],
+    borderRadius: theme.borderRadius ? Object.keys(theme.borderRadius) : ["none", "sm", "md", "lg", "xl", "2xl", "3xl", "full"],
+    boxShadow: theme.boxShadow ? Object.keys(theme.boxShadow) : ["sm", "md", "lg", "xl", "2xl", "inner", "none"],
+    opacity: theme.opacity ? Object.keys(theme.opacity) : [
+      "0",
+      "5",
+      "10",
+      "20",
+      "25",
+      "30",
+      "40",
+      "50",
+      "60",
+      "70",
+      "75",
+      "80",
+      "90",
+      "95",
+      "100"
+    ],
+    fontSize: theme.fontSize ? Object.keys(theme.fontSize) : [
+      "xs",
+      "sm",
+      "base",
+      "lg",
+      "xl",
+      "2xl",
+      "3xl",
+      "4xl",
+      "5xl",
+      "6xl",
+      "7xl",
+      "8xl",
+      "9xl"
+    ],
+    fontFamily: theme.fontFamily ? Object.keys(theme.fontFamily) : ["sans", "serif", "mono"],
+    lineHeight: [
+      "none",
+      "tight",
+      "snug",
+      "normal",
+      "relaxed",
+      "loose",
+      "3",
+      "4",
+      "5",
+      "6",
+      "7",
+      "8",
+      "9",
+      "10"
+    ],
+    letterSpacing: ["tighter", "tight", "normal", "wide", "wider", "widest"],
+    borderWidth: ["0", "2", "4", "8", ""],
+    minWidth: ["0", "full", "min", "max", "fit"],
+    maxWidth: [
+      "0",
+      "none",
+      "xs",
+      "sm",
+      "md",
+      "lg",
+      "xl",
+      "2xl",
+      "3xl",
+      "4xl",
+      "5xl",
+      "6xl",
+      "7xl",
+      "full",
+      "min",
+      "max",
+      "fit",
+      "prose",
+      "screen-sm",
+      "screen-md",
+      "screen-lg",
+      "screen-xl",
+      "screen-2xl"
+    ],
+    minHeight: ["0", "full", "screen", "svh", "lvh", "dvh", "min", "max", "fit"],
+    maxHeight: ["0", "none", "full", "screen", "svh", "lvh", "dvh", "min", "max", "fit"],
+    scale: ["0", "50", "75", "90", "95", "100", "105", "110", "125", "150"],
+    rotate: ["0", "1", "2", "3", "6", "12", "45", "90", "180"],
+    translate: spacing,
+    duration: ["0", "75", "100", "150", "200", "300", "500", "700", "1000"]
+  };
+  const properties = [];
+  for (const mapping of PROPERTY_MAPPINGS) {
+    const values = valueTypeMap[mapping.valueType] || [];
+    const unionType = generateUnionType(values);
+    let propDef = "";
+    if (includeComments && mapping.description) {
+      propDef += `    /** ${mapping.description} */
+`;
+    }
+    propDef += `    ${mapping.prop}?: ${unionType} | (string & {}) | number;`;
+    properties.push(propDef);
+  }
+  const variants = [
+    "hover",
+    "focus",
+    "active",
+    "disabled",
+    "visited",
+    "first",
+    "last",
+    "odd",
+    "even",
+    "group-hover",
+    "dark"
+  ];
+  const variantProps = [];
+  for (const variant of variants) {
+    if (includeComments) {
+      variantProps.push(`    /** Styles applied on ${variant} state */`);
+    }
+    variantProps.push(`    ${variant}?: SzVariantObject;`);
+  }
+  const responsiveProps = [];
+  for (const screen of screens) {
+    if (includeComments) {
+      responsiveProps.push(`    /** Styles applied at ${screen} breakpoint and above */`);
+    }
+    responsiveProps.push(`    ${screen}?: SzVariantObject;`);
+  }
+  const output = `/**
+ * Auto-generated TypeScript declarations for csszyx.
+ *
+ * This file provides strict typing for the sz prop based on your
+ * Tailwind CSS configuration.
+ *
+ * @generated by @csszyx/cli
+ * @see https://github.com/nguyennhutien/csszyx
+ */
+
+import '@csszyx/types';
+
+/**
+ * Variant object type (used for hover, focus, responsive breakpoints, etc.)
+ */
+type SzVariantObject = Partial<StrictSzObject>;
+
+/**
+ * Strict sz object interface with typed properties.
+ */
+interface StrictSzObject {
+${properties.join("\n")}
+
+    // State variants
+${variantProps.join("\n")}
+
+    // Responsive variants
+${responsiveProps.join("\n")}
+
+    // Allow arbitrary properties for escape hatch
+    [key: string]: string | number | boolean | SzVariantObject | undefined;
+}
+
+declare module '@csszyx/types' {
+    /**
+     * Override the base SzObject with strict typing.
+     */
+    interface SzObject extends StrictSzObject {}
+}
+
+declare module 'react' {
+    interface HTMLAttributes<T> {
+        /**
+         * csszyx object syntax for Tailwind CSS classes.
+         * Provides IntelliSense for all Tailwind utilities.
+         */
+        sz?: StrictSzObject;
+    }
+
+    interface SVGAttributes<T> {
+        /**
+         * csszyx object syntax for Tailwind CSS classes.
+         */
+        sz?: StrictSzObject;
+    }
+}
+
+export {};
+`;
+  return output;
+}
+async function writeDeclarationFile(content, outputPath) {
+  const absolutePath = resolve(outputPath);
+  const dir = dirname(absolutePath);
+  await mkdir(dir, { recursive: true });
+  writeFileSync(absolutePath, content, "utf-8");
+}
+async function generateAndWriteTypes(theme, options = {}) {
+  const outputPath = options.output || "./csszyx.d.ts";
+  const content = generateTypeDeclarations(theme, options);
+  await writeDeclarationFile(content, outputPath);
+  return resolve(outputPath);
+}
+
+async function generateTypes(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const log = options.silent ? () => {
+  } : console.log;
+  const error = options.silent ? () => {
+  } : console.error;
+  let configPath;
+  let scanResult;
+  if (options.config) {
+    configPath = resolve(cwd, options.config);
+  } else {
+    log("\u{1F50D} Searching for tailwind.config...");
+    const foundConfig = findConfigFile(cwd);
+    if (!foundConfig) {
+      error("\u274C Could not find tailwind.config.js in current directory");
+      error("   Please specify the path with --config flag");
+      process.exit(1);
+    }
+    configPath = foundConfig;
+  }
+  log(`\u{1F4D6} Reading config from: ${configPath}`);
+  try {
+    scanResult = await scanTailwindConfig(configPath);
+  } catch (err) {
+    error(
+      `\u274C Failed to read Tailwind config: ${err instanceof Error ? err.message : String(err)}`
+    );
+    process.exit(1);
+  }
+  log("\u2705 Config loaded successfully");
+  if (scanResult.hasCustomColors) {
+    log("   \u2022 Custom colors detected");
+  }
+  if (scanResult.hasCustomSpacing) {
+    log("   \u2022 Custom spacing detected");
+  }
+  const outputPath = options.output || "./csszyx.d.ts";
+  const generatorOptions = {
+    output: resolve(cwd, outputPath),
+    includeComments: true
+  };
+  log("\n\u{1F4DD} Generating TypeScript declarations...");
+  try {
+    const writtenPath = await generateAndWriteTypes(scanResult.theme, generatorOptions);
+    log("\n\u2728 Types generated successfully!");
+    log(`   Output: ${writtenPath}`);
+    log('\n\u{1F4A1} Add this to your tsconfig.json "include" array:');
+    log('   "include": ["src", "csszyx.d.ts"]');
+  } catch (err) {
+    error(`\u274C Failed to generate types: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+}
+
+function generateSzExpression(obj) {
+  return `{${objectToString(obj)}}`;
+}
+function generateSzHtmlValue(obj, braces = false) {
+  const s = objectToString(obj);
+  if (braces) {
+    return s;
+  }
+  if (s.startsWith("{ ") && s.endsWith(" }")) {
+    return s.slice(2, -2);
+  }
+  if (s.startsWith("{") && s.endsWith("}")) {
+    return s.slice(1, -1).trim();
+  }
+  return s;
+}
+function generateSzObjectLiteral(obj) {
+  return objectToString(obj);
+}
+function objectToString(obj, indent = 0) {
+  const entries = Object.entries(obj);
+  if (entries.length === 0) {
+    return "{}";
+  }
+  const spaces = " ".repeat(indent);
+  const innerSpaces = " ".repeat(indent + 2);
+  if (entries.length <= 2 && !hasDeepNesting(obj)) {
+    const parts = entries.map(([k, v]) => `${formatKey(k)}: ${formatValue(v, indent)}`);
+    return `{ ${parts.join(", ")} }`;
+  }
+  const lines = entries.map(
+    ([k, v]) => `${innerSpaces}${formatKey(k)}: ${formatValue(v, indent + 2)},`
+  );
+  return `{
+${lines.join("\n")}
+${spaces}}`;
+}
+function hasDeepNesting(obj) {
+  return Object.values(obj).some(
+    (v) => typeof v === "object" && v !== null && !isColorOpacityObj(v) && !isGradientObj(v)
+  );
+}
+function isColorOpacityObj(v) {
+  return typeof v === "object" && v !== null && "color" in v && "op" in v;
+}
+function isGradientObj(v) {
+  return typeof v === "object" && v !== null && "gradient" in v;
+}
+function formatKey(key) {
+  if (/^[a-z_$][\w$]*$/i.test(key)) {
+    return key;
+  }
+  return `'${key}'`;
+}
+function formatValue(value, indent) {
+  if (value === true) {
+    return "true";
+  }
+  if (value === false) {
+    return "false";
+  }
+  if (value === null) {
+    return "null";
+  }
+  if (typeof value === "number") {
+    return String(value);
+  }
+  if (typeof value === "string") {
+    return `'${escapeString(value)}'`;
+  }
+  if (Array.isArray(value)) {
+    const items = value.map((v) => formatValue(v, indent));
+    return `[${items.join(", ")}]`;
+  }
+  if (typeof value === "object") {
+    if (isColorOpacityObj(value)) {
+      const parts = [`color: '${escapeString(String(value.color))}'`];
+      if (typeof value.op === "number") {
+        parts.push(`op: ${value.op}`);
+      } else {
+        parts.push(`op: '${escapeString(String(value.op))}'`);
+      }
+      return `{ ${parts.join(", ")} }`;
+    }
+    if (isGradientObj(value)) {
+      const grad = value;
+      const parts = [`gradient: '${grad.gradient}'`];
+      if ("dir" in grad) {
+        if (typeof grad.dir === "number") {
+          parts.push(`dir: ${grad.dir}`);
+        } else {
+          parts.push(`dir: '${escapeString(String(grad.dir))}'`);
+        }
+      }
+      if ("in" in grad) {
+        parts.push(`in: '${escapeString(String(grad.in))}'`);
+      }
+      return `{ ${parts.join(", ")} }`;
+    }
+    return objectToString(value, indent);
+  }
+  return String(value);
+}
+function escapeString(s) {
+  return s.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
+
+const REVERSE_PROPERTY_MAP = {
+  // Background (ambiguous — disambiguated in class-parser)
+  bg: "bg",
+  "bg-clip": "bgClip",
+  "bg-origin": "bgOrigin",
+  // Border Radius
+  rounded: "rounded",
+  "rounded-t": "roundedT",
+  "rounded-r": "roundedR",
+  "rounded-b": "roundedB",
+  "rounded-l": "roundedL",
+  "rounded-tl": "roundedTl",
+  "rounded-tr": "roundedTr",
+  "rounded-bl": "roundedBl",
+  "rounded-br": "roundedBr",
+  "rounded-s": "roundedS",
+  "rounded-e": "roundedE",
+  "rounded-ss": "roundedSs",
+  "rounded-se": "roundedSe",
+  "rounded-es": "roundedEs",
+  "rounded-ee": "roundedEe",
+  // Border (ambiguous — disambiguated)
+  border: "border",
+  "border-t": "borderT",
+  "border-r": "borderR",
+  "border-b": "borderB",
+  "border-l": "borderL",
+  "border-x": "borderX",
+  "border-y": "borderY",
+  "border-s": "borderS",
+  "border-e": "borderE",
+  // Divide
+  "divide-x": "divideX",
+  "divide-y": "divideY",
+  divide: "divideColor",
+  // Outline (ambiguous)
+  outline: "outline",
+  "outline-offset": "outlineOffset",
+  // Ring (v4: outset ring + inset ring)
+  ring: "ring",
+  "ring-offset": "ringOffset",
+  "inset-ring": "insetRing",
+  // Spacing
+  p: "p",
+  pt: "pt",
+  pr: "pr",
+  pb: "pb",
+  pl: "pl",
+  px: "px",
+  py: "py",
+  ps: "ps",
+  pe: "pe",
+  m: "m",
+  mt: "mt",
+  mr: "mr",
+  mb: "mb",
+  ml: "ml",
+  mx: "mx",
+  my: "my",
+  ms: "ms",
+  me: "me",
+  // Space between
+  "space-x": "spaceX",
+  "space-y": "spaceY",
+  // Sizing
+  w: "w",
+  "min-w": "minW",
+  "max-w": "maxW",
+  h: "h",
+  "min-h": "minH",
+  "max-h": "maxH",
+  size: "size",
+  // Layout
+  aspect: "aspect",
+  columns: "columns",
+  "break-after": "breakAfter",
+  "break-before": "breakBefore",
+  "break-inside": "breakInside",
+  "box-decoration": "boxDecoration",
+  box: "box",
+  float: "float",
+  clear: "clear",
+  object: "objectFit",
+  // ambiguous — objectFit vs objectPos (objectPos for position values)
+  overflow: "overflow",
+  "overflow-x": "overflowX",
+  "overflow-y": "overflowY",
+  overscroll: "overscroll",
+  "overscroll-x": "overscrollX",
+  "overscroll-y": "overscrollY",
+  z: "z",
+  // Inset
+  inset: "inset",
+  "inset-x": "insetX",
+  "inset-y": "insetY",
+  top: "top",
+  right: "right",
+  bottom: "bottom",
+  left: "left",
+  // TW v4.2: start/end are deprecated — migrate to inset-s/inset-e
+  start: "insetS",
+  end: "insetE",
+  // Typography (ambiguous — text-*, font-* disambiguated)
+  text: "color",
+  // default for text- prefix
+  font: "fontWeight",
+  // default for font- prefix
+  decoration: "decoration",
+  // ambiguous
+  "underline-offset": "underlineOffset",
+  indent: "indent",
+  align: "align",
+  whitespace: "whitespace",
+  break: "break",
+  // ambiguous with break-after/before/inside (handled by prefix matching)
+  hyphens: "hyphens",
+  content: "content",
+  leading: "leading",
+  tracking: "tracking",
+  list: "list",
+  // ambiguous
+  "list-image": "listImg",
+  // Flex & Grid
+  basis: "basis",
+  flex: "flex",
+  // ambiguous (boolean flex, flexDirection, flexWrap)
+  grow: "grow",
+  shrink: "shrink",
+  order: "order",
+  items: "items",
+  self: "self",
+  justify: "justify",
+  "justify-items": "justifyItems",
+  "justify-self": "justifySelf",
+  "place-content": "placeContent",
+  "place-items": "placeItems",
+  "place-self": "placeSelf",
+  gap: "gap",
+  "gap-x": "gapX",
+  "gap-y": "gapY",
+  // Grid
+  "grid-cols": "gridCols",
+  "grid-rows": "gridRows",
+  col: "col",
+  "col-span": "colSpan",
+  "col-start": "colStart",
+  "col-end": "colEnd",
+  row: "row",
+  "row-span": "rowSpan",
+  "row-start": "rowStart",
+  "row-end": "rowEnd",
+  "grid-flow": "gridFlow",
+  "auto-cols": "autoCols",
+  "auto-rows": "autoRows",
+  // Effects
+  shadow: "shadow",
+  // ambiguous (shadow vs shadowColor)
+  "inset-shadow": "insetShadow",
+  opacity: "opacity",
+  "mix-blend": "mixBlend",
+  "bg-blend": "bgBlend",
+  // Filters
+  blur: "blur",
+  brightness: "brightness",
+  contrast: "contrast",
+  "drop-shadow": "dropShadow",
+  grayscale: "grayscale",
+  "hue-rotate": "hueRotate",
+  invert: "invert",
+  saturate: "saturate",
+  sepia: "sepia",
+  "backdrop-blur": "backdropBlur",
+  "backdrop-brightness": "backdropBrightness",
+  "backdrop-contrast": "backdropContrast",
+  "backdrop-grayscale": "backdropGrayscale",
+  "backdrop-hue-rotate": "backdropHueRotate",
+  "backdrop-invert": "backdropInvert",
+  "backdrop-opacity": "backdropOpacity",
+  "backdrop-saturate": "backdropSaturate",
+  "backdrop-sepia": "backdropSepia",
+  // Transforms
+  scale: "scale",
+  "scale-x": "scaleX",
+  "scale-y": "scaleY",
+  rotate: "rotate",
+  "translate-x": "translateX",
+  "translate-y": "translateY",
+  "skew-x": "skewX",
+  "skew-y": "skewY",
+  origin: "origin",
+  // Transitions & Animation
+  transition: "transition",
+  duration: "duration",
+  ease: "ease",
+  delay: "delay",
+  animate: "animate",
+  // Interactivity
+  cursor: "cursor",
+  caret: "caret",
+  "pointer-events": "pointerEvents",
+  resize: "resize",
+  scroll: "scroll",
+  "scroll-m": "scrollM",
+  "scroll-mt": "scrollMt",
+  "scroll-mr": "scrollMr",
+  "scroll-mb": "scrollMb",
+  "scroll-ml": "scrollMl",
+  "scroll-ms": "scrollMs",
+  "scroll-me": "scrollMe",
+  "scroll-mx": "scrollMx",
+  "scroll-my": "scrollMy",
+  "scroll-p": "scrollP",
+  "scroll-pt": "scrollPt",
+  "scroll-pr": "scrollPr",
+  "scroll-pb": "scrollPb",
+  "scroll-pl": "scrollPl",
+  "scroll-ps": "scrollPs",
+  "scroll-pe": "scrollPe",
+  "scroll-px": "scrollPx",
+  "scroll-py": "scrollPy",
+  snap: "snapType",
+  // ambiguous
+  touch: "touch",
+  select: "select",
+  "will-change": "willChange",
+  accent: "accent",
+  // SVG
+  fill: "fill",
+  stroke: "stroke",
+  // Tables
+  "border-spacing": "borderSpacing",
+  table: "tableLayout",
+  // ambiguous with boolean "table" display
+  caption: "caption",
+  // Line clamp
+  "line-clamp": "lineClamp",
+  wrap: "wrap",
+  // Text shadow
+  "text-shadow": "textShadow",
+  // Gradient stops
+  from: "from",
+  via: "via",
+  to: "to",
+  // Masks
+  mask: "mask",
+  // Forced colors
+  "forced-color-adjust": "forcedColorAdjust",
+  // Perspective
+  perspective: "perspective",
+  "perspective-origin": "perspectiveOrigin",
+  backface: "backface"
+};
+const REVERSE_BOOLEAN_MAP = {
+  // Display
+  block: "block",
+  inline: "inline",
+  "inline-block": "inlineBlock",
+  flex: "flex",
+  "inline-flex": "inlineFlex",
+  grid: "grid",
+  "inline-grid": "inlineGrid",
+  hidden: "hidden",
+  contents: "contents",
+  table: "table",
+  "table-row": "tableRow",
+  "table-cell": "tableCell",
+  "flow-root": "flowRoot",
+  "list-item": "listItem",
+  // Position
+  static: "static",
+  fixed: "fixed",
+  absolute: "absolute",
+  relative: "relative",
+  sticky: "sticky",
+  // Visibility
+  visible: "visible",
+  invisible: "invisible",
+  collapse: "collapse",
+  // Typography
+  truncate: "truncate",
+  uppercase: "uppercase",
+  lowercase: "lowercase",
+  capitalize: "capitalize",
+  "normal-case": "normalCase",
+  underline: "underline",
+  overline: "overline",
+  "line-through": "lineThrough",
+  "no-underline": "noUnderline",
+  italic: "italic",
+  "not-italic": "notItalic",
+  antialiased: "antialiased",
+  "subpixel-antialiased": "subpixelAntialiased",
+  // Flexbox
+  // flexWrap is string-based, not boolean — removed from boolean map
+  // Filters (defaults)
+  blur: "blur",
+  grayscale: "grayscale",
+  invert: "invert",
+  sepia: "sepia",
+  "backdrop-blur": "backdropBlur",
+  "backdrop-grayscale": "backdropGrayscale",
+  "backdrop-invert": "backdropInvert",
+  "backdrop-sepia": "backdropSepia",
+  // Misc
+  container: "container",
+  prose: "prose",
+  "sr-only": "srOnly",
+  "not-sr-only": "notSrOnly",
+  isolate: "isolate",
+  ordinal: "ordinal",
+  "slashed-zero": "slashedZero",
+  // Bare `transition` (common transition property) and the `group`/`peer`
+  // marker classes round-trip through the compiler as boolean sugar.
+  transition: "transition",
+  group: "group",
+  peer: "peer",
+  // Divide/Space reverse
+  "divide-x-reverse": "divideXReverse",
+  "divide-y-reverse": "divideYReverse",
+  "space-x-reverse": "spaceXReverse",
+  "space-y-reverse": "spaceYReverse",
+  // Ring/Outline/Border-radius (boolean defaults)
+  ring: "ring",
+  "inset-ring": "insetRing",
+  outline: "outline",
+  rounded: "rounded",
+  // Transforms
+  "scale-3d": "scale",
+  "translate-3d": "translate",
+  // transform-gpu/cpu/none use BOOLEAN_VALUE_MAP → { transform: 'gpu'/'cpu'/'none' }
+  // Font numeric
+  "normal-nums": "fontVariant",
+  "lining-nums": "fontVariant",
+  "oldstyle-nums": "fontVariant",
+  "proportional-nums": "fontVariant",
+  "tabular-nums": "fontVariant",
+  "diagonal-fractions": "fontVariant",
+  "stacked-fractions": "fontVariant",
+  // Snap
+  "snap-none": "snapType",
+  "snap-x": "snapType",
+  "snap-y": "snapType",
+  "snap-both": "snapType",
+  "snap-mandatory": "snapStrictness",
+  "snap-proximity": "snapStrictness",
+  "snap-start": "snapAlign",
+  "snap-end": "snapAlign",
+  "snap-center": "snapAlign",
+  "snap-align-none": "snapAlign",
+  "snap-normal": "snapStop",
+  "snap-always": "snapStop",
+  // Divide styles
+  "divide-solid": "divideStyle",
+  "divide-dashed": "divideStyle",
+  "divide-dotted": "divideStyle",
+  "divide-double": "divideStyle",
+  "divide-none": "divideStyle",
+  // Appearance
+  "appearance-none": "appearance",
+  "appearance-auto": "appearance"
+};
+const BOOLEAN_VALUE_MAP = {
+  // Snap types
+  "snap-none": { prop: "snapType", value: "none" },
+  "snap-x": { prop: "snapType", value: "x" },
+  "snap-y": { prop: "snapType", value: "y" },
+  "snap-both": { prop: "snapType", value: "both" },
+  "snap-mandatory": { prop: "snapStrictness", value: "mandatory" },
+  "snap-proximity": { prop: "snapStrictness", value: "proximity" },
+  "snap-start": { prop: "snapAlign", value: "start" },
+  "snap-end": { prop: "snapAlign", value: "end" },
+  "snap-center": { prop: "snapAlign", value: "center" },
+  "snap-align-none": { prop: "snapAlign", value: "none" },
+  "snap-normal": { prop: "snapStop", value: "normal" },
+  "snap-always": { prop: "snapStop", value: "always" },
+  // Divide styles
+  "divide-solid": { prop: "divideStyle", value: "solid" },
+  "divide-dashed": { prop: "divideStyle", value: "dashed" },
+  "divide-dotted": { prop: "divideStyle", value: "dotted" },
+  "divide-double": { prop: "divideStyle", value: "double" },
+  "divide-none": { prop: "divideStyle", value: "none" },
+  // Font variants
+  "normal-nums": { prop: "fontVariant", value: "normal-nums" },
+  "lining-nums": { prop: "fontVariant", value: "lining-nums" },
+  "oldstyle-nums": { prop: "fontVariant", value: "oldstyle-nums" },
+  "proportional-nums": { prop: "fontVariant", value: "proportional-nums" },
+  "tabular-nums": { prop: "fontVariant", value: "tabular-nums" },
+  "diagonal-fractions": { prop: "fontVariant", value: "diagonal-fractions" },
+  "stacked-fractions": { prop: "fontVariant", value: "stacked-fractions" },
+  // Appearance
+  "appearance-none": { prop: "appearance", value: "none" },
+  "appearance-auto": { prop: "appearance", value: "auto" },
+  // Transform
+  "transform-none": { prop: "transform", value: "none" },
+  "transform-gpu": { prop: "transform", value: "gpu" },
+  "transform-cpu": { prop: "transform", value: "cpu" }
+};
+const SORTED_PREFIXES = Object.keys(REVERSE_PROPERTY_MAP).sort((a, b) => {
+  if (b.length !== a.length) {
+    return b.length - a.length;
+  }
+  return a.localeCompare(b);
+});
+const NEGATIVE_ALLOWED = /* @__PURE__ */ new Set([
+  "m",
+  "mt",
+  "mr",
+  "mb",
+  "ml",
+  "mx",
+  "my",
+  "ms",
+  "me",
+  "top",
+  "right",
+  "bottom",
+  "left",
+  "inset",
+  "inset-x",
+  "inset-y",
+  "start",
+  "end",
+  "z",
+  "order",
+  "col",
+  "col-start",
+  "col-end",
+  "row",
+  "row-start",
+  "row-end",
+  "rotate",
+  "skew-x",
+  "skew-y",
+  "translate-x",
+  "translate-y",
+  "space-x",
+  "space-y",
+  "tracking",
+  "indent",
+  "scroll-m",
+  "scroll-mx",
+  "scroll-my",
+  "scroll-mt",
+  "scroll-mr",
+  "scroll-mb",
+  "scroll-ml",
+  "hue-rotate",
+  "backdrop-hue-rotate"
+]);
+const FRACTION_SUPPORTED = /* @__PURE__ */ new Set([
+  "w",
+  "min-w",
+  "max-w",
+  "h",
+  "min-h",
+  "max-h",
+  "size",
+  "basis",
+  "inset",
+  "inset-x",
+  "inset-y",
+  "top",
+  "right",
+  "bottom",
+  "left",
+  "start",
+  "end",
+  "translate-x",
+  "translate-y"
+]);
+const SPACING_PROPS = /* @__PURE__ */ new Set([
+  "p",
+  "pt",
+  "pr",
+  "pb",
+  "pl",
+  "px",
+  "py",
+  "ps",
+  "pe",
+  "m",
+  "mt",
+  "mr",
+  "mb",
+  "ml",
+  "mx",
+  "my",
+  "ms",
+  "me",
+  "gap",
+  "gap-x",
+  "gap-y",
+  "w",
+  "h",
+  "min-w",
+  "max-w",
+  "min-h",
+  "max-h",
+  "size",
+  "basis",
+  "inset",
+  "inset-x",
+  "inset-y",
+  "top",
+  "right",
+  "bottom",
+  "left",
+  "start",
+  "end",
+  "space-x",
+  "space-y",
+  "indent",
+  "scroll-m",
+  "scroll-mx",
+  "scroll-my",
+  "scroll-mt",
+  "scroll-mr",
+  "scroll-mb",
+  "scroll-ml",
+  "scroll-ms",
+  "scroll-me",
+  "scroll-p",
+  "scroll-px",
+  "scroll-py",
+  "scroll-pt",
+  "scroll-pr",
+  "scroll-pb",
+  "scroll-pl",
+  "scroll-ps",
+  "scroll-pe",
+  "border-spacing",
+  "translate-x",
+  "translate-y"
+]);
+const TEXT_SIZE_KEYWORDS = /* @__PURE__ */ new Set([
+  "xs",
+  "sm",
+  "base",
+  "lg",
+  "xl",
+  "2xl",
+  "3xl",
+  "4xl",
+  "5xl",
+  "6xl",
+  "7xl",
+  "8xl",
+  "9xl"
+]);
+const TEXT_ALIGN_KEYWORDS = /* @__PURE__ */ new Set(["left", "center", "right", "justify", "start", "end"]);
+const TEXT_WRAP_KEYWORDS = /* @__PURE__ */ new Set(["wrap", "nowrap", "balance", "pretty"]);
+const TEXT_OVERFLOW_KEYWORDS = /* @__PURE__ */ new Set(["ellipsis", "clip"]);
+const FONT_WEIGHT_KEYWORDS = /* @__PURE__ */ new Set([
+  "thin",
+  "extralight",
+  "light",
+  "normal",
+  "medium",
+  "semibold",
+  "bold",
+  "extrabold",
+  "black"
+]);
+const FONT_FAMILY_KEYWORDS = /* @__PURE__ */ new Set(["sans", "serif", "mono"]);
+const FONT_STRETCH_KEYWORDS = /* @__PURE__ */ new Set([
+  "ultra-condensed",
+  "extra-condensed",
+  "condensed",
+  "semi-condensed",
+  "semi-expanded",
+  "expanded",
+  "extra-expanded",
+  "ultra-expanded"
+]);
+const BORDER_WIDTH_KEYWORDS = /* @__PURE__ */ new Set(["0", "2", "4", "8"]);
+const BORDER_STYLE_KEYWORDS = /* @__PURE__ */ new Set([
+  "solid",
+  "dashed",
+  "dotted",
+  "double",
+  "none",
+  "hidden"
+]);
+const BG_POSITION_KEYWORDS = /* @__PURE__ */ new Set([
+  "center",
+  "top",
+  "bottom",
+  "left",
+  "right",
+  "left-top",
+  "left-bottom",
+  "right-top",
+  "right-bottom"
+]);
+const BG_SIZE_KEYWORDS = /* @__PURE__ */ new Set(["cover", "contain", "auto"]);
+const BG_REPEAT_KEYWORDS = /* @__PURE__ */ new Set([
+  "repeat",
+  "no-repeat",
+  "repeat-x",
+  "repeat-y",
+  "round",
+  "space"
+]);
+const BG_ATTACHMENT_KEYWORDS = /* @__PURE__ */ new Set(["fixed", "local", "scroll"]);
+const OBJECT_FIT_KEYWORDS = /* @__PURE__ */ new Set(["contain", "cover", "fill", "none", "scale-down"]);
+const OBJECT_POSITION_KEYWORDS = /* @__PURE__ */ new Set([
+  "center",
+  "top",
+  "bottom",
+  "left",
+  "right",
+  "left-top",
+  "left-bottom",
+  "right-top",
+  "right-bottom"
+]);
+const SHADOW_SIZE_KEYWORDS = /* @__PURE__ */ new Set(["sm", "md", "lg", "xl", "2xl", "inner", "none"]);
+const OUTLINE_STYLE_KEYWORDS = /* @__PURE__ */ new Set(["none", "dashed", "dotted", "double"]);
+const DECORATION_STYLE_KEYWORDS = /* @__PURE__ */ new Set(["solid", "double", "dotted", "dashed", "wavy"]);
+const DECORATION_THICKNESS_KEYWORDS = /* @__PURE__ */ new Set([
+  "auto",
+  "from-font",
+  "0",
+  "1",
+  "2",
+  "4",
+  "8"
+]);
+const TRANSITION_PROPERTY_KEYWORDS = /* @__PURE__ */ new Set([
+  "none",
+  "all",
+  "colors",
+  "opacity",
+  "shadow",
+  "transform"
+]);
+const REVERSE_VARIANT_MAP = {
+  "focus-within": "focusWithin",
+  "focus-visible": "focusVisible",
+  "first-of-type": "firstOfType",
+  "last-of-type": "lastOfType",
+  "only-of-type": "onlyOfType",
+  "motion-reduce": "motionReduce",
+  "motion-safe": "motionSafe",
+  "contrast-more": "contrastMore",
+  "contrast-less": "contrastLess",
+  "first-line": "firstLine",
+  "first-letter": "firstLetter",
+  "placeholder-shown": "placeholderShown",
+  "in-range": "inRange",
+  "out-of-range": "outOfRange",
+  "read-only": "readOnly",
+  "pointer-fine": "pointerFine",
+  "pointer-coarse": "pointerCoarse",
+  "pointer-none": "pointerNone",
+  "@max-sm": "@maxSm",
+  "@max-md": "@maxMd",
+  "@max-lg": "@maxLg",
+  "@max-xl": "@maxXl",
+  "@max-2xl": "@max2xl"
+};
+const KNOWN_SIMPLE_VARIANTS = /* @__PURE__ */ new Set([
+  "sm",
+  "md",
+  "lg",
+  "xl",
+  "2xl",
+  "@sm",
+  "@md",
+  "@lg",
+  "@xl",
+  "@2xl",
+  "dark",
+  "light",
+  "print",
+  "portrait",
+  "landscape",
+  "hover",
+  "focus",
+  "active",
+  "visited",
+  "target",
+  "disabled",
+  "enabled",
+  "checked",
+  "indeterminate",
+  "default",
+  "required",
+  "valid",
+  "invalid",
+  "autofill",
+  "open",
+  "first",
+  "last",
+  "only",
+  "odd",
+  "even",
+  "empty",
+  "before",
+  "after",
+  "placeholder",
+  "file",
+  "marker",
+  "selection",
+  "backdrop",
+  "ltr",
+  "rtl"
+]);
+/* @__PURE__ */ new Set([
+  ...KNOWN_SIMPLE_VARIANTS,
+  "focus-within",
+  "focus-visible",
+  "first-of-type",
+  "last-of-type",
+  "only-of-type",
+  "first-child",
+  "last-child",
+  "only-child",
+  "motion-reduce",
+  "motion-safe",
+  "contrast-more",
+  "contrast-less",
+  "first-line",
+  "first-letter",
+  "placeholder-shown",
+  "in-range",
+  "out-of-range",
+  "read-only",
+  "pointer-fine",
+  "pointer-coarse",
+  "pointer-none"
+]);
+
+function parseClass(cls, options = {}) {
+  let important = false;
+  let input = cls;
+  if (input.endsWith("!")) {
+    important = true;
+    input = input.slice(0, -1);
+  }
+  let negative = false;
+  let negInput = input;
+  if (input.startsWith("-")) {
+    negative = true;
+    negInput = input.slice(1);
+  }
+  const boolResult = tryBooleanMatch(input, options);
+  if (boolResult) {
+    return applyImportant(boolResult, important);
+  }
+  const gradResult = tryGradient(negInput, negative);
+  if (gradResult) {
+    return applyImportant(gradResult, important);
+  }
+  const source = negative ? negInput : input;
+  for (const prefix of SORTED_PREFIXES) {
+    if (source === prefix) {
+      const prop = REVERSE_PROPERTY_MAP[prefix];
+      if (negative && NEGATIVE_ALLOWED.has(prefix)) {
+        continue;
+      }
+      if (REVERSE_BOOLEAN_MAP[source]) {
+        return applyImportant(booleanClassToParsed(source, options), important);
+      }
+      if (prefix === "divide-x" || prefix === "divide-y") {
+        return applyImportant({ prop, value: true }, important);
+      }
+      if (prefix === "border") {
+        return applyImportant({ prop: "border", value: true }, important);
+      }
+      if ([
+        "border-t",
+        "border-r",
+        "border-b",
+        "border-l",
+        "border-x",
+        "border-y",
+        "border-s",
+        "border-e"
+      ].includes(prefix)) {
+        return applyImportant({ prop, value: true }, important);
+      }
+      continue;
+    }
+    if (source.startsWith(`${prefix}-`)) {
+      const rawValue = source.slice(prefix.length + 1);
+      if (!rawValue) {
+        continue;
+      }
+      if (negative && !NEGATIVE_ALLOWED.has(prefix)) {
+        continue;
+      }
+      if (SPACING_PROPS.has(prefix) && !isValidSpacingValue(rawValue)) {
+        continue;
+      }
+      const result = disambiguateAndParse(prefix, rawValue, negative);
+      if (result) {
+        return applyImportant(result, important);
+      }
+    }
+  }
+  const displayResult = tryDisplay(input, options);
+  if (displayResult) {
+    return applyImportant(displayResult, important);
+  }
+  if (input.startsWith("[") && input.endsWith("]") && input.includes(":")) {
+    const inner = input.slice(1, -1);
+    if (inner.startsWith("--")) {
+      const colonIdx = inner.indexOf(":");
+      return applyImportant(
+        {
+          prop: inner.slice(0, colonIdx),
+          value: inner.slice(colonIdx + 1)
+        },
+        important
+      );
+    }
+  }
+  return null;
+}
+function applyImportant(result, important) {
+  if (!important) {
+    return result;
+  }
+  if (typeof result.value === "string") {
+    return { prop: result.prop, value: `${result.value}!` };
+  }
+  if (typeof result.value === "boolean") {
+    return { prop: result.prop, value: "!" };
+  }
+  if (typeof result.value === "number") {
+    return { prop: result.prop, value: `${String(result.value)}!` };
+  }
+  return result;
+}
+function tryBooleanMatch(cls, options) {
+  if (BOOLEAN_VALUE_MAP[cls]) {
+    const { prop, value } = BOOLEAN_VALUE_MAP[cls];
+    return { prop, value };
+  }
+  if (REVERSE_BOOLEAN_MAP[cls]) {
+    return booleanClassToParsed(cls, options);
+  }
+  return null;
+}
+function tryDisplay(cls, options) {
+  const displayValues = /* @__PURE__ */ new Set([
+    "block",
+    "inline",
+    "inline-block",
+    "flex",
+    "inline-flex",
+    "grid",
+    "inline-grid",
+    "hidden",
+    "contents",
+    "table",
+    "table-row",
+    "table-cell",
+    "flow-root",
+    "list-item"
+  ]);
+  if (displayValues.has(cls)) {
+    return REVERSE_BOOLEAN_MAP[cls] ? booleanClassToParsed(cls, options) : null;
+  }
+  return null;
+}
+function booleanClassToParsed(cls, options) {
+  const displayValue = DISPLAY_CLASS_VALUES[cls];
+  if (options.display === "canonical" && displayValue) {
+    return { prop: "display", value: displayValue, cssProperty: "display" };
+  }
+  return { prop: REVERSE_BOOLEAN_MAP[cls], value: true };
+}
+const DISPLAY_CLASS_VALUES = {
+  block: "block",
+  inline: "inline",
+  "inline-block": "inline-block",
+  flex: "flex",
+  "inline-flex": "inline-flex",
+  grid: "grid",
+  "inline-grid": "inline-grid",
+  hidden: "none",
+  contents: "contents",
+  table: "table",
+  "table-row": "table-row",
+  "table-cell": "table-cell",
+  "flow-root": "flow-root",
+  "list-item": "list-item"
+};
+function tryGradient(cls, negative) {
+  let input = cls;
+  let type = null;
+  if (input.startsWith("bg-linear")) {
+    type = "linear";
+    input = input.slice("bg-linear".length);
+  } else if (input.startsWith("bg-radial")) {
+    type = "radial";
+    input = input.slice("bg-radial".length);
+  } else if (input.startsWith("bg-conic")) {
+    type = "conic";
+    input = input.slice("bg-conic".length);
+  }
+  if (!type) {
+    return null;
+  }
+  let colorInterp;
+  const slashIdx = findTopLevelSlash$1(input);
+  if (slashIdx !== -1) {
+    colorInterp = input.slice(slashIdx + 1);
+    input = input.slice(0, slashIdx);
+  }
+  const grad = { gradient: type };
+  if (input === "" || input === void 0) ; else if (input.startsWith("-")) {
+    const dir = input.slice(1);
+    if (dir.startsWith("[") && dir.endsWith("]")) {
+      grad.dir = dir.slice(1, -1).replace(/_/g, " ");
+    } else if (dir.startsWith("(") && dir.endsWith(")")) {
+      grad.dir = dir.slice(1, -1);
+    } else if (/^\d+$/.test(dir)) {
+      grad.dir = negative ? -parseInt(dir, 10) : parseInt(dir, 10);
+    } else {
+      grad.dir = dir;
+    }
+  }
+  if (colorInterp) {
+    grad.in = colorInterp;
+  }
+  return { prop: "bgImg", value: grad };
+}
+function findTopLevelSlash$1(s) {
+  let depth = 0;
+  for (let i = 0; i < s.length; i++) {
+    if (s[i] === "[" || s[i] === "(") {
+      depth++;
+    } else if (s[i] === "]" || s[i] === ")") {
+      depth--;
+    } else if (s[i] === "/" && depth === 0) {
+      return i;
+    }
+  }
+  return -1;
+}
+function disambiguateAndParse(prefix, rawValue, negative) {
+  const slashIdx = findTopLevelSlash$1(rawValue);
+  let opacity;
+  let value = rawValue;
+  if (slashIdx !== -1 && !isGradientPrefix(prefix)) {
+    const isFraction = FRACTION_SUPPORTED.has(prefix) && /^\d+\/\d+$/.test(rawValue);
+    if (!isFraction) {
+      opacity = rawValue.slice(slashIdx + 1);
+      value = rawValue.slice(0, slashIdx);
+      if (opacity.startsWith("[") && opacity.endsWith("]")) {
+        opacity = opacity.slice(1, -1);
+        if (!String(opacity).includes("%")) {
+          const opNum = Number(opacity);
+          if (!Number.isNaN(opNum)) {
+            opacity = opNum;
+          }
+        }
+      } else if (opacity.startsWith("(") && opacity.endsWith(")")) {
+        opacity = opacity.slice(1, -1);
+      } else {
+        const opNum = Number(opacity);
+        if (!Number.isNaN(opNum)) {
+          opacity = opNum;
+        }
+      }
+    }
+  }
+  const result = disambiguate(prefix, value, negative);
+  if (!result) {
+    return null;
+  }
+  if (opacity !== void 0 && typeof result.value === "string") {
+    return {
+      prop: result.prop,
+      value: { color: result.value, op: opacity }
+    };
+  }
+  return result;
+}
+function isGradientPrefix(prefix) {
+  return prefix === "from" || prefix === "via" || prefix === "to";
+}
+function disambiguate(prefix, value, negative) {
+  switch (prefix) {
+    case "text":
+      return disambiguateText(value);
+    case "font":
+      return disambiguateFont(value);
+    case "border":
+      return disambiguateBorder(value);
+    case "bg":
+      return disambiguateBg(value);
+    case "object":
+      return disambiguateObject(value);
+    case "shadow":
+      return disambiguateShadow(value);
+    case "outline":
+      return disambiguateOutline(value);
+    case "decoration":
+      return disambiguateDecoration(value);
+    case "transition":
+      return disambiguateTransition(value);
+    case "ring":
+      return disambiguateRing(value, negative);
+    case "ring-offset":
+      return disambiguateRingOffset(value);
+    case "inset-ring":
+      return disambiguateInsetRing(value, negative);
+    case "inset-shadow":
+      return disambiguateInsetShadow(value);
+    case "stroke":
+      return disambiguateStroke(value);
+    case "list":
+      return disambiguateList(value);
+    case "ease":
+      return { prop: "ease", value: parseValue("ease", value, negative) };
+    case "snap":
+      return disambiguateSnap();
+    case "flex":
+      return disambiguateFlex(value);
+    case "table":
+      return disambiguateTable(value);
+    case "divide":
+      return disambiguateDivide(value);
+    case "break":
+      if (value === "words") {
+        return { prop: "wrap", value: "break-word" };
+      }
+      return { prop: "break", value };
+    case "wrap":
+      return { prop: "wrap", value };
+    default:
+      return {
+        prop: REVERSE_PROPERTY_MAP[prefix] || prefix,
+        value: parseValue(prefix, value, negative)
+      };
+  }
+}
+function disambiguateText(value) {
+  if (TEXT_SIZE_KEYWORDS.has(value)) {
+    return { prop: "text", value };
+  }
+  if (TEXT_ALIGN_KEYWORDS.has(value)) {
+    return { prop: "textAlign", value };
+  }
+  if (TEXT_WRAP_KEYWORDS.has(value)) {
+    return { prop: "textWrap", value };
+  }
+  if (TEXT_OVERFLOW_KEYWORDS.has(value)) {
+    return { prop: "textOverflow", value };
+  }
+  if (isArbitraryDimension(value)) {
+    return { prop: "text", value: parseStringValue(value) };
+  }
+  return { prop: "color", value: parseStringValue(value) };
+}
+function disambiguateFont(value) {
+  if (FONT_WEIGHT_KEYWORDS.has(value)) {
+    return { prop: "fontWeight", value };
+  }
+  if (/^\d{3}$/.test(value)) {
+    return { prop: "fontWeight", value: parseInt(value, 10) };
+  }
+  if (FONT_FAMILY_KEYWORDS.has(value)) {
+    return { prop: "fontFamily", value };
+  }
+  if (value.startsWith("stretch-")) {
+    const stretchVal = value.slice("stretch-".length);
+    return { prop: "fontStretch", value: stretchVal };
+  }
+  if (FONT_STRETCH_KEYWORDS.has(value)) {
+    return { prop: "fontStretch", value };
+  }
+  return { prop: "fontFamily", value: parseStringValue(value) };
+}
+function disambiguateBorder(value) {
+  if (BORDER_WIDTH_KEYWORDS.has(value) || value === "px") {
+    return { prop: "border", value: parseNumericOrString("border", value, false) };
+  }
+  if (BORDER_STYLE_KEYWORDS.has(value)) {
+    return { prop: "borderStyle", value };
+  }
+  if (isArbitraryDimension(value)) {
+    return { prop: "border", value: parseStringValue(value) };
+  }
+  return { prop: "borderColor", value: parseStringValue(value) };
+}
+function disambiguateBg(value) {
+  if (BG_POSITION_KEYWORDS.has(value)) {
+    return { prop: "bgPos", value };
+  }
+  if (BG_SIZE_KEYWORDS.has(value)) {
+    return { prop: "bgSize", value };
+  }
+  if (BG_REPEAT_KEYWORDS.has(value)) {
+    return { prop: "bgRepeat", value };
+  }
+  if (BG_ATTACHMENT_KEYWORDS.has(value)) {
+    return { prop: "bgAttach", value };
+  }
+  if (value === "none") {
+    return { prop: "bgImg", value: "none" };
+  }
+  return { prop: "bg", value: parseStringValue(value) };
+}
+function disambiguateObject(value) {
+  if (OBJECT_FIT_KEYWORDS.has(value)) {
+    return { prop: "objectFit", value };
+  }
+  if (OBJECT_POSITION_KEYWORDS.has(value)) {
+    return { prop: "objectPos", value };
+  }
+  return { prop: "objectPos", value: parseStringValue(value) };
+}
+function disambiguateShadow(value) {
+  if (SHADOW_SIZE_KEYWORDS.has(value)) {
+    return { prop: "shadow", value };
+  }
+  return { prop: "shadowColor", value: parseStringValue(value) };
+}
+function disambiguateOutline(value) {
+  if (OUTLINE_STYLE_KEYWORDS.has(value)) {
+    return { prop: "outlineStyle", value };
+  }
+  const num = Number(value);
+  if (!Number.isNaN(num) && Number.isInteger(num)) {
+    return { prop: "outline", value: num };
+  }
+  if (isArbitraryDimension(value)) {
+    return { prop: "outline", value: parseStringValue(value) };
+  }
+  return { prop: "outlineColor", value: parseStringValue(value) };
+}
+function disambiguateDecoration(value) {
+  if (DECORATION_STYLE_KEYWORDS.has(value)) {
+    return { prop: "decorationStyle", value };
+  }
+  if (DECORATION_THICKNESS_KEYWORDS.has(value)) {
+    const num = Number(value);
+    if (!Number.isNaN(num)) {
+      return { prop: "decorationThickness", value };
+    }
+    return { prop: "decorationThickness", value };
+  }
+  return { prop: "decorationColor", value: parseStringValue(value) };
+}
+function disambiguateRing(value, negative) {
+  const num = Number(value);
+  if (!Number.isNaN(num) && Number.isInteger(num)) {
+    return { prop: "ring", value: negative ? -num : num };
+  }
+  if (isArbitraryDimension(value)) {
+    return { prop: "ring", value: parseStringValue(value) };
+  }
+  return { prop: "ringColor", value: parseStringValue(value) };
+}
+function disambiguateRingOffset(value) {
+  const num = Number(value);
+  if (!Number.isNaN(num) && Number.isInteger(num)) {
+    return { prop: "ringOffset", value: num };
+  }
+  return { prop: "ringOffsetColor", value: parseStringValue(value) };
+}
+function disambiguateInsetRing(value, negative) {
+  const num = Number(value);
+  if (!Number.isNaN(num) && Number.isInteger(num)) {
+    return { prop: "insetRing", value: negative ? -num : num };
+  }
+  if (isArbitraryDimension(value)) {
+    return { prop: "insetRing", value: parseStringValue(value) };
+  }
+  return { prop: "insetRingColor", value: parseStringValue(value) };
+}
+function disambiguateInsetShadow(value) {
+  const INSET_SHADOW_SIZE_KEYWORDS = /* @__PURE__ */ new Set(["sm", "md", "lg", "xl", "2xl", "none", "inner"]);
+  if (INSET_SHADOW_SIZE_KEYWORDS.has(value)) {
+    return { prop: "insetShadow", value };
+  }
+  if (isArbitraryDimension(value)) {
+    return { prop: "insetShadow", value: parseStringValue(value) };
+  }
+  return { prop: "insetShadowColor", value: parseStringValue(value) };
+}
+function disambiguateStroke(value) {
+  const num = Number(value);
+  if (!Number.isNaN(num) && Number.isInteger(num)) {
+    return { prop: "strokeWidth", value: num };
+  }
+  return { prop: "stroke", value: parseStringValue(value) };
+}
+function disambiguateTransition(value) {
+  if (TRANSITION_PROPERTY_KEYWORDS.has(value)) {
+    return { prop: "transition", value };
+  }
+  return { prop: "transition", value: parseStringValue(value) };
+}
+function disambiguateList(value) {
+  if (value === "inside" || value === "outside") {
+    return { prop: "listPos", value };
+  }
+  return { prop: "list", value: parseStringValue(value) };
+}
+function disambiguateSnap(_value) {
+  return null;
+}
+function disambiguateFlex(value) {
+  const dirValues = /* @__PURE__ */ new Set(["row", "col", "row-reverse", "col-reverse"]);
+  if (dirValues.has(value)) {
+    return { prop: "flexDir", value };
+  }
+  const wrapValues = /* @__PURE__ */ new Set(["wrap", "nowrap", "wrap-reverse"]);
+  if (wrapValues.has(value)) {
+    return { prop: "flexWrap", value };
+  }
+  if (value === "1" || value === "auto" || value === "initial" || value === "none") {
+    return { prop: "flex", value: parseStringValue(value) };
+  }
+  return { prop: "flex", value: parseStringValue(value) };
+}
+function disambiguateTable(value) {
+  if (value === "auto" || value === "fixed") {
+    return { prop: "tableLayout", value };
+  }
+  return null;
+}
+function disambiguateDivide(value) {
+  return { prop: "divideColor", value: parseStringValue(value) };
+}
+const CSS_DIMENSION_RE = /^-?[\d.]+(?:px|r?em|ex|ch|vw|vh|vmin|vmax|svh|svw|dvh|dvw|lvh|lvw|cqw|cqh|cqi|cqb|%|fr|deg|rad|turn|grad|ms|s|pt|pc|cm|mm|in)$/;
+function isArbitraryDimension(value) {
+  if (!value.startsWith("[") || !value.endsWith("]")) {
+    return false;
+  }
+  return CSS_DIMENSION_RE.test(value.slice(1, -1));
+}
+function isValidSpacingValue(value) {
+  if (value.startsWith("[") && value.endsWith("]")) {
+    return true;
+  }
+  if (value.startsWith("(") && value.endsWith(")")) {
+    return true;
+  }
+  if (!Number.isNaN(Number(value))) {
+    return true;
+  }
+  if (/^\d+\/\d+$/.test(value)) {
+    return true;
+  }
+  if ([
+    "auto",
+    "full",
+    "screen",
+    "px",
+    "min",
+    "max",
+    "fit",
+    "none",
+    "dvh",
+    "dvw",
+    "svh",
+    "svw",
+    "lvh",
+    "lvw",
+    // Max-width size keywords
+    "xs",
+    "sm",
+    "md",
+    "lg",
+    "xl",
+    "2xl",
+    "3xl",
+    "4xl",
+    "5xl",
+    "6xl",
+    "7xl",
+    "prose",
+    "screen-sm",
+    "screen-md",
+    "screen-lg",
+    "screen-xl",
+    "screen-2xl",
+    // Size keywords used in min-h, max-h
+    "content"
+  ].includes(value)) {
+    return true;
+  }
+  if (value.includes("/")) {
+    return true;
+  }
+  return false;
+}
+function parseValue(prefix, value, negative) {
+  if (value.startsWith("[") && value.endsWith("]")) {
+    const inner = value.slice(1, -1).replace(/_/g, " ");
+    if (negative) {
+      return `-${inner}`;
+    }
+    if (prefix === "content") {
+      const isQuoted = inner.startsWith("'") && inner.endsWith("'") || inner.startsWith('"') && inner.endsWith('"');
+      if (isQuoted) {
+        return `"${inner.slice(1, -1)}"`;
+      }
+    }
+    return inner;
+  }
+  if (value.startsWith("(") && value.endsWith(")")) {
+    const inner = value.slice(1, -1);
+    if (negative) {
+      return `-${inner}`;
+    }
+    return inner;
+  }
+  if (FRACTION_SUPPORTED.has(prefix) && /^\d+\/\d+$/.test(value)) {
+    return value;
+  }
+  if (value === "px") {
+    return negative ? "-px" : "px";
+  }
+  if (value === "auto") {
+    return "auto";
+  }
+  if (value === "full") {
+    return "full";
+  }
+  if (value === "screen") {
+    return "screen";
+  }
+  const num = Number(value);
+  if (!Number.isNaN(num)) {
+    if (negative) {
+      return -num;
+    }
+    return num;
+  }
+  if (negative) {
+    return `-${value}`;
+  }
+  return value;
+}
+function parseNumericOrString(prefix, value, negative) {
+  if (value === "px") {
+    return "px";
+  }
+  const num = Number(value);
+  if (!Number.isNaN(num)) {
+    return negative ? -num : num;
+  }
+  return value;
+}
+function parseStringValue(value) {
+  if (value.startsWith("[") && value.endsWith("]")) {
+    return value.slice(1, -1).replace(/_/g, " ");
+  }
+  if (value.startsWith("(") && value.endsWith(")")) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+
+function tokenize(className) {
+  return className.trim().split(/\s+/).filter(Boolean);
+}
+function extractVariants(token) {
+  const parts = [];
+  let current = "";
+  let depth = 0;
+  for (let i = 0; i < token.length; i++) {
+    const ch = token[i];
+    if (ch === "[" || ch === "(") {
+      depth++;
+      current += ch;
+    } else if (ch === "]" || ch === ")") {
+      depth--;
+      current += ch;
+    } else if (ch === ":" && depth === 0) {
+      parts.push(current);
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  if (parts.length === 0) {
+    return { variantParts: [], baseClass: current };
+  }
+  return { variantParts: parts, baseClass: current };
+}
+function mapVariant(variant) {
+  if (variant.startsWith("@")) {
+    if (variant === "@container") {
+      return ["@container"];
+    }
+    const slashIdx = variant.indexOf("/");
+    if (slashIdx !== -1) {
+      const queryPart = variant.slice(0, slashIdx);
+      const namePart = variant.slice(slashIdx + 1);
+      return [normalizeVariantKey(queryPart), namePart];
+    }
+    const match = variant.match(/^(@min|@max)-\[(.+)\]$/);
+    if (match) {
+      return [match[1], match[2]];
+    }
+    return [normalizeVariantKey(variant)];
+  }
+  if (variant.startsWith("group-") || variant.startsWith("peer-")) {
+    return parseGroupPeerVariant(variant);
+  }
+  if (variant.startsWith("has-")) {
+    const rest = variant.slice(4);
+    if (rest.startsWith("[") && rest.endsWith("]")) {
+      let selector = rest.slice(1, -1);
+      if (selector.startsWith(":")) {
+        selector = selector.slice(1);
+      }
+      return ["has", selector];
+    }
+    return ["has", rest];
+  }
+  if (variant.startsWith("not-")) {
+    const rest = variant.slice(4);
+    if (rest.startsWith("supports-[") && rest.endsWith("]")) {
+      const cond = rest.slice(10, -1);
+      return ["not", "supports", cond];
+    }
+    return ["not", normalizeVariantKey(rest)];
+  }
+  if (variant.startsWith("data-")) {
+    const rest = variant.slice(5);
+    if (rest.startsWith("[") && rest.endsWith("]")) {
+      return ["data", rest.slice(1, -1)];
+    }
+    return ["data", rest];
+  }
+  if (variant.startsWith("aria-")) {
+    const rest = variant.slice(5);
+    if (rest.startsWith("[") && rest.endsWith("]")) {
+      return ["aria", rest.slice(1, -1)];
+    }
+    return ["aria", rest];
+  }
+  if (variant.startsWith("supports-")) {
+    const rest = variant.slice(9);
+    if (rest.startsWith("[") && rest.endsWith("]")) {
+      return ["supports", rest.slice(1, -1)];
+    }
+    return ["supports", rest];
+  }
+  if (variant.startsWith("min-") || variant.startsWith("max-")) {
+    const prefix = variant.startsWith("min-") ? "min" : "max";
+    const rest = variant.slice(4);
+    if (rest.startsWith("[") && rest.endsWith("]")) {
+      return [prefix, rest.slice(1, -1)];
+    }
+    return [prefix, rest];
+  }
+  if (variant.startsWith("[") && variant.endsWith("]")) {
+    return [variant];
+  }
+  return [normalizeVariantKey(variant)];
+}
+function parseGroupPeerVariant(variant) {
+  const isGroup = variant.startsWith("group-");
+  const type = isGroup ? "group" : "peer";
+  let rest = variant.slice(type.length + 1);
+  let name;
+  const slashIdx = findTopLevelSlash(rest);
+  if (slashIdx !== -1) {
+    name = rest.slice(slashIdx + 1);
+    rest = rest.slice(0, slashIdx);
+  }
+  const keys = [type];
+  if (name) {
+    keys.push(name);
+  }
+  if (rest.startsWith("[") && rest.endsWith("]")) {
+    keys.push(rest.slice(1, -1));
+  } else if (rest.startsWith("has-")) {
+    const hasRest = rest.slice(4);
+    if (hasRest.startsWith("[") && hasRest.endsWith("]")) {
+      keys.push("has");
+      keys.push(hasRest.slice(1, -1));
+    } else {
+      keys.push("has");
+      keys.push(hasRest);
+    }
+  } else if (rest.startsWith("data-")) {
+    const dataRest = rest.slice(5);
+    keys.push("data");
+    if (dataRest.startsWith("[") && dataRest.endsWith("]")) {
+      keys.push(dataRest.slice(1, -1));
+    } else if (dataRest.startsWith("(") && dataRest.endsWith(")")) {
+      keys.push(dataRest.slice(1, -1));
+    } else {
+      keys.push(dataRest);
+    }
+  } else if (rest.startsWith("aria-")) {
+    const ariaRest = rest.slice(5);
+    keys.push("aria");
+    if (ariaRest.startsWith("[") && ariaRest.endsWith("]")) {
+      keys.push(ariaRest.slice(1, -1));
+    } else {
+      keys.push(ariaRest);
+    }
+  } else {
+    keys.push(normalizeVariantKey(rest));
+  }
+  return keys;
+}
+function findTopLevelSlash(s) {
+  let depth = 0;
+  for (let i = 0; i < s.length; i++) {
+    if (s[i] === "[" || s[i] === "(") {
+      depth++;
+    } else if (s[i] === "]" || s[i] === ")") {
+      depth--;
+    } else if (s[i] === "/" && depth === 0) {
+      return i;
+    }
+  }
+  return -1;
+}
+function normalizeVariantKey(variant) {
+  if (REVERSE_VARIANT_MAP[variant]) {
+    return REVERSE_VARIANT_MAP[variant];
+  }
+  if (variant.startsWith("@")) {
+    return variant;
+  }
+  return variant;
+}
+const TODO_KEEP = "sz:keep";
+const TODO_REMOVE = "sz:remove";
+const TODO_PENDING = "sz:todo";
+const MAX_TOKEN_CACHE_SIZE = 4096;
+const parsedTokenCache = /* @__PURE__ */ new Map();
+function resolveCustomMapEntry(token, customMap, resolveString) {
+  if (!(token in customMap)) {
+    return null;
+  }
+  const val = customMap[token];
+  if (val && typeof val === "object" && !Array.isArray(val)) {
+    return { action: "sz", value: val };
+  }
+  if (typeof val === "string") {
+    if (val === TODO_KEEP) {
+      return { action: "keep" };
+    }
+    if (val === TODO_REMOVE) {
+      return { action: "remove" };
+    }
+    if (val === TODO_PENDING) {
+      return { action: "unresolved" };
+    }
+    const result = resolveString(val);
+    if (result && Object.keys(result.sz).length > 0) {
+      return { action: "sz", value: result.sz, cascade: result.cascade };
+    }
+    return { action: "unresolved" };
+  }
+  return { action: "unresolved" };
+}
+function classNameToSzObject(className, customMap) {
+  const tokens = tokenize(className);
+  const szObject = {};
+  const unrecognized = [];
+  const keepInClassName = [];
+  const seenCssPropertiesByPath = /* @__PURE__ */ new Map();
+  const conflictedCssPropertiesByPath = /* @__PURE__ */ new Map();
+  for (const token of tokens) {
+    if (customMap && token in customMap) {
+      const entry = resolveCustomMapEntry(
+        token,
+        customMap,
+        // Inline resolver: parse Tailwind string recursively (no customMap to avoid infinite loop).
+        // Returns both the sz object and any unrecognized tokens from the string value,
+        // so partially-valid strings cascade their unknowns back to the unrecognized list.
+        (twStr) => {
+          const inner = classNameToSzObject(twStr);
+          if (Object.keys(inner.szObject).length === 0) {
+            return null;
+          }
+          return { sz: inner.szObject, cascade: inner.unrecognized };
+        }
+      );
+      if (entry) {
+        if (entry.action === "sz") {
+          Object.assign(szObject, entry.value);
+          if (entry.cascade && entry.cascade.length > 0) {
+            unrecognized.push(...entry.cascade);
+          }
+          continue;
+        }
+        if (entry.action === "keep") {
+          keepInClassName.push(token);
+          continue;
+        }
+        if (entry.action === "remove") {
+          continue;
+        }
+        if (entry.action === "unresolved") {
+          unrecognized.push(token);
+          continue;
+        }
+      }
+    }
+    const parsedToken = parseClassTokenCached(token);
+    if (!parsedToken) {
+      unrecognized.push(token);
+      continue;
+    }
+    if (isCssPropertyConflicted(conflictedCssPropertiesByPath, parsedToken)) {
+      unrecognized.push(token);
+      continue;
+    }
+    const conflict = findCssPropertyConflict(seenCssPropertiesByPath, parsedToken, token);
+    if (conflict) {
+      rememberCssPropertyConflict(conflictedCssPropertiesByPath, parsedToken);
+      unrecognized.push(conflict, token);
+      removeNestedValue(szObject, parsedToken.keyPath, parsedToken.prop);
+      continue;
+    }
+    rememberCssProperty(seenCssPropertiesByPath, parsedToken, token);
+    setNestedValue(
+      szObject,
+      parsedToken.keyPath,
+      parsedToken.prop,
+      cloneParsedValue(parsedToken.value)
+    );
+  }
+  return { szObject, unrecognized, keepInClassName };
+}
+function parseClassTokenCached(token) {
+  if (parsedTokenCache.has(token)) {
+    return parsedTokenCache.get(token) ?? null;
+  }
+  const parsed = parseClassToken(token);
+  rememberParsedToken(token, parsed);
+  return parsed;
+}
+function parseClassToken(token) {
+  const { variantParts, baseClass } = extractVariants(token);
+  const parsed = parseClass(baseClass, { display: "canonical" });
+  if (!parsed) {
+    return null;
+  }
+  const keyPath = [];
+  for (const variant of variantParts) {
+    keyPath.push(...mapVariant(variant));
+  }
+  return {
+    keyPath,
+    prop: parsed.prop,
+    value: parsed.value,
+    cssProperty: parsed.cssProperty
+  };
+}
+function rememberParsedToken(token, parsed) {
+  if (parsedTokenCache.size >= MAX_TOKEN_CACHE_SIZE) {
+    const oldest = parsedTokenCache.keys().next().value;
+    if (oldest !== void 0) {
+      parsedTokenCache.delete(oldest);
+    }
+  }
+  parsedTokenCache.set(token, parsed);
+}
+function cloneParsedValue(value) {
+  if (Array.isArray(value)) {
+    return value.map(cloneParsedValue);
+  }
+  if (value && typeof value === "object") {
+    const clone = {};
+    for (const [key, nested] of Object.entries(value)) {
+      clone[key] = cloneParsedValue(nested);
+    }
+    return clone;
+  }
+  return value;
+}
+function setNestedValue(obj, keyPath, prop, value) {
+  let current = obj;
+  for (const key of keyPath) {
+    if (!(key in current) || typeof current[key] !== "object" || current[key] === null) {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  current[prop] = value;
+}
+function findCssPropertyConflict(seen, parsed, token) {
+  if (!parsed.cssProperty) {
+    return null;
+  }
+  const scope = parsed.keyPath.join("\0");
+  const previous = seen.get(scope)?.get(parsed.cssProperty);
+  return previous && previous !== token ? previous : null;
+}
+function isCssPropertyConflicted(conflicted, parsed) {
+  if (!parsed.cssProperty) {
+    return false;
+  }
+  return conflicted.get(parsed.keyPath.join("\0"))?.has(parsed.cssProperty) === true;
+}
+function rememberCssPropertyConflict(conflicted, parsed) {
+  if (!parsed.cssProperty) {
+    return;
+  }
+  const scope = parsed.keyPath.join("\0");
+  let properties = conflicted.get(scope);
+  if (!properties) {
+    properties = /* @__PURE__ */ new Set();
+    conflicted.set(scope, properties);
+  }
+  properties.add(parsed.cssProperty);
+}
+function rememberCssProperty(seen, parsed, token) {
+  if (!parsed.cssProperty) {
+    return;
+  }
+  const scope = parsed.keyPath.join("\0");
+  let properties = seen.get(scope);
+  if (!properties) {
+    properties = /* @__PURE__ */ new Map();
+    seen.set(scope, properties);
+  }
+  properties.set(parsed.cssProperty, token);
+}
+function removeNestedValue(obj, keyPath, prop) {
+  let current = obj;
+  const parents = [];
+  for (const key of keyPath) {
+    const next = current[key];
+    if (!next || typeof next !== "object" || Array.isArray(next)) {
+      return;
+    }
+    parents.push([current, key]);
+    current = next;
+  }
+  delete current[prop];
+  for (let index = parents.length - 1; index >= 0; index--) {
+    const [parent, key] = parents[index];
+    const child = parent[key];
+    if (child && typeof child === "object" && Object.keys(child).length === 0) {
+      delete parent[key];
+    }
+  }
+}
+
+const CLSX_LIKE_NAMES = /* @__PURE__ */ new Set(["clsx", "cn", "cx", "twMerge", "classNames", "classnames"]);
+function isClsxLikeName(name) {
+  return CLSX_LIKE_NAMES.has(name);
+}
+function handleClsxCall(node, source, t, customMap) {
+  const warnings = [];
+  const allUnrecognized = [];
+  const elements = [];
+  let converted = 0;
+  for (const arg of node.arguments) {
+    if (t.isSpreadElement(arg)) {
+      const argSrc2 = safeSlice(source, arg.start, arg.end);
+      warnings.push(`Cannot migrate spread argument: ${argSrc2}`);
+      return skip(allUnrecognized, warnings);
+    }
+    if (t.isStringLiteral(arg)) {
+      const result = migrateString(arg.value, customMap);
+      if (!result) {
+        return skip(allUnrecognized, warnings);
+      }
+      elements.push(result.objectStr);
+      allUnrecognized.push(...result.unrecognized);
+      converted++;
+      continue;
+    }
+    if (t.isLogicalExpression(arg) && arg.operator === "&&") {
+      const result = handleLogicalAndInner(arg, source, t, customMap);
+      if (!result) {
+        const argSrc2 = safeSlice(source, arg.start, arg.end);
+        warnings.push(`Cannot migrate logical expression: ${argSrc2}`);
+        return skip(allUnrecognized, warnings);
+      }
+      elements.push(result.exprStr);
+      allUnrecognized.push(...result.unrecognized);
+      converted++;
+      continue;
+    }
+    if (t.isConditionalExpression(arg)) {
+      const result = handleTernaryInner(arg, source, t, customMap);
+      if (!result) {
+        const argSrc2 = safeSlice(source, arg.start, arg.end);
+        warnings.push(`Cannot migrate ternary: ${argSrc2}`);
+        return skip(allUnrecognized, warnings);
+      }
+      elements.push(result.exprStr);
+      allUnrecognized.push(...result.unrecognized);
+      converted++;
+      continue;
+    }
+    const argSrc = safeSlice(source, arg.start, arg.end);
+    warnings.push(`Cannot migrate argument: ${argSrc}`);
+    return skip(allUnrecognized, warnings);
+  }
+  if (elements.length === 0) {
+    return skip(allUnrecognized, warnings);
+  }
+  if (elements.length === 1 && !elements[0].includes("&&") && !elements[0].includes("?")) {
+    return {
+      replacement: `sz={${elements[0]}}`,
+      unrecognized: allUnrecognized,
+      warnings,
+      converted,
+      migrated: true
+    };
+  }
+  return {
+    replacement: `sz={[${elements.join(", ")}]}`,
+    unrecognized: allUnrecognized,
+    warnings,
+    converted,
+    migrated: true
+  };
+}
+function handleTernary(node, source, t, customMap) {
+  const result = handleTernaryInner(node, source, t, customMap);
+  if (!result) {
+    return {
+      replacement: "",
+      unrecognized: [],
+      warnings: ["Ternary branches must be string literals"],
+      converted: 0,
+      migrated: false
+    };
+  }
+  return {
+    replacement: `sz={${result.exprStr}}`,
+    unrecognized: result.unrecognized,
+    warnings: [],
+    converted: 1,
+    migrated: true
+  };
+}
+function handleLogicalAnd(node, source, t, customMap) {
+  if (node.operator !== "&&") {
+    return {
+      replacement: "",
+      unrecognized: [],
+      warnings: [`Unsupported logical operator: ${node.operator}`],
+      converted: 0,
+      migrated: false
+    };
+  }
+  const result = handleLogicalAndInner(node, source, t, customMap);
+  if (!result) {
+    return {
+      replacement: "",
+      unrecognized: [],
+      warnings: ["Right side of && must be a string literal"],
+      converted: 0,
+      migrated: false
+    };
+  }
+  return {
+    replacement: `sz={${result.exprStr}}`,
+    unrecognized: result.unrecognized,
+    warnings: [],
+    converted: 1,
+    migrated: true
+  };
+}
+function handleTemplateLiteral(node, source, t, customMap) {
+  const warnings = [];
+  const allUnrecognized = [];
+  const staticText = node.quasis.map((q) => q.value.cooked ?? q.value.raw).join(" ");
+  const trimmedStatic = staticText.replace(/\s+/g, " ").trim();
+  let baseObject = {};
+  if (trimmedStatic) {
+    const { szObject, unrecognized } = classNameToSzObject(trimmedStatic, customMap);
+    baseObject = szObject;
+    allUnrecognized.push(...unrecognized);
+  }
+  const dynamicElements = [];
+  let converted = 0;
+  for (const expr of node.expressions) {
+    if (!isExpression(expr, t)) {
+      const exprSrc2 = safeSlice(
+        source,
+        expr.start,
+        expr.end
+      );
+      warnings.push(`Cannot migrate template expression: ${exprSrc2}`);
+      return skip(allUnrecognized, warnings);
+    }
+    if (t.isStringLiteral(expr)) {
+      const result = migrateString(expr.value, customMap);
+      if (result) {
+        const { szObject } = classNameToSzObject(expr.value, customMap);
+        baseObject = { ...baseObject, ...szObject };
+        allUnrecognized.push(...result.unrecognized);
+        converted++;
+      }
+      continue;
+    }
+    if (t.isConditionalExpression(expr)) {
+      const result = handleTernaryInner(expr, source, t, customMap);
+      if (!result) {
+        const exprSrc2 = safeSlice(source, expr.start, expr.end);
+        warnings.push(`Cannot migrate template ternary: ${exprSrc2}`);
+        return skip(allUnrecognized, warnings);
+      }
+      dynamicElements.push(result.exprStr);
+      allUnrecognized.push(...result.unrecognized);
+      converted++;
+      continue;
+    }
+    if (t.isLogicalExpression(expr) && expr.operator === "&&") {
+      const result = handleLogicalAndInner(expr, source, t, customMap);
+      if (!result) {
+        const exprSrc2 = safeSlice(source, expr.start, expr.end);
+        warnings.push(`Cannot migrate template logical expr: ${exprSrc2}`);
+        return skip(allUnrecognized, warnings);
+      }
+      dynamicElements.push(result.exprStr);
+      allUnrecognized.push(...result.unrecognized);
+      converted++;
+      continue;
+    }
+    const exprSrc = safeSlice(source, expr.start, expr.end);
+    warnings.push(`Cannot migrate template expression: ${exprSrc}`);
+    return skip(allUnrecognized, warnings);
+  }
+  const hasBase = Object.keys(baseObject).length > 0;
+  const hasDynamic = dynamicElements.length > 0;
+  if (!hasBase && !hasDynamic) {
+    return skip(allUnrecognized, warnings);
+  }
+  if (hasBase && !hasDynamic) {
+    return {
+      replacement: `sz=${generateSzExpression(baseObject)}`,
+      unrecognized: allUnrecognized,
+      warnings,
+      converted: converted + 1,
+      migrated: true
+    };
+  }
+  const parts = [];
+  if (hasBase) {
+    parts.push(generateSzObjectLiteral(baseObject));
+  }
+  parts.push(...dynamicElements);
+  return {
+    replacement: `sz={[${parts.join(", ")}]}`,
+    unrecognized: allUnrecognized,
+    warnings,
+    converted: converted + (hasBase ? 1 : 0),
+    migrated: true
+  };
+}
+function handleTernaryInner(node, source, t, customMap) {
+  if (!t.isStringLiteral(node.consequent) || !t.isStringLiteral(node.alternate)) {
+    return null;
+  }
+  const condSource = safeSlice(source, node.test.start, node.test.end);
+  const conValue = node.consequent.value.trim();
+  const altValue = node.alternate.value.trim();
+  if (altValue === "") {
+    if (!conValue) {
+      return null;
+    }
+    const conResult2 = migrateString(conValue, customMap);
+    if (!conResult2 || conResult2.unrecognized.length > 0) {
+      return null;
+    }
+    return {
+      exprStr: `${condSource} && ${conResult2.objectStr}`,
+      unrecognized: []
+    };
+  }
+  if (conValue === "") {
+    const altResult2 = migrateString(altValue, customMap);
+    if (!altResult2 || altResult2.unrecognized.length > 0) {
+      return null;
+    }
+    return {
+      exprStr: `!${wrapCondition(condSource)} && ${altResult2.objectStr}`,
+      unrecognized: []
+    };
+  }
+  const conResult = migrateString(conValue, customMap);
+  const altResult = migrateString(altValue, customMap);
+  if (!conResult || !altResult) {
+    return null;
+  }
+  const unrecognized = [...conResult.unrecognized, ...altResult.unrecognized];
+  if (unrecognized.length > 0) {
+    return null;
+  }
+  return {
+    exprStr: `${condSource} ? ${conResult.objectStr} : ${altResult.objectStr}`,
+    unrecognized: []
+  };
+}
+function handleLogicalAndInner(node, source, t, customMap) {
+  if (!t.isStringLiteral(node.right)) {
+    return null;
+  }
+  const result = migrateString(node.right.value, customMap);
+  if (!result || result.unrecognized.length > 0) {
+    return null;
+  }
+  const condSource = safeSlice(source, node.left.start, node.left.end);
+  return {
+    exprStr: `${condSource} && ${result.objectStr}`,
+    unrecognized: []
+  };
+}
+function migrateString(className, customMap) {
+  const trimmed = className.trim();
+  if (!trimmed) {
+    return null;
+  }
+  const { szObject, unrecognized } = classNameToSzObject(trimmed, customMap);
+  if (Object.keys(szObject).length === 0) {
+    return null;
+  }
+  return {
+    objectStr: generateSzObjectLiteral(szObject),
+    unrecognized
+  };
+}
+function skip(unrecognized, warnings) {
+  return {
+    replacement: "",
+    unrecognized,
+    warnings,
+    converted: 0,
+    migrated: false
+  };
+}
+function safeSlice(source, start, end) {
+  if (start === null || start === void 0 || end === null || end === void 0) {
+    return "<unknown>";
+  }
+  return source.slice(start, end);
+}
+function wrapCondition(cond) {
+  if (cond.includes(" ") || cond.includes("||") || cond.includes("&&")) {
+    return `(${cond})`;
+  }
+  return cond;
+}
+function isExpression(node, t) {
+  return t.isExpression(node);
+}
+
+const VISITOR_KEYS = t.VISITOR_KEYS;
+function injectTodoComment(unrecognized, parent, options, replacements) {
+  if (!options.injectTodos || unrecognized.length === 0) {
+    return;
+  }
+  if (!t.isJSXOpeningElement(parent) || parent.start === null || parent.start === void 0) {
+    return;
+  }
+  replacements.push({
+    start: parent.start,
+    end: parent.start,
+    text: `
+{/* @sz-todo: ${unrecognized.join(", ")} */}
+`
+  });
+}
+function walkAst(node, visitors, ancestors = []) {
+  if (t.isImportDeclaration(node)) {
+    visitors.ImportDeclaration?.(node);
+  } else if (t.isCallExpression(node)) {
+    visitors.CallExpression?.(node, ancestors);
+  } else if (t.isJSXAttribute(node)) {
+    visitors.JSXAttribute?.(node, ancestors[ancestors.length - 1] ?? null);
+  }
+  const keys = VISITOR_KEYS[node.type];
+  if (!keys) {
+    return;
+  }
+  ancestors.push(node);
+  for (const key of keys) {
+    const child = node[key];
+    if (Array.isArray(child)) {
+      for (const item of child) {
+        if (isAstNode(item)) {
+          walkAst(item, visitors, ancestors);
+        }
+      }
+    } else if (isAstNode(child)) {
+      walkAst(child, visitors, ancestors);
+    }
+  }
+  ancestors.pop();
+}
+function isAstNode(value) {
+  return Boolean(value && typeof value === "object" && "type" in value);
+}
+function isClassNameJsxAttribute(node) {
+  return t.isJSXAttribute(node) && t.isJSXIdentifier(node.name) && node.name.name === "className";
+}
+function transformSource(source, filePath, options = {}) {
+  const warnings = [];
+  let classNamesTransformed = 0;
+  let classNamesSkipped = 0;
+  let classNamesSkippedComponent = 0;
+  const classesUnrecognized = [];
+  const replacements = [];
+  const clsxImportNames = /* @__PURE__ */ new Set();
+  let clsxUsedOutsideClassName = false;
+  const clsxCallsitesMigrated = /* @__PURE__ */ new Set();
+  let hasCvaImport = false;
+  if (source.indexOf("className") === -1 && source.indexOf("cva") === -1) {
+    return {
+      code: source,
+      changed: false,
+      warnings: [],
+      stats: {
+        classNamesTransformed: 0,
+        classNamesSkipped: 0,
+        classNamesSkippedComponent: 0,
+        classesUnrecognized: []
+      },
+      potentiallyUnusedImports: []
+    };
+  }
+  let ast;
+  try {
+    ast = parse(source, {
+      sourceType: "module",
+      plugins: ["jsx", "typescript", "decorators-legacy"],
+      ranges: true
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return {
+      code: source,
+      changed: false,
+      warnings: [`Parse error in ${filePath}: ${msg}`],
+      stats: {
+        classNamesTransformed: 0,
+        classNamesSkipped: 0,
+        classNamesSkippedComponent: 0,
+        classesUnrecognized: []
+      },
+      potentiallyUnusedImports: []
+    };
+  }
+  walkAst(ast, {
+    ImportDeclaration(node) {
+      const src = node.source.value;
+      const clsxPackages = ["clsx", "clsx/lite", "classnames", "tailwind-merge"];
+      const isClsxPkg = clsxPackages.some((p) => src === p || src.startsWith(`${p}/`));
+      const cvaPkgs = ["cva", "class-variance-authority"];
+      if (cvaPkgs.some((p) => src === p || src.startsWith(`${p}/`))) {
+        hasCvaImport = true;
+      }
+      for (const spec of node.specifiers) {
+        const localName = spec.local.name;
+        if (isClsxPkg || isClsxLikeName(localName)) {
+          clsxImportNames.add(localName);
+        }
+      }
+    },
+    CallExpression(node, ancestors) {
+      if (t.isIdentifier(node.callee) && clsxImportNames.has(node.callee.name)) {
+        const inClassName = ancestors.some(isClassNameJsxAttribute);
+        if (!inClassName) {
+          clsxUsedOutsideClassName = true;
+        }
+      }
+    },
+    JSXAttribute(node, parent) {
+      const attrName = node.name;
+      if (!t.isJSXIdentifier(attrName) || attrName.name !== "className") {
+        return;
+      }
+      if (t.isJSXOpeningElement(parent)) {
+        const elementName = parent.name;
+        const isCapitalized = t.isJSXIdentifier(elementName) && /^[A-Z]/.test(elementName.name) || t.isJSXMemberExpression(elementName);
+        if (isCapitalized) {
+          classNamesSkippedComponent++;
+          return;
+        }
+      }
+      if (t.isJSXOpeningElement(parent)) {
+        const hasSz = parent.attributes.some(
+          (attr) => t.isJSXAttribute(attr) && t.isJSXIdentifier(attr.name) && attr.name.name === "sz"
+        );
+        if (hasSz) {
+          classNamesSkipped++;
+          return;
+        }
+      }
+      const value = node.value;
+      const attrStart = node.start;
+      const attrEnd = node.end;
+      if (attrStart === null || attrStart === void 0 || attrEnd === null || attrEnd === void 0) {
+        return;
+      }
+      if (t.isStringLiteral(value)) {
+        const result = processStaticString(value.value, options.customMap);
+        if (result) {
+          replacements.push({ start: attrStart, end: attrEnd, text: result.replacement });
+          classNamesTransformed++;
+          classesUnrecognized.push(...result.unrecognized);
+          injectTodoComment(result.unrecognized, parent, options, replacements);
+        } else {
+          classNamesSkipped++;
+        }
+        return;
+      }
+      if (t.isJSXExpressionContainer(value)) {
+        const expr = value.expression;
+        if (t.isStringLiteral(expr)) {
+          const result = processStaticString(expr.value, options.customMap);
+          if (result) {
+            replacements.push({
+              start: attrStart,
+              end: attrEnd,
+              text: result.replacement
+            });
+            classNamesTransformed++;
+            classesUnrecognized.push(...result.unrecognized);
+            injectTodoComment(result.unrecognized, parent, options, replacements);
+          } else {
+            classNamesSkipped++;
+          }
+          return;
+        }
+        if (t.isTemplateLiteral(expr)) {
+          const result = handleTemplateLiteral(expr, source, t, options.customMap);
+          if (result.migrated) {
+            replacements.push({
+              start: attrStart,
+              end: attrEnd,
+              text: result.replacement
+            });
+            classNamesTransformed += result.converted;
+            classesUnrecognized.push(...result.unrecognized);
+          } else {
+            classNamesSkipped++;
+            warnings.push(...result.warnings.map((w) => `[${filePath}] ${w}`));
+            classesUnrecognized.push(...result.unrecognized);
+          }
+          injectTodoComment(result.unrecognized, parent, options, replacements);
+          return;
+        }
+        if (t.isCallExpression(expr) && t.isIdentifier(expr.callee) && isClsxLikeName(expr.callee.name)) {
+          const result = handleClsxCall(expr, source, t, options.customMap);
+          if (result.migrated) {
+            replacements.push({
+              start: attrStart,
+              end: attrEnd,
+              text: result.replacement
+            });
+            classNamesTransformed += result.converted;
+            classesUnrecognized.push(...result.unrecognized);
+            if (expr.start !== null && expr.start !== void 0) {
+              clsxCallsitesMigrated.add(expr.start);
+            }
+          } else {
+            classNamesSkipped++;
+            warnings.push(...result.warnings.map((w) => `[${filePath}] ${w}`));
+            classesUnrecognized.push(...result.unrecognized);
+          }
+          injectTodoComment(result.unrecognized, parent, options, replacements);
+          return;
+        }
+        if (t.isConditionalExpression(expr)) {
+          const result = handleTernary(expr, source, t, options.customMap);
+          if (result.migrated) {
+            replacements.push({
+              start: attrStart,
+              end: attrEnd,
+              text: result.replacement
+            });
+            classNamesTransformed += result.converted;
+            classesUnrecognized.push(...result.unrecognized);
+          } else {
+            classNamesSkipped++;
+            warnings.push(...result.warnings.map((w) => `[${filePath}] ${w}`));
+            classesUnrecognized.push(...result.unrecognized);
+          }
+          injectTodoComment(result.unrecognized, parent, options, replacements);
+          return;
+        }
+        if (t.isLogicalExpression(expr) && expr.operator === "&&") {
+          const result = handleLogicalAnd(expr, source, t, options.customMap);
+          if (result.migrated) {
+            replacements.push({
+              start: attrStart,
+              end: attrEnd,
+              text: result.replacement
+            });
+            classNamesTransformed += result.converted;
+            classesUnrecognized.push(...result.unrecognized);
+          } else {
+            classNamesSkipped++;
+            warnings.push(...result.warnings.map((w) => `[${filePath}] ${w}`));
+            classesUnrecognized.push(...result.unrecognized);
+          }
+          injectTodoComment(result.unrecognized, parent, options, replacements);
+          return;
+        }
+        classNamesSkipped++;
+        return;
+      }
+      classNamesSkipped++;
+    }
+  });
+  if (hasCvaImport) {
+    warnings.push(
+      `[${filePath}] File uses cva() \u2014 consider migrating to szv() from @csszyx/runtime for type-safe variant-based styling.`
+    );
+  }
+  let output = source;
+  const sorted = replacements.sort((a, b) => b.start - a.start);
+  for (const r of sorted) {
+    output = output.slice(0, r.start) + r.text + output.slice(r.end);
+  }
+  const potentiallyUnusedImports = [];
+  if (clsxImportNames.size > 0 && !clsxUsedOutsideClassName && replacements.length > 0) {
+    for (const name of clsxImportNames) {
+      const callPattern = new RegExp(`\\b${name}\\s*\\(`, "g");
+      if (!callPattern.test(output)) {
+        potentiallyUnusedImports.push(name);
+      }
+    }
+  }
+  return {
+    code: output,
+    changed: replacements.length > 0,
+    warnings,
+    stats: {
+      classNamesTransformed,
+      classNamesSkipped,
+      classNamesSkippedComponent,
+      classesUnrecognized
+    },
+    potentiallyUnusedImports
+  };
+}
+function processStaticString(classNameStr, customMap) {
+  const trimmed = classNameStr.trim();
+  if (!trimmed) {
+    return null;
+  }
+  const { szObject, unrecognized, keepInClassName } = classNameToSzObject(trimmed, customMap);
+  if (Object.keys(szObject).length === 0) {
+    return null;
+  }
+  const szExpr = generateSzExpression(szObject);
+  const remainingClassName = [...keepInClassName, ...unrecognized];
+  if (remainingClassName.length > 0) {
+    return {
+      replacement: `className="${remainingClassName.join(" ")}" sz=${szExpr}`,
+      unrecognized
+    };
+  }
+  return {
+    replacement: `sz=${szExpr}`,
+    unrecognized: []
+  };
+}
+const FOUC_CSS = `<style>
+  /* csszyx: hide [sz] elements until runtime processes them */
+  [sz] { visibility: hidden; }
+  body.sz-ready [sz] { visibility: visible; }
+</style>`;
+function transformHtmlSourceSimple(source, filePath, options = {}) {
+  const {
+    braces = false,
+    injectFouc = true,
+    injectRuntime = false,
+    cdnUrl = "https://cdn.csszyx.com/runtime.js",
+    localPath = "csszyx-runtime.js"
+  } = options;
+  const warnings = [];
+  let classNamesTransformed = 0;
+  let classNamesSkipped = 0;
+  const classNamesSkippedComponent = 0;
+  const classesUnrecognized = [];
+  let changed = false;
+  let output = source.replace(/\bclass="([^"]*)"/g, (match, classStr) => {
+    return processClassAttr(match, classStr, '"');
+  });
+  output = output.replace(/\bclass='([^']*)'/g, (match, classStr) => {
+    return processClassAttr(match, classStr, "'");
+  });
+  if (injectFouc && output.includes("</head>") && !output.includes("csszyx: hide [sz]")) {
+    output = output.replace("</head>", `${FOUC_CSS}
+</head>`);
+    changed = true;
+  }
+  if (injectRuntime && output.includes("</body>")) {
+    const scriptSrc = injectRuntime === "cdn" ? cdnUrl : localPath;
+    const scriptTag = `<script src="${scriptSrc}"><\/script>`;
+    if (!output.includes(scriptSrc)) {
+      output = output.replace("</body>", `${scriptTag}
+</body>`);
+      changed = true;
+    }
+  }
+  function processClassAttr(match, classStr, quote) {
+    const trimmed = classStr.trim();
+    if (!trimmed) {
+      classNamesSkipped++;
+      return match;
+    }
+    const { szObject, unrecognized } = classNameToSzObject(trimmed);
+    if (Object.keys(szObject).length === 0) {
+      classNamesSkipped++;
+      classesUnrecognized.push(...unrecognized);
+      return match;
+    }
+    const szVal = generateSzHtmlValue(szObject, braces);
+    changed = true;
+    classNamesTransformed++;
+    if (unrecognized.length > 0) {
+      classesUnrecognized.push(...unrecognized);
+      return `class=${quote}${unrecognized.join(" ")}${quote} sz="${szVal}"`;
+    }
+    return `sz="${szVal}"`;
+  }
+  return {
+    code: output,
+    changed,
+    warnings,
+    stats: {
+      classNamesTransformed,
+      classNamesSkipped,
+      classNamesSkippedComponent,
+      classesUnrecognized
+    },
+    potentiallyUnusedImports: []
+  };
+}
+
+export { extractSpacingKeys as a, flattenColors as b, classNameToSzObject as c, generateTypeDeclarations as d, extractScreenKeys as e, findConfigFile as f, generateAndWriteTypes as g, generateTypes as h, transformHtmlSourceSimple as i, scanTailwindConfig as s, transformSource as t, writeDeclarationFile as w };