@csszyx/cli 0.9.9 → 0.10.0

package/dist/index.mjs

@@ -1,4831 +1,9 @@
-#!/usr/bin/env node
-import fs$1, { existsSync, writeFileSync, readFileSync } from 'node:fs';
-import cac from 'cac';
-import * as path from 'node:path';
-import path__default, { resolve, dirname } from 'node:path';
-import fs from 'fs-extra';
-import ora from 'ora';
-import pc from 'picocolors';
-import { mkdir } from 'node:fs/promises';
-import { pathToFileURL } from 'node:url';
-import resolveConfig from 'tailwindcss/resolveConfig.js';
-import { execa } from 'execa';
-import prompts from 'prompts';
-import readline from 'node:readline';
-import fg from 'fast-glob';
-import { parse } from '@babel/parser';
-import * as t from '@babel/types';
-import { runNextPrebuild } from '@csszyx/unplugin/next-prebuild';
-import { NextSafelistWatcher } from '@csszyx/unplugin/next-watcher';
-import { watch } from 'chokidar';
-import { Minimatch } from 'minimatch';
-
-const colors = {
-  success: pc.green,
-  error: pc.red,
-  warn: pc.yellow,
-  info: pc.cyan,
-  dim: pc.dim,
-  bold: pc.bold
-};
-const icons = {
-  success: "\u2713",
-  error: "\u2717",
-  warn: "\u26A0",
-  info: "\u2139"
-};
-function printHeader(title) {
-  const width = 48;
-  const padding = Math.max(0, width - title.length - 4);
-  console.log(pc.cyan(`\u250C${"\u2500".repeat(width - 2)}\u2510`));
-  console.log(`${pc.cyan("\u2502")}  ${pc.bold(title)}${" ".repeat(padding)}${pc.cyan("\u2502")}`);
-  console.log(pc.cyan(`\u2514${"\u2500".repeat(width - 2)}\u2518`));
-  console.log();
-}
-function printSection(title) {
-  console.log();
-  console.log(pc.bold(title));
-  console.log(pc.dim("\u2501".repeat(48)));
-}
-function printSuccess(message) {
-  console.log(colors.success(`${icons.success} ${message}`));
-}
-function printError(message) {
-  console.log(colors.error(`${icons.error} ${message}`));
-}
-function printWarn(message) {
-  console.log(colors.warn(`${icons.warn} ${message}`));
-}
-function printInfo(message) {
-  console.log(colors.info(`${icons.info} ${message}`));
-}
-const spinner = {
-  start(text) {
-    return ora(text).start();
-  },
-  succeed(spinner2, text) {
-    spinner2.succeed(colors.success(text));
-  },
-  fail(spinner2, text) {
-    spinner2.fail(colors.error(text));
-  },
-  warn(spinner2, text) {
-    spinner2.warn(colors.warn(text));
-  }
-};
-function printBar(values, max, width = 20) {
-  const filled = Math.round(values.reduce((a, b) => a + b, 0) / max * width);
-  return "\u25A0".repeat(filled) + "\u25A1".repeat(width - filled);
-}
-
-async function audit(options = {}) {
-  const cwd = options.cwd || process.cwd();
-  const stats = await collectStats(cwd);
-  if (options.json) {
-    console.log(JSON.stringify(stats, null, 2));
-    return;
-  }
-  printHeader("csszyx Audit Report");
-  printSection("\u{1F4CA} Mangle Statistics");
-  if (stats.totalClasses === 0) {
-    console.log("  Tier distribution not yet available.");
-    console.log("  Run a production build first, then re-run csszyx audit.");
-  } else {
-    console.log(`  Total Classes:       ${stats.totalClasses}`);
-    console.log(`  Mangled Classes:     ${stats.totalClasses} (100%)`);
-    console.log("  Unmangled Classes:   0");
-    console.log();
-    console.log("  Tier Distribution:");
-    const tierNames = [
-      "Tier 1 (a-Z)",
-      "Tier 2 (a0-Z9)",
-      "Tier 3 (aa-ZZ)",
-      "Tier 4 (a00-Z99)",
-      "Tier 5 (aaa+)"
-    ];
-    for (let i = 1; i <= 5; i++) {
-      const count = stats.tierDistribution[i] || 0;
-      const percent = stats.totalClasses ? Math.round(count / stats.totalClasses * 100) : 0;
-      const bar = printBar([count], stats.totalClasses, 20);
-      console.log(
-        `  \u2022 ${tierNames[i - 1].padEnd(18)} ${String(count).padStart(3)} (${String(percent).padStart(2)}%)  ${colors.dim(bar)}`
-      );
-    }
-  }
-  printSection("\u{1F4BE} Bundle Size Impact");
-  if (stats.bundleSavings.originalHTML > 0) {
-    const htmlSavings = stats.bundleSavings.originalHTML - stats.bundleSavings.mangledHTML;
-    const htmlPercent = Math.round(htmlSavings / stats.bundleSavings.originalHTML * 100);
-    console.log(`  Original HTML:       ${formatBytes(stats.bundleSavings.originalHTML)}`);
-    console.log(
-      `  Mangled HTML:        ${formatBytes(stats.bundleSavings.mangledHTML)}   \u2193 ${htmlPercent}% (-${formatBytes(htmlSavings)})`
-    );
-    console.log();
-  }
-  if (stats.bundleSavings.originalCSS > 0) {
-    const cssSavings = stats.bundleSavings.originalCSS - stats.bundleSavings.mangledCSS;
-    const cssPercent = Math.round(cssSavings / stats.bundleSavings.originalCSS * 100);
-    console.log(`  Original CSS:        ${formatBytes(stats.bundleSavings.originalCSS)}`);
-    console.log(
-      `  Mangled CSS:         ${formatBytes(stats.bundleSavings.mangledCSS)}   \u2193 ${cssPercent}% (-${formatBytes(cssSavings)})`
-    );
-  }
-  console.log();
-  printInfo("\u{1F4A1} Tip: Enable runtime lite bundle for -1.1KB");
-  console.log("     \u2192 import { _sz } from 'csszyx/lite'");
-}
-async function collectStats(cwd) {
-  const stats = {
-    totalClasses: 0,
-    tierDistribution: {},
-    bundleSavings: {
-      originalHTML: 0,
-      mangledHTML: 0,
-      originalCSS: 0,
-      mangledCSS: 0
-    }
-  };
-  const distDir = path__default.join(cwd, "dist");
-  if (!fs.existsSync(distDir)) {
-    return stats;
-  }
-  const htmlFiles = fs.readdirSync(distDir, { recursive: true }).filter((f) => String(f).endsWith(".html"));
-  const cssFiles = fs.readdirSync(distDir, { recursive: true }).filter((f) => String(f).endsWith(".css"));
-  if (htmlFiles.length > 0) {
-    const htmlContent = fs.readFileSync(path__default.join(distDir, String(htmlFiles[0])), "utf-8");
-    stats.bundleSavings.mangledHTML = Buffer.byteLength(htmlContent);
-    stats.bundleSavings.originalHTML = Math.round(stats.bundleSavings.mangledHTML * 1.67);
-  }
-  if (cssFiles.length > 0) {
-    const cssContent = fs.readFileSync(path__default.join(distDir, String(cssFiles[0])), "utf-8");
-    stats.bundleSavings.mangledCSS = Buffer.byteLength(cssContent);
-    stats.bundleSavings.originalCSS = Math.round(stats.bundleSavings.mangledCSS * 1.71);
-  }
-  return stats;
-}
-function formatBytes(bytes) {
-  if (bytes === 0) {
-    return "0 B";
-  }
-  if (bytes < 1024) {
-    return `${bytes} B`;
-  }
-  if (bytes < 1024 * 1024) {
-    return `${(bytes / 1024).toFixed(1)} KB`;
-  }
-  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-}
-
-function detectFramework(cwd) {
-  try {
-    const pkgPath = path__default.join(cwd, "package.json");
-    if (!fs.existsSync(pkgPath)) {
-      return "unknown";
-    }
-    const pkg = fs.readJSONSync(pkgPath);
-    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
-    if (deps.next) {
-      const hasAppDir = fs.existsSync(path__default.join(cwd, "app"));
-      return hasAppDir ? "nextjs-app" : "nextjs-pages";
-    }
-    if (deps.nuxt) {
-      return "nuxt";
-    }
-    if (deps["@sveltejs/kit"]) {
-      return "sveltekit";
-    }
-    if (deps.astro) {
-      return "astro";
-    }
-    if (deps.vite) {
-      if (deps.react || deps["react-dom"]) {
-        return "vite-react";
-      }
-      if (deps.vue) {
-        return "vite-vue";
-      }
-      if (deps.svelte) {
-        return "vite-svelte";
-      }
-    }
-    return "unknown";
-  } catch {
-    return "unknown";
-  }
-}
-function detectPackageManager(cwd) {
-  if (fs.existsSync(path__default.join(cwd, "pnpm-lock.yaml"))) {
-    return "pnpm";
-  }
-  if (fs.existsSync(path__default.join(cwd, "yarn.lock"))) {
-    return "yarn";
-  }
-  if (fs.existsSync(path__default.join(cwd, "bun.lockb"))) {
-    return "bun";
-  }
-  return "npm";
-}
-function hasTailwindInstalled(cwd) {
-  try {
-    const pkgPath = path__default.join(cwd, "package.json");
-    if (!fs.existsSync(pkgPath)) {
-      return false;
-    }
-    const pkg = fs.readJSONSync(pkgPath);
-    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
-    return !!deps.tailwindcss;
-  } catch {
-    return false;
-  }
-}
-function hasTypeScript(cwd) {
-  return fs.existsSync(path__default.join(cwd, "tsconfig.json")) || fs.existsSync(path__default.join(cwd, "jsconfig.json"));
-}
-function getProjectInfo(cwd = process.cwd()) {
-  return {
-    framework: detectFramework(cwd),
-    packageManager: detectPackageManager(cwd),
-    hasTailwind: hasTailwindInstalled(cwd),
-    hasTypeScript: hasTypeScript(cwd),
-    rootDir: cwd
-  };
-}
-function getFrameworkName(framework) {
-  const names = {
-    "vite-react": "Vite + React",
-    "vite-vue": "Vite + Vue",
-    "vite-svelte": "Vite + Svelte",
-    "nextjs-app": "Next.js (App Router)",
-    "nextjs-pages": "Next.js (Pages Router)",
-    nuxt: "Nuxt 3",
-    sveltekit: "SvelteKit",
-    astro: "Astro",
-    unknown: "Unknown"
-  };
-  return names[framework];
-}
-
-async function doctor(options = {}) {
-  const cwd = options.cwd || process.cwd();
-  const projectInfo = getProjectInfo(cwd);
-  printHeader("csszyx Doctor");
-  let issueCount = 0;
-  printSection("\u{1F4CB} Configuration Health");
-  const hasConfig = fs.existsSync(path__default.join(cwd, "csszyx.config.ts")) || fs.existsSync(path__default.join(cwd, "csszyx.config.js"));
-  if (hasConfig) {
-    printSuccess("csszyx configuration found");
-  } else {
-    printWarn("No csszyx.config found - using defaults");
-  }
-  if (projectInfo.hasTailwind) {
-    printSuccess("Tailwind CSS installed");
-  } else {
-    printError("Tailwind CSS not found");
-    issueCount++;
-    if (options.verbose) {
-      console.log("  \u2192 Run: npm install -D tailwindcss");
-    }
-  }
-  printSection("\u{1F4E6} Package Versions");
-  try {
-    const pkgPath = path__default.join(cwd, "package.json");
-    const pkg = fs.readJSONSync(pkgPath);
-    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
-    if (deps.csszyx) {
-      printSuccess(`csszyx: ${deps.csszyx}`);
-    } else {
-      printError("csszyx package not installed");
-      issueCount++;
-    }
-  } catch {
-    printError("Failed to read package.json");
-    issueCount++;
-  }
-  printSection("\u{1F528} Build Output");
-  const distDir = path__default.join(cwd, "dist");
-  if (fs.existsSync(distDir)) {
-    const htmlFiles = fs.readdirSync(distDir, { recursive: true }).filter((f) => String(f).endsWith(".html"));
-    if (htmlFiles.length > 0) {
-      printSuccess(`Found ${htmlFiles.length} HTML file(s)`);
-      const htmlContent = fs.readFileSync(path__default.join(distDir, String(htmlFiles[0])), "utf-8");
-      if (htmlContent.includes("data-sz-checksum")) {
-        printSuccess("Checksum injection working");
-      } else {
-        printWarn("Checksum not found in HTML");
-        if (options.verbose) {
-          console.log("  \u2192 Enable injectChecksum in production config");
-        }
-      }
-    }
-  } else {
-    printWarn("No build output found - run build first");
-  }
-  console.log();
-  if (issueCount === 0) {
-    printSuccess("\u2728 No issues found! Your setup looks good.");
-  } else {
-    printWarn(`Found ${issueCount} issue(s)`);
-  }
-}
-
-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);
-  }
-}
-
-const VITE_FRAMEWORKS = /* @__PURE__ */ new Set(["vite-react", "vite-vue", "vite-svelte"]);
-async function readFileOrNull(filePath) {
-  try {
-    return await fs.readFile(filePath, "utf8");
-  } catch (err) {
-    if (err?.code === "ENOENT") {
-      return null;
-    }
-    throw err;
-  }
-}
-const NEXTJS_FRAMEWORKS = /* @__PURE__ */ new Set(["nextjs-app", "nextjs-pages"]);
-const CSS_ENTRY_CANDIDATES = [
-  "src/index.css",
-  "src/app.css",
-  "src/globals.css",
-  "app/globals.css",
-  "src/styles/index.css",
-  "styles/globals.css"
-];
-async function init(options = {}) {
-  const cwd = options.cwd || process.cwd();
-  const projectInfo = getProjectInfo(cwd);
-  printHeader("csszyx Setup Wizard");
-  if (projectInfo.framework !== "unknown") {
-    printSuccess(`Detected: ${getFrameworkName(projectInfo.framework)}`);
-    printInfo(`Package Manager: ${projectInfo.packageManager}`);
-  }
-  let config = {
-    enableSSR: true,
-    enableRecovery: true,
-    installTailwind: !projectInfo.hasTailwind,
-    setupGitignore: true,
-    setupTsconfig: !!projectInfo.hasTypeScript
-  };
-  if (!options.yes) {
-    const answers = await prompts([
-      {
-        type: projectInfo.hasTailwind ? null : "confirm",
-        name: "installTailwind",
-        message: "Install Tailwind CSS v4?",
-        initial: true
-      },
-      {
-        type: "confirm",
-        name: "enableSSR",
-        message: "Enable SSR Hydration Guard?",
-        initial: true
-      },
-      {
-        type: "confirm",
-        name: "enableRecovery",
-        message: "Enable development mode recovery?",
-        initial: true
-      },
-      {
-        type: "confirm",
-        name: "setupGitignore",
-        message: "Add .csszyx to .gitignore?",
-        initial: true
-      },
-      {
-        type: projectInfo.hasTypeScript ? "confirm" : null,
-        name: "setupTsconfig",
-        message: "Add .csszyx/theme.d.ts to tsconfig.json (Theme Auto-Scan)?",
-        initial: true
-      }
-    ]);
-    config = { ...config, ...answers };
-  }
-  const spin = spinner.start("Installing csszyx...");
-  try {
-    await execa(projectInfo.packageManager, ["add", "csszyx", "@csszyx/runtime"], { cwd });
-    if (projectInfo.hasTypeScript) {
-      await execa(projectInfo.packageManager, ["add", "-D", "@csszyx/types"], { cwd });
-    }
-    if (config.installTailwind) {
-      const twPackage = VITE_FRAMEWORKS.has(projectInfo.framework) ? "@tailwindcss/vite" : "@tailwindcss/postcss";
-      await execa(projectInfo.packageManager, ["add", "-D", "tailwindcss", twPackage], {
-        cwd
-      });
-    }
-    spinner.succeed(spin, "Installed csszyx");
-  } catch (error) {
-    spinner.fail(spin, "Failed to install packages");
-    printError(String(error));
-    return;
-  }
-  const spin2 = spinner.start("Creating config files...");
-  try {
-    const configContent = generateConfigFile(config);
-    const configPath = path__default.join(
-      cwd,
-      projectInfo.hasTypeScript ? "csszyx.config.ts" : "csszyx.config.js"
-    );
-    await fs.writeFile(configPath, configContent);
-    if (config.installTailwind) {
-      await setupTailwindCss(cwd, projectInfo.framework);
-    }
-    await injectPlugin(cwd, projectInfo.framework);
-    if (config.setupGitignore) {
-      const gitignorePath = path__default.join(cwd, ".gitignore");
-      const ignoreEntry = "\n# csszyx generated theme types\n.csszyx\n";
-      const existing = await readFileOrNull(gitignorePath);
-      if (existing !== null) {
-        if (!existing.includes(".csszyx")) {
-          await fs.appendFile(gitignorePath, ignoreEntry);
-        }
-      } else {
-        await fs.writeFile(gitignorePath, "node_modules\n.csszyx\n");
-      }
-    }
-    if (config.setupTsconfig) {
-      await setupTsconfig(cwd);
-    }
-    if (projectInfo.hasTypeScript) {
-      await setupSzTypes(cwd);
-    }
-    spinner.succeed(spin2, "Created configuration files");
-  } catch (error) {
-    spinner.fail(spin2, "Failed to create config files");
-    printError(String(error));
-    return;
-  }
-  console.log();
-  printSuccess("\u{1F389} All done!");
-  console.log();
-  printInfo("Next steps:");
-  console.log(`  \u2022 Run '${projectInfo.packageManager} run dev' to start`);
-  if (projectInfo.hasTypeScript) {
-    console.log("  \u2022 The `sz` prop is typed via csszyx-env.d.ts");
-  }
-  console.log("  \u2022 Check the docs at https://csszyx.dev");
-}
-async function setupTailwindCss(cwd, framework) {
-  let cssPath;
-  let content = null;
-  for (const candidate of CSS_ENTRY_CANDIDATES) {
-    const full = path__default.join(cwd, candidate);
-    const existing = await readFileOrNull(full);
-    if (existing !== null) {
-      cssPath = full;
-      content = existing;
-      break;
-    }
-  }
-  if (!cssPath || content === null) {
-    cssPath = path__default.join(cwd, "src/index.css");
-    await fs.ensureDir(path__default.dirname(cssPath));
-    await fs.writeFile(cssPath, '@import "tailwindcss";\n');
-    printInfo(`Created ${path__default.relative(cwd, cssPath)} with Tailwind v4 import`);
-    return;
-  }
-  if (!content.includes('@import "tailwindcss"') && !content.includes("@import 'tailwindcss'")) {
-    await fs.writeFile(cssPath, `@import "tailwindcss";
-
-${content}`);
-    printInfo(`Added Tailwind v4 import to ${path__default.relative(cwd, cssPath)}`);
-  }
-  if (NEXTJS_FRAMEWORKS.has(framework)) {
-    const postcssMjs = path__default.join(cwd, "postcss.config.mjs");
-    const postcssJs = path__default.join(cwd, "postcss.config.js");
-    const postcssTs = path__default.join(cwd, "postcss.config.ts");
-    const hasExisting = await readFileOrNull(postcssMjs) !== null || await readFileOrNull(postcssJs) !== null || await readFileOrNull(postcssTs) !== null;
-    if (!hasExisting) {
-      await fs.writeFile(postcssMjs, generatePostcssConfig());
-      printInfo("Created postcss.config.mjs for Tailwind v4");
-    }
-  }
-}
-async function injectPlugin(cwd, framework) {
-  if (VITE_FRAMEWORKS.has(framework)) {
-    const injected = await injectVitePlugin(cwd);
-    if (!injected) {
-      printWarn("Could not auto-inject csszyx plugin. Add manually to vite.config.ts:");
-      console.log(generateVitePluginInstructions());
-    }
-  } else if (NEXTJS_FRAMEWORKS.has(framework)) {
-    const injected = await injectNextPlugin(cwd);
-    if (!injected) {
-      printWarn("Could not auto-inject csszyx plugin. Add manually to next.config.js:");
-      console.log(generateNextPluginInstructions());
-    }
-  } else {
-    printInfo("Add csszyx plugin to your bundler config:");
-    console.log(generateVitePluginInstructions());
-  }
-}
-async function injectVitePlugin(cwd) {
-  const candidates = [
-    path__default.join(cwd, "vite.config.ts"),
-    path__default.join(cwd, "vite.config.js"),
-    path__default.join(cwd, "vite.config.mts"),
-    path__default.join(cwd, "vite.config.mjs")
-  ];
-  let configPath;
-  let content = null;
-  for (const c of candidates) {
-    const existing = await readFileOrNull(c);
-    if (existing !== null) {
-      configPath = c;
-      content = existing;
-      break;
-    }
-  }
-  if (!configPath || content === null) {
-    return false;
-  }
-  if (content.includes("csszyx")) {
-    return true;
-  }
-  const importBlock = [
-    "import csszyx from 'csszyx/vite';",
-    content.includes("@tailwindcss/vite") ? null : "import tailwindcss from '@tailwindcss/vite';"
-  ].filter(Boolean).join("\n");
-  const lastImportMatch = [...content.matchAll(/^import .+$/gm)].pop();
-  if (!lastImportMatch || lastImportMatch.index === void 0) {
-    return false;
-  }
-  const insertAt = lastImportMatch.index + lastImportMatch[0].length;
-  content = `${content.slice(0, insertAt)}
-${importBlock}${content.slice(insertAt)}`;
-  const pluginsMatch = content.match(/plugins\s*:\s*\[/);
-  if (!pluginsMatch || pluginsMatch.index === void 0) {
-    return false;
-  }
-  const pluginsInsertAt = pluginsMatch.index + pluginsMatch[0].length;
-  const twEntry = content.includes("tailwindcss()") ? "" : "\n    tailwindcss(),";
-  content = content.slice(0, pluginsInsertAt) + `
-    ...csszyx(),      // csszyx MUST come before tailwindcss${twEntry}` + content.slice(pluginsInsertAt);
-  await fs.writeFile(configPath, content);
-  printInfo(`Injected csszyx plugin into ${path__default.basename(configPath)}`);
-  return true;
-}
-async function injectNextPlugin(cwd) {
-  const candidates = [
-    path__default.join(cwd, "next.config.ts"),
-    path__default.join(cwd, "next.config.mjs"),
-    path__default.join(cwd, "next.config.js")
-  ];
-  let configPath;
-  let content = null;
-  for (const c of candidates) {
-    const existing = await readFileOrNull(c);
-    if (existing !== null) {
-      configPath = c;
-      content = existing;
-      break;
-    }
-  }
-  if (!configPath) {
-    configPath = path__default.join(cwd, "next.config.js");
-    await fs.writeFile(configPath, generateNextConfig());
-    printInfo("Created next.config.js with csszyx plugin");
-    return true;
-  }
-  if (content?.includes("csszyx")) {
-    return true;
-  }
-  return false;
-}
-async function setupTsconfig(cwd) {
-  const primary = path__default.join(cwd, "tsconfig.json");
-  const viteTsConfig = path__default.join(cwd, "tsconfig.app.json");
-  let tsconfigPath = primary;
-  let content = await readFileOrNull(tsconfigPath);
-  if (content === null) {
-    tsconfigPath = viteTsConfig;
-    content = await readFileOrNull(tsconfigPath);
-  }
-  if (content === null) {
-    return;
-  }
-  if (content.includes(".csszyx")) {
-    return;
-  }
-  const includeMatch = content.match(/"include"\s*:\s*\[/);
-  if (includeMatch && includeMatch.index !== void 0) {
-    const insertPos = includeMatch.index + includeMatch[0].length;
-    content = content.slice(0, insertPos) + '\n    "./.csszyx/theme.d.ts",\n    "./.csszyx",' + content.slice(insertPos);
-    await fs.writeFile(tsconfigPath, content);
-  }
-}
-async function setupSzTypes(cwd) {
-  const envPath = path__default.join(cwd, "csszyx-env.d.ts");
-  const reference = '/// <reference types="@csszyx/types/jsx" />';
-  const existing = await readFileOrNull(envPath);
-  if (existing === null) {
-    await fs.writeFile(
-      envPath,
-      `// Generated by csszyx. Enables the \`sz\` JSX prop types.
-${reference}
-`
-    );
-    printInfo("Created csszyx-env.d.ts (sz prop types)");
-  } else if (!existing.includes("@csszyx/types/jsx")) {
-    await fs.writeFile(envPath, `${existing.trimEnd()}
-${reference}
-`);
-    printInfo("Added the sz type reference to csszyx-env.d.ts");
-  }
-  await ensureTsconfigInclude(cwd, "csszyx-env.d.ts");
-}
-async function ensureTsconfigInclude(cwd, entry) {
-  for (const name of ["tsconfig.json", "tsconfig.app.json"]) {
-    const tsconfigPath = path__default.join(cwd, name);
-    const content = await readFileOrNull(tsconfigPath);
-    if (content === null) {
-      continue;
-    }
-    if (content.includes(entry)) {
-      return;
-    }
-    const includeMatch = content.match(/"include"\s*:\s*\[/);
-    if (includeMatch && includeMatch.index !== void 0) {
-      const insertPos = includeMatch.index + includeMatch[0].length;
-      await fs.writeFile(
-        tsconfigPath,
-        `${content.slice(0, insertPos)}
-    "${entry}",${content.slice(insertPos)}`
-      );
-    }
-    return;
-  }
-}
-function generateConfigFile(config) {
-  return `import type { CsszyxConfig } from 'csszyx';
-
-const config: CsszyxConfig = {
-  development: {
-    debug: true,
-  },
-  production: {
-    injectChecksum: ${config.enableSSR},
-  },
-};
-
-export default config;
-`;
-}
-function generatePostcssConfig() {
-  return `export default {
-  plugins: {
-    '@tailwindcss/postcss': {},
-  },
-};
-`;
-}
-function generateNextConfig() {
-  return `const csszyxWebpack = require('@csszyx/unplugin/webpack').default;
-
-/** @type {import('next').NextConfig} */
-const nextConfig = {
-  webpack(config) {
-    config.plugins.unshift(...csszyxWebpack());
-    return config;
-  },
-};
-
-module.exports = nextConfig;
-`;
-}
-function generateVitePluginInstructions() {
-  return `
-  import csszyx from 'csszyx/vite';
-  import tailwindcss from '@tailwindcss/vite';
-
-  export default defineConfig({
-    plugins: [
-      ...csszyx(),      // csszyx MUST come before tailwindcss
-      tailwindcss(),
-      // ...your other plugins
-    ],
-  });
-`;
-}
-function generateNextPluginInstructions() {
-  return `
-  const csszyxWebpack = require('@csszyx/unplugin/webpack').default;
-
-  module.exports = {
-    webpack(config) {
-      config.plugins.unshift(...csszyxWebpack());
-      return config;
-    },
-  };
-`;
-}
-
-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: []
-  };
-}
-
-function createLogFile(cwd) {
-  const now = /* @__PURE__ */ new Date();
-  const ts = now.toISOString().slice(0, 19).replace("T", "_").replace(/:/g, "-");
-  const logDir = path__default.join(cwd, ".csszyx", "logs");
-  fs$1.mkdirSync(logDir, { recursive: true });
-  const filePath = path__default.join(logDir, `migrate-${ts}.log`);
-  const lines = [`csszyx migrate \u2014 ${now.toISOString()}`, ""];
-  return {
-    filePath,
-    writeLine: (line) => lines.push(line),
-    flush: () => fs$1.writeFileSync(filePath, `${lines.join("\n")}
-`, "utf-8")
-  };
-}
-function isGitignored(cwd, pattern) {
-  try {
-    const content = fs$1.readFileSync(path__default.join(cwd, ".gitignore"), "utf-8");
-    return content.split("\n").some((l) => {
-      const t = l.trim();
-      return t === pattern || t === `${pattern}/` || t === `/${pattern}`;
-    });
-  } catch {
-    return false;
-  }
-}
-async function askYesNo(question) {
-  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve) => {
-    rl.question(question, (answer) => {
-      rl.close();
-      resolve(answer.trim().toLowerCase() === "y");
-    });
-  });
-}
-async function migrate(options = {}) {
-  const cwd = options.cwd || process.cwd();
-  let dryRun = options.dryRun || false;
-  const ignorePatterns = options.ignore || [];
-  const audit = options.audit || false;
-  const resolveTodosPath = options.resolveTodos;
-  let customMap, files;
-  if (audit) {
-    dryRun = true;
-  }
-  let injectTodos = options.injectTodos || false;
-  if (resolveTodosPath && !injectTodos) {
-    injectTodos = true;
-  }
-  printHeader("csszyx Migration Tool");
-  if (process.stdout.isTTY && !injectTodos && !audit && !resolveTodosPath) {
-    const answer = await askYesNo(
-      "Add {/* @sz-todo */} comments above elements with unrecognized classes? [y/N] "
-    );
-    if (answer) {
-      injectTodos = true;
-    }
-  }
-  if (resolveTodosPath) {
-    try {
-      const absolutePath = path__default.resolve(cwd, resolveTodosPath);
-      const content = fs$1.readFileSync(absolutePath, "utf-8");
-      customMap = JSON.parse(content);
-      printInfo(`Loaded resolution map from ${resolveTodosPath}`);
-    } catch {
-      printWarn(
-        `Could not load resolve map from ${resolveTodosPath}. Ensure the file exists and is valid JSON.`
-      );
-      return;
-    }
-  }
-  if (audit) {
-    printInfo("Audit mode \u2014 scanning for unrecognized classes to generate a mapping file...");
-  } else if (dryRun) {
-    printInfo("Dry run mode \u2014 no files will be modified");
-  }
-  const log = createLogFile(cwd);
-  log.writeLine(
-    `Mode: ${audit ? "audit" : dryRun ? "dry-run" : "migrate"}${resolveTodosPath ? ` (resolve-todos: ${resolveTodosPath})` : ""}`
-  );
-  log.writeLine(`injectTodos: ${injectTodos}`);
-  log.writeLine("");
-  if (!isGitignored(cwd, ".csszyx")) {
-    printWarn(
-      "Tip: add .csszyx/ to your .gitignore to exclude migration logs from version control."
-    );
-  }
-  const patterns = options.pattern ? [options.pattern] : ["**/*.{jsx,tsx,html}"];
-  const ignore = [
-    "**/node_modules/**",
-    "**/dist/**",
-    "**/build/**",
-    "**/.next/**",
-    "**/.nuxt/**",
-    ...ignorePatterns
-  ];
-  const s = spinner.start("Scanning for files...");
-  try {
-    files = await fg(patterns, { cwd, ignore, absolute: true });
-  } catch (err) {
-    s.fail("File scan failed");
-    printWarn(`Could not scan files: ${err instanceof Error ? err.message : String(err)}`);
-    log.flush();
-    return;
-  }
-  s.succeed(`Found ${files.length} files`);
-  if (files.length === 0) {
-    printWarn(
-      options.pattern ? `No files found matching pattern: ${options.pattern}` : "No JSX/TSX/HTML files found"
-    );
-    log.writeLine("No files found.");
-    log.flush();
-    return;
-  }
-  let totalTransformed = 0;
-  let totalSkipped = 0;
-  let totalSkippedComponent = 0;
-  let totalFiles = 0;
-  const allUnrecognized = [];
-  const allWarnings = [];
-  const unusedImportFiles = [];
-  const s2 = spinner.start("Migrating...");
-  for (const filePath of files) {
-    const source = fs$1.readFileSync(filePath, "utf-8");
-    const isHtml = filePath.endsWith(".html");
-    const hasRelevantAttr = isHtml ? source.includes("class=") : source.includes("className=");
-    if (!hasRelevantAttr) {
-      continue;
-    }
-    let processSource = source;
-    if (resolveTodosPath && !isHtml) {
-      processSource = processSource.replace(
-        /\{\/\*\s*@sz-todo:\s*(\S(?:.*\S)?)\s*\*\/\}\n?/g,
-        ""
-      );
-    }
-    const result = isHtml ? transformHtmlSourceSimple(processSource, filePath, {
-      braces: options.braces,
-      injectFouc: options.injectFouc,
-      injectRuntime: options.injectRuntime,
-      cdnUrl: options.cdnUrl,
-      localPath: options.localPath
-    }) : transformSource(processSource, filePath, { injectTodos, customMap });
-    allWarnings.push(...result.warnings);
-    if (result.changed) {
-      totalFiles++;
-      totalTransformed += result.stats.classNamesTransformed;
-      totalSkipped += result.stats.classNamesSkipped;
-      totalSkippedComponent += result.stats.classNamesSkippedComponent;
-      allUnrecognized.push(...result.stats.classesUnrecognized);
-      if (result.potentiallyUnusedImports.length > 0) {
-        const rel2 = path__default.relative(cwd, filePath);
-        unusedImportFiles.push({ file: rel2, imports: result.potentiallyUnusedImports });
-      }
-      if (!dryRun) {
-        try {
-          fs$1.writeFileSync(filePath, result.code, "utf-8");
-        } catch (err) {
-          const rel2 = path__default.relative(cwd, filePath);
-          printWarn(
-            `Could not write ${rel2}: ${err instanceof Error ? err.message : String(err)}`
-          );
-          log.writeLine(`  Write error: ${rel2}`);
-          continue;
-        }
-      }
-      const rel = path__default.relative(cwd, filePath);
-      if (dryRun) {
-        printInfo(`  ${rel}: ${result.stats.classNamesTransformed} className(s) \u2192 sz`);
-        log.writeLine(`  ${rel}: ${result.stats.classNamesTransformed} className(s) \u2192 sz`);
-      } else {
-        log.writeLine(`  ${rel}: ${result.stats.classNamesTransformed} className(s) \u2192 sz`);
-      }
-    }
-  }
-  s2.succeed("Migration complete");
-  console.info();
-  printSuccess(`Files modified: ${totalFiles}`);
-  printSuccess(`classNames converted: ${totalTransformed}`);
-  log.writeLine(`Files modified: ${totalFiles}`);
-  log.writeLine(`classNames converted: ${totalTransformed}`);
-  if (totalSkipped > 0) {
-    printWarn(`classNames skipped (dynamic): ${totalSkipped}`);
-    log.writeLine(`classNames skipped (dynamic): ${totalSkipped}`);
-  }
-  if (totalSkippedComponent > 0) {
-    printWarn(`classNames kept on components (no sz support): ${totalSkippedComponent}`);
-    log.writeLine(`classNames kept on components (no sz support): ${totalSkippedComponent}`);
-  }
-  if (allUnrecognized.length > 0) {
-    const unique = [...new Set(allUnrecognized)];
-    printWarn(
-      `Unrecognized classes (${unique.length}): ${unique.slice(0, 10).join(", ")}${unique.length > 10 ? "..." : ""}`
-    );
-    log.writeLine(`Unrecognized classes (${unique.length}): ${unique.join(", ")}`);
-  }
-  if (allWarnings.length > 0) {
-    console.info();
-    for (const w of allWarnings.slice(0, 5)) {
-      printWarn(w);
-    }
-    if (allWarnings.length > 5) {
-      printWarn(`... and ${allWarnings.length - 5} more warnings`);
-    }
-    log.writeLine("");
-    log.writeLine("Warnings:");
-    for (const w of allWarnings) {
-      log.writeLine(`  ${w}`);
-    }
-  }
-  if (audit) {
-    const todoPath = path__default.join(cwd, ".csszyx-todo.json");
-    const unique = [...new Set(allUnrecognized)];
-    console.info();
-    if (unique.length === 0) {
-      printSuccess(
-        "Audit complete. 100% of your classes are perfectly recognized by csszyx!"
-      );
-      log.writeLine("Audit: 100% recognized.");
-    } else {
-      const todoObj = {};
-      for (const u of unique) {
-        todoObj[u] = "sz:todo";
-      }
-      try {
-        fs$1.writeFileSync(todoPath, JSON.stringify(todoObj, null, 2));
-      } catch (err) {
-        printWarn(
-          `Could not write ${path__default.relative(cwd, todoPath)}: ${err instanceof Error ? err.message : String(err)}`
-        );
-        log.flush();
-        return;
-      }
-      printSuccess(
-        `Audit complete. Exported ${unique.length} unrecognized classes to ${path__default.relative(cwd, todoPath)}.`
-      );
-      printInfo(
-        "Edit this file to map custom classes, then run: npx @csszyx/cli migrate --resolve-todos .csszyx-todo.json"
-      );
-      log.writeLine(
-        `Audit: ${unique.length} unrecognized classes written to ${path__default.relative(cwd, todoPath)}`
-      );
-    }
-  }
-  if (resolveTodosPath) {
-    const unique = [...new Set(allUnrecognized)];
-    if (unique.length > 0) {
-      console.info();
-      printWarn(
-        `Still unresolved after this pass (${unique.length}): ${unique.slice(0, 10).join(", ")}${unique.length > 10 ? "..." : ""}`
-      );
-      printInfo("Re-run --audit to generate a fresh snapshot when ready.");
-      log.writeLine(`Still unresolved (${unique.length}): ${unique.join(", ")}`);
-    }
-  }
-  if (unusedImportFiles.length > 0) {
-    console.info();
-    printWarn("Potentially unused imports (run ESLint to clean up):");
-    for (const { file, imports } of unusedImportFiles) {
-      printInfo(`  ${file}: ${imports.map((i) => `import { ${i} }`).join(", ")}`);
-      log.writeLine(`  Unused import in ${file}: ${imports.join(", ")}`);
-    }
-  }
-  try {
-    log.flush();
-    printInfo(`Migration log saved to ${path__default.relative(cwd, log.filePath)}`);
-  } catch {
-  }
-}
-
-const DEFAULT_NEXT_SOURCE_PATTERN = "{app,pages,src}/**/*.{ts,tsx,js,jsx,mjs,cjs}";
-const DEFAULT_NEXT_SOURCE_IGNORE = [
-  "node_modules/**",
-  ".git/**",
-  ".next/**",
-  ".next-turbo-*/**",
-  ".csszyx/**",
-  "dist/**",
-  "build/**"
-];
-
-async function nextPrebuild(options = {}) {
-  const cwd = path__default.resolve(options.cwd ?? process.cwd());
-  const root = path__default.resolve(options.root ?? cwd);
-  const pattern = options.pattern ?? DEFAULT_NEXT_SOURCE_PATTERN;
-  try {
-    const mode = normalizeMode(options.mode);
-    const parserMode = normalizeParserMode$1(options.parserMode);
-    const matches = await fg(pattern, {
-      cwd: root,
-      absolute: true,
-      ignore: [...DEFAULT_NEXT_SOURCE_IGNORE, ...options.extraIgnore ?? []],
-      dot: false,
-      onlyFiles: true
-    });
-    if (matches.length === 0) {
-      const message = `No source files matched pattern \`${pattern}\` under ${root}.`;
-      if (options.json) {
-        console.log(
-          JSON.stringify(
-            { ok: false, reason: "no-files-matched", root, pattern, mode },
-            null,
-            2
-          )
-        );
-      } else {
-        console.error(`${colors.error(icons.error)} ${message}`);
-      }
-      return 1;
-    }
-    const result = runNextPrebuild({
-      files: matches,
-      explicitRoot: root,
-      cwd,
-      mode,
-      parserMode,
-      safelistOutputFile: options.outputFile,
-      cacheDir: options.cacheDir,
-      config: { mangleVars: false }
-      // Versions intentionally omitted: runNextPrebuild's package.json
-      // fallback reads the real installed @csszyx/unplugin and
-      // @csszyx/compiler versions so the manifest's generation identity
-      // tracks the engine that actually runs the transform.
-    });
-    if (options.json) {
-      console.log(
-        JSON.stringify(
-          {
-            ok: true,
-            root,
-            mode,
-            scannedCount: result.scannedCount,
-            transformedCount: result.transformedCount,
-            skippedMissingCount: result.skippedMissingCount,
-            sourceCount: result.sourceCount,
-            classCount: result.classCount,
-            manifestPath: result.manifestPath,
-            safelistOutputPath: result.safelistOutputPath
-          },
-          null,
-          2
-        )
-      );
-    } else {
-      console.log(`${colors.success(icons.success)} csszyx next prebuild done`);
-      console.log(`  root:        ${root}`);
-      console.log(`  mode:        ${mode}`);
-      console.log(`  scanned:     ${result.scannedCount}`);
-      console.log(`  transformed: ${result.transformedCount}`);
-      console.log(`  skipped:     ${result.skippedMissingCount}`);
-      console.log(`  sources:     ${result.sourceCount}`);
-      console.log(`  classes:     ${result.classCount}`);
-      console.log(`  safelist:    ${result.safelistOutputPath}`);
-      console.log(`  manifest:    ${result.manifestPath}`);
-    }
-    return 0;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    if (options.json) {
-      console.log(JSON.stringify({ ok: false, reason: message }, null, 2));
-    } else {
-      console.error(`${colors.error(icons.error)} ${message}`);
-    }
-    return 1;
-  }
-}
-function normalizeMode(mode) {
-  if (mode === void 0) {
-    return "production";
-  }
-  if (mode === "development" || mode === "production") {
-    return mode;
-  }
-  throw new Error(`Invalid --mode "${mode}". Expected "development" or "production".`);
-}
-function normalizeParserMode$1(parserMode) {
-  if (parserMode === void 0) {
-    return void 0;
-  }
-  if (parserMode === "rust" || parserMode === "oxc" || parserMode === "babel") {
-    return parserMode;
-  }
-  throw new Error(`Invalid --parser-mode "${parserMode}". Expected "rust", "oxc", or "babel".`);
-}
-
-const SOURCE_EXTENSION = /\.[cm]?[jt]sx?$/i;
-async function startNextWatch(options = {}, dependencies = {}) {
-  const cwd = path.resolve(options.cwd ?? process.cwd());
-  const root = path.resolve(options.root ?? cwd);
-  const pattern = options.pattern ?? DEFAULT_NEXT_SOURCE_PATTERN;
-  const ignore = [...DEFAULT_NEXT_SOURCE_IGNORE, ...options.extraIgnore ?? []];
-  const parserMode = normalizeParserMode(options.parserMode);
-  const debounceMs = normalizeDebounceMs(options.debounceMs);
-  const files = await fg(pattern, {
-    cwd: root,
-    absolute: true,
-    ignore,
-    dot: false,
-    onlyFiles: true
-  });
-  if (files.length === 0) {
-    throw new Error(`No source files matched pattern \`${pattern}\` under ${root}.`);
-  }
-  const prebuild = runNextPrebuild({
-    files,
-    explicitRoot: root,
-    cwd,
-    mode: "development",
-    parserMode,
-    safelistOutputFile: options.outputFile,
-    cacheDir: options.cacheDir,
-    config: { mangleVars: false }
-  });
-  let resolveFailure = () => {
-  };
-  let failed = false;
-  const failure = new Promise((resolve) => {
-    resolveFailure = resolve;
-  });
-  const reportFailure = (error) => {
-    if (failed) {
-      return;
-    }
-    failed = true;
-    resolveFailure(error instanceof Error ? error : new Error(String(error)));
-  };
-  const controller = new NextSafelistWatcher({
-    context: prebuild.context,
-    debounceMs,
-    onError: reportFailure
-  });
-  const watchFactory = dependencies.watch ?? watch;
-  const fsWatcher = watchFactory(root, {
-    ignoreInitial: true,
-    persistent: true,
-    atomic: true,
-    awaitWriteFinish: {
-      stabilityThreshold: 25,
-      pollInterval: 10
-    },
-    ignored: createIgnoredMatcher(root, prebuild.context.safelist.shardsDir, ignore)
-  });
-  fsWatcher.on("all", (event, filePath) => {
-    const absolutePath = path.resolve(filePath);
-    if (event === "add" || event === "change" || event === "unlink") {
-      if (controller.notify(event, absolutePath) || event !== "unlink" || !SOURCE_EXTENSION.test(absolutePath)) {
-        return;
-      }
-      controller.notifySourceRemoval(absolutePath);
-    }
-  });
-  fsWatcher.on("error", reportFailure);
-  try {
-    await waitForWatcherReady(fsWatcher);
-    controller.start();
-  } catch (error) {
-    await fsWatcher.close();
-    controller.close();
-    throw error;
-  }
-  let closed = false;
-  return {
-    root,
-    sourcePattern: pattern,
-    safelistOutputPath: prebuild.safelistOutputPath,
-    manifestPath: prebuild.manifestPath,
-    failure,
-    close: async () => {
-      if (closed) {
-        return;
-      }
-      closed = true;
-      await fsWatcher.close();
-      controller.close();
-    }
-  };
-}
-async function nextWatch(options = {}) {
-  let session;
-  let exitCode = 0;
-  try {
-    session = await startNextWatch(options);
-    if (!options.silent) {
-      console.log(`${colors.success(icons.success)} csszyx next watch ready`);
-      console.log(`  root:     ${session.root}`);
-      console.log(`  pattern:  ${session.sourcePattern}`);
-      console.log(`  safelist: ${session.safelistOutputPath}`);
-      console.log(`  manifest: ${session.manifestPath}`);
-    }
-    const outcome = await waitForShutdown(session.failure);
-    if (outcome) {
-      console.error(`${colors.error(icons.error)} ${outcome.message}`);
-      exitCode = 1;
-    }
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    console.error(`${colors.error(icons.error)} ${message}`);
-    exitCode = 1;
-  }
-  try {
-    await session?.close();
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    console.error(`${colors.error(icons.error)} Failed to close Next watcher: ${message}`);
-    exitCode = 1;
-  }
-  return exitCode;
-}
-function waitForWatcherReady(watcher) {
-  return new Promise((resolve, reject) => {
-    const onReady = () => {
-      watcher.off("error", onStartupError);
-      resolve();
-    };
-    const onStartupError = (error) => {
-      watcher.off("ready", onReady);
-      reject(error);
-    };
-    watcher.once("ready", onReady);
-    watcher.once("error", onStartupError);
-  });
-}
-function waitForShutdown(failure) {
-  return new Promise((resolve) => {
-    const cleanup = () => {
-      process.off("SIGINT", onSignal);
-      process.off("SIGTERM", onSignal);
-    };
-    const onSignal = () => {
-      cleanup();
-      resolve(void 0);
-    };
-    process.once("SIGINT", onSignal);
-    process.once("SIGTERM", onSignal);
-    failure.then((error) => {
-      cleanup();
-      resolve(error);
-    });
-  });
-}
-function createIgnoredMatcher(root, shardsDir, ignore) {
-  const normalizedShardsDir = path.resolve(shardsDir);
-  const matchers = ignore.flatMap((pattern) => {
-    const normalized = pattern.replace(/\\/g, "/");
-    const variants = normalized.endsWith("/**") ? [normalized, normalized.slice(0, -3)] : [normalized];
-    return variants.map((variant) => new Minimatch(variant, { dot: true }));
-  });
-  return (candidate) => {
-    const absolute = path.resolve(candidate);
-    const relativeToShards = path.relative(absolute, normalizedShardsDir);
-    if (absolute === normalizedShardsDir || absolute.startsWith(`${normalizedShardsDir}${path.sep}`) || relativeToShards !== ".." && !relativeToShards.startsWith(`..${path.sep}`) && !path.isAbsolute(relativeToShards)) {
-      return false;
-    }
-    const relative = path.relative(root, absolute).replace(/\\/g, "/");
-    if (!relative || relative.startsWith("../") || path.isAbsolute(relative)) {
-      return false;
-    }
-    return matchers.some((matcher) => matcher.match(relative));
-  };
-}
-function normalizeParserMode(parserMode) {
-  if (parserMode === void 0) {
-    return void 0;
-  }
-  if (parserMode === "rust" || parserMode === "oxc" || parserMode === "babel") {
-    return parserMode;
-  }
-  throw new Error(`Invalid --parser-mode "${parserMode}". Expected "rust", "oxc", or "babel".`);
-}
-function normalizeDebounceMs(debounceMs) {
-  if (debounceMs === void 0) {
-    return void 0;
-  }
-  const parsed = typeof debounceMs === "number" ? debounceMs : Number(debounceMs);
-  if (!Number.isInteger(parsed) || parsed < 0 || parsed > 6e4) {
-    throw new Error("Invalid --debounce-ms. Expected an integer between 0 and 60000.");
-  }
-  return parsed;
-}
-
-const cli = cac("csszyx");
-normalizeNextCommandAlias(process.argv);
-function readCliVersion() {
-  try {
-    const manifest = JSON.parse(
-      readFileSync(new URL("../package.json", import.meta.url), "utf8")
-    );
-    return typeof manifest.version === "string" ? manifest.version : "0.0.0";
-  } catch {
-    return "0.0.0";
-  }
-}
-const VERSION = readCliVersion();
-async function runNextPrebuildCommand(pattern, options) {
-  const code = await nextPrebuild({
-    cwd: options.cwd,
-    root: options.root,
-    mode: options.mode,
-    parserMode: options.parserMode,
-    outputFile: options.outputFile,
-    cacheDir: options.cacheDir,
-    pattern,
-    extraIgnore: options.ignore ? String(options.ignore).split(",") : void 0,
-    json: options.json
-  });
-  if (code !== 0) {
-    process.exit(code);
-  }
-}
-async function runNextWatchCommand(pattern, options) {
-  const code = await nextWatch({
-    cwd: options.cwd,
-    root: options.root,
-    parserMode: options.parserMode,
-    outputFile: options.outputFile,
-    cacheDir: options.cacheDir,
-    pattern,
-    extraIgnore: options.ignore ? String(options.ignore).split(",") : void 0,
-    debounceMs: options.debounceMs
-  });
-  process.exitCode = code;
-}
-cli.command("init", "Setup csszyx in your project").option("--framework <name>", "Specify framework").option("--yes", "Skip prompts (use defaults)").option("--cwd <dir>", "Current working directory").action(async (options) => {
-  await init({
-    framework: options.framework,
-    yes: options.yes,
-    cwd: options.cwd
-  });
-});
-cli.command("doctor", "Diagnose mangling issues").option("--verbose", "Show detailed output").option("--cwd <dir>", "Current working directory").action(async (options) => {
-  await doctor({
-    verbose: options.verbose,
-    cwd: options.cwd
-  });
-});
-cli.command("audit", "Analyze mangling performance").option("--json", "Output as JSON").option("--watch", "Live updates").option("--compare <dir>", "Compare with previous build").option("--cwd <dir>", "Current working directory").action(async (options) => {
-  await audit({
-    json: options.json,
-    watch: options.watch,
-    compare: options.compare,
-    cwd: options.cwd
-  });
-});
-cli.command("generate-types", "Generate TypeScript declarations from tailwind.config.js").option("-c, --config <path>", "Path to tailwind.config.js").option("-o, --output <path>", "Output file path (default: ./csszyx.d.ts)").option("--cwd <dir>", "Current working directory").option("--silent", "Silent mode (no output)").action(async (options) => {
-  await generateTypes({
-    config: options.config,
-    output: options.output,
-    cwd: options.cwd,
-    silent: options.silent
-  });
-});
-cli.command("migrate [dir]", "Convert Tailwind className to sz prop").option("--dry-run", "Show changes without modifying files").option("--ignore <patterns>", "Glob patterns to ignore (comma-separated)").option("--pattern <glob>", "Custom glob pattern for file discovery").option("--cwd <dir>", "Current working directory").option("--braces", "Wrap HTML sz values in outer { } braces (default: bare)").option("--no-fouc", "Skip FOUC-prevention CSS injection into HTML files").option("--inject-runtime <mode>", "Inject runtime script into HTML: local | cdn").option("--cdn-url <url>", "Custom CDN URL for --inject-runtime cdn").option(
-  "--local-path <path>",
-  "Local script path for --inject-runtime local (default: csszyx-runtime.js)"
-).option("--audit", "Scan without modifying files and output .csszyx-todo.json").option("--inject-todos", "Inject {/* @sz-todo */} comments above unrecognized classes").option("--resolve-todos <file>", "Path to a JSON file mapping custom classes to sz properties").action(async (dir, options) => {
-  await migrate({
-    dryRun: options.dryRun,
-    ignore: options.ignore ? options.ignore.split(",") : void 0,
-    pattern: options.pattern,
-    cwd: dir || options.cwd,
-    braces: options.braces,
-    injectFouc: options.fouc !== false,
-    injectRuntime: options.injectRuntime === "local" ? "local" : options.injectRuntime === "cdn" ? "cdn" : false,
-    cdnUrl: options.cdnUrl,
-    localPath: options.localPath,
-    audit: options.audit,
-    injectTodos: options.injectTodos,
-    resolveTodos: options.resolveTodos
-  });
-});
-cli.command(
-  "next-prebuild [pattern]",
-  "Seed the Next.js Turbopack csszyx safelist and generation manifest"
-).option("--root <dir>", "Next app root (defaults to cwd)").option("--cwd <dir>", "Current working directory").option("--mode <mode>", "development | production (default: production)").option("--parser-mode <mode>", "rust | oxc | babel (default: rust)").option(
-  "--output-file <path>",
-  "Tailwind @source safelist output (default: csszyx-classes.html)"
-).option("--cache-dir <dir>", "Cache directory relative to root (default: .csszyx/cache)").option("--ignore <patterns>", "Extra glob patterns to ignore (comma-separated)").option("--json", "Emit a single JSON result instead of formatted text").action(runNextPrebuildCommand);
-cli.command("next-watch [pattern]", "Maintain the Next.js Turbopack csszyx safelist").option("--root <dir>", "Next app root (defaults to cwd)").option("--cwd <dir>", "Current working directory").option("--parser-mode <mode>", "rust | oxc | babel (default: rust)").option(
-  "--output-file <path>",
-  "Tailwind @source safelist output (default: csszyx-classes.html)"
-).option("--cache-dir <dir>", "Cache directory relative to root (default: .csszyx/cache)").option("--ignore <patterns>", "Extra glob patterns to ignore (comma-separated)").option("--debounce-ms <ms>", "Safelist materialization debounce (default: 50)").action(runNextWatchCommand);
-cli.command("").action(() => {
-  cli.outputHelp();
-});
-cli.help();
-cli.version(VERSION);
-cli.parse();
-function normalizeNextCommandAlias(argv) {
-  if (argv[2] === "next" && (argv[3] === "prebuild" || argv[3] === "watch")) {
-    argv.splice(2, 2, `next-${argv[3]}`);
-  }
-}
-
-export { classNameToSzObject, extractScreenKeys, extractSpacingKeys, findConfigFile, flattenColors, generateAndWriteTypes, generateTypeDeclarations, generateTypes, transformSource as migrateSource, scanTailwindConfig, writeDeclarationFile };
+export { c as classNameToSzObject, e as extractScreenKeys, a as extractSpacingKeys, f as findConfigFile, b as flattenColors, g as generateAndWriteTypes, d as generateTypeDeclarations, h as generateTypes, t as migrateSource, s as scanTailwindConfig, w as writeDeclarationFile } from './shared/cli.C2lx9IpE.mjs';
+import 'node:path';
+import 'node:fs';
+import 'node:fs/promises';
+import 'node:url';
+import 'tailwindcss/resolveConfig.js';
+import '@babel/parser';
+import '@babel/types';
+import '@csszyx/compiler';