@csszyx/unplugin 0.7.0 → 0.9.0

package/dist/shared/unplugin.BEOG6ePC.mjs

@@ -0,0 +1,2159 @@
+import * as fs from 'node:fs';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import * as path from 'node:path';
+import { dirname } from 'node:path';
+import { performance } from 'node:perf_hooks';
+import { fileURLToPath } from 'node:url';
+import { ensureRustTransformAvailable, transformSourceCode, transformRust, transformOxc, transform } from '@csszyx/compiler';
+import { encode, compute_mangle_checksum } from '@csszyx/core';
+import { preprocess as preprocess$1 } from '@csszyx/svelte-adapter';
+import { DEFAULT_BUILD_CONFIG } from '@csszyx/types';
+import { preprocess } from '@csszyx/vue-adapter';
+import { createUnplugin } from 'unplugin';
+import { mangleCSSSync } from '../css-mangler.mjs';
+import { createHash } from 'node:crypto';
+
+const SERVER_DIRECTIVE_RE = /^['"]use server['"];?$/;
+const CLIENT_DIRECTIVE_RE = /^['"]use client['"];?$/;
+const RUNTIME_HELPER_MODULES = /* @__PURE__ */ new Set([
+  "@csszyx/runtime",
+  "@csszyx/runtime/lite",
+  "csszyx",
+  "csszyx/lite"
+]);
+const CLIENT_RUNTIME_MODULES = /* @__PURE__ */ new Set(["csszyx/browser"]);
+const CLIENT_RUNTIME_MODULE_ROOTS = ["@csszyx/dynamic", "csszyx/dynamic"];
+const normalizedModuleIdCache = /* @__PURE__ */ new Map();
+const resolvedLocalModuleCache = /* @__PURE__ */ new Map();
+const FORBIDDEN_SYMBOLS = /* @__PURE__ */ new Set([
+  "_sz",
+  "_sz2",
+  "_sz3",
+  "_szIf",
+  "_szMerge",
+  "_szSwitch",
+  "__csszyx_runtime__"
+]);
+function hasUseServerDirective(code) {
+  for (const statement of readDirectivePrologue(code)) {
+    if (SERVER_DIRECTIVE_RE.test(statement)) {
+      return true;
+    }
+    if (CLIENT_DIRECTIVE_RE.test(statement)) {
+      return false;
+    }
+  }
+  return false;
+}
+function hasUseClientDirective(code) {
+  for (const statement of readDirectivePrologue(code)) {
+    if (CLIENT_DIRECTIVE_RE.test(statement)) {
+      return true;
+    }
+    if (SERVER_DIRECTIVE_RE.test(statement)) {
+      return false;
+    }
+  }
+  return false;
+}
+function isRSCServerModule(code, id) {
+  if (hasUseServerDirective(code)) {
+    return true;
+  }
+  if (hasUseClientDirective(code)) {
+    return false;
+  }
+  return isNextAppRouterEntry(id);
+}
+function findRSCBoundaryViolation(code, id) {
+  if (!isRSCServerModule(code, id)) {
+    return null;
+  }
+  for (const imported of findRuntimeImports(code)) {
+    for (const symbol of imported.symbols) {
+      if (FORBIDDEN_SYMBOLS.has(symbol)) {
+        return {
+          symbol,
+          path: id,
+          importChain: [id, imported.source]
+        };
+      }
+    }
+  }
+  return null;
+}
+function createRSCModuleRecord(code, id) {
+  const normalized = normalizeModuleId(id);
+  return {
+    id: normalized,
+    isServer: isRSCServerModule(code, normalized),
+    isClient: hasUseClientDirective(code),
+    imports: findLocalImportSources(code).map((source) => resolveLocalModule(normalized, source)).filter((resolved) => resolved !== null),
+    runtimeImports: findRuntimeImports(code).filter(
+      (imported) => imported.symbols.some((symbol) => FORBIDDEN_SYMBOLS.has(symbol))
+    )
+  };
+}
+function deleteRSCModuleRecord(records, id) {
+  const normalized = normalizeModuleId(id);
+  const clean = id.split("?")[0]?.replace(/\\/g, "/") ?? id;
+  const resolved = path.resolve(clean).replace(/\\/g, "/");
+  pruneRSCModulePathCaches(/* @__PURE__ */ new Set([normalized, resolved, clean]));
+  let deleted = records.delete(normalized);
+  if (resolved !== normalized) {
+    deleted = records.delete(resolved) || deleted;
+  }
+  if (clean !== normalized && clean !== resolved) {
+    deleted = records.delete(clean) || deleted;
+  }
+  return deleted;
+}
+function findRSCGraphViolation(records) {
+  for (const root of records.values()) {
+    if (!root.isServer) {
+      continue;
+    }
+    const violation = walkRSCGraph(root, records, [root.id], /* @__PURE__ */ new Set([root.id]));
+    if (violation) {
+      return {
+        symbol: violation.symbol,
+        path: root.id,
+        importChain: violation.importChain
+      };
+    }
+  }
+  return null;
+}
+function assertNoRSCGraphViolation(records) {
+  const violation = findRSCGraphViolation(records);
+  if (!violation) {
+    return;
+  }
+  throw new Error(formatRSCViolation(violation));
+}
+const APP_ROUTER_ENTRIES = /* @__PURE__ */ new Set([
+  "page",
+  "layout",
+  "template",
+  "loading",
+  "error",
+  "not-found",
+  "global-error",
+  "default",
+  "route"
+]);
+function isNextAppRouterEntry(id) {
+  const clean = id.split("?")[0]?.replace(/\\/g, "/") ?? id;
+  if (!clean.includes("/app/") && !clean.startsWith("app/")) return false;
+  const basename = clean.split("/").pop() ?? "";
+  const dotIdx = basename.indexOf(".");
+  if (dotIdx === -1) return false;
+  const stem = basename.slice(0, dotIdx);
+  const ext = basename.slice(dotIdx + 1);
+  return APP_ROUTER_ENTRIES.has(stem) && /^[cm]?[tj]sx?$/.test(ext);
+}
+function assertNoRSCBoundaryViolation(code, id) {
+  const violation = findRSCBoundaryViolation(code, id);
+  if (!violation) {
+    return;
+  }
+  throw new Error(formatRSCViolation(violation));
+}
+function formatRSCViolation(violation) {
+  return `csszyxRSCViolation: ${violation.symbol} imported in Server Component ${violation.path}
+  Import chain: ${violation.importChain.join(" -> ")}`;
+}
+function walkRSCGraph(current, records, chain, seen) {
+  if (current.isClient) {
+    return null;
+  }
+  const runtime = current.runtimeImports[0];
+  const symbol = runtime?.symbols.find((s) => FORBIDDEN_SYMBOLS.has(s));
+  if (runtime && symbol) {
+    return {
+      symbol,
+      path: chain[0] ?? current.id,
+      importChain: [...chain, runtime.source]
+    };
+  }
+  for (const importedId of current.imports) {
+    if (seen.has(importedId)) {
+      continue;
+    }
+    const next = records.get(importedId);
+    if (!next) {
+      continue;
+    }
+    seen.add(importedId);
+    const violation = walkRSCGraph(next, records, [...chain, importedId], seen);
+    if (violation) {
+      return violation;
+    }
+  }
+  return null;
+}
+function readDirectivePrologue(code) {
+  const out = [];
+  let i = code.charCodeAt(0) === 65279 ? 1 : 0;
+  while (i < code.length) {
+    i = skipWhitespaceAndComments(code, i);
+    const quote = code[i];
+    if (quote !== '"' && quote !== "'") {
+      break;
+    }
+    let j = i + 1;
+    let escaped = false;
+    while (j < code.length) {
+      const ch = code[j];
+      if (escaped) {
+        escaped = false;
+      } else if (ch === "\\") {
+        escaped = true;
+      } else if (ch === quote) {
+        break;
+      }
+      j++;
+    }
+    if (j >= code.length) {
+      break;
+    }
+    let end = j + 1;
+    while (end < code.length && /[ \t\r\n]/.test(code[end])) {
+      end++;
+    }
+    if (code[end] === ";") {
+      end++;
+    }
+    out.push(code.slice(i, end).trim());
+    i = end;
+  }
+  return out;
+}
+function skipWhitespaceAndComments(code, start) {
+  let i = start;
+  while (i < code.length) {
+    while (i < code.length && /\s/.test(code[i])) {
+      i++;
+    }
+    if (code.startsWith("//", i)) {
+      const next = code.indexOf("\n", i + 2);
+      i = next === -1 ? code.length : next + 1;
+      continue;
+    }
+    if (code.startsWith("/*", i)) {
+      const next = code.indexOf("*/", i + 2);
+      i = next === -1 ? code.length : next + 2;
+      continue;
+    }
+    break;
+  }
+  return i;
+}
+function findRuntimeImports(code) {
+  const imports = [];
+  const scanCode = stripCommentsForImportScan(code);
+  const staticImportRe = /import\s+(?!type\b)(\S(?:.*\S)?)\s+from\s+['"]([^'"]+)['"]/g;
+  const sideEffectImportRe = /import\s+['"]([^'"]+)['"]/g;
+  const dynamicImportRe = /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+  for (const match of scanCode.matchAll(staticImportRe)) {
+    const clause = match[1];
+    const source = match[2];
+    if (!isRuntimeImportSource(source)) {
+      continue;
+    }
+    imports.push({ source, symbols: readRuntimeImportSymbols(source, clause) });
+  }
+  for (const match of scanCode.matchAll(sideEffectImportRe)) {
+    const source = match[1];
+    if (isRuntimeImportSource(source)) {
+      imports.push({
+        source,
+        symbols: isWholeRuntimeModuleForbidden(source) ? Array.from(FORBIDDEN_SYMBOLS) : []
+      });
+    }
+  }
+  for (const match of scanCode.matchAll(dynamicImportRe)) {
+    const source = match[1];
+    if (isRuntimeImportSource(source)) {
+      imports.push({ source, symbols: Array.from(FORBIDDEN_SYMBOLS) });
+    }
+  }
+  return imports;
+}
+function isRuntimeImportSource(source) {
+  return RUNTIME_HELPER_MODULES.has(source) || source.startsWith("@csszyx/runtime/") || CLIENT_RUNTIME_MODULES.has(source) || CLIENT_RUNTIME_MODULE_ROOTS.some((root) => source === root || source.startsWith(`${root}/`));
+}
+function isWholeRuntimeModuleForbidden(source) {
+  return source.startsWith("@csszyx/runtime/") || CLIENT_RUNTIME_MODULES.has(source) || CLIENT_RUNTIME_MODULE_ROOTS.some((root) => source === root || source.startsWith(`${root}/`));
+}
+function readRuntimeImportSymbols(source, clause) {
+  if (isWholeRuntimeModuleForbidden(source)) {
+    return Array.from(FORBIDDEN_SYMBOLS);
+  }
+  return readImportedSymbols(clause);
+}
+function findLocalImportSources(code) {
+  const out = [];
+  const staticImportRe = /import\s+(?!type\b)(?:\S(?:.*\S)?\s+from\s+)?['"]([^'"]+)['"]/g;
+  const exportFromRe = /export\s+(?!type\b)\S(?:.*\S)?\s+from\s+['"]([^'"]+)['"]/g;
+  const dynamicImportRe = /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+  for (const re of [staticImportRe, exportFromRe, dynamicImportRe]) {
+    for (const match of code.matchAll(re)) {
+      const source = match[1];
+      if (source.startsWith(".") || source.startsWith("/")) {
+        out.push(source);
+      }
+    }
+  }
+  return out;
+}
+function normalizeModuleId(id) {
+  const clean = id.split("?")[0] ?? id;
+  const cached = normalizedModuleIdCache.get(clean);
+  if (cached) {
+    return cached;
+  }
+  let normalized;
+  try {
+    normalized = fs.realpathSync.native(clean).replace(/\\/g, "/");
+  } catch {
+    normalized = path.resolve(clean).replace(/\\/g, "/");
+  }
+  normalizedModuleIdCache.set(clean, normalized);
+  return normalized;
+}
+function resolveLocalModule(importer, source) {
+  const cacheKey = `${importer}\0${source}`;
+  const cached = resolvedLocalModuleCache.get(cacheKey);
+  if (cached) {
+    return cached;
+  }
+  const base = source.startsWith("/") ? source : path.resolve(path.dirname(importer), source);
+  const candidates = [
+    base,
+    `${base}.tsx`,
+    `${base}.ts`,
+    `${base}.jsx`,
+    `${base}.js`,
+    `${base}.mjs`,
+    `${base}.cjs`,
+    path.join(base, "index.tsx"),
+    path.join(base, "index.ts"),
+    path.join(base, "index.jsx"),
+    path.join(base, "index.js")
+  ];
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {
+      const resolved = normalizeModuleId(candidate);
+      resolvedLocalModuleCache.set(cacheKey, resolved);
+      return resolved;
+    }
+  }
+  return null;
+}
+function pruneRSCModulePathCaches(moduleIds) {
+  for (const [key, value] of normalizedModuleIdCache) {
+    const normalizedKey = key.replace(/\\/g, "/");
+    if (moduleIds.has(value) || moduleIds.has(normalizedKey)) {
+      normalizedModuleIdCache.delete(key);
+    }
+  }
+  for (const [key, value] of resolvedLocalModuleCache) {
+    if (moduleIds.has(value)) {
+      resolvedLocalModuleCache.delete(key);
+    }
+  }
+}
+function readImportedSymbols(clause) {
+  const symbols = [];
+  const named = clause.match(/\{([\s\S]*?)\}/);
+  if (named) {
+    for (const part of named[1].split(",")) {
+      const trimmed = part.trim();
+      if (!trimmed || trimmed.startsWith("type ")) {
+        continue;
+      }
+      const sourceName = trimmed.replace(/^type\s+/, "").split(/\s+as\s+/)[0]?.trim();
+      if (sourceName) {
+        symbols.push(sourceName);
+      }
+    }
+  }
+  if (/\*\s+as\s+\w+/.test(clause)) {
+    symbols.push(...FORBIDDEN_SYMBOLS);
+  }
+  const braceStart = clause.indexOf("{");
+  const braceEnd = clause.indexOf("}", braceStart);
+  const stripped = braceStart !== -1 && braceEnd !== -1 ? clause.slice(0, braceStart) + clause.slice(braceEnd + 1) : clause;
+  const defaultImport = stripped.match(/^\s*([A-Z_$][\w$]*)\s*(?:,|$)/i);
+  const defaultSymbol = defaultImport?.[1];
+  if (defaultSymbol && FORBIDDEN_SYMBOLS.has(defaultSymbol)) {
+    symbols.push(defaultSymbol);
+  }
+  return symbols;
+}
+function stripCommentsForImportScan(code) {
+  let out = "";
+  let i = 0;
+  let quote = null;
+  let escaped = false;
+  while (i < code.length) {
+    const ch = code[i];
+    const next = code[i + 1];
+    if (quote) {
+      out += ch;
+      if (escaped) {
+        escaped = false;
+      } else if (ch === "\\") {
+        escaped = true;
+      } else if (ch === quote) {
+        quote = null;
+      }
+      i++;
+      continue;
+    }
+    if (ch === '"' || ch === "'" || ch === "`") {
+      quote = ch;
+      out += ch;
+      i++;
+      continue;
+    }
+    if (ch === "/" && next === "/") {
+      out += "  ";
+      i += 2;
+      while (i < code.length && code[i] !== "\n") {
+        out += " ";
+        i++;
+      }
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      out += "  ";
+      i += 2;
+      while (i < code.length) {
+        const blockCh = code[i];
+        const blockNext = code[i + 1];
+        if (blockCh === "*" && blockNext === "/") {
+          out += "  ";
+          i += 2;
+          break;
+        }
+        out += blockCh === "\n" ? "\n" : " ";
+        i++;
+      }
+      continue;
+    }
+    out += ch;
+    i++;
+  }
+  return out;
+}
+
+const EMPTY_THEME = { colors: [], spacings: [], fonts: [], radii: [], shadows: [] };
+function stripLayerWrappers(css) {
+  let result = "";
+  let i = 0;
+  while (i < css.length) {
+    const layerIdx = css.indexOf("@layer", i);
+    if (layerIdx === -1) {
+      result += css.slice(i);
+      break;
+    }
+    result += css.slice(i, layerIdx);
+    const openBrace = css.indexOf("{", layerIdx);
+    if (openBrace === -1) {
+      result += css.slice(layerIdx);
+      break;
+    }
+    let depth = 0;
+    let j = openBrace;
+    while (j < css.length) {
+      if (css[j] === "{") {
+        depth++;
+      }
+      if (css[j] === "}") {
+        depth--;
+        if (depth === 0) {
+          result += css.slice(openBrace + 1, j);
+          i = j + 1;
+          break;
+        }
+      }
+      j++;
+    }
+    if (depth !== 0) {
+      result += css.slice(openBrace);
+      break;
+    }
+  }
+  return result;
+}
+function extractThemeBlocks(css) {
+  const blocks = [];
+  const themeStart = /@theme\s+(?:inline\s+)?\{|@theme\{/g;
+  for (const match of css.matchAll(themeStart)) {
+    const openPos = css.indexOf("{", match.index);
+    let depth = 0;
+    let j = openPos;
+    while (j < css.length) {
+      if (css[j] === "{") {
+        depth++;
+      }
+      if (css[j] === "}") {
+        depth--;
+        if (depth === 0) {
+          blocks.push(css.slice(openPos + 1, j));
+          break;
+        }
+      }
+      j++;
+    }
+  }
+  return blocks;
+}
+function categorizeProperty(prop) {
+  const categoryMap = [
+    ["color-", "colors"],
+    ["spacing-", "spacings"],
+    ["font-", "fonts"],
+    ["radius-", "radii"],
+    ["shadow-", "shadows"]
+  ];
+  for (const [prefix, category] of categoryMap) {
+    if (prop.startsWith(prefix)) {
+      let token = prop.slice(prefix.length);
+      token = token.replace(/-\d+$/, "");
+      if (token) {
+        return { category, token };
+      }
+    }
+  }
+  return null;
+}
+function parseThemeBlocks(cssContent) {
+  const result = {
+    colors: /* @__PURE__ */ new Set(),
+    spacings: /* @__PURE__ */ new Set(),
+    fonts: /* @__PURE__ */ new Set(),
+    radii: /* @__PURE__ */ new Set(),
+    shadows: /* @__PURE__ */ new Set()
+  };
+  const stripped = stripLayerWrappers(cssContent);
+  const blocks = extractThemeBlocks(stripped);
+  const propPattern = /--([a-z][a-z0-9-]*)(?:\s*:[^;]+)?;/g;
+  for (const block of blocks) {
+    for (const match of block.matchAll(propPattern)) {
+      const categorized = categorizeProperty(match[1]);
+      if (categorized) {
+        result[categorized.category].add(categorized.token);
+      }
+    }
+  }
+  return {
+    colors: [...result.colors].sort(),
+    spacings: [...result.spacings].sort(),
+    fonts: [...result.fonts].sort(),
+    radii: [...result.radii].sort(),
+    shadows: [...result.shadows].sort()
+  };
+}
+function mergeThemes(themes) {
+  if (themes.length === 0) {
+    return { ...EMPTY_THEME };
+  }
+  const merged = {
+    colors: /* @__PURE__ */ new Set(),
+    spacings: /* @__PURE__ */ new Set(),
+    fonts: /* @__PURE__ */ new Set(),
+    radii: /* @__PURE__ */ new Set(),
+    shadows: /* @__PURE__ */ new Set()
+  };
+  for (const theme of themes) {
+    for (const cat of Object.keys(merged)) {
+      for (const token of theme[cat]) {
+        merged[cat].add(token);
+      }
+    }
+  }
+  return {
+    colors: [...merged.colors].sort(),
+    spacings: [...merged.spacings].sort(),
+    fonts: [...merged.fonts].sort(),
+    radii: [...merged.radii].sort(),
+    shadows: [...merged.shadows].sort()
+  };
+}
+function hasTokens(theme) {
+  return Object.values(theme).some((arr) => arr.length > 0);
+}
+
+const GLOB_MAGIC_RE = /[*?[\]{}]/;
+const DEFAULT_IGNORED_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", ".next", ".turbo", "dist", "build"]);
+function normalizeFileId(id) {
+  return id.split(/[?#]/, 1)[0].replace(/\\/g, "/");
+}
+function normalizeRoot(rootDir) {
+  return path.resolve(rootDir).replace(/\\/g, "/");
+}
+function hasGlobMagic(pattern) {
+  return GLOB_MAGIC_RE.test(pattern);
+}
+function escapeRegExp(ch) {
+  return /[|\\{}()[\]^$+?.]/.test(ch) ? `\\${ch}` : ch;
+}
+function globToRegExp(pattern) {
+  const normalized = pattern.replace(/\\/g, "/");
+  let out = "^";
+  for (let i = 0; i < normalized.length; i++) {
+    const ch = normalized[i];
+    if (ch === "*") {
+      if (normalized[i + 1] === "*") {
+        out += ".*";
+        i++;
+      } else {
+        out += "[^/]*";
+      }
+    } else if (ch === "?") {
+      out += "[^/]";
+    } else {
+      out += escapeRegExp(ch);
+    }
+  }
+  out += "$";
+  return new RegExp(out);
+}
+function relativeToRoot(file, rootDir) {
+  const root = normalizeRoot(rootDir);
+  const normalizedFile = normalizeFileId(file);
+  return path.posix.relative(root, normalizedFile).replace(/\\/g, "/");
+}
+function matchesPattern(id, pattern, rootDir) {
+  const file = normalizeFileId(id);
+  const relative = relativeToRoot(file, rootDir);
+  if (pattern instanceof RegExp) {
+    pattern.lastIndex = 0;
+    return pattern.test(file) || pattern.test(relative);
+  }
+  const normalizedPattern = pattern.replace(/\\/g, "/");
+  if (hasGlobMagic(normalizedPattern)) {
+    const re = globToRegExp(normalizedPattern);
+    return re.test(file) || re.test(relative);
+  }
+  const absolutePattern = path.isAbsolute(normalizedPattern) ? normalizeFileId(normalizedPattern) : normalizeFileId(path.join(rootDir, normalizedPattern));
+  return file === absolutePattern || relative === normalizedPattern;
+}
+function matchesAnyPattern(id, patterns, rootDir) {
+  if (!patterns) {
+    return false;
+  }
+  const list = Array.isArray(patterns) ? patterns : [patterns];
+  return list.some((pattern) => matchesPattern(id, pattern, rootDir));
+}
+function expandFilePatterns(rootDir, patterns) {
+  const list = Array.isArray(patterns) ? patterns : [patterns];
+  const files = /* @__PURE__ */ new Set();
+  const walk = (dir) => {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (!DEFAULT_IGNORED_DIRS.has(entry.name) && !entry.name.startsWith(".")) {
+          walk(full);
+        }
+      } else {
+        files.add(path.resolve(full));
+      }
+    }
+  };
+  let needsWalk = false;
+  for (const pattern of list) {
+    const resolved = path.isAbsolute(pattern) ? pattern : path.join(rootDir, pattern);
+    if (hasGlobMagic(pattern)) {
+      needsWalk = true;
+      continue;
+    }
+    if (fs.existsSync(resolved)) {
+      files.add(path.resolve(resolved));
+    }
+  }
+  if (needsWalk) {
+    walk(rootDir);
+    for (const file of Array.from(files)) {
+      if (!list.some(
+        (pattern) => hasGlobMagic(pattern) && matchesPattern(file, pattern, rootDir)
+      )) {
+        const isLiteralMatch = list.some((pattern) => {
+          if (hasGlobMagic(pattern)) {
+            return false;
+          }
+          const resolved = path.isAbsolute(pattern) ? pattern : path.join(rootDir, pattern);
+          return normalizeFileId(path.resolve(resolved)) === normalizeFileId(file);
+        });
+        if (!isLiteralMatch) {
+          files.delete(file);
+        }
+      }
+    }
+  }
+  return Array.from(files).sort();
+}
+
+function injectChecksum(html, checksum, minify = false) {
+  const attrName = minify ? "data-sz-cs" : "data-sz-checksum";
+  const htmlTagPattern = /<html([^>]*)>/i;
+  const match = html.match(htmlTagPattern);
+  if (!match) {
+    return html;
+  }
+  const existingAttrs = match[1];
+  const checksumAttr = ` ${attrName}="${checksum}"`;
+  return html.replace(htmlTagPattern, `<html${checksumAttr}${existingAttrs}>`);
+}
+function injectMangleMapScript(html, mangleMap, options = {}) {
+  const { prettyPrint = false } = options;
+  const jsonContent = prettyPrint ? JSON.stringify(mangleMap, null, 2) : JSON.stringify(mangleMap);
+  const scriptTag = `<script id="__CSSZYX_MANGLE_MAP__" type="application/json">${jsonContent}<\/script>`;
+  const debugScript = `<script>(function(){var m=${jsonContent};var r={};for(var k in m)r[m[k]]=k;var cs=document.documentElement.getAttribute("data-sz-checksum")||"";window.__csszyx={mangleMap:m,checksum:cs,decode:function(c){return r[c]},encode:function(c){return m[c]},decodeAll:function(el){return(el.className||"").split(" ").map(function(c){return r[c]||c})}}})()<\/script>`;
+  const combined = `${scriptTag}
+${debugScript}`;
+  if (html.includes("</head>")) {
+    return html.replace("</head>", `${combined}
+</head>`);
+  } else if (html.includes("</html>")) {
+    return html.replace("</html>", `${combined}
+</html>`);
+  }
+  return html + combined;
+}
+function injectMangleMapAttribute(html, mangleMap, minify = false) {
+  const attrName = minify ? "data-sz-m" : "data-sz-map";
+  const jsonContent = JSON.stringify(mangleMap);
+  const htmlTagPattern = /<html([^>]*)>/i;
+  const match = html.match(htmlTagPattern);
+  if (!match) {
+    return html;
+  }
+  const existingAttrs = match[1];
+  const mapAttr = ` ${attrName}='${jsonContent}'`;
+  return html.replace(htmlTagPattern, `<html${mapAttr}${existingAttrs}>`);
+}
+function injectHydrationData(html, mangleMap, checksum, options = {}) {
+  const { mode = "script", minify = false } = options;
+  let result = html;
+  result = injectChecksum(result, checksum, minify);
+  if (mode === "inline") {
+    result = injectMangleMapAttribute(result, mangleMap, minify);
+  } else if (mode === "script") {
+    result = injectMangleMapScript(result, mangleMap, options);
+  } else if (mode === "both") {
+    result = injectMangleMapAttribute(result, mangleMap, minify);
+    result = injectMangleMapScript(result, mangleMap, options);
+  }
+  return result;
+}
+function transformIndexHtml(html, mangleMap, checksum, options = {}) {
+  return injectHydrationData(html, mangleMap, checksum, options);
+}
+function buildRecoveryManifest(tokens, options) {
+  const stripped = options.production === true;
+  const strippedDevOnlyPaths = [];
+  const sorted = {};
+  const sortedKeys = [...tokens.keys()].sort();
+  for (const key of sortedKeys) {
+    const data = tokens.get(key);
+    if (!data) {
+      continue;
+    }
+    if (stripped && data.mode === "dev-only") {
+      strippedDevOnlyPaths.push(data.path);
+      continue;
+    }
+    sorted[key] = stripped ? { mode: data.mode, component: data.component, path: "" } : data;
+  }
+  const serialised = JSON.stringify(sorted);
+  const fullChecksum = createHash("sha256").update(serialised).digest("hex");
+  const checksum = fullChecksum.substring(0, 16);
+  const buildId = `${Date.now().toString(36)}-${fullChecksum.substring(0, 6)}`;
+  return {
+    manifest: { buildId, checksum, mangleChecksum: options.mangleChecksum, tokens: sorted },
+    strippedDevOnlyPaths
+  };
+}
+function injectRecoveryManifest(html, manifest) {
+  if (Object.keys(manifest.tokens).length === 0) {
+    return html;
+  }
+  const json = JSON.stringify(manifest);
+  const scriptTag = `<script id="__SZ_RECOVERY_MANIFEST__" type="application/json">${json}<\/script>`;
+  if (html.includes("</head>")) {
+    return html.replace("</head>", `${scriptTag}
+</head>`);
+  } else if (html.includes("</html>")) {
+    return html.replace("</html>", `${scriptTag}
+</html>`);
+  }
+  return html + scriptTag;
+}
+
+function generateThemeDts(opts) {
+  const { theme, sourceFiles } = opts;
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const sources = sourceFiles.join(", ");
+  const toUnion = (tokens) => tokens.map((t) => `'${t}'`).join(" | ");
+  const entries = [];
+  if (theme.colors.length > 0) {
+    entries.push(`        colors: ${toUnion(theme.colors)};`);
+  }
+  if (theme.spacings.length > 0) {
+    entries.push(`        spacings: ${toUnion(theme.spacings)};`);
+  }
+  if (theme.fonts.length > 0) {
+    entries.push(`        fonts: ${toUnion(theme.fonts)};`);
+  }
+  if (theme.radii.length > 0) {
+    entries.push(`        radii: ${toUnion(theme.radii)};`);
+  }
+  if (theme.shadows.length > 0) {
+    entries.push(`        shadows: ${toUnion(theme.shadows)};`);
+  }
+  return [
+    "// Auto-generated by csszyx theme-scanner \u2014 DO NOT EDIT",
+    `// Source: ${sources}`,
+    `// Updated: ${timestamp}`,
+    "",
+    "declare module '@csszyx/compiler' {",
+    "    /**",
+    "     * Custom design tokens extracted from @theme blocks.",
+    "     * These tokens are surfaced in sz prop IntelliSense.",
+    "     */",
+    "    interface CustomTheme {",
+    ...entries,
+    "    }",
+    "}",
+    "",
+    "export {};",
+    ""
+  ].join("\n");
+}
+function writeThemeDts(opts) {
+  const content = generateThemeDts(opts);
+  mkdirSync(dirname(opts.outputPath), { recursive: true });
+  writeFileSync(opts.outputPath, content, "utf-8");
+}
+
+const CACHE_SCHEMA_VERSION = 2;
+function resolveTransformCacheDir(rootDir, cacheDir) {
+  return path.resolve(rootDir, cacheDir ?? ".csszyx/cache", "transform");
+}
+function createTransformCacheKey(input) {
+  const inputSha256 = createHash("sha256").update(input.source).digest("hex");
+  const keyMaterial = [
+    `schema=${CACHE_SCHEMA_VERSION}`,
+    `plugin=${input.pluginVersion}`,
+    `compiler=${input.compilerVersion}`,
+    `parser=${input.parserMode}`,
+    `producer=${input.producer}`,
+    `astBudget=${input.astBudget ?? "default"}`,
+    `filename=${input.filename}`,
+    `source=${inputSha256}`
+  ].join("\n");
+  return {
+    key: createHash("sha256").update(keyMaterial).digest("hex").slice(0, 16),
+    inputSha256
+  };
+}
+function readTransformCache(cacheRoot, input, precomputedKey) {
+  const { key, inputSha256 } = precomputedKey ?? createTransformCacheKey(input);
+  const file = cacheEntryPath(cacheRoot, key);
+  let entry;
+  try {
+    entry = JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+  if (entry.version !== CACHE_SCHEMA_VERSION || entry.pluginVersion !== input.pluginVersion || entry.compilerVersion !== input.compilerVersion || entry.parserMode !== input.parserMode || entry.producer !== input.producer || entry.astBudget !== (input.astBudget ?? null) || entry.filename !== input.filename || entry.inputSha256 !== inputSha256) {
+    return null;
+  }
+  return deserializeResult(entry.result);
+}
+function writeTransformCache(cacheRoot, input, result, precomputedKey) {
+  const { key, inputSha256 } = precomputedKey ?? createTransformCacheKey(input);
+  const file = cacheEntryPath(cacheRoot, key);
+  const dir = path.dirname(file);
+  const tmp = path.join(
+    dir,
+    `.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.json`
+  );
+  const entry = {
+    version: CACHE_SCHEMA_VERSION,
+    pluginVersion: input.pluginVersion,
+    compilerVersion: input.compilerVersion,
+    parserMode: input.parserMode,
+    producer: input.producer,
+    astBudget: input.astBudget ?? null,
+    filename: input.filename,
+    inputSha256,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    result: serializeResult(result)
+  };
+  try {
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(tmp, JSON.stringify(entry), "utf8");
+    fs.renameSync(tmp, file);
+  } catch {
+    try {
+      fs.rmSync(tmp, { force: true });
+    } catch {
+    }
+  }
+}
+function evictOldTransformCacheEntries(cacheRoot, options) {
+  let deleted = 0;
+  const now = options.now ?? Date.now();
+  const survivors = [];
+  for (const file of listJsonFiles(cacheRoot)) {
+    try {
+      const entry = JSON.parse(fs.readFileSync(file, "utf8"));
+      const timestamp = typeof entry.timestamp === "string" ? Date.parse(entry.timestamp) : 0;
+      if (!Number.isFinite(timestamp) || now - timestamp > options.maxAgeMs) {
+        fs.rmSync(file, { force: true });
+        deleted++;
+      } else {
+        survivors.push({ file, timestamp });
+      }
+    } catch {
+      fs.rmSync(file, { force: true });
+      deleted++;
+    }
+  }
+  const overflow = survivors.length - options.maxEntries ;
+  if (overflow > 0) {
+    survivors.sort((a, b) => a.timestamp - b.timestamp);
+    for (const survivor of survivors.slice(0, overflow)) {
+      fs.rmSync(survivor.file, { force: true });
+      deleted++;
+    }
+  }
+  return deleted;
+}
+function cacheEntryPath(cacheRoot, key) {
+  return path.join(cacheRoot, key.slice(0, 2), `${key.slice(2)}.json`);
+}
+function serializeResult(result) {
+  return {
+    code: result.code,
+    transformed: result.transformed,
+    usesRuntime: result.usesRuntime,
+    usesMerge: result.usesMerge,
+    usesColorVar: result.usesColorVar,
+    classes: [...result.classes],
+    rawClassNames: [...result.rawClassNames],
+    diagnostics: [...result.diagnostics],
+    recoveryTokens: [...result.recoveryTokens]
+  };
+}
+function deserializeResult(result) {
+  return {
+    code: result.code,
+    transformed: result.transformed,
+    usesRuntime: result.usesRuntime,
+    usesMerge: result.usesMerge,
+    usesColorVar: result.usesColorVar,
+    classes: new Set(result.classes),
+    rawClassNames: new Set(result.rawClassNames),
+    diagnostics: [...result.diagnostics],
+    recoveryTokens: new Map(result.recoveryTokens)
+  };
+}
+function listJsonFiles(dir) {
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const files = [];
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...listJsonFiles(fullPath));
+    } else if (entry.isFile() && entry.name.endsWith(".json")) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+
+const VIRTUAL_MODULE_ID = "virtual:csszyx/mangle-map";
+const RESOLVED_VIRTUAL_MODULE_ID = `\0${VIRTUAL_MODULE_ID}`;
+const VIRTUAL_CHECKSUM_ID = "virtual:csszyx/checksum";
+const RESOLVED_VIRTUAL_CHECKSUM_ID = `\0${VIRTUAL_CHECKSUM_ID}`;
+function createMangleMapModule(mangleMap, checksum) {
+  return `/**
+ * Auto-generated mangle map for csszyx.
+ * This module is generated at build time and contains the mapping
+ * from original class names to mangled class names.
+ *
+ * @generated
+ */
+
+export const mangleMap = ${JSON.stringify(mangleMap, null, 2)};
+
+export const checksum = ${JSON.stringify(checksum)};
+
+export default {
+  mangleMap,
+  checksum,
+};
+`;
+}
+function createChecksumModule(checksum) {
+  return `/**
+ * Auto-generated checksum for csszyx mangle map.
+ *
+ * @generated
+ */
+
+export const checksum = ${JSON.stringify(checksum)};
+
+export default checksum;
+`;
+}
+function isVirtualModule(id) {
+  return id === VIRTUAL_MODULE_ID || id === VIRTUAL_CHECKSUM_ID;
+}
+function resolveVirtualModule(id) {
+  if (id === VIRTUAL_MODULE_ID) {
+    return RESOLVED_VIRTUAL_MODULE_ID;
+  }
+  if (id === VIRTUAL_CHECKSUM_ID) {
+    return RESOLVED_VIRTUAL_CHECKSUM_ID;
+  }
+  return void 0;
+}
+
+const CHECKSUM_PLACEHOLDER = "___CSSZYX_CHECKSUM___";
+const MANGLE_MAP_PLACEHOLDER = "___CSSZYX_MANGLE_MAP___";
+const UNKNOWN_PACKAGE_VERSION = "0.0.0";
+const TRANSFORM_CACHE_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1e3;
+const TRANSFORM_CACHE_MAX_ENTRIES = 1e4;
+const TRANSFORM_MEMORY_CACHE_MAX_ENTRIES = 1e3;
+const DIRECTIVE_PROLOGUE_PREFIX_RE = /^((?:\s|\/\/[^\n]*\n|\/\*(?:[^*]|\*(?!\/))*\*\/)*)(['"]use (?:client|server)['"];?\s*)/;
+const RUNTIME_HELPER_IMPORT_RE = {
+  _sz: /\{[^}]*\b_sz\b[^}]*\}\s*from\s*['"]@csszyx\/runtime['"]/,
+  _szMerge: /\{[^}]*\b_szMerge\b[^}]*\}\s*from\s*['"]@csszyx\/runtime['"]/,
+  __szColorVar: /\{[^}]*\b__szColorVar\b[^}]*\}\s*from\s*['"]@csszyx\/runtime['"]/
+};
+let _hasWarnedTsConfig = false;
+let _hasWarnedTransformCacheVersion = false;
+const requireFromHere = createRequire(import.meta.url);
+const PLUGIN_VERSION = findPackageVersionFromFile(
+  fileURLToPath(import.meta.url),
+  UNKNOWN_PACKAGE_VERSION
+);
+const COMPILER_VERSION = findPackageVersionFromModule("@csszyx/compiler", UNKNOWN_PACKAGE_VERSION);
+const BENCH_TRACE_ENABLED = process.env.CSSZYX_BENCH_TRACE === "1";
+const BENCH_TRACE_FILE = process.env.CSSZYX_BENCH_TRACE_FILE;
+function traceBenchTiming(label, filename, elapsedMs) {
+  if (!BENCH_TRACE_ENABLED) {
+    return;
+  }
+  if (BENCH_TRACE_FILE && !filename.includes(BENCH_TRACE_FILE)) {
+    return;
+  }
+  console.log(
+    `[csszyx:bench] ${label} ${elapsedMs.toFixed(3)}ms ${normalizeSourceFilename(filename)}`
+  );
+}
+function runThemeScan(rootDir, scanCss) {
+  if (!scanCss) {
+    return;
+  }
+  const sourceFiles = expandFilePatterns(rootDir, scanCss).filter((file) => file.endsWith(".css"));
+  if (sourceFiles.length === 0) {
+    return;
+  }
+  const themes = sourceFiles.map((f) => {
+    try {
+      return parseThemeBlocks(fs.readFileSync(f, "utf-8"));
+    } catch {
+      return null;
+    }
+  }).filter((t) => t !== null);
+  const merged = mergeThemes(themes);
+  const outputPath = path.join(rootDir, ".csszyx", "theme.d.ts");
+  writeThemeDts({ outputPath, theme: merged, sourceFiles });
+  if (!_hasWarnedTsConfig) {
+    _hasWarnedTsConfig = true;
+    try {
+      const checkFile = (cfgPath) => {
+        if (fs.existsSync(cfgPath)) {
+          const content = fs.readFileSync(cfgPath, "utf-8");
+          if (!content.includes(".csszyx")) {
+            console.warn(
+              `
+\x1B[33m\u26A0\uFE0F CSSzyx: Theme Auto-Scan enabled, but TypeScript isn't configured. Run "npx @csszyx/cli init" to fix.\x1B[0m
+`
+            );
+          }
+          return true;
+        }
+        return false;
+      };
+      if (!checkFile(path.join(rootDir, "tsconfig.json"))) {
+        checkFile(path.join(rootDir, "tsconfig.app.json"));
+      }
+    } catch {
+    }
+  }
+}
+function findPackageVersionFromModule(specifier, fallback) {
+  try {
+    return findPackageVersionFromFile(requireFromHere.resolve(specifier), fallback);
+  } catch {
+    return fallback;
+  }
+}
+function findPackageVersionFromFile(file, fallback) {
+  let dir = path.dirname(file);
+  while (true) {
+    const packageJson = path.join(dir, "package.json");
+    try {
+      const parsed = JSON.parse(fs.readFileSync(packageJson, "utf8"));
+      if (typeof parsed.version === "string") {
+        return parsed.version;
+      }
+      return fallback;
+    } catch {
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) {
+      return fallback;
+    }
+    dir = parent;
+  }
+}
+function normalizeSourceFilename(filename) {
+  return filename.replace(/\\/g, "/");
+}
+function insertRuntimeImport(code, importStmt) {
+  const directiveMatch = code.match(DIRECTIVE_PROLOGUE_PREFIX_RE);
+  if (!directiveMatch) {
+    return `${importStmt}${code}`;
+  }
+  return code.replace(directiveMatch[0], `${directiveMatch[1]}${directiveMatch[2]}${importStmt}`);
+}
+function mangleCodeClassesSync(code, mangleMap) {
+  function mangleClassString(classString) {
+    return classString.split(/\s+/).filter(Boolean).map((cls) => {
+      return mangleMap[cls.replace(/\\(.)/g, "$1")] || cls;
+    }).join(" ");
+  }
+  let result = code.replace(/(?:class(?:Name)?|sz)[:=]\s*"((?:[^"\\]|\\.)*)"/g, (match, classes) => {
+    const mangled = mangleClassString(classes);
+    if (mangled === classes) {
+      return match;
+    }
+    return match.replace(classes, mangled);
+  }).replace(/(?:class(?:Name)?|sz)[:=]\s*'((?:[^'\\]|\\.)*)'/g, (match, classes) => {
+    const mangled = mangleClassString(classes);
+    if (mangled === classes) {
+      return match;
+    }
+    return match.replace(classes, mangled);
+  });
+  result = result.replace(/className:\s*`([^`]+)`/g, (fullMatch, tplContent) => {
+    let changed = false;
+    let out = "";
+    let i = 0;
+    while (i < tplContent.length) {
+      const interStart = tplContent.indexOf("${", i);
+      if (interStart === -1) {
+        const quasi2 = tplContent.slice(i);
+        const trimmed2 = quasi2.trim();
+        if (trimmed2) {
+          const m = mangleClassString(trimmed2);
+          if (m !== trimmed2) {
+            changed = true;
+            out += quasi2.replace(trimmed2, m);
+          } else {
+            out += quasi2;
+          }
+        } else {
+          out += quasi2;
+        }
+        break;
+      }
+      const quasi = tplContent.slice(i, interStart);
+      const trimmed = quasi.trim();
+      if (trimmed) {
+        const m = mangleClassString(trimmed);
+        if (m !== trimmed) {
+          changed = true;
+          out += quasi.replace(trimmed, m);
+        } else {
+          out += quasi;
+        }
+      } else {
+        out += quasi;
+      }
+      let j = interStart + 2;
+      let depth = 0;
+      while (j < tplContent.length) {
+        if (tplContent[j] === "{") {
+          depth++;
+        } else if (tplContent[j] === "}") {
+          if (depth === 0) {
+            j++;
+            break;
+          }
+          depth--;
+        }
+        j++;
+      }
+      const interInner = tplContent.slice(interStart + 2, j - 1);
+      const mangledInner = interInner.replace(/"([^"]*)"/g, (qm, inner) => {
+        const parts = inner.split(/\s+/).filter(Boolean);
+        if (parts.length === 0) {
+          return qm;
+        }
+        const m = parts.map((p) => mangleMap[p] || p).join(" ");
+        if (m === inner) {
+          return qm;
+        }
+        changed = true;
+        return `"${m}"`;
+      });
+      out += `\${${mangledInner}}`;
+      i = j;
+    }
+    return changed ? `className:\`${out}\`` : fullMatch;
+  });
+  {
+    const marker = "className:";
+    let searchFrom = 0;
+    let out = "";
+    while (searchFrom < result.length) {
+      const idx = result.indexOf(marker, searchFrom);
+      if (idx === -1) {
+        out += result.slice(searchFrom);
+        break;
+      }
+      out += result.slice(searchFrom, idx + marker.length);
+      const afterColon = idx + marker.length;
+      let exprStart = afterColon;
+      while (exprStart < result.length && result[exprStart] === " ") {
+        exprStart++;
+      }
+      const firstChar = result[exprStart];
+      if (firstChar === '"' || firstChar === "'" || firstChar === "`") {
+        searchFrom = afterColon;
+        continue;
+      }
+      let depth = 0;
+      let j = afterColon;
+      while (j < result.length) {
+        const ch = result[j];
+        if (ch === "(" || ch === "[") {
+          depth++;
+        } else if (ch === ")" || ch === "]") {
+          if (depth === 0) {
+            break;
+          }
+          depth--;
+        } else if (depth === 0 && (ch === "," || ch === ";" || ch === "\n" || ch === "}")) {
+          break;
+        }
+        j++;
+      }
+      const expr = result.slice(afterColon, j);
+      const qIdx = expr.indexOf("?");
+      if (qIdx === -1 || !expr.slice(qIdx).includes(":")) {
+        out += expr;
+        searchFrom = j;
+        continue;
+      }
+      let changed = false;
+      const mangled = expr.replace(/"([^"]*)"/g, (qm, inner) => {
+        const parts = inner.split(/\s+/).filter(Boolean);
+        if (parts.length === 0) {
+          return qm;
+        }
+        const mangledStr = parts.map((p) => mangleMap[p] || p).join(" ");
+        if (mangledStr !== inner) {
+          changed = true;
+          return `"${mangledStr}"`;
+        }
+        return qm;
+      });
+      out += changed ? mangled : expr;
+      searchFrom = j;
+    }
+    result = out;
+  }
+  result = result.replace(/(?<=(?:[,(]|&&)\s*)"([^"]+)"/g, (match, inner) => {
+    const tokens = inner.split(/\s+/).filter(Boolean);
+    if (tokens.length === 0) {
+      return match;
+    }
+    let changed = false;
+    const mangled = [];
+    for (const t of tokens) {
+      const m = mangleMap[t];
+      if (m === void 0) {
+        return match;
+      }
+      if (m !== t) {
+        changed = true;
+      }
+      mangled.push(m);
+    }
+    if (!changed) {
+      return match;
+    }
+    return `"${mangled.join(" ")}"`;
+  });
+  return result;
+}
+function createCsszyxPlugins(options = {}) {
+  const manglingEnabled = options.production?.mangle !== false;
+  const astBudgetOverride = options.build?.astBudgetLimit;
+  const cacheRequested = (options.build?.cache ?? DEFAULT_BUILD_CONFIG.cache) !== false;
+  const cacheVersionsKnown = PLUGIN_VERSION !== UNKNOWN_PACKAGE_VERSION && COMPILER_VERSION !== UNKNOWN_PACKAGE_VERSION;
+  const cacheEnabled = cacheRequested && cacheVersionsKnown;
+  if (cacheRequested && !cacheVersionsKnown && !_hasWarnedTransformCacheVersion) {
+    _hasWarnedTransformCacheVersion = true;
+    console.warn(
+      "[csszyx] Transform cache disabled because package versions could not be resolved."
+    );
+  }
+  const parserOverride = process.env.CSSZYX_PARSER;
+  const defaultParser = DEFAULT_BUILD_CONFIG.parser ?? "rust";
+  const parserMode = parserOverride === "babel" || parserOverride === "oxc" || parserOverride === "rust" ? parserOverride : options.build?.parser ?? defaultParser;
+  let evictedCacheRoot = null;
+  const transformMemoryCache = /* @__PURE__ */ new Map();
+  const state = {
+    classes: /* @__PURE__ */ new Set(),
+    mangleMap: {},
+    checksum: "",
+    finalized: false,
+    rootDir: process.cwd(),
+    recoveryTokens: /* @__PURE__ */ new Map(),
+    rscModules: /* @__PURE__ */ new Map()
+  };
+  const SAFELIST_FILENAME = "csszyx-classes.html";
+  const SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".tsx", ".jsx", ".ts", ".js"]);
+  const IGNORE_DIRS = /* @__PURE__ */ new Set(["node_modules", ".next", ".git", "dist", "build", ".turbo"]);
+  function isUserExcluded(id) {
+    return matchesAnyPattern(id, options.exclude, state.rootDir);
+  }
+  function isUserIncluded(id) {
+    return !options.include || matchesAnyPattern(id, options.include, state.rootDir);
+  }
+  function isHardIgnored(id) {
+    return id.includes("node_modules") || id.includes("/packages/") || id.includes(".next") && !id.includes("static");
+  }
+  function shouldProcessSource(id) {
+    return !isHardIgnored(id) && !isUserExcluded(id) && isUserIncluded(id) && (/\.[tj]sx?(\?.*)?$/.test(id) || id.endsWith(".vue") || id.endsWith(".svelte"));
+  }
+  function shouldProcessCss(id) {
+    return !isHardIgnored(id) && !isUserExcluded(id) && /\.css(\?.*)?$/.test(id);
+  }
+  function transformConfiguredSource(source, filename) {
+    const compilerOptions = { astBudget: astBudgetOverride };
+    const effectiveFilename = normalizeSourceFilename(filename);
+    const cacheRoot = resolveTransformCacheDir(state.rootDir, options.build?.cacheDir);
+    if (cacheEnabled) {
+      evictTransformCacheOnce();
+    }
+    const cacheInput = {
+      pluginVersion: PLUGIN_VERSION,
+      compilerVersion: COMPILER_VERSION,
+      parserMode,
+      producer: parserMode,
+      astBudget: astBudgetOverride,
+      filename: effectiveFilename,
+      source
+    };
+    if (parserMode === "rust") {
+      ensureRustTransformAvailable();
+    }
+    const cacheKey = cacheEnabled ? createTransformCacheKey(cacheInput) : null;
+    if (cacheEnabled && cacheKey) {
+      const memoryCached = transformMemoryCache.get(cacheKey.key);
+      if (memoryCached) {
+        transformMemoryCache.delete(cacheKey.key);
+        transformMemoryCache.set(cacheKey.key, memoryCached);
+        return memoryCached;
+      }
+      const cached = readTransformCache(cacheRoot, cacheInput, cacheKey);
+      if (cached) {
+        rememberTransformCacheEntry(cacheKey.key, cached);
+        return cached;
+      }
+    }
+    let result;
+    if (parserMode === "babel") {
+      result = transformSourceCode(source, effectiveFilename, compilerOptions);
+    } else if (parserMode === "rust") {
+      result = transformRust(source, effectiveFilename, compilerOptions);
+    } else {
+      try {
+        result = transformOxc(source, effectiveFilename, compilerOptions);
+      } catch (err) {
+        result = transformSourceCode(source, effectiveFilename, compilerOptions);
+        const reason = err instanceof Error ? err.message : String(err);
+        result.diagnostics.push(
+          `[csszyx] oxc parser fell back to Babel for ${effectiveFilename}: ${reason}`
+        );
+        return result;
+      }
+    }
+    if (cacheEnabled && cacheKey) {
+      writeTransformCache(cacheRoot, cacheInput, result, cacheKey);
+      rememberTransformCacheEntry(cacheKey.key, result);
+    }
+    return result;
+  }
+  function rememberTransformCacheEntry(key, result) {
+    transformMemoryCache.delete(key);
+    transformMemoryCache.set(key, result);
+    if (transformMemoryCache.size <= TRANSFORM_MEMORY_CACHE_MAX_ENTRIES) {
+      return;
+    }
+    const oldest = transformMemoryCache.keys().next().value;
+    if (oldest) {
+      transformMemoryCache.delete(oldest);
+    }
+  }
+  function evictTransformCacheOnce() {
+    if (!cacheEnabled) {
+      return;
+    }
+    const cacheRoot = resolveTransformCacheDir(state.rootDir, options.build?.cacheDir);
+    if (evictedCacheRoot === cacheRoot) {
+      return;
+    }
+    evictedCacheRoot = cacheRoot;
+    evictOldTransformCacheEntries(cacheRoot, {
+      maxAgeMs: TRANSFORM_CACHE_MAX_AGE_MS,
+      maxEntries: TRANSFORM_CACHE_MAX_ENTRIES
+    });
+  }
+  function writeSafelistFile(classes) {
+    if (classes.size === 0) {
+      return;
+    }
+    const safelistPath = path.join(state.rootDir, SAFELIST_FILENAME);
+    const classList = Array.from(classes).join(" ");
+    const content = `<!-- Auto-generated by csszyx \u2014 DO NOT EDIT -->
+<!-- Tailwind CSS scans this file for class name detection -->
+<div class="${classList}"><div class="${classList}">x</div><div class="${classList}">x</div></div>
+`;
+    try {
+      const existing = fs.existsSync(safelistPath) ? fs.readFileSync(safelistPath, "utf-8") : "";
+      if (existing !== content) {
+        fs.writeFileSync(safelistPath, content);
+      }
+    } catch {
+    }
+  }
+  function prescanAndWriteClasses() {
+    const discoveredClasses = /* @__PURE__ */ new Set();
+    const rawDiscoveredClasses = /* @__PURE__ */ new Set();
+    function scanDir(dir) {
+      let entries;
+      try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          if (!IGNORE_DIRS.has(entry.name) && !entry.name.startsWith(".")) {
+            scanDir(path.join(dir, entry.name));
+          }
+        } else if (SOURCE_EXTENSIONS.has(path.extname(entry.name))) {
+          const filePath = path.join(dir, entry.name);
+          if (!shouldProcessSource(filePath)) {
+            continue;
+          }
+          try {
+            const content = fs.readFileSync(filePath, "utf-8");
+            if (!content.includes("sz=") && !content.includes("sz:")) {
+              continue;
+            }
+            const result = transformConfiguredSource(content, filePath);
+            if (!result.transformed) {
+              continue;
+            }
+            for (const cls of result.classes) {
+              discoveredClasses.add(cls);
+            }
+            for (const cls of result.rawClassNames) {
+              rawDiscoveredClasses.add(cls);
+            }
+            for (const [token, data] of result.recoveryTokens) {
+              state.recoveryTokens.set(token, data);
+            }
+            if (result.usesRuntime) {
+              const szCallRe = /_sz\(\s*\{/g;
+              for (const szMatch of result.code.matchAll(szCallRe)) {
+                let depth = 1;
+                let idx = (szMatch.index ?? 0) + szMatch[0].length;
+                while (idx < result.code.length && depth > 0) {
+                  if (result.code[idx] === "{") {
+                    depth++;
+                  } else if (result.code[idx] === "}") {
+                    depth--;
+                  }
+                  idx++;
+                }
+                const objStr = result.code.slice(
+                  (szMatch.index ?? 0) + szMatch[0].length,
+                  idx - 1
+                );
+                const strKv = /(\w+)\s*:\s*(?:"([^"]*)"|'([^']*)')/g;
+                for (const kv of objStr.matchAll(strKv)) {
+                  try {
+                    const val = kv[2] ?? kv[3];
+                    const r = transform({ [kv[1]]: val });
+                    for (const c of r.className.split(/\s+/).filter(Boolean)) {
+                      discoveredClasses.add(c);
+                    }
+                  } catch {
+                  }
+                }
+                const numKv = /(\w+)\s*:\s*(-?\d+(?:\.\d+)?)\s*(?=[,}\n])/g;
+                for (const kv of objStr.matchAll(numKv)) {
+                  try {
+                    const r = transform({ [kv[1]]: parseFloat(kv[2]) });
+                    for (const c of r.className.split(/\s+/).filter(Boolean)) {
+                      discoveredClasses.add(c);
+                    }
+                  } catch {
+                  }
+                }
+                const boolKv = /(\w+)\s*:\s*(true|false)\s*(?=[,}\n])/g;
+                for (const kv of objStr.matchAll(boolKv)) {
+                  try {
+                    const r = transform({ [kv[1]]: kv[2] === "true" });
+                    for (const c of r.className.split(/\s+/).filter(Boolean)) {
+                      discoveredClasses.add(c);
+                    }
+                  } catch {
+                  }
+                }
+              }
+            }
+          } catch {
+          }
+        }
+      }
+    }
+    scanDir(state.rootDir);
+    for (const cls of discoveredClasses) {
+      state.classes.add(cls);
+    }
+    const safelistClasses = /* @__PURE__ */ new Set([...discoveredClasses, ...rawDiscoveredClasses]);
+    writeSafelistFile(safelistClasses);
+  }
+  function extractClasses(code) {
+    const dqPattern = /(?:class(?:Name)?|sz)[:=]\s*"([^"]*)"/g;
+    const sqPattern = /(?:class(?:Name)?|sz)[:=]\s*'([^']*)'/g;
+    for (const classPattern of [dqPattern, sqPattern]) {
+      for (const match of code.matchAll(classPattern)) {
+        const classes = match[1].split(/\s+/).filter(Boolean);
+        for (const cls of classes) {
+          state.classes.add(cls);
+        }
+      }
+    }
+    const exprStart = /className=\{/g;
+    for (const match of code.matchAll(exprStart)) {
+      let depth = 1;
+      let i = (match.index ?? 0) + match[0].length;
+      while (i < code.length && depth > 0) {
+        if (code[i] === "{") {
+          depth++;
+        } else if (code[i] === "}") {
+          depth--;
+        }
+        i++;
+      }
+      const expr = code.slice((match.index ?? 0) + match[0].length, i - 1);
+      const strPattern = /"([^"]+)"|'([^']+)'/g;
+      for (const strMatch of expr.matchAll(strPattern)) {
+        const str = strMatch[1] || strMatch[2];
+        const classes = str.split(/\s+/).filter(Boolean);
+        for (const cls of classes) {
+          state.classes.add(cls);
+        }
+      }
+    }
+  }
+  function finalizeMangleMap() {
+    const sortedClasses = Array.from(state.classes);
+    const newMap = {};
+    for (let i = 0; i < sortedClasses.length; i++) {
+      newMap[sortedClasses[i]] = encode(i);
+    }
+    state.mangleMap = newMap;
+    state.checksum = compute_mangle_checksum(state.mangleMap);
+    state.finalized = true;
+  }
+  function mangleCodeClasses(code) {
+    return mangleCodeClassesSync(code, state.mangleMap);
+  }
+  function replacePlaceholders(code) {
+    let result = code;
+    if (result.includes(CHECKSUM_PLACEHOLDER)) {
+      result = result.split(CHECKSUM_PLACEHOLDER).join(state.checksum);
+    }
+    if (result.includes(MANGLE_MAP_PLACEHOLDER)) {
+      const jsonMap = JSON.stringify(state.mangleMap);
+      const escapedMap = result.includes("eval(") ? jsonMap.replace(/"/g, '\\"') : jsonMap;
+      result = result.split(MANGLE_MAP_PLACEHOLDER).join(escapedMap);
+    }
+    return result;
+  }
+  const prePlugin = createUnplugin(
+    (_pluginOptions) => ({
+      name: "csszyx:pre",
+      enforce: "pre",
+      /**
+       * Resolves virtual module IDs for csszyx mangle-map and checksum modules.
+       * @param id - the module ID to resolve
+       * @returns resolved ID if virtual, null otherwise
+       */
+      resolveId(id) {
+        if (isVirtualModule(id)) {
+          return resolveVirtualModule(id);
+        }
+        return null;
+      },
+      /**
+       * Loads virtual module content — generates mangle map or checksum module code.
+       * @param id - the resolved module ID to load
+       * @returns generated module source if virtual, null otherwise
+       */
+      load(id) {
+        if (id === RESOLVED_VIRTUAL_MODULE_ID) {
+          finalizeMangleMap();
+          return createMangleMapModule(state.mangleMap, state.checksum);
+        }
+        if (id === RESOLVED_VIRTUAL_CHECKSUM_ID) {
+          finalizeMangleMap();
+          return createChecksumModule(state.checksum);
+        }
+        return null;
+      },
+      /**
+       * Filters files for the pre-transform phase — source files plus CSS files.
+       * CSS files need special handling to inject @source inline() for Tailwind class discovery.
+       * @param id - the file path to check for inclusion
+       * @returns true if the file should be transformed, false otherwise
+       */
+      transformInclude(id) {
+        if (shouldProcessCss(id)) {
+          return true;
+        }
+        return shouldProcessSource(id);
+      },
+      /**
+       * Core transform: detects sz prop, compiles to className, injects runtime, collects classes.
+       * For CSS files: injects @source inline() so Tailwind generates CSS for sz-derived classes.
+       * @param code - the source code to transform
+       * @param id - the file path of the module being transformed
+       * @returns transformed code with source map, or null if no changes were made
+       */
+      transform(code, id) {
+        if (!shouldProcessCss(id) && !shouldProcessSource(id)) {
+          return null;
+        }
+        if (/\.[tj]sx?(\?.*)?$/.test(id)) {
+          assertNoRSCBoundaryViolation(code, id);
+        }
+        if (/\.css(\?.*)?$/.test(id)) {
+          const hasTailwindImport = code.includes('@import "tailwindcss') || code.includes("@import 'tailwindcss");
+          if (hasTailwindImport && state.classes.size > 0) {
+            const candidates = Array.from(state.classes).filter((c) => c.length >= 2 && /^[a-z]/.test(c)).join(" ");
+            if (candidates) {
+              const safelistPath = path.join(state.rootDir, SAFELIST_FILENAME).replace(/\\/g, "/");
+              const cssDir = path.dirname(id).replace(/\\/g, "/");
+              let relPath = path.posix.relative(cssDir, safelistPath);
+              if (!relPath.startsWith(".")) {
+                relPath = `./${relPath}`;
+              }
+              const sourceDirective = `@source "${relPath}";
+`;
+              const transformed2 = code.replace(
+                /(@import\s+["']tailwindcss[^"']*["'];)/,
+                `$1
+${sourceDirective}`
+              );
+              if (transformed2 !== code) {
+                return { code: transformed2, map: null };
+              }
+            }
+          }
+          return null;
+        }
+        let transformedCode = code;
+        let usesRuntime = false;
+        let usesMerge = false;
+        let usesColorVar = false;
+        let transformed = false;
+        let szClasses;
+        const hasSzProp = code.includes("sz=") || /\bsz\s*:\s*["'{]/.test(code) || code.includes('sz: "');
+        if (hasSzProp) {
+          if (id.endsWith(".vue")) {
+            const result = preprocess(code, options);
+            if (result.transformed) {
+              transformedCode = result.code;
+              transformed = true;
+            }
+          } else if (id.endsWith(".svelte")) {
+            const result = preprocess$1(code, options);
+            if (result) {
+              transformedCode = result.code;
+              transformed = true;
+            }
+          } else {
+            const transformStarted = performance.now();
+            const result = transformConfiguredSource(code, id);
+            traceBenchTiming(
+              "transform-hook",
+              id,
+              performance.now() - transformStarted
+            );
+            transformedCode = result.code;
+            usesRuntime = result.usesRuntime;
+            usesMerge = result.usesMerge;
+            usesColorVar = result.usesColorVar;
+            transformed = result.transformed;
+            szClasses = result.classes;
+            if (result.diagnostics.length > 0 && process.env.NODE_ENV !== "production") {
+              for (const msg of result.diagnostics) {
+                this.warn(`[csszyx] ${id}
+  ${msg}`);
+              }
+            }
+            for (const [token, data] of result.recoveryTokens) {
+              state.recoveryTokens.set(token, data);
+            }
+          }
+        }
+        if (transformedCode.includes("<html") && /layout|Root|Document|app\\.tsx?$/i.test(id)) {
+          const attrName = options.production?.minify ? "data-sz-cs" : "data-sz-checksum";
+          transformedCode = transformedCode.replace(
+            /<html([^>]*)>/i,
+            `<html$1 ${attrName}="${CHECKSUM_PLACEHOLDER}">`
+          );
+          const debugScript = `<script dangerouslySetInnerHTML={{__html: \`(function(){var m=${MANGLE_MAP_PLACEHOLDER};var r={};for(var k in m)r[m[k]]=k;window.__csszyx={mangleMap:m,checksum:"${CHECKSUM_PLACEHOLDER}",decode:function(c){return r[c]},encode:function(c){return m[c]},decodeAll:function(el){return(el.className||"").split(" ").map(function(c){return r[c]||c})}}})()\`}} />`;
+          if (transformedCode.includes("<body")) {
+            transformedCode = transformedCode.replace(
+              /(<body[^>]*>)/i,
+              `$1${debugScript}`
+            );
+          }
+          transformed = true;
+        }
+        {
+          const imports = [];
+          if (usesRuntime) {
+            imports.push("_sz");
+          }
+          if (usesMerge) {
+            imports.push("_szMerge");
+          }
+          if (usesColorVar) {
+            imports.push("__szColorVar");
+          }
+          const hasRuntimeImport = imports.length > 0 && transformedCode.includes("@csszyx/runtime");
+          const needed = hasRuntimeImport ? imports.filter(
+            (name) => !RUNTIME_HELPER_IMPORT_RE[name]?.test(transformedCode)
+          ) : imports;
+          if (needed.length > 0) {
+            const existingImport = transformedCode.match(
+              /^(import\s*\{[^}]*)\}\s*from\s*'@csszyx\/runtime'/m
+            );
+            if (existingImport) {
+              transformedCode = transformedCode.replace(
+                existingImport[0],
+                `${existingImport[1]}, ${needed.join(", ")} } from '@csszyx/runtime'`
+              );
+            } else {
+              const importStmt = `import { ${needed.join(", ")} } from '@csszyx/runtime';
+`;
+              transformedCode = insertRuntimeImport(transformedCode, importStmt);
+            }
+            transformed = true;
+          }
+        }
+        if (/\.[tj]sx?(\?.*)?$/.test(id)) {
+          assertNoRSCBoundaryViolation(transformedCode, id);
+          const record = createRSCModuleRecord(transformedCode, id);
+          state.rscModules.set(record.id, record);
+        }
+        if (transformed || transformedCode.includes("class=") || transformedCode.includes("className=")) {
+          if (szClasses !== void 0) {
+            for (const cls of szClasses) {
+              state.classes.add(cls);
+            }
+          } else {
+            extractClasses(transformedCode);
+          }
+          return { code: transformedCode, map: null };
+        }
+        return null;
+      },
+      /** Finalizes the mangle map after all source modules have been processed. */
+      buildEnd() {
+        finalizeMangleMap();
+        assertNoRSCGraphViolation(state.rscModules);
+        if (manglingEnabled && Object.keys(state.mangleMap).length > 0) {
+          globalThis.__csszyx_ssr_mangle_map = state.mangleMap;
+        }
+      },
+      watchChange(id, change) {
+        if (change.event === "delete") {
+          deleteRSCModuleRecord(state.rscModules, id);
+        }
+      },
+      /**
+       * Webpack hook: pre-scans source files before compilation for Tailwind class discovery.
+       * @param compiler - the Webpack compiler instance
+       */
+      webpack(compiler) {
+        compiler.hooks.beforeCompile.tap("csszyx:prescan", () => {
+          const root = compiler.context || process.cwd();
+          state.rootDir = root;
+          evictTransformCacheOnce();
+          if (state.classes.size === 0) {
+            prescanAndWriteClasses();
+          }
+          runThemeScan(root, options.build?.scanCss);
+        });
+        if (options.build?.scanCss) {
+          compiler.hooks.thisCompilation.tap("csszyx:theme-deps", (compilation) => {
+            const root = compiler.context || process.cwd();
+            for (const file of expandFilePatterns(root, options.build?.scanCss ?? [])) {
+              compilation.fileDependencies.add(file);
+            }
+          });
+        }
+      },
+      vite: {
+        /**
+         * Vite hook: pre-scans source files when config is resolved.
+         * Also runs theme scan to generate .csszyx/theme.d.ts if scanCss is configured.
+         * @param config - the resolved Vite configuration object
+         */
+        configResolved(config) {
+          const root = config.root || process.cwd();
+          state.rootDir = root;
+          evictTransformCacheOnce();
+          prescanAndWriteClasses();
+          runThemeScan(root, options.build?.scanCss);
+        },
+        /**
+         * Vite HMR hook: re-runs theme scan when a watched CSS file changes,
+         * and incrementally updates csszyx-classes.html when a source file gains new sz classes.
+         * @param ctx - HMR context containing the changed file
+         */
+        handleHotUpdate(ctx) {
+          const scanCss = options.build?.scanCss;
+          if (scanCss) {
+            const root = ctx.server.config.root || process.cwd();
+            if (matchesAnyPattern(ctx.file, scanCss, root)) {
+              runThemeScan(root, scanCss);
+            }
+          }
+          if (!shouldProcessSource(ctx.file)) {
+            return;
+          }
+          let fileContent, result;
+          try {
+            fileContent = fs.readFileSync(ctx.file, "utf-8");
+          } catch {
+            return;
+          }
+          if (!fileContent.includes("sz=") && !/\bsz\s*:\s*["'{]/.test(fileContent)) {
+            return;
+          }
+          try {
+            const hmrTransformStarted = performance.now();
+            result = transformConfiguredSource(fileContent, ctx.file);
+            traceBenchTiming(
+              "handle-hot-update",
+              ctx.file,
+              performance.now() - hmrTransformStarted
+            );
+          } catch {
+            return;
+          }
+          if (!result.transformed) {
+            return;
+          }
+          const sizeBefore = state.classes.size;
+          for (const cls of result.classes) {
+            state.classes.add(cls);
+          }
+          for (const [token, data] of result.recoveryTokens) {
+            state.recoveryTokens.set(token, data);
+          }
+          if (state.classes.size > sizeBefore) {
+            writeSafelistFile(state.classes);
+            const safelistPath = path.join(state.rootDir, SAFELIST_FILENAME);
+            ctx.server.watcher.emit("change", safelistPath);
+          }
+        },
+        transformIndexHtml: {
+          order: "pre",
+          /**
+           * Injects hydration data (mangle map + checksum) into the HTML document.
+           * Also mangles class attributes in SSR-rendered HTML so they match mangled CSS selectors.
+           * @param html - the raw HTML string to transform
+           * @returns transformed HTML with injected hydration data
+           */
+          handler(html) {
+            finalizeMangleMap();
+            let result = transformIndexHtml(html, state.mangleMap, state.checksum, {
+              mode: options.production?.injectChecksum === false ? "script" : "script",
+              minify: process.env.NODE_ENV === "production"
+            });
+            if (state.recoveryTokens.size > 0) {
+              const isProduction = process.env.NODE_ENV === "production";
+              const { manifest, strippedDevOnlyPaths } = buildRecoveryManifest(
+                state.recoveryTokens,
+                {
+                  production: isProduction,
+                  mangleChecksum: state.checksum
+                }
+              );
+              if (strippedDevOnlyPaths.length > 0) {
+                console.warn(
+                  `[csszyx] Stripped ${strippedDevOnlyPaths.length} szRecover="dev-only" token(s) from the production manifest. Recovery for these elements is disabled in production by design. Sites: ${strippedDevOnlyPaths.join(", ")}`
+                );
+              }
+              result = injectRecoveryManifest(result, manifest);
+            }
+            return result;
+          }
+        }
+      }
+    })
+  );
+  const postPlugin = createUnplugin(() => ({
+    name: "csszyx:post",
+    enforce: "post",
+    // No transform hook — all mangling is deferred to asset processing
+    // where the complete mangle map is available.
+    /**
+     * Webpack hook: mangles CSS/JS class names in processAssets after compilation.
+     * @param compiler - the Webpack compiler instance
+     */
+    webpack(compiler) {
+      compiler.hooks.compilation.tap("csszyx:post", (compilation) => {
+        const stage = compiler.webpack?.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE || compilation.constructor.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE;
+        compilation.hooks.processAssets.tap(
+          {
+            name: "csszyx:post",
+            stage: stage || 400
+            // Fallback integer
+          },
+          (assets) => {
+            finalizeMangleMap();
+            const isWebpackDevMode = compiler.options.mode === "development";
+            const manifestData = {
+              version: "0.4.0",
+              buildId: state.checksum,
+              classes: Object.keys(state.mangleMap)
+            };
+            if (manglingEnabled && !isWebpackDevMode && Object.keys(state.mangleMap).length > 0) {
+              manifestData.mangleMap = state.mangleMap;
+            }
+            compilation.emitAsset(
+              "csszyx-manifest.json",
+              new compiler.webpack.sources.RawSource(JSON.stringify(manifestData))
+            );
+            for (const file in assets) {
+              const asset = assets[file];
+              const source = asset.source().toString();
+              if (manglingEnabled && !isWebpackDevMode && Object.keys(state.mangleMap).length > 0) {
+                if (file.endsWith(".css")) {
+                  try {
+                    const result = mangleCSSSync(source, state.mangleMap, {
+                      debug: options.development?.debug,
+                      from: file
+                    });
+                    if (result.transformedCount > 0) {
+                      compilation.updateAsset(
+                        file,
+                        new compiler.webpack.sources.RawSource(result.css)
+                      );
+                      continue;
+                    }
+                  } catch (e) {
+                    if (e && typeof e === "object" && "name" in e && e.name === "CssSyntaxError") ; else {
+                      throw e;
+                    }
+                  }
+                } else if (file.endsWith(".html")) {
+                  const mangledHtml = source.replace(
+                    /\bclass="([^"]*)"/g,
+                    (_m, cls) => {
+                      const out = cls.split(/\s+/).filter(Boolean).map((c) => state.mangleMap[c] || c).join(" ");
+                      return out !== cls ? `class="${out}"` : _m;
+                    }
+                  ).replace(
+                    /\bclass='([^']*)'/g,
+                    (_m, cls) => {
+                      const out = cls.split(/\s+/).filter(Boolean).map((c) => state.mangleMap[c] || c).join(" ");
+                      return out !== cls ? `class='${out}'` : _m;
+                    }
+                  );
+                  if (mangledHtml !== source) {
+                    compilation.updateAsset(
+                      file,
+                      new compiler.webpack.sources.RawSource(mangledHtml)
+                    );
+                    continue;
+                  }
+                } else if (file.endsWith(".js")) {
+                  let mangled = mangleCodeClasses(source);
+                  mangled = replacePlaceholders(mangled);
+                  if (mangled !== source) {
+                    compilation.updateAsset(
+                      file,
+                      new compiler.webpack.sources.RawSource(mangled)
+                    );
+                    continue;
+                  }
+                }
+              }
+              if (file.endsWith(".js") && (source.includes(CHECKSUM_PLACEHOLDER) || source.includes(MANGLE_MAP_PLACEHOLDER))) {
+                const replaced = replacePlaceholders(source);
+                if (replaced !== source) {
+                  compilation.updateAsset(
+                    file,
+                    new compiler.webpack.sources.RawSource(replaced)
+                  );
+                }
+              }
+            }
+          }
+        );
+      });
+    },
+    vite: {
+      /**
+       * Vite hook: mangles CSS selectors and JS class strings in the final bundle.
+       * @param _options - the output options (unused)
+       * @param bundle - the output bundle containing chunks and assets to process
+       */
+      generateBundle(_options, bundle) {
+        finalizeMangleMap();
+        const manifestData = {
+          version: "0.4.0",
+          buildId: state.checksum,
+          classes: Object.keys(state.mangleMap)
+        };
+        if (manglingEnabled && Object.keys(state.mangleMap).length > 0) {
+          manifestData.mangleMap = state.mangleMap;
+        }
+        this.emitFile({
+          type: "asset",
+          fileName: "csszyx-manifest.json",
+          source: JSON.stringify(manifestData)
+        });
+        for (const file in bundle) {
+          const chunk = bundle[file];
+          if (manglingEnabled && Object.keys(state.mangleMap).length > 0) {
+            if (chunk.type === "asset" && chunk.fileName.endsWith(".css")) {
+              const css = chunk.source.toString();
+              try {
+                const result = mangleCSSSync(css, state.mangleMap, {
+                  debug: options.development?.debug,
+                  from: file
+                });
+                if (result.transformedCount > 0) {
+                  chunk.source = result.css;
+                }
+              } catch (e) {
+                if (e && typeof e === "object" && "name" in e && e.name === "CssSyntaxError") ; else {
+                  throw e;
+                }
+              }
+              continue;
+            } else if (chunk.type === "chunk") {
+              let mangledCode = mangleCodeClasses(chunk.code);
+              mangledCode = replacePlaceholders(mangledCode);
+              if (mangledCode !== chunk.code) {
+                chunk.code = mangledCode;
+              }
+              continue;
+            }
+          }
+          if (chunk.type === "chunk" && (chunk.code.includes(CHECKSUM_PLACEHOLDER) || chunk.code.includes(MANGLE_MAP_PLACEHOLDER))) {
+            const replaced = replacePlaceholders(chunk.code);
+            if (replaced !== chunk.code) {
+              chunk.code = replaced;
+            }
+          }
+        }
+      }
+    }
+  }));
+  return { prePlugin, postPlugin };
+}
+const defaultInstance = createCsszyxPlugins();
+const unplugin = defaultInstance.prePlugin;
+const vitePlugin = (options = {}) => {
+  const { prePlugin, postPlugin } = createCsszyxPlugins(options);
+  return [prePlugin.vite(options), postPlugin.vite(options)];
+};
+const webpackPlugin = (options = {}) => {
+  const { prePlugin, postPlugin } = createCsszyxPlugins(options);
+  return {
+    /**
+     * Applies both pre and post plugins to the Webpack compiler.
+     * @param compiler - the Webpack compiler instance to apply plugins to
+     */
+    apply(compiler) {
+      prePlugin.webpack(options).apply(compiler);
+      postPlugin.webpack(options).apply(compiler);
+    }
+  };
+};
+const rollupPlugin = (options = {}) => {
+  const { prePlugin, postPlugin } = createCsszyxPlugins(options);
+  return [
+    prePlugin.rollup(options),
+    postPlugin.rollup(options)
+  ];
+};
+const esbuildPlugin = (options = {}) => {
+  const { prePlugin, postPlugin } = createCsszyxPlugins(options);
+  return {
+    name: "csszyx",
+    /**
+     * Registers both pre and post plugin setup hooks with the esbuild build.
+     * @param build - the esbuild plugin build context
+     */
+    setup(build) {
+      const b = build;
+      prePlugin.esbuild(options).setup(b);
+      postPlugin.esbuild(options).setup(b);
+    }
+  };
+};
+
+export { assertNoRSCBoundaryViolation as a, assertNoRSCGraphViolation as b, createRSCModuleRecord as c, deleteRSCModuleRecord as d, esbuildPlugin as e, findRSCBoundaryViolation as f, findRSCGraphViolation as g, hasTokens as h, hasUseClientDirective as i, hasUseServerDirective as j, isRSCServerModule as k, mergeThemes as l, mangleCodeClassesSync as m, parseThemeBlocks as p, rollupPlugin as r, unplugin as u, vitePlugin as v, webpackPlugin as w };