@csszyx/unplugin 0.7.0 → 0.9.0

package/dist/chunk-GXGGTRUA.js

@@ -1,1602 +0,0 @@
-import {
-  mangleCSSSync
-} from "./chunk-4M7CPGP7.js";
-
-// src/rsc-boundary.ts
-import * as fs from "fs";
-import * as path from "path";
-var SERVER_DIRECTIVE_RE = /^['"]use server['"];?$/;
-var CLIENT_DIRECTIVE_RE = /^['"]use client['"];?$/;
-var RUNTIME_MODULES = /* @__PURE__ */ new Set([
-  "@csszyx/runtime",
-  "@csszyx/runtime/lite",
-  "csszyx",
-  "csszyx/lite"
-]);
-var 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 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));
-}
-function isNextAppRouterEntry(id) {
-  const clean = id.split("?")[0]?.replace(/\\/g, "/") ?? id;
-  return /(^|\/)app\/.*\/?(?:page|layout|template|loading|error|not-found|global-error|default|route)\.[cm]?[tj]sx?$/.test(clean);
-}
-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 staticImportRe = /import\s+(?!type\b)([\s\S]*?)\s+from\s+['"]([^'"]+)['"]/g;
-  const sideEffectImportRe = /import\s+['"]([^'"]+)['"]/g;
-  const dynamicImportRe = /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
-  let match;
-  while ((match = staticImportRe.exec(code)) !== null) {
-    const clause = match[1];
-    const source = match[2];
-    if (!RUNTIME_MODULES.has(source)) {
-      continue;
-    }
-    imports.push({ source, symbols: readImportedSymbols(clause) });
-  }
-  while ((match = sideEffectImportRe.exec(code)) !== null) {
-    const source = match[1];
-    if (RUNTIME_MODULES.has(source)) {
-      imports.push({ source, symbols: [] });
-    }
-  }
-  while ((match = dynamicImportRe.exec(code)) !== null) {
-    const source = match[1];
-    if (RUNTIME_MODULES.has(source)) {
-      imports.push({ source, symbols: Array.from(FORBIDDEN_SYMBOLS) });
-    }
-  }
-  return imports;
-}
-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;
-  let match;
-  for (const re of [staticImportRe, exportFromRe, dynamicImportRe]) {
-    while ((match = re.exec(code)) !== null) {
-      const source = match[1];
-      if (source.startsWith(".") || source.startsWith("/")) {
-        out.push(source);
-      }
-    }
-  }
-  return out;
-}
-function normalizeModuleId(id) {
-  const clean = id.split("?")[0] ?? id;
-  try {
-    return fs.realpathSync.native(clean).replace(/\\/g, "/");
-  } catch {
-    return path.resolve(clean).replace(/\\/g, "/");
-  }
-}
-function resolveLocalModule(importer, source) {
-  const base = source.startsWith("/") ? source : path.resolve(path.dirname(importer), source);
-  const candidates = [
-    base,
-    `${base}.tsx`,
-    `${base}.ts`,
-    `${base}.jsx`,
-    `${base}.js`,
-    `${base}.mjs`,
-    `${base}.cjs`,
-    path.join(base, "index.tsx"),
-    path.join(base, "index.ts"),
-    path.join(base, "index.jsx"),
-    path.join(base, "index.js")
-  ];
-  for (const candidate of candidates) {
-    if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {
-      return normalizeModuleId(candidate);
-    }
-  }
-  return null;
-}
-function readImportedSymbols(clause) {
-  const symbols = [];
-  const named = clause.match(/\{([\s\S]*?)\}/);
-  if (named) {
-    for (const part of named[1].split(",")) {
-      const trimmed = part.trim();
-      if (!trimmed || trimmed.startsWith("type ")) {
-        continue;
-      }
-      const sourceName = trimmed.replace(/^type\s+/, "").split(/\s+as\s+/)[0]?.trim();
-      if (sourceName) {
-        symbols.push(sourceName);
-      }
-    }
-  }
-  if (/\*\s+as\s+\w+/.test(clause)) {
-    symbols.push(...FORBIDDEN_SYMBOLS);
-  }
-  return symbols;
-}
-
-// src/theme-scanner.ts
-var 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;
-  let match;
-  while ((match = themeStart.exec(css)) !== null) {
-    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) {
-    let match;
-    while ((match = propPattern.exec(block)) !== null) {
-      const categorized = categorizeProperty(match[1]);
-      if (categorized) {
-        result[categorized.category].add(categorized.token);
-      }
-    }
-    propPattern.lastIndex = 0;
-  }
-  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);
-}
-
-// src/unplugin.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
-import { transform, transformSourceCode } from "@csszyx/compiler";
-import { compute_mangle_checksum, encode } from "@csszyx/core";
-import { preprocess as sveltePreprocess } from "@csszyx/svelte-adapter";
-import { preprocess as vuePreprocess } from "@csszyx/vue-adapter";
-import { createUnplugin } from "unplugin";
-
-// src/html-transformer.ts
-import { createHash } from "crypto";
-function injectChecksum(html, checksum, minify = false) {
-  const attrName = minify ? "data-sz-cs" : "data-sz-checksum";
-  const htmlTagPattern = /<html([^>]*)>/i;
-  const match = html.match(htmlTagPattern);
-  if (!match) {
-    return html;
-  }
-  const existingAttrs = match[1];
-  const checksumAttr = ` ${attrName}="${checksum}"`;
-  return html.replace(
-    htmlTagPattern,
-    `<html${checksumAttr}${existingAttrs}>`
-  );
-}
-function injectMangleMapScript(html, mangleMap, options = {}) {
-  const { prettyPrint = false } = options;
-  const jsonContent = prettyPrint ? JSON.stringify(mangleMap, null, 2) : JSON.stringify(mangleMap);
-  const scriptTag = `<script id="__CSSZYX_MANGLE_MAP__" type="application/json">${jsonContent}</script>`;
-  const debugScript = `<script>(function(){var m=${jsonContent};var r={};for(var k in m)r[m[k]]=k;var cs=document.documentElement.getAttribute("data-sz-checksum")||"";window.__csszyx={mangleMap:m,checksum:cs,decode:function(c){return r[c]},encode:function(c){return m[c]},decodeAll:function(el){return(el.className||"").split(" ").map(function(c){return r[c]||c})}}})()</script>`;
-  const combined = `${scriptTag}
-${debugScript}`;
-  if (html.includes("</head>")) {
-    return html.replace("</head>", `${combined}
-</head>`);
-  } else if (html.includes("</html>")) {
-    return html.replace("</html>", `${combined}
-</html>`);
-  }
-  return html + combined;
-}
-function injectMangleMapAttribute(html, mangleMap, minify = false) {
-  const attrName = minify ? "data-sz-m" : "data-sz-map";
-  const jsonContent = JSON.stringify(mangleMap);
-  const htmlTagPattern = /<html([^>]*)>/i;
-  const match = html.match(htmlTagPattern);
-  if (!match) {
-    return html;
-  }
-  const existingAttrs = match[1];
-  const mapAttr = ` ${attrName}='${jsonContent}'`;
-  return html.replace(htmlTagPattern, `<html${mapAttr}${existingAttrs}>`);
-}
-function injectHydrationData(html, mangleMap, checksum, options = {}) {
-  const { mode = "script", minify = false } = options;
-  let result = html;
-  result = injectChecksum(result, checksum, minify);
-  if (mode === "inline") {
-    result = injectMangleMapAttribute(result, mangleMap, minify);
-  } else if (mode === "script") {
-    result = injectMangleMapScript(result, mangleMap, options);
-  } else if (mode === "both") {
-    result = injectMangleMapAttribute(result, mangleMap, minify);
-    result = injectMangleMapScript(result, mangleMap, options);
-  }
-  return result;
-}
-function transformIndexHtml(html, mangleMap, checksum, options = {}) {
-  return injectHydrationData(html, mangleMap, checksum, options);
-}
-function buildRecoveryManifest(tokens, options) {
-  const stripped = options.production === true;
-  const strippedDevOnlyPaths = [];
-  const sorted = {};
-  const sortedKeys = [...tokens.keys()].sort();
-  for (const key of sortedKeys) {
-    const data = tokens.get(key);
-    if (!data) {
-      continue;
-    }
-    if (stripped && data.mode === "dev-only") {
-      strippedDevOnlyPaths.push(data.path);
-      continue;
-    }
-    sorted[key] = stripped ? { mode: data.mode, component: data.component, path: "" } : data;
-  }
-  const serialised = JSON.stringify(sorted);
-  const fullChecksum = createHash("sha256").update(serialised).digest("hex");
-  const checksum = fullChecksum.substring(0, 16);
-  const buildId = `${Date.now().toString(36)}-${fullChecksum.substring(0, 6)}`;
-  return {
-    manifest: { buildId, checksum, mangleChecksum: options.mangleChecksum, tokens: sorted },
-    strippedDevOnlyPaths
-  };
-}
-function injectRecoveryManifest(html, manifest) {
-  if (Object.keys(manifest.tokens).length === 0) {
-    return html;
-  }
-  const json = JSON.stringify(manifest);
-  const scriptTag = `<script id="__SZ_RECOVERY_MANIFEST__" type="application/json">${json}</script>`;
-  if (html.includes("</head>")) {
-    return html.replace("</head>", `${scriptTag}
-</head>`);
-  } else if (html.includes("</html>")) {
-    return html.replace("</html>", `${scriptTag}
-</html>`);
-  }
-  return html + scriptTag;
-}
-
-// src/theme-type-writer.ts
-import { mkdirSync, writeFileSync } from "fs";
-import { dirname as dirname2 } from "path";
-function generateThemeDts(opts) {
-  const { theme, sourceFiles } = opts;
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-  const sources = sourceFiles.join(", ");
-  const toUnion = (tokens) => tokens.map((t) => `'${t}'`).join(" | ");
-  const entries = [];
-  if (theme.colors.length > 0) {
-    entries.push(`        colors: ${toUnion(theme.colors)};`);
-  }
-  if (theme.spacings.length > 0) {
-    entries.push(`        spacings: ${toUnion(theme.spacings)};`);
-  }
-  if (theme.fonts.length > 0) {
-    entries.push(`        fonts: ${toUnion(theme.fonts)};`);
-  }
-  if (theme.radii.length > 0) {
-    entries.push(`        radii: ${toUnion(theme.radii)};`);
-  }
-  if (theme.shadows.length > 0) {
-    entries.push(`        shadows: ${toUnion(theme.shadows)};`);
-  }
-  return [
-    "// Auto-generated by csszyx theme-scanner \u2014 DO NOT EDIT",
-    `// Source: ${sources}`,
-    `// Updated: ${timestamp}`,
-    "",
-    "declare module '@csszyx/compiler' {",
-    "    /**",
-    "     * Custom design tokens extracted from @theme blocks.",
-    "     * These tokens are surfaced in sz prop IntelliSense.",
-    "     */",
-    "    interface CustomTheme {",
-    ...entries,
-    "    }",
-    "}",
-    "",
-    "export {};",
-    ""
-  ].join("\n");
-}
-function writeThemeDts(opts) {
-  const content = generateThemeDts(opts);
-  mkdirSync(dirname2(opts.outputPath), { recursive: true });
-  writeFileSync(opts.outputPath, content, "utf-8");
-}
-
-// src/virtual-modules.ts
-var VIRTUAL_MODULE_ID = "virtual:csszyx/mangle-map";
-var RESOLVED_VIRTUAL_MODULE_ID = "\0" + VIRTUAL_MODULE_ID;
-var VIRTUAL_CHECKSUM_ID = "virtual:csszyx/checksum";
-var RESOLVED_VIRTUAL_CHECKSUM_ID = "\0" + VIRTUAL_CHECKSUM_ID;
-function createMangleMapModule(mangleMap, checksum) {
-  return `/**
- * Auto-generated mangle map for csszyx.
- * This module is generated at build time and contains the mapping
- * from original class names to mangled class names.
- *
- * @generated
- */
-
-export const mangleMap = ${JSON.stringify(mangleMap, null, 2)};
-
-export const checksum = ${JSON.stringify(checksum)};
-
-export default {
-  mangleMap,
-  checksum,
-};
-`;
-}
-function createChecksumModule(checksum) {
-  return `/**
- * Auto-generated checksum for csszyx mangle map.
- *
- * @generated
- */
-
-export const checksum = ${JSON.stringify(checksum)};
-
-export default checksum;
-`;
-}
-function isVirtualModule(id) {
-  return id === VIRTUAL_MODULE_ID || id === VIRTUAL_CHECKSUM_ID;
-}
-function resolveVirtualModule(id) {
-  if (id === VIRTUAL_MODULE_ID) {
-    return RESOLVED_VIRTUAL_MODULE_ID;
-  }
-  if (id === VIRTUAL_CHECKSUM_ID) {
-    return RESOLVED_VIRTUAL_CHECKSUM_ID;
-  }
-  return void 0;
-}
-
-// src/unplugin.ts
-var CHECKSUM_PLACEHOLDER = "___CSSZYX_CHECKSUM___";
-var MANGLE_MAP_PLACEHOLDER = "___CSSZYX_MANGLE_MAP___";
-var _hasWarnedTsConfig = false;
-function runThemeScan(rootDir, scanCss) {
-  if (!scanCss) {
-    return;
-  }
-  const patterns = Array.isArray(scanCss) ? scanCss : [scanCss];
-  const sourceFiles = [];
-  for (const pattern of patterns) {
-    const resolved = path2.isAbsolute(pattern) ? pattern : path2.join(rootDir, pattern);
-    if (fs2.existsSync(resolved)) {
-      sourceFiles.push(resolved);
-    }
-  }
-  if (sourceFiles.length === 0) {
-    return;
-  }
-  const themes = sourceFiles.map((f) => {
-    try {
-      return parseThemeBlocks(fs2.readFileSync(f, "utf-8"));
-    } catch {
-      return null;
-    }
-  }).filter((t) => t !== null);
-  const merged = mergeThemes(themes);
-  const outputPath = path2.join(rootDir, ".csszyx", "theme.d.ts");
-  writeThemeDts({ outputPath, theme: merged, sourceFiles });
-  if (!_hasWarnedTsConfig) {
-    _hasWarnedTsConfig = true;
-    try {
-      const checkFile = (cfgPath) => {
-        if (fs2.existsSync(cfgPath)) {
-          const content = fs2.readFileSync(cfgPath, "utf-8");
-          if (!content.includes(".csszyx")) {
-            console.warn(`
-\x1B[33m\u26A0\uFE0F CSSzyx: Theme Auto-Scan enabled, but TypeScript isn't configured. Run "npx @csszyx/cli init" to fix.\x1B[0m
-`);
-          }
-          return true;
-        }
-        return false;
-      };
-      if (!checkFile(path2.join(rootDir, "tsconfig.json"))) {
-        checkFile(path2.join(rootDir, "tsconfig.app.json"));
-      }
-    } catch {
-    }
-  }
-}
-function mangleCodeClassesSync(code, mangleMap) {
-  function mangleClassString(classString) {
-    return classString.split(/\s+/).filter(Boolean).map((cls) => {
-      return mangleMap[cls.replace(/\\(.)/g, "$1")] || cls;
-    }).join(" ");
-  }
-  let result = code.replace(/(?:class(?:Name)?|sz)[:=]\s*"((?:[^"\\]|\\.)*)"/g, (match, classes) => {
-    const mangled = mangleClassString(classes);
-    if (mangled === classes) {
-      return match;
-    }
-    return match.replace(classes, mangled);
-  }).replace(/(?:class(?:Name)?|sz)[:=]\s*'((?:[^'\\]|\\.)*)'/g, (match, classes) => {
-    const mangled = mangleClassString(classes);
-    if (mangled === classes) {
-      return match;
-    }
-    return match.replace(classes, mangled);
-  });
-  result = result.replace(/className:\s*`([^`]+)`/g, (fullMatch, tplContent) => {
-    let changed = false;
-    let out = "";
-    let i = 0;
-    while (i < tplContent.length) {
-      const interStart = tplContent.indexOf("${", i);
-      if (interStart === -1) {
-        const quasi2 = tplContent.slice(i);
-        const trimmed2 = quasi2.trim();
-        if (trimmed2) {
-          const m = mangleClassString(trimmed2);
-          if (m !== trimmed2) {
-            changed = true;
-            out += quasi2.replace(trimmed2, m);
-          } else {
-            out += quasi2;
-          }
-        } else {
-          out += quasi2;
-        }
-        break;
-      }
-      const quasi = tplContent.slice(i, interStart);
-      const trimmed = quasi.trim();
-      if (trimmed) {
-        const m = mangleClassString(trimmed);
-        if (m !== trimmed) {
-          changed = true;
-          out += quasi.replace(trimmed, m);
-        } else {
-          out += quasi;
-        }
-      } else {
-        out += quasi;
-      }
-      let j = interStart + 2;
-      let depth = 0;
-      while (j < tplContent.length) {
-        if (tplContent[j] === "{") {
-          depth++;
-        } else if (tplContent[j] === "}") {
-          if (depth === 0) {
-            j++;
-            break;
-          }
-          depth--;
-        }
-        j++;
-      }
-      const interInner = tplContent.slice(interStart + 2, j - 1);
-      const mangledInner = interInner.replace(/"([^"]*)"/g, (qm, inner) => {
-        const parts = inner.split(/\s+/).filter(Boolean);
-        if (parts.length === 0) {
-          return qm;
-        }
-        const m = parts.map((p) => mangleMap[p] || p).join(" ");
-        if (m === inner) {
-          return qm;
-        }
-        changed = true;
-        return '"' + m + '"';
-      });
-      out += "${" + mangledInner + "}";
-      i = j;
-    }
-    return changed ? "className:`" + out + "`" : fullMatch;
-  });
-  {
-    const marker = "className:";
-    let searchFrom = 0;
-    let out = "";
-    while (searchFrom < result.length) {
-      const idx = result.indexOf(marker, searchFrom);
-      if (idx === -1) {
-        out += result.slice(searchFrom);
-        break;
-      }
-      out += result.slice(searchFrom, idx + marker.length);
-      const afterColon = idx + marker.length;
-      let exprStart = afterColon;
-      while (exprStart < result.length && result[exprStart] === " ") {
-        exprStart++;
-      }
-      const firstChar = result[exprStart];
-      if (firstChar === '"' || firstChar === "'" || firstChar === "`") {
-        searchFrom = afterColon;
-        continue;
-      }
-      let depth = 0;
-      let j = afterColon;
-      while (j < result.length) {
-        const ch = result[j];
-        if (ch === "(" || ch === "[") {
-          depth++;
-        } else if (ch === ")" || ch === "]") {
-          if (depth === 0) {
-            break;
-          }
-          depth--;
-        } else if (depth === 0 && (ch === "," || ch === ";" || ch === "\n" || ch === "}")) {
-          break;
-        }
-        j++;
-      }
-      const expr = result.slice(afterColon, j);
-      const qIdx = expr.indexOf("?");
-      if (qIdx === -1 || !expr.slice(qIdx).includes(":")) {
-        out += expr;
-        searchFrom = j;
-        continue;
-      }
-      let changed = false;
-      const mangled = expr.replace(/"([^"]*)"/g, (qm, inner) => {
-        const parts = inner.split(/\s+/).filter(Boolean);
-        if (parts.length === 0) {
-          return qm;
-        }
-        const mangledStr = parts.map((p) => mangleMap[p] || p).join(" ");
-        if (mangledStr !== inner) {
-          changed = true;
-          return '"' + mangledStr + '"';
-        }
-        return qm;
-      });
-      out += changed ? mangled : expr;
-      searchFrom = j;
-    }
-    result = out;
-  }
-  result = result.replace(/(?<=(?:[,(]|&&)\s*)"([^"]+)"/g, (match, inner) => {
-    const tokens = inner.split(/\s+/).filter(Boolean);
-    if (tokens.length === 0) {
-      return match;
-    }
-    let changed = false;
-    const mangled = [];
-    for (const t of tokens) {
-      const m = mangleMap[t];
-      if (m === void 0) {
-        return match;
-      }
-      if (m !== t) {
-        changed = true;
-      }
-      mangled.push(m);
-    }
-    if (!changed) {
-      return match;
-    }
-    return '"' + mangled.join(" ") + '"';
-  });
-  return result;
-}
-function createCsszyxPlugins(options = {}) {
-  const manglingEnabled = options.production?.mangle !== false;
-  const astBudgetOverride = options.build?.astBudgetLimit;
-  const state = {
-    classes: /* @__PURE__ */ new Set(),
-    mangleMap: {},
-    checksum: "",
-    finalized: false,
-    rootDir: process.cwd(),
-    recoveryTokens: /* @__PURE__ */ new Map(),
-    rscModules: /* @__PURE__ */ new Map()
-  };
-  const SAFELIST_FILENAME = "csszyx-classes.html";
-  const SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".tsx", ".jsx", ".ts", ".js"]);
-  const IGNORE_DIRS = /* @__PURE__ */ new Set(["node_modules", ".next", ".git", "dist", "build", ".turbo"]);
-  function writeSafelistFile(classes) {
-    if (classes.size === 0) {
-      return;
-    }
-    const safelistPath = path2.join(state.rootDir, SAFELIST_FILENAME);
-    const classList = Array.from(classes).join(" ");
-    const content = `<!-- Auto-generated by csszyx \u2014 DO NOT EDIT -->
-<!-- Tailwind CSS scans this file for class name detection -->
-<div class="${classList}"><div class="${classList}">x</div><div class="${classList}">x</div></div>
-`;
-    try {
-      const existing = fs2.existsSync(safelistPath) ? fs2.readFileSync(safelistPath, "utf-8") : "";
-      if (existing !== content) {
-        fs2.writeFileSync(safelistPath, content);
-      }
-    } catch {
-    }
-  }
-  function prescanAndWriteClasses() {
-    const discoveredClasses = /* @__PURE__ */ new Set();
-    const rawDiscoveredClasses = /* @__PURE__ */ new Set();
-    function scanDir(dir) {
-      let entries;
-      try {
-        entries = fs2.readdirSync(dir, { withFileTypes: true });
-      } catch {
-        return;
-      }
-      for (const entry of entries) {
-        if (entry.isDirectory()) {
-          if (!IGNORE_DIRS.has(entry.name) && !entry.name.startsWith(".")) {
-            scanDir(path2.join(dir, entry.name));
-          }
-        } else if (SOURCE_EXTENSIONS.has(path2.extname(entry.name))) {
-          const filePath = path2.join(dir, entry.name);
-          try {
-            const content = fs2.readFileSync(filePath, "utf-8");
-            if (!content.includes("sz=") && !content.includes("sz:")) {
-              continue;
-            }
-            const result = transformSourceCode(content, filePath, { astBudget: astBudgetOverride });
-            if (!result.transformed) {
-              continue;
-            }
-            for (const cls of result.classes) {
-              discoveredClasses.add(cls);
-            }
-            for (const cls of result.rawClassNames) {
-              rawDiscoveredClasses.add(cls);
-            }
-            for (const [token, data] of result.recoveryTokens) {
-              state.recoveryTokens.set(token, data);
-            }
-            if (result.usesRuntime) {
-              const szCallRe = /_sz\(\s*\{/g;
-              let szMatch;
-              while ((szMatch = szCallRe.exec(result.code)) !== null) {
-                let depth = 1;
-                let idx = szMatch.index + 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 + szMatch[0].length, idx - 1);
-                const strKv = /(\w+)\s*:\s*(?:"([^"]*)"|'([^']*)')/g;
-                let kv;
-                while ((kv = strKv.exec(objStr)) !== null) {
-                  try {
-                    const val = kv[2] ?? kv[3];
-                    const r = transform({ [kv[1]]: val });
-                    for (const c of r.className.split(/\s+/).filter(Boolean)) {
-                      discoveredClasses.add(c);
-                    }
-                  } catch {
-                  }
-                }
-                const numKv = /(\w+)\s*:\s*(-?\d+(?:\.\d+)?)\s*(?=[,}\n])/g;
-                while ((kv = numKv.exec(objStr)) !== null) {
-                  try {
-                    const r = transform({ [kv[1]]: parseFloat(kv[2]) });
-                    for (const c of r.className.split(/\s+/).filter(Boolean)) {
-                      discoveredClasses.add(c);
-                    }
-                  } catch {
-                  }
-                }
-                const boolKv = /(\w+)\s*:\s*(true|false)\s*(?=[,}\n])/g;
-                while ((kv = boolKv.exec(objStr)) !== null) {
-                  try {
-                    const r = transform({ [kv[1]]: kv[2] === "true" });
-                    for (const c of r.className.split(/\s+/).filter(Boolean)) {
-                      discoveredClasses.add(c);
-                    }
-                  } catch {
-                  }
-                }
-              }
-            }
-          } catch {
-          }
-        }
-      }
-    }
-    scanDir(state.rootDir);
-    for (const cls of discoveredClasses) {
-      state.classes.add(cls);
-    }
-    const safelistClasses = /* @__PURE__ */ new Set([...discoveredClasses, ...rawDiscoveredClasses]);
-    writeSafelistFile(safelistClasses);
-  }
-  function extractClasses(code) {
-    const dqPattern = /(?:class(?:Name)?|sz)[:=]\s*"([^"]*)"/g;
-    const sqPattern = /(?:class(?:Name)?|sz)[:=]\s*'([^']*)'/g;
-    let match;
-    for (const classPattern of [dqPattern, sqPattern]) {
-      while ((match = classPattern.exec(code)) !== null) {
-        const classes = match[1].split(/\s+/).filter(Boolean);
-        for (const cls of classes) {
-          state.classes.add(cls);
-        }
-      }
-    }
-    const exprStart = /className=\{/g;
-    while ((match = exprStart.exec(code)) !== null) {
-      let depth = 1;
-      let i = match.index + 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 + match[0].length, i - 1);
-      const strPattern = /"([^"]+)"|'([^']+)'/g;
-      let strMatch;
-      while ((strMatch = strPattern.exec(expr)) !== null) {
-        const str = strMatch[1] || strMatch[2];
-        const classes = str.split(/\s+/).filter(Boolean);
-        for (const cls of classes) {
-          state.classes.add(cls);
-        }
-      }
-    }
-  }
-  function finalizeMangleMap() {
-    const sortedClasses = Array.from(state.classes);
-    const newMap = {};
-    for (let i = 0; i < sortedClasses.length; i++) {
-      newMap[sortedClasses[i]] = encode(i);
-    }
-    state.mangleMap = newMap;
-    state.checksum = compute_mangle_checksum(state.mangleMap);
-    state.finalized = true;
-  }
-  function mangleCodeClasses(code) {
-    return mangleCodeClassesSync(code, state.mangleMap);
-  }
-  function replacePlaceholders(code) {
-    let result = code;
-    if (result.includes(CHECKSUM_PLACEHOLDER)) {
-      result = result.split(CHECKSUM_PLACEHOLDER).join(state.checksum);
-    }
-    if (result.includes(MANGLE_MAP_PLACEHOLDER)) {
-      const jsonMap = JSON.stringify(state.mangleMap);
-      const escapedMap = result.includes("eval(") ? jsonMap.replace(/"/g, '\\"') : jsonMap;
-      result = result.split(MANGLE_MAP_PLACEHOLDER).join(escapedMap);
-    }
-    return result;
-  }
-  const prePlugin = createUnplugin((_pluginOptions) => ({
-    name: "csszyx:pre",
-    enforce: "pre",
-    /**
-     * Resolves virtual module IDs for csszyx mangle-map and checksum modules.
-     * @param id - the module ID to resolve
-     * @returns resolved ID if virtual, null otherwise
-     */
-    resolveId(id) {
-      if (isVirtualModule(id)) {
-        return resolveVirtualModule(id);
-      }
-      return null;
-    },
-    /**
-     * Loads virtual module content — generates mangle map or checksum module code.
-     * @param id - the resolved module ID to load
-     * @returns generated module source if virtual, null otherwise
-     */
-    load(id) {
-      if (id === RESOLVED_VIRTUAL_MODULE_ID) {
-        finalizeMangleMap();
-        return createMangleMapModule(state.mangleMap, state.checksum);
-      }
-      if (id === RESOLVED_VIRTUAL_CHECKSUM_ID) {
-        finalizeMangleMap();
-        return createChecksumModule(state.checksum);
-      }
-      return null;
-    },
-    /**
-     * Filters files for the pre-transform phase — source files plus CSS files.
-     * CSS files need special handling to inject @source inline() for Tailwind class discovery.
-     * @param id - the file path to check for inclusion
-     * @returns true if the file should be transformed, false otherwise
-     */
-    transformInclude(id) {
-      if (id.includes("node_modules") || id.includes("/packages/") || id.includes(".next") && !id.includes("static")) {
-        return false;
-      }
-      if (/\.css(\?.*)?$/.test(id)) {
-        return true;
-      }
-      return /\.[tj]sx?$/.test(id) || id.endsWith(".vue") || id.endsWith(".svelte");
-    },
-    /**
-     * 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 (/\.[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 = path2.join(state.rootDir, SAFELIST_FILENAME).replace(/\\/g, "/");
-            const cssDir = path2.dirname(id).replace(/\\/g, "/");
-            let relPath = path2.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 = vuePreprocess(code, options);
-          if (result.transformed) {
-            transformedCode = result.code;
-            transformed = true;
-          }
-        } else if (id.endsWith(".svelte")) {
-          const result = sveltePreprocess(code, options);
-          if (result) {
-            transformedCode = result.code;
-            transformed = true;
-          }
-        } else {
-          const result = transformSourceCode(code, id, { astBudget: astBudgetOverride });
-          transformedCode = result.code;
-          usesRuntime = result.usesRuntime;
-          usesMerge = result.usesMerge;
-          usesColorVar = result.usesColorVar;
-          transformed = result.transformed;
-          szClasses = result.classes;
-          if (result.diagnostics.length > 0 && process.env.NODE_ENV !== "production") {
-            for (const msg of result.diagnostics) {
-              this.warn(`[csszyx] ${id}
-  ${msg}`);
-            }
-          }
-          for (const [token, data] of result.recoveryTokens) {
-            state.recoveryTokens.set(token, data);
-          }
-        }
-      }
-      if (transformedCode.includes("<html") && /layout|Root|Document|app\\.tsx?$/i.test(id)) {
-        const attrName = options.production?.minify ? "data-sz-cs" : "data-sz-checksum";
-        transformedCode = transformedCode.replace(/<html([^>]*)>/i, `<html$1 ${attrName}="${CHECKSUM_PLACEHOLDER}">`);
-        const debugScript = `<script dangerouslySetInnerHTML={{__html: \`(function(){var m=${MANGLE_MAP_PLACEHOLDER};var r={};for(var k in m)r[m[k]]=k;window.__csszyx={mangleMap:m,checksum:"${CHECKSUM_PLACEHOLDER}",decode:function(c){return r[c]},encode:function(c){return m[c]},decodeAll:function(el){return(el.className||"").split(" ").map(function(c){return r[c]||c})}}})()\`}} />`;
-        if (transformedCode.includes("<body")) {
-          transformedCode = transformedCode.replace(
-            /(<body[^>]*>)/i,
-            `$1${debugScript}`
-          );
-        }
-        transformed = true;
-      }
-      {
-        const imports = [];
-        if (usesRuntime) {
-          imports.push("_sz");
-        }
-        if (usesMerge) {
-          imports.push("_szMerge");
-        }
-        if (usesColorVar) {
-          imports.push("__szColorVar");
-        }
-        const needed = imports.filter(
-          (name) => !new RegExp(`\\{[^}]*\\b${name}\\b[^}]*\\}\\s*from\\s*['"]@csszyx/runtime['"]`).test(transformedCode)
-        );
-        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';
-`;
-            const directiveMatch = transformedCode.match(/^['"]use (client|server)['"];?\s*/);
-            if (directiveMatch) {
-              const directive = directiveMatch[0];
-              transformedCode = transformedCode.replace(directive, `${directive}${importStmt}`);
-            } else {
-              transformedCode = `${importStmt}${transformedCode}`;
-            }
-          }
-          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;
-      }
-    },
-    /**
-     * 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;
-        if (state.classes.size === 0) {
-          prescanAndWriteClasses();
-        }
-        runThemeScan(root, options.build?.scanCss);
-      });
-      if (options.build?.scanCss) {
-        const patterns = Array.isArray(options.build.scanCss) ? options.build.scanCss : [options.build.scanCss];
-        compiler.hooks.thisCompilation.tap("csszyx:theme-deps", (compilation) => {
-          const root = compiler.context || process.cwd();
-          for (const pattern of patterns) {
-            const resolved = path2.isAbsolute(pattern) ? pattern : path2.join(root, pattern);
-            if (fs2.existsSync(resolved)) {
-              compilation.fileDependencies.add(resolved);
-            }
-          }
-        });
-      }
-    },
-    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;
-        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 patterns = Array.isArray(scanCss) ? scanCss : [scanCss];
-          const root = ctx.server.config.root || process.cwd();
-          const isWatched = patterns.some((p) => {
-            const resolved = path2.isAbsolute(p) ? p : path2.join(root, p);
-            return ctx.file === resolved;
-          });
-          if (isWatched) {
-            runThemeScan(root, scanCss);
-          }
-        }
-        if (!SOURCE_EXTENSIONS.has(path2.extname(ctx.file))) {
-          return;
-        }
-        if (ctx.file.includes("node_modules")) {
-          return;
-        }
-        let fileContent, result;
-        try {
-          fileContent = fs2.readFileSync(ctx.file, "utf-8");
-        } catch {
-          return;
-        }
-        if (!fileContent.includes("sz=") && !/\bsz\s*:\s*["'{]/.test(fileContent)) {
-          return;
-        }
-        try {
-          result = transformSourceCode(fileContent, ctx.file, { astBudget: astBudgetOverride });
-        } catch {
-          return;
-        }
-        if (!result.transformed) {
-          return;
-        }
-        const sizeBefore = state.classes.size;
-        for (const cls of result.classes) {
-          state.classes.add(cls);
-        }
-        for (const [token, data] of result.recoveryTokens) {
-          state.recoveryTokens.set(token, data);
-        }
-        if (state.classes.size > sizeBefore) {
-          writeSafelistFile(state.classes);
-          const safelistPath = path2.join(state.rootDir, SAFELIST_FILENAME);
-          ctx.server.watcher.emit("change", safelistPath);
-        }
-      },
-      transformIndexHtml: {
-        order: "pre",
-        /**
-         * Injects hydration data (mangle map + checksum) into the HTML document.
-         * Also mangles class attributes in SSR-rendered HTML so they match mangled CSS selectors.
-         * @param html - the raw HTML string to transform
-         * @returns transformed HTML with injected hydration data
-         */
-        handler(html) {
-          finalizeMangleMap();
-          let result = transformIndexHtml(html, state.mangleMap, state.checksum, {
-            mode: options.production?.injectChecksum === false ? "script" : "script",
-            minify: process.env.NODE_ENV === "production"
-          });
-          if (state.recoveryTokens.size > 0) {
-            const isProduction = process.env.NODE_ENV === "production";
-            const { manifest, strippedDevOnlyPaths } = buildRecoveryManifest(
-              state.recoveryTokens,
-              {
-                production: isProduction,
-                mangleChecksum: state.checksum
-              }
-            );
-            if (strippedDevOnlyPaths.length > 0) {
-              console.warn(
-                `[csszyx] Stripped ${strippedDevOnlyPaths.length} szRecover="dev-only" token(s) from the production manifest. Recovery for these elements is disabled in production by design. Sites: ${strippedDevOnlyPaths.join(", ")}`
-              );
-            }
-            result = injectRecoveryManifest(result, manifest);
-          }
-          return result;
-        }
-      }
-    }
-  }));
-  const postPlugin = createUnplugin(() => ({
-    name: "csszyx:post",
-    enforce: "post",
-    // No transform hook — all mangling is deferred to asset processing
-    // where the complete mangle map is available.
-    /**
-     * Webpack hook: mangles CSS/JS class names in processAssets after compilation.
-     * @param compiler - the Webpack compiler instance
-     */
-    webpack(compiler) {
-      compiler.hooks.compilation.tap("csszyx:post", (compilation) => {
-        const stage = compiler.webpack?.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE || // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        compilation.constructor.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE;
-        compilation.hooks.processAssets.tap(
-          {
-            name: "csszyx:post",
-            stage: stage || 400
-            // Fallback integer
-          },
-          (assets) => {
-            finalizeMangleMap();
-            const isWebpackDevMode = compiler.options.mode === "development";
-            const manifestData = {
-              version: "0.4.0",
-              buildId: state.checksum,
-              classes: Object.keys(state.mangleMap)
-            };
-            if (manglingEnabled && !isWebpackDevMode && Object.keys(state.mangleMap).length > 0) {
-              manifestData.mangleMap = state.mangleMap;
-            }
-            compilation.emitAsset(
-              "csszyx-manifest.json",
-              new compiler.webpack.sources.RawSource(JSON.stringify(manifestData))
-            );
-            for (const file in assets) {
-              const asset = assets[file];
-              const source = asset.source().toString();
-              if (manglingEnabled && !isWebpackDevMode && Object.keys(state.mangleMap).length > 0) {
-                if (file.endsWith(".css")) {
-                  try {
-                    const result = mangleCSSSync(source, state.mangleMap, {
-                      debug: options.development?.debug,
-                      from: file
-                    });
-                    if (result.transformedCount > 0) {
-                      compilation.updateAsset(
-                        file,
-                        new compiler.webpack.sources.RawSource(result.css)
-                      );
-                      continue;
-                    }
-                  } catch (e) {
-                    if (e && typeof e === "object" && "name" in e && e.name === "CssSyntaxError") {
-                    } else {
-                      throw e;
-                    }
-                  }
-                } else if (file.endsWith(".html")) {
-                  const mangledHtml = source.replace(/\bclass="([^"]*)"/g, (_m, cls) => {
-                    const out = cls.split(/\s+/).filter(Boolean).map((c) => state.mangleMap[c] || c).join(" ");
-                    return out !== cls ? `class="${out}"` : _m;
-                  }).replace(/\bclass='([^']*)'/g, (_m, cls) => {
-                    const out = cls.split(/\s+/).filter(Boolean).map((c) => state.mangleMap[c] || c).join(" ");
-                    return out !== cls ? `class='${out}'` : _m;
-                  });
-                  if (mangledHtml !== source) {
-                    compilation.updateAsset(
-                      file,
-                      new compiler.webpack.sources.RawSource(mangledHtml)
-                    );
-                    continue;
-                  }
-                } else if (file.endsWith(".js")) {
-                  let mangled = mangleCodeClasses(source);
-                  mangled = replacePlaceholders(mangled);
-                  if (mangled !== source) {
-                    compilation.updateAsset(
-                      file,
-                      new compiler.webpack.sources.RawSource(mangled)
-                    );
-                    continue;
-                  }
-                }
-              }
-              if (file.endsWith(".js") && (source.includes(CHECKSUM_PLACEHOLDER) || source.includes(MANGLE_MAP_PLACEHOLDER))) {
-                const replaced = replacePlaceholders(source);
-                if (replaced !== source) {
-                  compilation.updateAsset(
-                    file,
-                    new compiler.webpack.sources.RawSource(replaced)
-                  );
-                }
-              }
-            }
-          }
-        );
-      });
-    },
-    vite: {
-      /**
-       * Vite hook: mangles CSS selectors and JS class strings in the final bundle.
-       * @param _options - the output options (unused)
-       * @param bundle - the output bundle containing chunks and assets to process
-       */
-      generateBundle(_options, bundle) {
-        finalizeMangleMap();
-        const manifestData = {
-          version: "0.4.0",
-          buildId: state.checksum,
-          classes: Object.keys(state.mangleMap)
-        };
-        if (manglingEnabled && Object.keys(state.mangleMap).length > 0) {
-          manifestData.mangleMap = state.mangleMap;
-        }
-        this.emitFile({
-          type: "asset",
-          fileName: "csszyx-manifest.json",
-          source: JSON.stringify(manifestData)
-        });
-        for (const file in bundle) {
-          const chunk = bundle[file];
-          if (manglingEnabled && Object.keys(state.mangleMap).length > 0) {
-            if (chunk.type === "asset" && chunk.fileName.endsWith(".css")) {
-              const css = chunk.source.toString();
-              try {
-                const result = mangleCSSSync(css, state.mangleMap, {
-                  debug: options.development?.debug,
-                  from: file
-                });
-                if (result.transformedCount > 0) {
-                  chunk.source = result.css;
-                }
-              } catch (e) {
-                if (e && typeof e === "object" && "name" in e && e.name === "CssSyntaxError") {
-                } else {
-                  throw e;
-                }
-              }
-              continue;
-            } else if (chunk.type === "chunk") {
-              let mangledCode = mangleCodeClasses(chunk.code);
-              mangledCode = replacePlaceholders(mangledCode);
-              if (mangledCode !== chunk.code) {
-                chunk.code = mangledCode;
-              }
-              continue;
-            }
-          }
-          if (chunk.type === "chunk" && (chunk.code.includes(CHECKSUM_PLACEHOLDER) || chunk.code.includes(MANGLE_MAP_PLACEHOLDER))) {
-            const replaced = replacePlaceholders(chunk.code);
-            if (replaced !== chunk.code) {
-              chunk.code = replaced;
-            }
-          }
-        }
-      }
-    }
-  }));
-  return { prePlugin, postPlugin };
-}
-var defaultInstance = createCsszyxPlugins();
-var unplugin = defaultInstance.prePlugin;
-var vitePlugin = (options = {}) => {
-  const { prePlugin, postPlugin } = createCsszyxPlugins(options);
-  return [prePlugin.vite(options), postPlugin.vite(options)];
-};
-var 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);
-    }
-  };
-};
-var rollupPlugin = (options = {}) => {
-  const { prePlugin, postPlugin } = createCsszyxPlugins(options);
-  return [prePlugin.rollup(options), postPlugin.rollup(options)];
-};
-var esbuildPlugin = (options = {}) => {
-  const { prePlugin, postPlugin } = createCsszyxPlugins(options);
-  return {
-    name: "csszyx",
-    /**
-     * Registers both pre and post plugin setup hooks with the esbuild build.
-     * @param build - the esbuild plugin build context
-     */
-    setup(build) {
-      const b = build;
-      prePlugin.esbuild(options).setup(b);
-      postPlugin.esbuild(options).setup(b);
-    }
-  };
-};
-
-export {
-  hasUseServerDirective,
-  hasUseClientDirective,
-  isRSCServerModule,
-  findRSCBoundaryViolation,
-  createRSCModuleRecord,
-  findRSCGraphViolation,
-  assertNoRSCGraphViolation,
-  assertNoRSCBoundaryViolation,
-  parseThemeBlocks,
-  mergeThemes,
-  hasTokens,
-  mangleCodeClassesSync,
-  unplugin,
-  vitePlugin,
-  webpackPlugin,
-  rollupPlugin,
-  esbuildPlugin
-};