@csszyx/unplugin 0.8.0 → 0.9.1

package/dist/shared/unplugin.CFp386gH.cjs

@@ -0,0 +1,3321 @@
+'use strict';
+
+const fs = require('node:fs');
+const node_module = require('node:module');
+const path = require('node:path');
+const node_perf_hooks = require('node:perf_hooks');
+const node_url = require('node:url');
+const compiler = require('@csszyx/compiler');
+const core = require('@csszyx/core');
+const svelteAdapter = require('@csszyx/svelte-adapter');
+const types = require('@csszyx/types');
+const vueAdapter = require('@csszyx/vue-adapter');
+const unplugin$1 = require('unplugin');
+const cssMangler = require('../css-mangler.cjs');
+const node_crypto = require('node:crypto');
+const transformCache = require('./unplugin.DUxdYaSG.cjs');
+const postcss = require('postcss');
+const valueParser = require('postcss-value-parser');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+function _interopNamespaceCompat(e) {
+    if (e && typeof e === 'object' && 'default' in e) return e;
+    const n = Object.create(null);
+    if (e) {
+        for (const k in e) {
+            n[k] = e[k];
+        }
+    }
+    n.default = e;
+    return n;
+}
+
+const fs__namespace = /*#__PURE__*/_interopNamespaceCompat(fs);
+const path__namespace = /*#__PURE__*/_interopNamespaceCompat(path);
+const postcss__default = /*#__PURE__*/_interopDefaultCompat(postcss);
+const valueParser__default = /*#__PURE__*/_interopDefaultCompat(valueParser);
+
+function resolveGlobalVarScanCacheDir(cacheDir) {
+  return path__namespace.join(cacheDir, "global-vars");
+}
+function createGlobalVarScanCacheKey(input) {
+  const hash = node_crypto.createHash("sha256");
+  hash.update(input.filePath);
+  hash.update("\0");
+  hash.update(String(input.mtimeMs));
+  hash.update("\0");
+  hash.update(node_crypto.createHash("sha256").update(input.css).digest("hex"));
+  return hash.digest("hex");
+}
+function readGlobalVarScanCache(cacheDir, key) {
+  try {
+    const raw = fs__namespace.readFileSync(globalVarScanCacheFile(cacheDir, key), "utf8");
+    const entry = JSON.parse(raw);
+    if (entry.key !== key || !entry.result) {
+      return null;
+    }
+    return entry.result;
+  } catch {
+    return null;
+  }
+}
+function writeGlobalVarScanCache(cacheDir, key, result) {
+  try {
+    fs__namespace.mkdirSync(cacheDir, { recursive: true });
+    fs__namespace.writeFileSync(
+      globalVarScanCacheFile(cacheDir, key),
+      JSON.stringify({ key, result }),
+      "utf8"
+    );
+  } catch {
+  }
+}
+function globalVarScanCacheFile(cacheDir, key) {
+  return path__namespace.join(cacheDir, `${key}.json`);
+}
+
+const DEFAULT_SCOPE_ID = "<root>";
+function isInsideThemeAtRule(node) {
+  let current = node.parent;
+  while (current && current.type !== "root") {
+    if (current.type === "atrule" && current.name === "theme") {
+      return true;
+    }
+    current = current.parent;
+  }
+  return false;
+}
+function hasSiblingDeclaration(decl, prop) {
+  const parent = decl.parent;
+  if (!parent || !("nodes" in parent)) {
+    return false;
+  }
+  return parent.nodes.some((node) => node.type === "decl" && node.prop === prop);
+}
+function nodeLocation(node, filePath) {
+  return {
+    filePath,
+    line: node.source?.start?.line ?? 1,
+    column: node.source?.start?.column ?? 1
+  };
+}
+function buildScopeId(node) {
+  const parts = [];
+  let current = node.parent;
+  while (current && current.type !== "root") {
+    if (current.type === "rule") {
+      parts.push(`rule:${current.selector}`);
+    } else if (current.type === "atrule") {
+      const atRule = current;
+      parts.push(`@${atRule.name} ${atRule.params}`.trim());
+    }
+    current = current.parent;
+  }
+  return parts.reverse().join(" > ") || DEFAULT_SCOPE_ID;
+}
+
+const VAR_REFERENCE_RE = /var\(\s*(--[\w-]+)/g;
+function scanGlobalVarCss(css, options = {}) {
+  const filePath = options.filePath ?? "<inline>";
+  const root = postcss__default.parse(css, { from: filePath });
+  const registered = collectRegisteredProperties(root);
+  const definitions = [];
+  const references = [];
+  root.walkDecls((decl) => {
+    const scopeId = buildScopeId(decl);
+    const tailwindOwned = isInsideThemeAtRule(decl);
+    if (decl.prop.startsWith("--")) {
+      definitions.push({
+        name: decl.prop,
+        scopeId,
+        tailwindOwned,
+        registered: registered.has(decl.prop),
+        ...nodeLocation(decl, filePath)
+      });
+    }
+    for (const name of extractVarReferences(decl.value)) {
+      references.push({
+        name,
+        scopeId,
+        owner: decl.prop,
+        tailwindOwned,
+        ...nodeLocation(decl, filePath)
+      });
+    }
+  });
+  root.walkAtRules((atRule) => {
+    if (atRule.name === "property") {
+      return;
+    }
+    for (const name of extractVarReferences(atRule.params)) {
+      references.push({
+        name,
+        scopeId: buildScopeId(atRule),
+        owner: `@${atRule.name}`,
+        tailwindOwned: isInsideThemeAtRule(atRule),
+        ...nodeLocation(atRule, filePath)
+      });
+    }
+  });
+  return {
+    filePath,
+    definitions,
+    references,
+    registered: [...registered].sort(),
+    thirdParty: isThirdPartyCssPath(filePath)
+  };
+}
+function collectRegisteredProperties(root) {
+  const registered = /* @__PURE__ */ new Set();
+  root.walkAtRules("property", (atRule) => {
+    const name = atRule.params.trim();
+    if (name.startsWith("--")) {
+      registered.add(name);
+    }
+  });
+  return registered;
+}
+function extractVarReferences(value) {
+  const references = /* @__PURE__ */ new Set();
+  for (const match of value.matchAll(VAR_REFERENCE_RE)) {
+    references.add(match[1]);
+  }
+  return [...references].sort();
+}
+function isThirdPartyCssPath(filePath) {
+  return filePath.split(/[\\/]/).includes("node_modules");
+}
+
+function planGlobalVarAliases(input) {
+  const definitions = flattenDefinitions(input.scans);
+  const candidates = collectCandidates(input, definitions);
+  const aliasPrefix = input.aliasPrefix ?? types.CSSZYX_GLOBAL_ALIAS_PREFIX;
+  const diagnostics = validateCandidates(
+    candidates,
+    definitions,
+    input.reserved ?? [],
+    aliasPrefix
+  );
+  if (diagnostics.length > 0) {
+    return { entries: [], aliases: /* @__PURE__ */ new Map(), diagnostics };
+  }
+  const definitionNames = new Set(definitions.keys());
+  const entries = [];
+  for (const [index, original] of candidates.entries()) {
+    const alias = `${aliasPrefix}${core.encode(index)}`;
+    if (definitionNames.has(alias)) {
+      return {
+        entries: [],
+        aliases: /* @__PURE__ */ new Map(),
+        diagnostics: [
+          {
+            code: "alias-collision",
+            severity: "error",
+            name: alias,
+            message: `Generated alias ${alias} collides with an existing CSS custom property.`,
+            location: definitions.get(alias)?.[0]
+          }
+        ]
+      };
+    }
+    entries.push({
+      original,
+      alias,
+      scopes: [
+        ...new Set((definitions.get(original) ?? []).map((definition) => definition.scopeId))
+      ].sort()
+    });
+  }
+  return {
+    entries,
+    aliases: new Map(entries.map((entry) => [entry.original, entry.alias])),
+    diagnostics: []
+  };
+}
+function isTailwindReservedGlobalVar(name) {
+  return types.isTailwindReservedCustomProperty(name);
+}
+function flattenDefinitions(scans) {
+  const definitions = /* @__PURE__ */ new Map();
+  for (const scan of scans) {
+    for (const definition of scan.definitions) {
+      const existing = definitions.get(definition.name) ?? [];
+      existing.push(definition);
+      definitions.set(definition.name, existing);
+    }
+  }
+  return definitions;
+}
+function collectCandidates(input, definitions) {
+  const candidates = new Set(input.tokens ?? []);
+  const autoPrefix = input.autoPrefix ?? "";
+  if (autoPrefix !== "") {
+    for (const name of definitions.keys()) {
+      if (name.startsWith(autoPrefix)) {
+        candidates.add(name);
+      }
+    }
+  }
+  return [...candidates].sort();
+}
+function validateCandidates(candidates, definitions, reserved, aliasPrefix) {
+  const diagnostics = [];
+  for (const name of candidates) {
+    const tokenDefinitions = definitions.get(name) ?? [];
+    if (tokenDefinitions.length === 0) {
+      diagnostics.push({
+        code: "missing-definition",
+        severity: "error",
+        name,
+        message: `Global variable token ${name} is not defined in scanned CSS.`
+      });
+      continue;
+    }
+    if (isTailwindReservedGlobalVar(name) || matchesUserReserved(name, reserved)) {
+      diagnostics.push({
+        code: "tailwind-reserved",
+        severity: "error",
+        name,
+        message: `Global variable token ${name} is reserved and cannot be aliased.`,
+        location: tokenDefinitions[0]
+      });
+    }
+    if (types.isCsszyxGlobalAliasCustomProperty(name, aliasPrefix)) {
+      diagnostics.push({
+        code: "tailwind-reserved",
+        severity: "error",
+        name,
+        message: `Global variable token ${name} uses csszyx reserved namespace ${aliasPrefix}* and cannot be aliased.`,
+        location: tokenDefinitions[0]
+      });
+    }
+    const tailwindDefinition = tokenDefinitions.find((definition) => definition.tailwindOwned);
+    if (tailwindDefinition) {
+      diagnostics.push({
+        code: "tailwind-owned",
+        severity: "error",
+        name,
+        message: `Global variable token ${name} is declared inside @theme and cannot be aliased.`,
+        location: tailwindDefinition
+      });
+    }
+    const registeredDefinition = tokenDefinitions.find((definition) => definition.registered);
+    if (registeredDefinition) {
+      diagnostics.push({
+        code: "registered-property",
+        severity: "error",
+        name,
+        message: `Registered custom property ${name} is not aliasable in Phase H v1.`,
+        location: registeredDefinition
+      });
+    }
+  }
+  return diagnostics;
+}
+function matchesUserReserved(name, reserved) {
+  return reserved.some((pattern) => {
+    if (pattern.endsWith("*")) {
+      return name.startsWith(pattern.slice(0, -1));
+    }
+    return name === pattern;
+  });
+}
+
+function rewriteGlobalVarCssAliases(options) {
+  if (options.plan.diagnostics.length > 0 || options.plan.entries.length === 0) {
+    return {
+      css: options.css,
+      aliasDeclarations: 0,
+      rewrittenReferences: 0,
+      diagnostics: options.plan.diagnostics
+    };
+  }
+  const root = postcss__default.parse(options.css, { from: options.filePath });
+  const aliasNames = new Set(options.plan.entries.map((entry) => entry.alias));
+  const referenceAliases = new Map(
+    options.plan.entries.filter((entry) => canRewriteGlobalVarReferences(entry)).map((entry) => [entry.original, entry.alias])
+  );
+  let aliasDeclarations = 0;
+  let rewrittenReferences = 0;
+  root.walkDecls((decl) => {
+    if (isInsideThemeAtRule(decl)) {
+      return;
+    }
+    const alias = options.plan.aliases.get(decl.prop);
+    if (alias && !hasSiblingDeclaration(decl, alias)) {
+      decl.cloneAfter({ prop: alias, value: `var(${decl.prop})` });
+      aliasDeclarations++;
+    }
+    if (options.plan.aliases.has(decl.prop) || aliasNames.has(decl.prop)) {
+      return;
+    }
+    const rewrite = rewriteGlobalVarValue(decl.value, referenceAliases);
+    if (rewrite.count > 0) {
+      decl.value = rewrite.value;
+      rewrittenReferences += rewrite.count;
+    }
+  });
+  return {
+    css: root.toString(),
+    aliasDeclarations,
+    rewrittenReferences,
+    diagnostics: []
+  };
+}
+function canRewriteGlobalVarReferences(entry) {
+  return entry.scopes.some(isInheritedGlobalAliasScope);
+}
+function isInheritedGlobalAliasScope(scope) {
+  const leaf = scope.split(" > ").at(-1);
+  if (!leaf?.startsWith("rule:")) {
+    return false;
+  }
+  const selector = leaf.slice("rule:".length);
+  return selector.split(",").some((part) => {
+    const normalized = part.trim();
+    return normalized === ":root" || normalized === "html" || normalized === "body";
+  });
+}
+function rewriteGlobalVarValue(value, aliases) {
+  const parsed = valueParser__default(value);
+  let count = 0;
+  parsed.walk((node) => {
+    if (node.type !== "function" || node.value.toLowerCase() !== "var") {
+      return;
+    }
+    const firstArgument = node.nodes.find((child) => child.type !== "space");
+    if (!firstArgument || firstArgument.type !== "word") {
+      return;
+    }
+    const alias = aliases.get(firstArgument.value);
+    if (!alias) {
+      return;
+    }
+    firstArgument.value = alias;
+    count++;
+  });
+  return { value: count > 0 ? valueParser__default.stringify(parsed.nodes) : value, count };
+}
+
+function validateGlobalVarAliasInputs(options) {
+  const scans = options.cssFiles.map(
+    (file) => scanCssSourceWithOptionalCache(file, options.cacheDir)
+  );
+  const plan = planGlobalVarAliases({
+    scans,
+    tokens: options.tokens,
+    autoPrefix: options.autoPrefix,
+    aliasPrefix: options.aliasPrefix,
+    reserved: options.reserved
+  });
+  if (plan.diagnostics.length > 0 || plan.entries.length === 0) {
+    return { scans, plan, usageDiagnostics: [] };
+  }
+  const candidateTokens = plan.entries.map((entry) => entry.original);
+  const usageDiagnostics = (options.sourceFiles ?? []).flatMap(
+    (file) => compiler.scanGlobalVarUsages(file.code, file.filePath, { tokens: candidateTokens })
+  );
+  return { scans, plan, usageDiagnostics };
+}
+function createGlobalVarAliasValidationOptions(input) {
+  return {
+    cssFiles: input.cssAssets.filter((asset) => /\.css(?:$|\?)/.test(asset.fileName)).map((asset) => ({
+      filePath: normalizeBuildAssetPath(input.rootDir, asset.fileName),
+      css: cssAssetSourceToString(asset.source),
+      mtimeMs: asset.mtimeMs
+    })),
+    sourceFiles: input.sourceFiles ?? [],
+    tokens: input.tokens,
+    autoPrefix: input.autoPrefix,
+    aliasPrefix: input.aliasPrefix,
+    reserved: input.reserved,
+    cacheDir: input.cacheDir
+  };
+}
+function scanCssSourceWithOptionalCache(file, cacheDir) {
+  if (cacheDir === void 0 || file.mtimeMs === void 0) {
+    return scanGlobalVarCss(file.css, { filePath: file.filePath });
+  }
+  const key = createGlobalVarScanCacheKey({
+    filePath: file.filePath,
+    css: file.css,
+    mtimeMs: file.mtimeMs
+  });
+  const cached = readGlobalVarScanCache(cacheDir, key);
+  if (cached) {
+    return cached;
+  }
+  const result = scanGlobalVarCss(file.css, { filePath: file.filePath });
+  writeGlobalVarScanCache(cacheDir, key, result);
+  return result;
+}
+function normalizeBuildAssetPath(rootDir, fileName) {
+  return (path__namespace.isAbsolute(fileName) ? fileName : path__namespace.join(rootDir, fileName)).replace(
+    /\\/g,
+    "/"
+  );
+}
+function cssAssetSourceToString(source) {
+  return typeof source === "string" ? source : Buffer.from(source).toString("utf8");
+}
+
+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__namespace.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 dynamicImportRe = /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+  for (const { clause, source } of findStaticImports(scanCode)) {
+    if (!isRuntimeImportSource(source)) {
+      continue;
+    }
+    if (clause === null) {
+      imports.push({
+        source,
+        symbols: isWholeRuntimeModuleForbidden(source) ? Array.from(FORBIDDEN_SYMBOLS) : []
+      });
+    } else {
+      imports.push({ source, symbols: readRuntimeImportSymbols(source, clause) });
+    }
+  }
+  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 findStaticImports(code) {
+  const imports = [];
+  let cursor = 0;
+  while (cursor < code.length) {
+    const importStart = code.indexOf("import", cursor);
+    if (importStart === -1) {
+      break;
+    }
+    cursor = importStart + 6;
+    if (importStart > 0 && isIdentifierPart(code.charCodeAt(importStart - 1)) || isIdentifierPart(code.charCodeAt(cursor))) {
+      continue;
+    }
+    let position = skipAsciiWhitespace(code, cursor);
+    const opener = code.charAt(position);
+    if (opener === "(") {
+      continue;
+    }
+    if (opener === '"' || opener === "'") {
+      const literal2 = readQuotedString(code, position);
+      if (literal2) {
+        imports.push({ clause: null, source: literal2.value });
+        cursor = literal2.end;
+      }
+      continue;
+    }
+    const clauseStart = position;
+    let fromStart = -1;
+    while (position < code.length) {
+      if (code.startsWith("from", position) && (position === clauseStart || !isIdentifierPart(code.charCodeAt(position - 1))) && !isIdentifierPart(code.charCodeAt(position + 4))) {
+        fromStart = position;
+        break;
+      }
+      if (code.charAt(position) === ";") {
+        break;
+      }
+      position += 1;
+    }
+    if (fromStart === -1) {
+      continue;
+    }
+    const clause = code.slice(clauseStart, fromStart).trim();
+    if (splitAsciiWhitespace(clause)[0] === "type") {
+      cursor = fromStart + 4;
+      continue;
+    }
+    position = skipAsciiWhitespace(code, fromStart + 4);
+    const literal = readQuotedString(code, position);
+    if (literal) {
+      imports.push({ clause, source: literal.value });
+      cursor = literal.end;
+    }
+  }
+  return imports;
+}
+function readQuotedString(code, start) {
+  const quote = code.charAt(start);
+  if (quote !== '"' && quote !== "'") {
+    return null;
+  }
+  let value = "";
+  for (let index = start + 1; index < code.length; index += 1) {
+    const char = code.charAt(index);
+    if (char === "\\") {
+      if (index + 1 >= code.length) {
+        return null;
+      }
+      value += code.charAt(index + 1);
+      index += 1;
+    } else if (char === quote) {
+      return { end: index + 1, value };
+    } else if (char === "\n" || char === "\r") {
+      return null;
+    } else {
+      value += char;
+    }
+  }
+  return null;
+}
+function skipAsciiWhitespace(code, start) {
+  let index = start;
+  while (index < code.length) {
+    const charCode = code.charCodeAt(index);
+    if (charCode !== 9 && charCode !== 10 && charCode !== 13 && charCode !== 32) {
+      break;
+    }
+    index += 1;
+  }
+  return index;
+}
+function isIdentifierPart(code) {
+  return isIdentifierStart(code) || code >= 48 && code <= 57;
+}
+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__namespace.realpathSync.native(clean).replace(/\\/g, "/");
+  } catch {
+    normalized = path__namespace.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__namespace.resolve(path__namespace.dirname(importer), source);
+  const candidates = [
+    base,
+    `${base}.tsx`,
+    `${base}.ts`,
+    `${base}.jsx`,
+    `${base}.js`,
+    `${base}.mjs`,
+    `${base}.cjs`,
+    path__namespace.join(base, "index.tsx"),
+    path__namespace.join(base, "index.ts"),
+    path__namespace.join(base, "index.jsx"),
+    path__namespace.join(base, "index.js")
+  ];
+  for (const candidate of candidates) {
+    try {
+      if (!fs__namespace.statSync(candidate).isFile()) {
+        continue;
+      }
+      const resolved = normalizeModuleId(candidate);
+      resolvedLocalModuleCache.set(cacheKey, resolved);
+      return resolved;
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+  }
+  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 openBrace = clause.indexOf("{");
+  const closeBrace = openBrace === -1 ? -1 : clause.indexOf("}", openBrace);
+  if (openBrace !== -1 && closeBrace !== -1) {
+    const namedPart = clause.slice(openBrace + 1, closeBrace);
+    for (const part of namedPart.split(",")) {
+      const trimmed = part.trim();
+      if (!trimmed || trimmed.startsWith("type ")) {
+        continue;
+      }
+      const sourceName = trimmed.replace(/^type[ \t]+/, "").split(/[ \t]+as[ \t]+/)[0]?.trim();
+      if (sourceName) {
+        symbols.push(sourceName);
+      }
+    }
+  }
+  const namespaceParts = splitAsciiWhitespace(clause);
+  if (namespaceParts.length >= 3 && namespaceParts[0] === "*" && namespaceParts[1] === "as" && isIdentifier(namespaceParts[2] ?? "")) {
+    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 defaultCandidate = stripped.trimStart().split(",", 1)[0]?.trim() ?? "";
+  const defaultSymbol = isIdentifier(defaultCandidate) ? defaultCandidate : void 0;
+  if (defaultSymbol && FORBIDDEN_SYMBOLS.has(defaultSymbol)) {
+    symbols.push(defaultSymbol);
+  }
+  return symbols;
+}
+function isIdentifier(value) {
+  if (value.length === 0 || !isIdentifierStart(value.charCodeAt(0))) {
+    return false;
+  }
+  for (let index = 1; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (!isIdentifierStart(code) && (code < 48 || code > 57)) {
+      return false;
+    }
+  }
+  return true;
+}
+function isIdentifierStart(code) {
+  return code === 36 || code === 95 || code >= 65 && code <= 90 || code >= 97 && code <= 122;
+}
+function splitAsciiWhitespace(value) {
+  const parts = [];
+  let start = -1;
+  for (let index = 0; index <= value.length; index += 1) {
+    const code = index < value.length ? value.charCodeAt(index) : 32;
+    const whitespace = code === 9 || code === 10 || code === 13 || code === 32;
+    if (whitespace) {
+      if (start !== -1) {
+        parts.push(value.slice(start, index));
+        start = -1;
+      }
+    } else if (start === -1) {
+      start = index;
+    }
+  }
+  return parts;
+}
+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__namespace.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__namespace.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__namespace.isAbsolute(normalizedPattern) ? normalizeFileId(normalizedPattern) : normalizeFileId(path__namespace.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__namespace.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const full = path__namespace.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (!DEFAULT_IGNORED_DIRS.has(entry.name) && !entry.name.startsWith(".")) {
+          walk(full);
+        }
+      } else {
+        files.add(path__namespace.resolve(full));
+      }
+    }
+  };
+  let needsWalk = false;
+  for (const pattern of list) {
+    const resolved = path__namespace.isAbsolute(pattern) ? pattern : path__namespace.join(rootDir, pattern);
+    if (hasGlobMagic(pattern)) {
+      needsWalk = true;
+      continue;
+    }
+    if (fs__namespace.existsSync(resolved)) {
+      files.add(path__namespace.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__namespace.isAbsolute(pattern) ? pattern : path__namespace.join(rootDir, pattern);
+          return normalizeFileId(path__namespace.resolve(resolved)) === normalizeFileId(file);
+        });
+        if (!isLiteralMatch) {
+          files.delete(file);
+        }
+      }
+    }
+  }
+  return Array.from(files).sort();
+}
+
+function safeJsonForScriptTag(value, prettyPrint = false) {
+  const json = prettyPrint ? JSON.stringify(value, null, 2) : JSON.stringify(value);
+  return json.replace(/</g, "\\u003C").replace(/>/g, "\\u003E").replace(/&/g, "\\u0026").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+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,
+    varMangleMap = {},
+    globalVarAliasPrefix = types.CSSZYX_GLOBAL_ALIAS_PREFIX
+  } = options;
+  const checksumMap = createHydrationMangleMap(mangleMap, varMangleMap);
+  const jsonContent = safeJsonForScriptTag(checksumMap, prettyPrint);
+  const classMapContent = safeJsonForScriptTag(mangleMap);
+  const varMapContent = safeJsonForScriptTag(varMangleMap);
+  const scriptTag = `<script id="__CSSZYX_MANGLE_MAP__" type="application/json">${jsonContent}<\/script>`;
+  const prefixContent = safeJsonForScriptTag(globalVarAliasPrefix);
+  const debugScript = `<script>(function(){var m=${classMapContent};var vm=${varMapContent};var gp=${prefixContent};var r={};var vr={};for(var k in m)r[m[k]]=k;for(var vk in vm){var vv=vm[vk];var vs=Array.isArray(vv)?vv:[vv];for(var vi=0;vi<vs.length;vi++)(vr[vs[vi]]||(vr[vs[vi]]=[])).push(vk)}var cs=document.documentElement.getAttribute("data-sz-checksum")||"";window.__csszyx={mangleMap:m,varMangleMap:vm,checksum:cs,decode:function(c){return r[c]},encode:function(c){return m[c]},decodeVar:function(v){return vr[v]||[]},encodeVar:function(v){return vm[v]},decodeGlobalVar:function(v){var a=vr[v]||[];return v.indexOf(gp)===0?a[0]:void 0},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, varMangleMap = {}) {
+  const attrName = minify ? "data-sz-m" : "data-sz-map";
+  const jsonContent = JSON.stringify(createHydrationMangleMap(mangleMap, varMangleMap));
+  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, options.varMangleMap);
+  } else if (mode === "script") {
+    result = injectMangleMapScript(result, mangleMap, options);
+  } else if (mode === "both") {
+    result = injectMangleMapAttribute(result, mangleMap, minify, options.varMangleMap);
+    result = injectMangleMapScript(result, mangleMap, options);
+  }
+  return result;
+}
+function transformIndexHtml(html, mangleMap, checksum, options = {}) {
+  return injectHydrationData(html, mangleMap, checksum, options);
+}
+function createHydrationMangleMap(classMap, varMap = {}) {
+  if (Object.keys(varMap).length === 0) {
+    return classMap;
+  }
+  const payload = {};
+  for (const [key, value] of Object.entries(classMap)) {
+    payload[`class:${key}`] = value;
+  }
+  for (const [key, value] of Object.entries(varMap)) {
+    if (Array.isArray(value)) {
+      for (const mangled of value) {
+        payload[`var:${key}:${mangled}`] = mangled;
+      }
+    } else {
+      payload[`var:${key}`] = value;
+    }
+  }
+  return payload;
+}
+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 = node_crypto.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;
+}
+
+const DEFAULT_MAX_ATTEMPTS = 3;
+const NODE_FS = {
+  openSync: fs__namespace.openSync,
+  fstatSync: (fd, options) => fs__namespace.fstatSync(fd, options),
+  readFileSync: (fd, encoding) => fs__namespace.readFileSync(fd, encoding),
+  closeSync: fs__namespace.closeSync
+};
+function readStableTextFileSnapshotSync(file, maxAttempts = DEFAULT_MAX_ATTEMPTS, fsApi = NODE_FS) {
+  if (!Number.isInteger(maxAttempts) || maxAttempts < 1) {
+    throw new RangeError("maxAttempts must be a positive integer.");
+  }
+  for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+    const fd = fsApi.openSync(file, "r");
+    try {
+      const before = fsApi.fstatSync(fd, { bigint: true });
+      const source = fsApi.readFileSync(fd, "utf8");
+      const after = fsApi.fstatSync(fd, { bigint: true });
+      if (isSameFileVersion(before, after)) {
+        return { source, mtimeMs: Number(after.mtimeMs) };
+      }
+    } finally {
+      fsApi.closeSync(fd);
+    }
+  }
+  throw new Error(`CSS source changed while being read: ${file}`);
+}
+function isSameFileVersion(before, after) {
+  return before.dev === after.dev && before.ino === after.ino && before.size === after.size && before.mtimeNs === after.mtimeNs && before.ctimeNs === after.ctimeNs;
+}
+
+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);
+  fs.mkdirSync(path.dirname(opts.outputPath), { recursive: true });
+  fs.writeFileSync(opts.outputPath, content, "utf-8");
+}
+
+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, varMangleMap = {}, cssVarMetrics = null) {
+  return `/**
+ * Auto-generated mangle map for csszyx.
+ * This module is generated at build time and contains the mapping
+ * from original class names and CSS variable names to mangled names.
+ *
+ * @generated
+ */
+
+export const mangleMap = ${JSON.stringify(mangleMap, null, 2)};
+
+export const varMangleMap = ${JSON.stringify(varMangleMap, null, 2)};
+
+export const cssVarMetrics = ${JSON.stringify(cssVarMetrics, null, 2)};
+
+export const checksum = ${JSON.stringify(checksum)};
+
+export default {
+  mangleMap,
+  varMangleMap,
+  cssVarMetrics,
+  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 VAR_MANGLE_MAP_PLACEHOLDER = "___CSSZYX_VAR_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 DEFAULT_VAR_MANGLE_MAP_MAX_BYTES = 100 * 1024;
+const GLOBAL_VAR_ALIAS_MAP_OWNER = "\0csszyx:global-var-aliases";
+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 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('shared/unplugin.CFp386gH.cjs', document.baseURI).href)));
+const PLUGIN_VERSION = findPackageVersionFromFile(
+  node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('shared/unplugin.CFp386gH.cjs', document.baseURI).href))),
+  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 cssVariableEntries(result) {
+  const entries = [];
+  for (const [original, value] of result.cssVariableMap ?? []) {
+    if (Array.isArray(value)) {
+      for (const mangled of value) {
+        entries.push([original, mangled]);
+      }
+    } else {
+      entries.push([original, value]);
+    }
+  }
+  return entries;
+}
+function recordFileVarMangleEntries(state, filename, entries) {
+  const normalizedFilename = normalizeSourceFilename(filename);
+  if (entries.length === 0) {
+    state.varMangleEntriesByFile.delete(normalizedFilename);
+  } else {
+    state.varMangleEntriesByFile.set(normalizedFilename, entries);
+  }
+  state.varMangleMap = buildVarMangleMap(state.varMangleEntriesByFile);
+}
+function recordGlobalVarSourceFile(state, filename, code) {
+  const normalizedFilename = normalizeSourceFilename(filename);
+  if (!/\.[tj]sx?(?:\?.*)?$/.test(normalizedFilename)) {
+    return;
+  }
+  if (code === null) {
+    state.globalVarSourceFilesByFile.delete(normalizedFilename);
+  } else {
+    state.globalVarSourceFilesByFile.set(normalizedFilename, code);
+  }
+}
+function buildGlobalVarSourceFiles(state) {
+  return [...state.globalVarSourceFilesByFile.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([filePath, code]) => ({ filePath, code }));
+}
+function collectRollupGlobalVarCssAssets(bundle) {
+  return Object.values(bundle).filter(
+    (chunk) => chunk.type === "asset" && typeof chunk.fileName === "string" && /\.css(?:$|\?)/.test(chunk.fileName) && (typeof chunk.source === "string" || chunk.source instanceof Uint8Array)
+  ).sort((left, right) => left.fileName.localeCompare(right.fileName)).map((asset) => ({
+    fileName: asset.fileName,
+    source: asset.source
+  }));
+}
+function collectConfiguredGlobalVarCssSources(rootDir, scanCss) {
+  if (!scanCss) {
+    return [];
+  }
+  return expandFilePatterns(rootDir, scanCss).filter((file) => file.endsWith(".css")).sort((left, right) => left.localeCompare(right)).flatMap((file) => {
+    try {
+      const snapshot = readStableTextFileSnapshotSync(file);
+      return [
+        {
+          fileName: file,
+          source: snapshot.source,
+          mtimeMs: snapshot.mtimeMs
+        }
+      ];
+    } catch {
+      return [];
+    }
+  });
+}
+function collectWebpackGlobalVarCssAssets(assets) {
+  return Object.entries(assets).flatMap(([fileName, asset]) => {
+    if (!/\.css(?:$|\?)/.test(fileName)) {
+      return [];
+    }
+    const source = asset.source();
+    if (typeof source !== "string" && !(source instanceof Uint8Array)) {
+      return [];
+    }
+    return [{ fileName, source }];
+  }).sort((left, right) => left.fileName.localeCompare(right.fileName)).map(({ fileName, source }) => ({ fileName, source }));
+}
+function assertNoGlobalVarAliasValidationErrors(result) {
+  const messages = [
+    ...result.plan.diagnostics.map((diagnostic) => {
+      const location = diagnostic.location ? ` (${diagnostic.location.filePath}:${diagnostic.location.line}:${diagnostic.location.column})` : "";
+      return `[${diagnostic.code}] ${diagnostic.name}${location}: ${diagnostic.message}`;
+    }),
+    ...result.usageDiagnostics.map((diagnostic) => {
+      const location = diagnostic.location;
+      return `[${diagnostic.kind}] ${diagnostic.name} (${location.filePath}:${location.line}:${location.column}): ${diagnostic.message}`;
+    })
+  ];
+  if (messages.length > 0) {
+    throw new Error(
+      `[csszyx] production.mangleGlobalVars validation failed:
+${messages.join("\n")}`
+    );
+  }
+}
+function rewriteCssWithValidatedGlobalVarPlan(css, filePath, result) {
+  if (result === null || result.plan.entries.length === 0) {
+    return css;
+  }
+  const rewrite = rewriteGlobalVarCssAliases({
+    css,
+    plan: result.plan,
+    filePath
+  });
+  assertNoGlobalVarAliasValidationErrors({
+    scans: result.scans,
+    plan: {
+      ...result.plan,
+      diagnostics: rewrite.diagnostics
+    },
+    usageDiagnostics: []
+  });
+  return rewrite.css;
+}
+function assertGlobalVarPlanMatchesEarlyAliases(result, expectedEntries) {
+  const actualEntries = [...result.plan.aliases.entries()].sort(
+    ([left], [right]) => left.localeCompare(right)
+  );
+  const expected = expectedEntries.map(([original, alias]) => [original, alias]).sort(([left], [right]) => left.localeCompare(right));
+  const expectedJson = JSON.stringify(expected);
+  const actualJson = JSON.stringify(actualEntries);
+  if (expectedJson !== actualJson) {
+    throw new Error(
+      `[csszyx] production.mangleGlobalVars validation failed:
+CSS alias plan ${actualJson} does not match source-transform alias table ${expectedJson}.`
+    );
+  }
+}
+function buildVarMangleMap(entriesByFile) {
+  const next = {};
+  const files = [...entriesByFile.keys()].sort();
+  for (const file of files) {
+    for (const [original, mangled] of entriesByFile.get(file) ?? []) {
+      addVarMangleMapping(next, original, mangled);
+    }
+  }
+  return next;
+}
+function extractGlobalVarAliasesForManifest(varMangleMap, aliasPrefix = types.CSSZYX_GLOBAL_ALIAS_PREFIX, validationResult = null) {
+  const aliases = {};
+  for (const [original, value] of Object.entries(varMangleMap).sort(
+    ([left], [right]) => left.localeCompare(right)
+  )) {
+    const values = Array.isArray(value) ? value : [value];
+    const alias = values.find((candidate) => candidate.startsWith(aliasPrefix));
+    if (alias) {
+      aliases[original] = alias;
+    }
+  }
+  for (const entry of validationResult?.plan.entries ?? []) {
+    if (entry.alias.startsWith(aliasPrefix)) {
+      aliases[entry.original] = entry.alias;
+    }
+  }
+  return Object.fromEntries(
+    Object.entries(aliases).sort(([left], [right]) => left.localeCompare(right))
+  );
+}
+function createGlobalVarMapAssetSource(varMangleMap, aliasPrefix = types.CSSZYX_GLOBAL_ALIAS_PREFIX, validationResult = null) {
+  const aliases = extractGlobalVarAliasesForManifest(varMangleMap, aliasPrefix, validationResult);
+  return Object.keys(aliases).length > 0 ? JSON.stringify(aliases) : null;
+}
+function normalizeGlobalVarAliasesForCache(aliases) {
+  if (!aliases) {
+    return [];
+  }
+  const entries = aliases instanceof Map ? aliases.entries() : Array.isArray(aliases) ? aliases : Object.entries(aliases);
+  const normalized = /* @__PURE__ */ new Map();
+  for (const [original, alias] of entries) {
+    if (original.startsWith("--") && alias.startsWith("--")) {
+      normalized.set(original, alias);
+    }
+  }
+  return [...normalized].sort(([left], [right]) => left.localeCompare(right));
+}
+function createEarlyGlobalVarAliasEntries(config, aliasPrefix) {
+  if (config?.enabled !== true || !config.tokens || config.tokens.length === 0) {
+    return [];
+  }
+  const tokens = [...new Set(config.tokens)].sort();
+  return tokens.map((original, index) => [original, `${aliasPrefix}${core.encode(index)}`]);
+}
+function shouldEmitGlobalVarMapAsset(config) {
+  return config?.emitMap !== false;
+}
+function assertVarMangleMapSize(varMangleMap, maxBytes) {
+  const size = Buffer.byteLength(JSON.stringify(varMangleMap), "utf8");
+  if (size <= maxBytes) {
+    return;
+  }
+  throw new Error(
+    `[csszyx] CSS variable mangle map is ${size} bytes, which exceeds the ${maxBytes} byte safety cap. Reduce production.mangleVars usage, split the bundle, or raise CSSZYX_VAR_MANGLE_MAP_MAX_BYTES if this payload size is intentional.`
+  );
+}
+function resolveVarMangleMapMaxBytes() {
+  const raw = process.env.CSSZYX_VAR_MANGLE_MAP_MAX_BYTES;
+  if (!raw) {
+    return DEFAULT_VAR_MANGLE_MAP_MAX_BYTES;
+  }
+  const value = Number.parseInt(raw, 10);
+  return Number.isFinite(value) && value > 0 ? value : DEFAULT_VAR_MANGLE_MAP_MAX_BYTES;
+}
+function addVarMangleMapping(map, original, mangled) {
+  const existing = map[original];
+  if (!existing) {
+    map[original] = mangled;
+    return;
+  }
+  const values = Array.isArray(existing) ? existing : [existing];
+  if (!values.includes(mangled)) {
+    map[original] = [...values, mangled];
+  }
+}
+function emptyCSSVariableMetrics() {
+  return {
+    componentClassUses: 0,
+    componentStyleDeclarations: 0,
+    estimatedHoistedDeclarationsSaved: 0,
+    scopedClassUses: 0,
+    scopedStyleDeclarations: 0
+  };
+}
+function recordFileCSSVariableMetrics(state, filename, code) {
+  const normalizedFilename = normalizeSourceFilename(filename);
+  if (!code) {
+    state.cssVarMetricsByFile.delete(normalizedFilename);
+  } else {
+    const metrics = collectCSSVariableMetrics(code);
+    if (hasCSSVariableMetrics(metrics)) {
+      state.cssVarMetricsByFile.set(normalizedFilename, metrics);
+    } else {
+      state.cssVarMetricsByFile.delete(normalizedFilename);
+    }
+  }
+  state.cssVarMetrics = buildCSSVariableMetrics(state.cssVarMetricsByFile);
+}
+function collectCSSVariableMetrics(code) {
+  const componentUses = /* @__PURE__ */ new Map();
+  const componentDeclarations = /* @__PURE__ */ new Map();
+  const metrics = emptyCSSVariableMetrics();
+  for (const match of code.matchAll(/\(--([cs][A-Za-z0-9]+)\)/g)) {
+    const name = `--${match[1]}`;
+    if (name.startsWith("--c")) {
+      metrics.componentClassUses++;
+      incrementCount(componentUses, name);
+    } else {
+      metrics.scopedClassUses++;
+    }
+  }
+  for (const match of code.matchAll(/["'](--([cs][A-Za-z0-9]+))["']\s*:/g)) {
+    const name = match[1];
+    if (name.startsWith("--c")) {
+      metrics.componentStyleDeclarations++;
+      incrementCount(componentDeclarations, name);
+    } else {
+      metrics.scopedStyleDeclarations++;
+    }
+  }
+  for (const [name, uses] of componentUses) {
+    const declarations = componentDeclarations.get(name) ?? 0;
+    metrics.estimatedHoistedDeclarationsSaved += Math.max(0, uses - declarations);
+  }
+  return metrics;
+}
+function buildCSSVariableMetrics(metricsByFile) {
+  const total = emptyCSSVariableMetrics();
+  for (const file of [...metricsByFile.keys()].sort()) {
+    const metrics = metricsByFile.get(file);
+    if (!metrics) {
+      continue;
+    }
+    total.componentClassUses += metrics.componentClassUses;
+    total.componentStyleDeclarations += metrics.componentStyleDeclarations;
+    total.estimatedHoistedDeclarationsSaved += metrics.estimatedHoistedDeclarationsSaved;
+    total.scopedClassUses += metrics.scopedClassUses;
+    total.scopedStyleDeclarations += metrics.scopedStyleDeclarations;
+  }
+  return total;
+}
+function hasCSSVariableMetrics(metrics) {
+  return Object.values(metrics).some((value) => value > 0);
+}
+function incrementCount(map, key) {
+  map.set(key, (map.get(key) ?? 0) + 1);
+}
+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(readStableTextFileSnapshotSync(f).source);
+    } catch {
+      return null;
+    }
+  }).filter((t) => t !== null);
+  const merged = mergeThemes(themes);
+  const outputPath = path__namespace.join(rootDir, ".csszyx", "theme.d.ts");
+  writeThemeDts({ outputPath, theme: merged, sourceFiles });
+  if (!_hasWarnedTsConfig) {
+    _hasWarnedTsConfig = true;
+    try {
+      const checkFile = (cfgPath) => {
+        let content;
+        try {
+          content = fs__namespace.readFileSync(cfgPath, "utf-8");
+        } catch (err) {
+          if (err?.code === "ENOENT") {
+            return false;
+          }
+          throw err;
+        }
+        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;
+      };
+      if (!checkFile(path__namespace.join(rootDir, "tsconfig.json"))) {
+        checkFile(path__namespace.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__namespace.dirname(file);
+  while (true) {
+    const packageJson = path__namespace.join(dir, "package.json");
+    try {
+      const parsed = JSON.parse(fs__namespace.readFileSync(packageJson, "utf8"));
+      if (typeof parsed.version === "string") {
+        return parsed.version;
+      }
+      return fallback;
+    } catch {
+    }
+    const parent = path__namespace.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 assertGlobalVarMangleConfig(options) {
+  const config = options.production?.mangleGlobalVars;
+  const errors = types.validateGlobalVarMangleConfig(config);
+  if (errors.length > 0) {
+    throw new Error(
+      `[csszyx] Invalid production.mangleGlobalVars config:
+${errors.join("\n")}`
+    );
+  }
+  if (config?.enabled === true) {
+    if (!config.tokens || config.tokens.length === 0) {
+      throw new Error(
+        "[csszyx] production.mangleGlobalVars.enabled requires explicit tokens in Phase H v1."
+      );
+    }
+    if (config.autoPrefix !== void 0 && config.autoPrefix !== "") {
+      throw new Error(
+        "[csszyx] production.mangleGlobalVars.autoPrefix requires CSS pre-scan support and is not enabled in Phase H v1."
+      );
+    }
+  }
+}
+function createCsszyxPlugins(options = {}) {
+  assertGlobalVarMangleConfig(options);
+  const manglingEnabled = options.production?.mangle !== false;
+  const astBudgetOverride = options.build?.astBudgetLimit;
+  const cacheRequested = (options.build?.cache ?? types.DEFAULT_BUILD_CONFIG.cache) !== false;
+  const cacheVersionsKnown = PLUGIN_VERSION !== UNKNOWN_PACKAGE_VERSION && COMPILER_VERSION !== UNKNOWN_PACKAGE_VERSION;
+  const cacheEnabled = cacheRequested && cacheVersionsKnown;
+  const varMangleMapMaxBytes = resolveVarMangleMapMaxBytes();
+  const globalVarMangleConfig = options.production?.mangleGlobalVars;
+  const globalVarAliasPrefix = globalVarMangleConfig?.aliasPrefix ?? types.CSSZYX_GLOBAL_ALIAS_PREFIX;
+  const encodedGlobalVarAliasPrefix = encodeURIComponent(globalVarAliasPrefix);
+  const earlyGlobalVarAliasEntries = createEarlyGlobalVarAliasEntries(
+    globalVarMangleConfig,
+    globalVarAliasPrefix
+  );
+  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 = types.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: {},
+    varMangleEntriesByFile: /* @__PURE__ */ new Map(),
+    varMangleMap: Object.fromEntries(earlyGlobalVarAliasEntries),
+    cssVarMetricsByFile: /* @__PURE__ */ new Map(),
+    cssVarMetrics: emptyCSSVariableMetrics(),
+    checksum: "",
+    finalized: false,
+    rootDir: process.cwd(),
+    recoveryTokens: /* @__PURE__ */ new Map(),
+    rscModules: /* @__PURE__ */ new Map(),
+    globalVarSourceFilesByFile: /* @__PURE__ */ new Map(),
+    globalVarValidationResult: null
+  };
+  if (earlyGlobalVarAliasEntries.length > 0) {
+    state.varMangleEntriesByFile.set(GLOBAL_VAR_ALIAS_MAP_OWNER, earlyGlobalVarAliasEntries);
+  }
+  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 resolveGlobalVarValidationCacheDir() {
+    if (!cacheEnabled) {
+      return void 0;
+    }
+    const cacheRoot = path__namespace.resolve(
+      state.rootDir,
+      options.build?.cacheDir ?? types.DEFAULT_BUILD_CONFIG.cacheDir ?? ".csszyx/cache"
+    );
+    return resolveGlobalVarScanCacheDir(cacheRoot);
+  }
+  function validateGlobalVarBundleInputs(cssAssets) {
+    if (globalVarMangleConfig?.enabled !== true) {
+      return null;
+    }
+    const configuredCssAssets = collectConfiguredGlobalVarCssSources(
+      state.rootDir,
+      options.build?.scanCss
+    );
+    const result = validateGlobalVarAliasInputs(
+      createGlobalVarAliasValidationOptions({
+        rootDir: state.rootDir,
+        cssAssets: [...configuredCssAssets, ...cssAssets],
+        sourceFiles: buildGlobalVarSourceFiles(state),
+        tokens: globalVarMangleConfig.tokens,
+        autoPrefix: globalVarMangleConfig.autoPrefix,
+        aliasPrefix: globalVarAliasPrefix,
+        reserved: globalVarMangleConfig.reserved,
+        cacheDir: resolveGlobalVarValidationCacheDir()
+      })
+    );
+    assertNoGlobalVarAliasValidationErrors(result);
+    assertGlobalVarPlanMatchesEarlyAliases(result, earlyGlobalVarAliasEntries);
+    return result;
+  }
+  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 = createCompilerOptions();
+    const effectiveFilename = normalizeSourceFilename(filename);
+    const cacheRoot = transformCache.resolveTransformCacheDir(state.rootDir, options.build?.cacheDir);
+    if (cacheEnabled) {
+      evictTransformCacheOnce();
+    }
+    const cacheInput = createConfiguredTransformCacheInput(
+      source,
+      effectiveFilename,
+      compilerOptions
+    );
+    if (parserMode === "rust") {
+      compiler.ensureRustTransformAvailable();
+    }
+    const cacheKey = cacheEnabled ? transformCache.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 = transformCache.readTransformCache(cacheRoot, cacheInput, cacheKey);
+      if (cached) {
+        rememberTransformCacheEntry(cacheKey.key, cached);
+        return cached;
+      }
+    }
+    let result;
+    if (parserMode === "babel") {
+      result = compiler.transformSourceCode(source, effectiveFilename, compilerOptions);
+    } else if (parserMode === "rust") {
+      result = compiler.transformRust(source, effectiveFilename, compilerOptions);
+    } else {
+      try {
+        result = compiler.transformOxc(source, effectiveFilename, compilerOptions);
+      } catch (err) {
+        result = compiler.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) {
+      transformCache.writeTransformCache(cacheRoot, cacheInput, result, cacheKey);
+      rememberTransformCacheEntry(cacheKey.key, result);
+    }
+    return result;
+  }
+  function createCompilerOptions() {
+    return {
+      astBudget: astBudgetOverride,
+      mangleVars: options.production?.mangleVars === true,
+      mangleVarHoistMaxDepth: options.production?.mangleVarHoistMaxDepth,
+      globalVarAliases: earlyGlobalVarAliasEntries.length > 0 ? earlyGlobalVarAliasEntries : void 0
+    };
+  }
+  function createConfiguredTransformCacheInput(source, effectiveFilename, compilerOptions) {
+    return {
+      pluginVersion: PLUGIN_VERSION,
+      compilerVersion: COMPILER_VERSION,
+      parserMode,
+      producer: parserMode,
+      astBudget: astBudgetOverride,
+      mangleVars: compilerOptions.mangleVars,
+      mangleVarHoistMaxDepth: compilerOptions.mangleVarHoistMaxDepth,
+      globalVarAliases: normalizeGlobalVarAliasesForCache(compilerOptions.globalVarAliases),
+      filename: effectiveFilename,
+      source
+    };
+  }
+  function transformPrescanSources(files) {
+    if (parserMode !== "rust" || files.length <= 1) {
+      return transformPrescanSourcesIndividually(files);
+    }
+    const compilerOptions = createCompilerOptions();
+    const cacheRoot = transformCache.resolveTransformCacheDir(state.rootDir, options.build?.cacheDir);
+    const results = /* @__PURE__ */ new Map();
+    const misses = [];
+    if (cacheEnabled) {
+      evictTransformCacheOnce();
+    }
+    compiler.ensureRustTransformAvailable();
+    for (const file of files) {
+      const effectiveFilename = normalizeSourceFilename(file.filePath);
+      const cacheInput = createConfiguredTransformCacheInput(
+        file.content,
+        effectiveFilename,
+        compilerOptions
+      );
+      const cacheKey = cacheEnabled ? transformCache.createTransformCacheKey(cacheInput) : null;
+      if (cacheEnabled && cacheKey) {
+        const memoryCached = transformMemoryCache.get(cacheKey.key);
+        if (memoryCached) {
+          transformMemoryCache.delete(cacheKey.key);
+          transformMemoryCache.set(cacheKey.key, memoryCached);
+          results.set(file.filePath, memoryCached);
+          continue;
+        }
+        const cached = transformCache.readTransformCache(cacheRoot, cacheInput, cacheKey);
+        if (cached) {
+          rememberTransformCacheEntry(cacheKey.key, cached);
+          results.set(file.filePath, cached);
+          continue;
+        }
+      }
+      misses.push({
+        filePath: file.filePath,
+        effectiveFilename,
+        content: file.content,
+        cacheInput,
+        cacheKey
+      });
+    }
+    if (misses.length === 0) {
+      return files.map((file) => {
+        const result = results.get(file.filePath);
+        return result ? { filePath: file.filePath, result } : null;
+      }).filter((entry) => entry !== null);
+    }
+    try {
+      const batchResults = compiler.transformRustBatch(
+        misses.map((file) => ({
+          filename: file.effectiveFilename,
+          source: file.content
+        })),
+        compilerOptions
+      );
+      for (let index = 0; index < misses.length; index++) {
+        const miss = misses[index];
+        const result = batchResults[index];
+        if (!miss || !result) {
+          continue;
+        }
+        if (cacheEnabled && miss.cacheKey) {
+          transformCache.writeTransformCache(cacheRoot, miss.cacheInput, result, miss.cacheKey);
+          rememberTransformCacheEntry(miss.cacheKey.key, result);
+        }
+        results.set(miss.filePath, result);
+      }
+    } catch {
+      for (const miss of misses) {
+        try {
+          results.set(
+            miss.filePath,
+            transformConfiguredSource(miss.content, miss.effectiveFilename)
+          );
+        } catch {
+        }
+      }
+    }
+    return files.map((file) => {
+      const result = results.get(file.filePath);
+      return result ? { filePath: file.filePath, result } : null;
+    }).filter((entry) => entry !== null);
+  }
+  function transformPrescanSourcesIndividually(files) {
+    const results = [];
+    for (const file of files) {
+      try {
+        results.push({
+          filePath: file.filePath,
+          result: transformConfiguredSource(file.content, file.filePath)
+        });
+      } catch {
+      }
+    }
+    return results;
+  }
+  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 = transformCache.resolveTransformCacheDir(state.rootDir, options.build?.cacheDir);
+    if (evictedCacheRoot === cacheRoot) {
+      return;
+    }
+    evictedCacheRoot = cacheRoot;
+    transformCache.evictOldTransformCacheEntries(cacheRoot, {
+      maxAgeMs: TRANSFORM_CACHE_MAX_AGE_MS,
+      maxEntries: TRANSFORM_CACHE_MAX_ENTRIES
+    });
+  }
+  function writeSafelistFile(classes) {
+    if (classes.size === 0) {
+      return;
+    }
+    const safelistPath = path__namespace.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 {
+      let existing = "";
+      try {
+        existing = fs__namespace.readFileSync(safelistPath, "utf-8");
+      } catch (err) {
+        if (err?.code !== "ENOENT") {
+          throw err;
+        }
+      }
+      if (existing !== content) {
+        fs__namespace.writeFileSync(safelistPath, content);
+      }
+    } catch {
+    }
+  }
+  function prescanAndWriteClasses() {
+    const prescanStarted = node_perf_hooks.performance.now();
+    const discoveredClasses = /* @__PURE__ */ new Set();
+    const rawDiscoveredClasses = /* @__PURE__ */ new Set();
+    const prescanSources = [];
+    function scanDir(dir) {
+      let entries;
+      try {
+        entries = fs__namespace.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__namespace.join(dir, entry.name));
+          }
+        } else if (SOURCE_EXTENSIONS.has(path__namespace.extname(entry.name))) {
+          const filePath = path__namespace.join(dir, entry.name);
+          if (!shouldProcessSource(filePath)) {
+            continue;
+          }
+          let content;
+          try {
+            content = fs__namespace.readFileSync(filePath, "utf-8");
+          } catch {
+            continue;
+          }
+          if (!content.includes("sz=") && !content.includes("sz:")) {
+            continue;
+          }
+          prescanSources.push({ filePath, content });
+        }
+      }
+    }
+    scanDir(state.rootDir);
+    for (const { filePath, result } of transformPrescanSources(prescanSources)) {
+      if (!result.transformed) {
+        continue;
+      }
+      collectPrescanResult(result, filePath, discoveredClasses, rawDiscoveredClasses);
+    }
+    for (const cls of discoveredClasses) {
+      state.classes.add(cls);
+    }
+    const safelistClasses = /* @__PURE__ */ new Set([...discoveredClasses, ...rawDiscoveredClasses]);
+    writeSafelistFile(safelistClasses);
+    traceBenchTiming("prescan", state.rootDir, node_perf_hooks.performance.now() - prescanStarted);
+  }
+  function collectPrescanResult(result, filePath, discoveredClasses, rawDiscoveredClasses) {
+    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);
+    }
+    recordFileVarMangleEntries(state, filePath, cssVariableEntries(result));
+    recordFileCSSVariableMetrics(state, filePath, result.code);
+    collectRuntimeStaticClasses(result, discoveredClasses);
+  }
+  function collectRuntimeStaticClasses(result, discoveredClasses) {
+    if (!result.usesRuntime) {
+      return;
+    }
+    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);
+      collectRuntimeStringClasses(objStr, discoveredClasses);
+      collectRuntimeNumberClasses(objStr, discoveredClasses);
+      collectRuntimeBooleanClasses(objStr, discoveredClasses);
+    }
+  }
+  function collectRuntimeStringClasses(objStr, discoveredClasses) {
+    const strKv = /(\w+)\s*:\s*(?:"([^"]*)"|'([^']*)')/g;
+    for (const kv of objStr.matchAll(strKv)) {
+      try {
+        const val = kv[2] ?? kv[3];
+        collectTransformClasses(compiler.transform({ [kv[1]]: val }), discoveredClasses);
+      } catch {
+      }
+    }
+  }
+  function collectRuntimeNumberClasses(objStr, discoveredClasses) {
+    const numKv = /(\w+)\s*:\s*(-?\d+(?:\.\d+)?)\s*(?=[,}\n])/g;
+    for (const kv of objStr.matchAll(numKv)) {
+      try {
+        collectTransformClasses(
+          compiler.transform({ [kv[1]]: parseFloat(kv[2]) }),
+          discoveredClasses
+        );
+      } catch {
+      }
+    }
+  }
+  function collectRuntimeBooleanClasses(objStr, discoveredClasses) {
+    const boolKv = /(\w+)\s*:\s*(true|false)\s*(?=[,}\n])/g;
+    for (const kv of objStr.matchAll(boolKv)) {
+      try {
+        collectTransformClasses(
+          compiler.transform({ [kv[1]]: kv[2] === "true" }),
+          discoveredClasses
+        );
+      } catch {
+      }
+    }
+  }
+  function collectTransformClasses(result, discoveredClasses) {
+    for (const cls of result.className.split(/\s+/).filter(Boolean)) {
+      discoveredClasses.add(cls);
+    }
+  }
+  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]] = core.encode(i);
+    }
+    state.mangleMap = newMap;
+    assertVarMangleMapSize(state.varMangleMap, varMangleMapMaxBytes);
+    state.checksum = core.compute_mangle_checksum(
+      createHydrationMangleMap(state.mangleMap, state.varMangleMap)
+    );
+    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);
+    }
+    if (result.includes(VAR_MANGLE_MAP_PLACEHOLDER)) {
+      const jsonMap = JSON.stringify(state.varMangleMap);
+      const escapedMap = result.includes("eval(") ? jsonMap.replace(/"/g, '\\"') : jsonMap;
+      result = result.split(VAR_MANGLE_MAP_PLACEHOLDER).join(escapedMap);
+    }
+    return result;
+  }
+  const prePlugin = unplugin$1.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,
+            state.varMangleMap,
+            state.cssVarMetrics
+          );
+        }
+        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 (shouldProcessSource(id)) {
+          recordGlobalVarSourceFile(state, id, code);
+        }
+        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__namespace.join(state.rootDir, SAFELIST_FILENAME).replace(/\\/g, "/");
+              const cssDir = path__namespace.dirname(id).replace(/\\/g, "/");
+              let relPath = path__namespace.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 = vueAdapter.preprocess(code, options);
+            if (result.transformed) {
+              transformedCode = result.code;
+              transformed = true;
+            }
+          } else if (id.endsWith(".svelte")) {
+            const result = svelteAdapter.preprocess(code, options);
+            if (result) {
+              transformedCode = result.code;
+              transformed = true;
+            }
+          } else {
+            const transformStarted = node_perf_hooks.performance.now();
+            const result = transformConfiguredSource(code, id);
+            traceBenchTiming(
+              "transform-hook",
+              id,
+              node_perf_hooks.performance.now() - transformStarted
+            );
+            transformedCode = result.code;
+            usesRuntime = result.usesRuntime;
+            usesMerge = result.usesMerge;
+            usesColorVar = result.usesColorVar;
+            transformed = result.transformed;
+            szClasses = result.classes;
+            recordFileVarMangleEntries(state, id, cssVariableEntries(result));
+            recordFileCSSVariableMetrics(state, id, result.code);
+            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);
+            }
+          }
+        } else if (shouldProcessSource(id)) {
+          recordFileVarMangleEntries(state, id, []);
+          recordFileCSSVariableMetrics(state, id, null);
+        }
+        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 vm=${VAR_MANGLE_MAP_PLACEHOLDER};var gp=decodeURIComponent(${JSON.stringify(encodedGlobalVarAliasPrefix)});var r={};var vr={};for(var k in m)r[m[k]]=k;for(var vk in vm){var vv=vm[vk];var vs=Array.isArray(vv)?vv:[vv];for(var vi=0;vi<vs.length;vi++)(vr[vs[vi]]||(vr[vs[vi]]=[])).push(vk)}window.__csszyx={mangleMap:m,varMangleMap:vm,checksum:"${CHECKSUM_PLACEHOLDER}",decode:function(c){return r[c]},encode:function(c){return m[c]},decodeVar:function(v){return vr[v]||[]},encodeVar:function(v){return vm[v]},decodeGlobalVar:function(v){var a=vr[v]||[];return v.indexOf(gp)===0?a[0]:void 0},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);
+          recordGlobalVarSourceFile(state, id, null);
+          recordFileVarMangleEntries(state, id, []);
+          recordFileCSSVariableMetrics(state, id, null);
+        }
+      },
+      /**
+       * 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__namespace.readFileSync(ctx.file, "utf-8");
+          } catch {
+            return;
+          }
+          if (!fileContent.includes("sz=") && !/\bsz\s*:\s*["'{]/.test(fileContent)) {
+            recordGlobalVarSourceFile(state, ctx.file, fileContent);
+            recordFileVarMangleEntries(state, ctx.file, []);
+            recordFileCSSVariableMetrics(state, ctx.file, null);
+            return;
+          }
+          try {
+            const hmrTransformStarted = node_perf_hooks.performance.now();
+            result = transformConfiguredSource(fileContent, ctx.file);
+            traceBenchTiming(
+              "handle-hot-update",
+              ctx.file,
+              node_perf_hooks.performance.now() - hmrTransformStarted
+            );
+          } catch {
+            recordGlobalVarSourceFile(state, ctx.file, fileContent);
+            recordFileVarMangleEntries(state, ctx.file, []);
+            recordFileCSSVariableMetrics(state, ctx.file, null);
+            return;
+          }
+          if (!result.transformed) {
+            recordGlobalVarSourceFile(state, ctx.file, fileContent);
+            recordFileVarMangleEntries(state, ctx.file, []);
+            recordFileCSSVariableMetrics(state, ctx.file, null);
+            return;
+          }
+          const sizeBefore = state.classes.size;
+          recordGlobalVarSourceFile(state, ctx.file, fileContent);
+          for (const cls of result.classes) {
+            state.classes.add(cls);
+          }
+          recordFileVarMangleEntries(state, ctx.file, cssVariableEntries(result));
+          recordFileCSSVariableMetrics(state, ctx.file, result.code);
+          for (const [token, data] of result.recoveryTokens) {
+            state.recoveryTokens.set(token, data);
+          }
+          if (state.classes.size > sizeBefore) {
+            writeSafelistFile(state.classes);
+            const safelistPath = path__namespace.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",
+              varMangleMap: state.varMangleMap,
+              globalVarAliasPrefix
+            });
+            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 = unplugin$1.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();
+            state.globalVarValidationResult = validateGlobalVarBundleInputs(
+              collectWebpackGlobalVarCssAssets(assets)
+            );
+            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;
+            }
+            if (Object.keys(state.varMangleMap).length > 0) {
+              manifestData.varMangleMap = state.varMangleMap;
+            }
+            const globalVarAliases = extractGlobalVarAliasesForManifest(
+              state.varMangleMap,
+              globalVarAliasPrefix,
+              state.globalVarValidationResult
+            );
+            if (Object.keys(globalVarAliases).length > 0) {
+              manifestData.globalVarAliases = globalVarAliases;
+            }
+            if (hasCSSVariableMetrics(state.cssVarMetrics)) {
+              manifestData.cssVarMetrics = state.cssVarMetrics;
+            }
+            compilation.emitAsset(
+              "csszyx-manifest.json",
+              new compiler.webpack.sources.RawSource(JSON.stringify(manifestData))
+            );
+            if (shouldEmitGlobalVarMapAsset(globalVarMangleConfig)) {
+              const globalVarMapAsset = createGlobalVarMapAssetSource(
+                state.varMangleMap,
+                globalVarAliasPrefix,
+                state.globalVarValidationResult
+              );
+              if (globalVarMapAsset) {
+                compilation.emitAsset(
+                  ".csszyx/global-var-map.json",
+                  new compiler.webpack.sources.RawSource(globalVarMapAsset)
+                );
+              }
+            }
+            for (const file in assets) {
+              const asset = assets[file];
+              const source = asset.source().toString();
+              if (file.endsWith(".css")) {
+                let css = rewriteCssWithValidatedGlobalVarPlan(
+                  source,
+                  file,
+                  state.globalVarValidationResult
+                );
+                if (manglingEnabled && !isWebpackDevMode && Object.keys(state.mangleMap).length > 0) {
+                  try {
+                    const result = cssMangler.mangleCSSSync(css, state.mangleMap, {
+                      debug: options.development?.debug,
+                      from: file
+                    });
+                    if (result.transformedCount > 0) {
+                      css = result.css;
+                    }
+                  } catch (e) {
+                    if (e && typeof e === "object" && "name" in e && e.name === "CssSyntaxError") ; else {
+                      throw e;
+                    }
+                  }
+                }
+                if (css !== source) {
+                  compilation.updateAsset(
+                    file,
+                    new compiler.webpack.sources.RawSource(css)
+                  );
+                }
+                continue;
+              }
+              if (manglingEnabled && !isWebpackDevMode && Object.keys(state.mangleMap).length > 0) {
+                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();
+        state.globalVarValidationResult = validateGlobalVarBundleInputs(
+          collectRollupGlobalVarCssAssets(bundle)
+        );
+        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;
+        }
+        if (Object.keys(state.varMangleMap).length > 0) {
+          manifestData.varMangleMap = state.varMangleMap;
+        }
+        const globalVarAliases = extractGlobalVarAliasesForManifest(
+          state.varMangleMap,
+          globalVarAliasPrefix,
+          state.globalVarValidationResult
+        );
+        if (Object.keys(globalVarAliases).length > 0) {
+          manifestData.globalVarAliases = globalVarAliases;
+        }
+        if (hasCSSVariableMetrics(state.cssVarMetrics)) {
+          manifestData.cssVarMetrics = state.cssVarMetrics;
+        }
+        this.emitFile({
+          type: "asset",
+          fileName: "csszyx-manifest.json",
+          source: JSON.stringify(manifestData)
+        });
+        if (shouldEmitGlobalVarMapAsset(globalVarMangleConfig)) {
+          const globalVarMapAsset = createGlobalVarMapAssetSource(
+            state.varMangleMap,
+            globalVarAliasPrefix,
+            state.globalVarValidationResult
+          );
+          if (globalVarMapAsset) {
+            this.emitFile({
+              type: "asset",
+              fileName: ".csszyx/global-var-map.json",
+              source: globalVarMapAsset
+            });
+          }
+        }
+        for (const file in bundle) {
+          const chunk = bundle[file];
+          if (chunk.type === "asset" && chunk.fileName.endsWith(".css")) {
+            const originalCss = chunk.source.toString();
+            let css = rewriteCssWithValidatedGlobalVarPlan(
+              originalCss,
+              file,
+              state.globalVarValidationResult
+            );
+            if (manglingEnabled && Object.keys(state.mangleMap).length > 0) {
+              try {
+                const result = cssMangler.mangleCSSSync(css, state.mangleMap, {
+                  debug: options.development?.debug,
+                  from: file
+                });
+                if (result.transformedCount > 0) {
+                  css = result.css;
+                }
+              } catch (e) {
+                if (e && typeof e === "object" && "name" in e && e.name === "CssSyntaxError") ; else {
+                  throw e;
+                }
+              }
+            }
+            if (css !== originalCss) {
+              chunk.source = css;
+            }
+            continue;
+          }
+          if (manglingEnabled && Object.keys(state.mangleMap).length > 0) {
+            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);
+    }
+  };
+};
+
+exports.assertNoRSCBoundaryViolation = assertNoRSCBoundaryViolation;
+exports.assertNoRSCGraphViolation = assertNoRSCGraphViolation;
+exports.createGlobalVarAliasValidationOptions = createGlobalVarAliasValidationOptions;
+exports.createGlobalVarMapAssetSource = createGlobalVarMapAssetSource;
+exports.createGlobalVarScanCacheKey = createGlobalVarScanCacheKey;
+exports.createRSCModuleRecord = createRSCModuleRecord;
+exports.deleteRSCModuleRecord = deleteRSCModuleRecord;
+exports.esbuildPlugin = esbuildPlugin;
+exports.extractGlobalVarAliasesForManifest = extractGlobalVarAliasesForManifest;
+exports.findRSCBoundaryViolation = findRSCBoundaryViolation;
+exports.findRSCGraphViolation = findRSCGraphViolation;
+exports.hasTokens = hasTokens;
+exports.hasUseClientDirective = hasUseClientDirective;
+exports.hasUseServerDirective = hasUseServerDirective;
+exports.isRSCServerModule = isRSCServerModule;
+exports.isTailwindReservedGlobalVar = isTailwindReservedGlobalVar;
+exports.mangleCodeClassesSync = mangleCodeClassesSync;
+exports.mergeThemes = mergeThemes;
+exports.normalizeGlobalVarAliasesForCache = normalizeGlobalVarAliasesForCache;
+exports.parseThemeBlocks = parseThemeBlocks;
+exports.planGlobalVarAliases = planGlobalVarAliases;
+exports.readGlobalVarScanCache = readGlobalVarScanCache;
+exports.resolveGlobalVarScanCacheDir = resolveGlobalVarScanCacheDir;
+exports.rewriteGlobalVarCssAliases = rewriteGlobalVarCssAliases;
+exports.rollupPlugin = rollupPlugin;
+exports.scanGlobalVarCss = scanGlobalVarCss;
+exports.unplugin = unplugin;
+exports.validateGlobalVarAliasInputs = validateGlobalVarAliasInputs;
+exports.vitePlugin = vitePlugin;
+exports.webpackPlugin = webpackPlugin;
+exports.writeGlobalVarScanCache = writeGlobalVarScanCache;