@csszyx/unplugin 0.11.6 → 0.11.8

package/dist/shared/{unplugin.BS60onPk.mjs → unplugin.DtYxS8M8.mjs}

@@ -6,7 +6,7 @@ import * as path from 'node:path';
 import { dirname } from 'node:path';
 import { performance } from 'node:perf_hooks';
 import { fileURLToPath } from 'node:url';
-import { scanGlobalVarUsages, sortStrings as sortStrings$1, ensureRustTransformAvailable, transformSourceCode, transformRust, transformOxc, transformRustBatch, ASTBudgetExceededError, transform, isRustTransformAvailable } from '@csszyx/compiler';
+import { scanGlobalVarUsages, sortStrings as sortStrings$1, ensureRustTransformAvailable, transformSourceCode, transformRust, transformOxc, ASTBudgetExceededError, transformRustBatch, transform, isRustTransformAvailable } from '@csszyx/compiler';
 import { encode, compute_mangle_checksum } from '@csszyx/core';
 import { getNativePackageName } from '@csszyx/core/native';
 import { preprocess as preprocess$1 } from '@csszyx/svelte-adapter';
@@ -14,9 +14,9 @@ import { isTailwindReservedCustomProperty, CSSZYX_GLOBAL_ALIAS_PREFIX, isCsszyxG
 import { preprocess } from '@csszyx/vue-adapter';
 import { createUnplugin } from 'unplugin';
 import { mangleCSSSync } from '../css-mangler.mjs';
-import { s as sortStrings, e as escapeHtmlAttribute } from './unplugin.B1mblcm-.mjs';
-import { i as importsRuntimeHelper, f as findRuntimeImportClause } from './unplugin.B3RHYokB.mjs';
-import { r as resolveTransformCacheDir, c as createTransformCacheKey, a as readTransformCache, w as writeTransformCache, e as evictOldTransformCacheEntries, b as evictMemoryCacheToBudget } from './unplugin.ByzV6iZE.mjs';
+import { i as importsRuntimeHelper, f as findRuntimeImportClause, a as insertAfterUseDirective } from './unplugin.nnsa7OVW.mjs';
+import { n as normalizePathSeparators, r as resolveTransformCacheDir, c as createTransformCacheKey, w as writeTransformCache, e as evictOldTransformCacheEntries, a as readTransformCache, b as evictMemoryCacheToBudget } from './unplugin.D-K57LNR.mjs';
+import { s as sortStrings, a as replaceEveryLiteral, u as unicodeEscape, b as escapeDoubleQuotedString, c as escapeSingleQuotedString, e as escapeHtmlAttribute, r as renderTailwindScannerCandidates } from './unplugin.TtmP77BS.mjs';
 import postcss from 'postcss';
 import valueParser from 'postcss-value-parser';
 
@@ -96,7 +96,8 @@ function buildScopeId(node) {
     }
     current = current.parent;
   }
-  return parts.reverse().join(" > ") || DEFAULT_SCOPE_ID;
+  parts.reverse();
+  return parts.join(" > ") || DEFAULT_SCOPE_ID;
 }
 
 const VAR_REFERENCE_RE = /var\(\s*(--[\w-]+)/g;
@@ -369,7 +370,7 @@ function rewriteGlobalVarValue(value, aliases) {
       return;
     }
     const firstArgument = node.nodes.find((child) => child.type !== "space");
-    if (!firstArgument || firstArgument.type !== "word") {
+    if (firstArgument?.type !== "word") {
       return;
     }
     const alias = aliases.get(firstArgument.value);
@@ -519,8 +520,8 @@ function createRSCModuleRecord(code, id) {
 }
 function deleteRSCModuleRecord(records, id) {
   const normalized = normalizeModuleId(id);
-  const clean = id.split("?")[0]?.replace(/\\/g, "/") ?? id;
-  const resolved = path.resolve(clean).replace(/\\/g, "/");
+  const clean = normalizePathSeparators(id.split("?")[0] ?? id);
+  const resolved = normalizePathSeparators(path.resolve(clean));
   pruneRSCModulePathCaches(/* @__PURE__ */ new Set([normalized, resolved, clean]));
   let deleted = records.delete(normalized);
   if (resolved !== normalized) {
@@ -566,7 +567,7 @@ const APP_ROUTER_ENTRIES = /* @__PURE__ */ new Set([
   "route"
 ]);
 function isNextAppRouterEntry(id) {
-  const clean = id.split("?")[0]?.replace(/\\/g, "/") ?? id;
+  const clean = normalizePathSeparators(id.split("?")[0] ?? id);
   if (!clean.includes("/app/") && !clean.startsWith("app/")) return false;
   const basename = clean.split("/").pop() ?? "";
   const dotIdx = basename.indexOf(".");
@@ -615,38 +616,41 @@ function walkRSCGraph(current, records, chain, seen) {
   }
   return null;
 }
+function findDirectiveQuoteEnd(code, start, quote) {
+  let escaped = false;
+  for (let index = start + 1; index < code.length; index++) {
+    const char = code[index];
+    if (escaped) {
+      escaped = false;
+    } else if (char === "\\") {
+      escaped = true;
+    } else if (char === quote) {
+      return index;
+    }
+  }
+  return -1;
+}
+function findDirectiveStatementEnd(code, start) {
+  let end = start;
+  while (end < code.length && /[ \t\r\n]/.test(code[end])) {
+    end++;
+  }
+  return code[end] === ";" ? end + 1 : end;
+}
 function readDirectivePrologue(code) {
   const out = [];
-  let i = code.charCodeAt(0) === 65279 ? 1 : 0;
+  let i = readCodePoint(code, 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) {
+    const quoteEnd = findDirectiveQuoteEnd(code, i, quote);
+    if (quoteEnd === -1) {
       break;
     }
-    let end = j + 1;
-    while (end < code.length && /[ \t\r\n]/.test(code[end])) {
-      end++;
-    }
-    if (code[end] === ";") {
-      end++;
-    }
+    const end = findDirectiveStatementEnd(code, quoteEnd + 1);
     out.push(code.slice(i, end).trim());
     i = end;
   }
@@ -702,55 +706,50 @@ function findStaticImports(code) {
   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;
-    }
+    if (importStart === -1) break;
+    const result = scanStaticImport(code, importStart);
+    cursor = result.nextCursor;
+    if (result.value) imports.push(result.value);
   }
   return imports;
 }
+function scanStaticImport(code, importStart) {
+  const afterKeyword = importStart + 6;
+  if (importStart > 0 && isIdentifierPart(readCodePoint(code, importStart - 1)) || isIdentifierPart(readCodePoint(code, afterKeyword))) {
+    return { nextCursor: afterKeyword };
+  }
+  const clauseStart = skipAsciiWhitespace(code, afterKeyword);
+  const opener = code.charAt(clauseStart);
+  if (opener === "(") return { nextCursor: afterKeyword };
+  if (opener === '"' || opener === "'") {
+    return scanSideEffectImport(code, clauseStart, afterKeyword);
+  }
+  return scanImportClause(code, clauseStart, afterKeyword);
+}
+function scanSideEffectImport(code, literalStart, fallbackCursor) {
+  const literal = readQuotedString(code, literalStart);
+  return literal ? { nextCursor: literal.end, value: { clause: null, source: literal.value } } : { nextCursor: fallbackCursor };
+}
+function scanImportClause(code, clauseStart, fallbackCursor) {
+  const fromStart = findImportFromKeyword(code, clauseStart);
+  if (fromStart === -1) return { nextCursor: fallbackCursor };
+  const clause = code.slice(clauseStart, fromStart).trim();
+  if (splitAsciiWhitespace(clause)[0] === "type") {
+    return { nextCursor: fromStart + 4 };
+  }
+  const literalStart = skipAsciiWhitespace(code, fromStart + 4);
+  const literal = readQuotedString(code, literalStart);
+  return literal ? { nextCursor: literal.end, value: { clause, source: literal.value } } : { nextCursor: fallbackCursor };
+}
+function findImportFromKeyword(code, clauseStart) {
+  for (let position = clauseStart; position < code.length; position += 1) {
+    if (code.charAt(position) === ";") return -1;
+    if (code.startsWith("from", position) && (position === clauseStart || !isIdentifierPart(readCodePoint(code, position - 1))) && !isIdentifierPart(readCodePoint(code, position + 4))) {
+      return position;
+    }
+  }
+  return -1;
+}
 function readQuotedString(code, start) {
   const quote = code.charAt(start);
   if (quote !== '"' && quote !== "'") {
@@ -778,7 +777,7 @@ function readQuotedString(code, start) {
 function skipAsciiWhitespace(code, start) {
   let index = start;
   while (index < code.length) {
-    const charCode = code.charCodeAt(index);
+    const charCode = readCodePoint(code, index);
     if (charCode !== 9 && charCode !== 10 && charCode !== 13 && charCode !== 32) {
       break;
     }
@@ -923,9 +922,9 @@ function normalizeModuleId(id) {
   }
   let normalized;
   try {
-    normalized = fs.realpathSync.native(clean).replace(/\\/g, "/");
+    normalized = normalizePathSeparators(fs.realpathSync.native(clean));
   } catch {
-    normalized = path.resolve(clean).replace(/\\/g, "/");
+    normalized = normalizePathSeparators(path.resolve(clean));
   }
   normalizedModuleIdCache.set(clean, normalized);
   return normalized;
@@ -971,7 +970,7 @@ function resolveLocalModule(importer, source) {
 }
 function pruneRSCModulePathCaches(moduleIds) {
   for (const [key, value] of normalizedModuleIdCache) {
-    const normalizedKey = key.replace(/\\/g, "/");
+    const normalizedKey = normalizePathSeparators(key);
     if (moduleIds.has(value) || moduleIds.has(normalizedKey)) {
       normalizedModuleIdCache.delete(key);
     }
@@ -982,43 +981,44 @@ function pruneRSCModulePathCaches(moduleIds) {
     }
   }
 }
-function readImportedSymbols(clause) {
-  const symbols = [];
+function readNamedImportedSymbols(clause) {
   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])[ \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);
+  if (openBrace === -1 || closeBrace === -1) {
+    return [];
   }
+  return clause.slice(openBrace + 1, closeBrace).split(",").map((part) => part.trim()).filter((part) => part !== "" && !part.startsWith("type ")).map(
+    (part) => part.replace(/^type[ \t]+/, "").split(/(?<![ \t])[ \t]+as[ \t]+/)[0]?.trim()
+  ).filter((symbol) => Boolean(symbol));
+}
+function readForbiddenDefaultSymbol(clause) {
   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)) {
+  const candidate = stripped.trimStart().split(",", 1)[0]?.trim() ?? "";
+  return isIdentifier(candidate) && FORBIDDEN_SYMBOLS.has(candidate) ? candidate : null;
+}
+function hasNamespaceImport(clause) {
+  const parts = splitAsciiWhitespace(clause);
+  return parts.length >= 3 && parts[0] === "*" && parts[1] === "as" && isIdentifier(parts[2] ?? "");
+}
+function readImportedSymbols(clause) {
+  const symbols = readNamedImportedSymbols(clause);
+  if (hasNamespaceImport(clause)) {
+    symbols.push(...FORBIDDEN_SYMBOLS);
+  }
+  const defaultSymbol = readForbiddenDefaultSymbol(clause);
+  if (defaultSymbol) {
     symbols.push(defaultSymbol);
   }
   return symbols;
 }
 function isIdentifier(value) {
-  if (value.length === 0 || !isIdentifierStart(value.charCodeAt(0))) {
+  if (value.length === 0 || !isIdentifierStart(readCodePoint(value, 0))) {
     return false;
   }
   for (let index = 1; index < value.length; index += 1) {
-    const code = value.charCodeAt(index);
+    const code = readCodePoint(value, index);
     if (!isIdentifierStart(code) && (code < 48 || code > 57)) {
       return false;
     }
@@ -1028,11 +1028,14 @@ function isIdentifier(value) {
 function isIdentifierStart(code) {
   return code === 36 || code === 95 || code >= 65 && code <= 90 || code >= 97 && code <= 122;
 }
+function readCodePoint(value, index) {
+  return value.codePointAt(index) ?? -1;
+}
 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 code = index < value.length ? readCodePoint(value, index) : 32;
     const whitespace = code === 9 || code === 10 || code === 13 || code === 32;
     if (whitespace) {
       if (start !== -1) {
@@ -1055,13 +1058,7 @@ function stripCommentsForImportScan(code) {
     const next = code[i + 1];
     if (quote) {
       out += ch;
-      if (escaped) {
-        escaped = false;
-      } else if (ch === "\\") {
-        escaped = true;
-      } else if (ch === quote) {
-        quote = null;
-      }
+      ({ quote, escaped } = advanceQuotedImportScan(ch, quote, escaped));
       i++;
       continue;
     }
@@ -1072,28 +1069,15 @@ function stripCommentsForImportScan(code) {
       continue;
     }
     if (ch === "/" && next === "/") {
-      out += "  ";
-      i += 2;
-      while (i < code.length && code[i] !== "\n") {
-        out += " ";
-        i++;
-      }
+      const masked = maskLineComment(code, i);
+      out += masked.value;
+      i = masked.end;
       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++;
-      }
+      const masked = maskBlockComment(code, i);
+      out += masked.value;
+      i = masked.end;
       continue;
     }
     out += ch;
@@ -1101,6 +1085,31 @@ function stripCommentsForImportScan(code) {
   }
   return out;
 }
+function advanceQuotedImportScan(character, quote, escaped) {
+  if (escaped) return { quote, escaped: false };
+  if (character === "\\") return { quote, escaped: true };
+  return { quote: character === quote ? null : quote, escaped: false };
+}
+function maskLineComment(code, start) {
+  const newline = code.indexOf("\n", start + 2);
+  const end = newline === -1 ? code.length : newline;
+  return { end, value: " ".repeat(end - start) };
+}
+function maskBlockComment(code, start) {
+  let end = start + 2;
+  while (end < code.length) {
+    if (code.charAt(end) === "*" && code.charAt(end + 1) === "/") {
+      end += 2;
+      break;
+    }
+    end += 1;
+  }
+  let value = "";
+  for (let index = start; index < end; index += 1) {
+    value += code.charAt(index) === "\n" ? "\n" : " ";
+  }
+  return { end, value };
+}
 
 const EMPTY_THEME = {
   colors: [],
@@ -1112,6 +1121,20 @@ const EMPTY_THEME = {
   shadows: [],
   breakpoints: []
 };
+function findMatchingBrace(source, openBrace) {
+  let depth = 0;
+  for (let index = openBrace; index < source.length; index++) {
+    if (source[index] === "{") {
+      depth++;
+    } else if (source[index] === "}") {
+      depth--;
+      if (depth === 0) {
+        return index;
+      }
+    }
+  }
+  return -1;
+}
 function stripLayerWrappers(css) {
   let result = "";
   let i = 0;
@@ -1127,26 +1150,13 @@ function stripLayerWrappers(css) {
       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) {
+    const closeBrace = findMatchingBrace(css, openBrace);
+    if (closeBrace === -1) {
       result += css.slice(openBrace);
       break;
     }
+    result += css.slice(openBrace + 1, closeBrace);
+    i = closeBrace + 1;
   }
   return result;
 }
@@ -1155,20 +1165,9 @@ function extractThemeBlocks(css) {
   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++;
+    const closePos = findMatchingBrace(css, openPos);
+    if (closePos !== -1) {
+      blocks.push(css.slice(openPos + 1, closePos));
     }
   }
   return blocks;
@@ -1267,6 +1266,29 @@ function mergeThemes(themes) {
 function hasTokens(theme) {
   return Object.values(theme).some((arr) => arr.length > 0);
 }
+function readCustomPropertyName(block, dashes) {
+  let end = dashes + 2;
+  if (end >= block.length || !/[a-z]/.test(block[end])) {
+    return null;
+  }
+  end++;
+  while (end < block.length && /[a-z0-9-]/.test(block[end])) {
+    end++;
+  }
+  return { name: block.slice(dashes + 2, end), end };
+}
+function findCustomPropertyDeclarationEnd(block, nameEnd) {
+  let cursor = nameEnd;
+  while (cursor < block.length && /\s/.test(block[cursor])) {
+    cursor++;
+  }
+  if (block[cursor] === ":") {
+    const valueStart = cursor + 1;
+    const semicolon = block.indexOf(";", valueStart);
+    return semicolon > valueStart ? semicolon + 1 : -1;
+  }
+  return block[nameEnd] === ";" ? nameEnd + 1 : -1;
+}
 function scanCustomPropertyNames(block) {
   const names = [];
   let i = 0;
@@ -1275,48 +1297,392 @@ function scanCustomPropertyNames(block) {
     if (dashes === -1) {
       break;
     }
-    let end = dashes + 2;
-    if (end >= block.length || !/[a-z]/.test(block[end])) {
+    const property = readCustomPropertyName(block, dashes);
+    if (!property) {
       i = dashes + 1;
       continue;
     }
-    end++;
-    while (end < block.length && /[a-z0-9-]/.test(block[end])) {
-      end++;
+    const matchEnd = findCustomPropertyDeclarationEnd(block, property.end);
+    if (matchEnd === -1) {
+      i = dashes + 1;
+      continue;
+    }
+    names.push(property.name);
+    i = matchEnd;
+  }
+  return names;
+}
+
+const REGEX_PREFIXES = new Set("([{:,;=!?&|+-*%^~<>/");
+const REGEX_PREFIX_KEYWORDS = /* @__PURE__ */ new Set([
+  "await",
+  "case",
+  "delete",
+  "do",
+  "else",
+  "in",
+  "instanceof",
+  "of",
+  "return",
+  "throw",
+  "typeof",
+  "void",
+  "yield"
+]);
+const SIMPLE_ESCAPES = {
+  b: "\b",
+  f: "\f",
+  n: "\n",
+  r: "\r",
+  t: "	",
+  v: "\v",
+  "0": "\0"
+};
+function isFixedHex(value, width) {
+  if (value.length !== width) return false;
+  for (const character of value) {
+    if (!"0123456789abcdefABCDEF".includes(character)) return false;
+  }
+  return true;
+}
+function decodeEscape(value, cursor) {
+  const escaped = value[cursor];
+  if (SIMPLE_ESCAPES[escaped] !== void 0) {
+    return { value: SIMPLE_ESCAPES[escaped], cursor };
+  }
+  if (escaped === "\r" && value[cursor + 1] === "\n") {
+    return { value: "", cursor: cursor + 1 };
+  }
+  if (escaped === "u" && value[cursor + 1] === "{") {
+    const close = value.indexOf("}", cursor + 2);
+    const hex2 = close === -1 ? "" : value.slice(cursor + 2, close);
+    const codePoint = hex2 && /^[\dA-F]+$/i.test(hex2) ? Number.parseInt(hex2, 16) : -1;
+    if (codePoint >= 0 && codePoint <= 1114111) {
+      return { value: String.fromCodePoint(codePoint), cursor: close };
+    }
+  }
+  let width = 0;
+  if (escaped === "x") width = 2;
+  else if (escaped === "u") width = 4;
+  const hex = value.slice(cursor + 1, cursor + width + 1);
+  if (width > 0 && isFixedHex(hex, width)) {
+    return {
+      value: String.fromCodePoint(Number.parseInt(hex, 16)),
+      cursor: cursor + width
+    };
+  }
+  const decoded = escaped === "\n" || escaped === "\r" ? "" : escaped;
+  return { value: decoded, cursor };
+}
+function decodeJavaScriptString(value) {
+  let output = "";
+  let cursor = 0;
+  while (cursor < value.length) {
+    if (value[cursor] !== "\\" || cursor + 1 >= value.length) {
+      output += value[cursor++];
+      continue;
+    }
+    const decoded = decodeEscape(value, cursor + 1);
+    output += decoded.value;
+    cursor = decoded.cursor + 1;
+  }
+  return output;
+}
+function decodeAttributeWhitespace(value) {
+  return value.replace(
+    /&#(?:(\d+)|x([\da-f]+));|&(?:Tab|NewLine);/gi,
+    (entity, decimal, hexadecimal) => {
+      if (!decimal && !hexadecimal) return " ";
+      const codePoint = Number.parseInt(decimal ?? hexadecimal ?? "", decimal ? 10 : 16);
+      return [9, 10, 12, 13, 32].includes(codePoint) ? " " : entity;
+    }
+  );
+}
+function collectClassTokens(target, value) {
+  for (const className of value.split(/\s+/)) {
+    if (className) target.add(className);
+  }
+}
+function quotedEnd(source, start, quote) {
+  let cursor = start + 1;
+  while (cursor < source.length) {
+    if (source[cursor] === "\\") cursor += 2;
+    else if (source[cursor++] === quote) break;
+  }
+  return cursor;
+}
+function commentEnd(source, start) {
+  if (source[start + 1] === "/") {
+    const end2 = source.indexOf("\n", start + 2);
+    return end2 === -1 ? source.length : end2 + 1;
+  }
+  const end = source.indexOf("*/", start + 2);
+  return end === -1 ? source.length : end + 2;
+}
+function isRegexStart(source, start) {
+  let cursor = start - 1;
+  while (cursor >= 0 && /\s/.test(source[cursor])) cursor--;
+  if (source[cursor] === "<" && /[A-Z]/i.test(source[start + 1] ?? "")) return false;
+  if (cursor < 0 || REGEX_PREFIXES.has(source[cursor])) return true;
+  if (!/[\w$]/.test(source[cursor])) return false;
+  const end = cursor + 1;
+  while (cursor >= 0 && /[\w$]/.test(source[cursor])) cursor--;
+  return REGEX_PREFIX_KEYWORDS.has(source.slice(cursor + 1, end));
+}
+function regexEnd(source, start) {
+  let cursor = start + 1;
+  let inCharacterClass = false;
+  while (cursor < source.length) {
+    const character = source[cursor];
+    if (character === "\\") cursor += 2;
+    else if (character === "[") {
+      inCharacterClass = true;
+      cursor++;
+    } else if (character === "]") {
+      inCharacterClass = false;
+      cursor++;
+    } else if (character === "/" && !inCharacterClass) {
+      cursor++;
+      while (/[A-Z]/i.test(source[cursor] ?? "")) cursor++;
+      break;
+    } else cursor++;
+  }
+  return cursor;
+}
+function templateEnd(source, start) {
+  let cursor = start + 1;
+  while (cursor < source.length) {
+    if (source[cursor] === "\\") cursor += 2;
+    else if (source[cursor] === "`") return cursor + 1;
+    else if (source[cursor] === "$" && source[cursor + 1] === "{") {
+      cursor = findBalancedCodeEnd(source, cursor + 2);
+    } else cursor++;
+  }
+  return source.length;
+}
+function lexicalRegionEnd(source, start) {
+  const character = source[start];
+  if (character === '"' || character === "'") return quotedEnd(source, start, character);
+  if (character === "`") return templateEnd(source, start);
+  if (character === "/" && (source[start + 1] === "/" || source[start + 1] === "*")) {
+    return commentEnd(source, start);
+  }
+  if (character === "/" && isRegexStart(source, start)) return regexEnd(source, start);
+  return start;
+}
+function findBalancedCodeEnd(source, bodyStart) {
+  let depth = 1;
+  let cursor = bodyStart;
+  while (cursor < source.length) {
+    const regionEnd = lexicalRegionEnd(source, cursor);
+    if (regionEnd !== cursor) {
+      cursor = regionEnd;
+      continue;
+    }
+    if (source[cursor] === "{") depth++;
+    else if (source[cursor] === "}" && --depth === 0) return cursor;
+    cursor++;
+  }
+  return source.length;
+}
+function collectTemplateTokens(target, source, start) {
+  let cursor = start + 1;
+  let quasiStart = cursor;
+  while (cursor < source.length) {
+    if (source[cursor] === "\\") {
+      cursor += 2;
+      continue;
+    }
+    if (source[cursor] === "`") {
+      collectClassTokens(target, decodeJavaScriptString(source.slice(quasiStart, cursor)));
+      return cursor + 1;
+    }
+    if (source[cursor] === "$" && source[cursor + 1] === "{") {
+      collectClassTokens(target, decodeJavaScriptString(source.slice(quasiStart, cursor)));
+      const expressionEnd = findBalancedCodeEnd(source, cursor + 2);
+      collectExpressionTokens(target, source.slice(cursor + 2, expressionEnd));
+      cursor = expressionEnd + 1;
+      quasiStart = cursor;
+      continue;
+    }
+    cursor++;
+  }
+  collectClassTokens(target, decodeJavaScriptString(source.slice(quasiStart)));
+  return source.length;
+}
+function collectExpressionTokens(target, expression) {
+  let cursor = 0;
+  let pendingLiteral = "";
+  let previousLiteralEnd = -1;
+  const flushPending = () => {
+    if (pendingLiteral) collectClassTokens(target, pendingLiteral);
+    pendingLiteral = "";
+  };
+  while (cursor < expression.length) {
+    const character = expression[cursor];
+    if (character === "/" && (expression[cursor + 1] === "/" || expression[cursor + 1] === "*")) {
+      cursor = commentEnd(expression, cursor);
+      continue;
+    }
+    if (character === "/" && isRegexStart(expression, cursor)) {
+      cursor = regexEnd(expression, cursor);
+      continue;
+    }
+    if (character === "`") {
+      flushPending();
+      cursor = collectTemplateTokens(target, expression, cursor);
+      previousLiteralEnd = -1;
+      continue;
     }
-    const name = block.slice(dashes + 2, end);
-    let matchEnd = -1;
-    let cursor = end;
-    while (cursor < block.length && /\s/.test(block[cursor])) {
+    if (character !== '"' && character !== "'") {
       cursor++;
+      continue;
     }
-    if (block[cursor] === ":") {
-      const valueStart = cursor + 1;
-      const semi = block.indexOf(";", valueStart);
-      if (semi > valueStart) {
-        matchEnd = semi + 1;
-      }
+    const end = quotedEnd(expression, cursor, character);
+    const decoded = decodeJavaScriptString(expression.slice(cursor + 1, end - 1));
+    const joinsPrevious = previousLiteralEnd >= 0 && expression.slice(previousLiteralEnd, cursor).trim() === "+";
+    if (!joinsPrevious) flushPending();
+    pendingLiteral += decoded;
+    previousLiteralEnd = end;
+    cursor = end;
+  }
+  flushPending();
+}
+function triviaEnd(source, start) {
+  let cursor = start;
+  while (cursor < source.length) {
+    if (/\s/.test(source[cursor])) cursor++;
+    else if (source[cursor] === "/" && (source[cursor + 1] === "/" || source[cursor + 1] === "*")) {
+      cursor = commentEnd(source, cursor);
+    } else break;
+  }
+  return cursor;
+}
+function propertyExpressionEnd(source, start) {
+  let cursor = start;
+  let parenDepth = 0;
+  let bracketDepth = 0;
+  let braceDepth = 0;
+  while (cursor < source.length) {
+    const regionEnd = lexicalRegionEnd(source, cursor);
+    if (regionEnd !== cursor) {
+      cursor = regionEnd;
+      continue;
     }
-    if (matchEnd === -1 && block[end] === ";") {
-      matchEnd = end + 1;
+    const character = source[cursor];
+    if (character === "(") parenDepth++;
+    else if (character === ")") parenDepth--;
+    else if (character === "[") bracketDepth++;
+    else if (character === "]") bracketDepth--;
+    else if (character === "{") braceDepth++;
+    else if (character === "}" && braceDepth > 0) braceDepth--;
+    else if ((character === "," || character === ";" || character === "}") && parenDepth === 0 && bracketDepth === 0 && braceDepth === 0)
+      return cursor;
+    cursor++;
+  }
+  return source.length;
+}
+function isClassSink(source, start, end) {
+  const name = source.slice(start, end);
+  if (name !== "class" && name !== "className") return false;
+  let previous = start - 1;
+  while (previous >= 0 && /\s/.test(source[previous])) previous--;
+  return source[previous] !== "." && source[previous] !== "-";
+}
+function collectClassDirective(target, source, sinkStart, valueStart) {
+  if (!/[\w$-]/.test(source[valueStart] ?? "")) return null;
+  let directiveEnd = valueStart;
+  while (/[\w$-]/.test(source[directiveEnd] ?? "")) directiveEnd++;
+  const equals = triviaEnd(source, directiveEnd);
+  if (source[equals] !== "=") {
+    const insideMarkupTag = source.lastIndexOf("<", sinkStart) > source.lastIndexOf(">", sinkStart);
+    const next = source[equals] ?? "";
+    const continuesMarkupTag = next === "/" || next === ">" || next === "{" || /[A-Z_:]/i.test(next);
+    if (!insideMarkupTag || !continuesMarkupTag) return null;
+    collectClassTokens(target, source.slice(valueStart, directiveEnd));
+    return directiveEnd;
+  }
+  const directive = source.slice(valueStart, directiveEnd);
+  const directiveValueStart = triviaEnd(source, equals + 1);
+  const directiveQuote = source[directiveValueStart];
+  if (directive !== "list") collectClassTokens(target, directive);
+  if (directiveQuote === "{") {
+    const end = findBalancedCodeEnd(source, directiveValueStart + 1);
+    if (directive === "list") {
+      collectExpressionTokens(target, source.slice(directiveValueStart + 1, end));
+    }
+    return end + 1;
+  }
+  if (directive === "list" && (directiveQuote === '"' || directiveQuote === "'")) {
+    const end = quotedEnd(source, directiveValueStart, directiveQuote);
+    collectExpressionTokens(target, source.slice(directiveValueStart, end));
+    return end;
+  }
+  return directiveValueStart;
+}
+function collectClassSink(target, source, start, nameEnd) {
+  const operatorStart = triviaEnd(source, nameEnd);
+  const operator = source[operatorStart];
+  if (operator !== "=" && operator !== ":") return nameEnd;
+  const valueStart = triviaEnd(source, operatorStart + 1);
+  const quote = source[valueStart];
+  const vueBinding = operator === "=" && source.slice(Math.max(0, start - 1), start) === ":";
+  if (operator === ":" && valueStart === operatorStart + 1) {
+    const directiveEnd = collectClassDirective(target, source, start, valueStart);
+    if (directiveEnd !== null) return directiveEnd;
+  }
+  if (quote === '"' || quote === "'") {
+    const end = quotedEnd(source, valueStart, quote);
+    const value = source.slice(valueStart + 1, end - 1);
+    if (vueBinding) collectExpressionTokens(target, decodeAttributeWhitespace(value));
+    else collectClassTokens(target, decodeAttributeWhitespace(value));
+    return end;
+  }
+  if (operator === "=" && quote === "{") {
+    const end = findBalancedCodeEnd(source, valueStart + 1);
+    collectExpressionTokens(target, source.slice(valueStart + 1, end));
+    return end + 1;
+  }
+  if (operator === ":") {
+    const end = propertyExpressionEnd(source, valueStart);
+    collectExpressionTokens(target, source.slice(valueStart, end));
+    return end;
+  }
+  return valueStart;
+}
+function collectAuthoredClassNames(source) {
+  const classes = /* @__PURE__ */ new Set();
+  let cursor = 0;
+  while (cursor < source.length) {
+    if (source[cursor] === '"' || source[cursor] === "'") {
+      const keyEnd = quotedEnd(source, cursor, source[cursor]);
+      const key = decodeJavaScriptString(source.slice(cursor + 1, keyEnd - 1));
+      cursor = key === "class" || key === "className" ? collectClassSink(classes, source, cursor, keyEnd) : keyEnd;
+      continue;
     }
-    if (matchEnd === -1) {
-      i = dashes + 1;
+    const regionEnd = lexicalRegionEnd(source, cursor);
+    if (regionEnd !== cursor) {
+      cursor = regionEnd;
       continue;
     }
-    names.push(name);
-    i = matchEnd;
+    if (!/[A-Z_$]/i.test(source[cursor])) {
+      cursor++;
+      continue;
+    }
+    let nameEnd = cursor + 1;
+    while (/[\w$]/.test(source[nameEnd] ?? "")) nameEnd++;
+    cursor = isClassSink(source, cursor, nameEnd) ? collectClassSink(classes, source, cursor, nameEnd) : nameEnd;
   }
-  return names;
+  return classes;
 }
 
 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, "/");
+  return normalizePathSeparators(id.split(/[?#]/, 1)[0]);
 }
 function normalizeRoot(rootDir) {
-  return path.resolve(rootDir).replace(/\\/g, "/");
+  return normalizePathSeparators(path.resolve(rootDir));
 }
 function hasGlobMagic(pattern) {
   return GLOB_MAGIC_RE.test(pattern);
@@ -1325,7 +1691,7 @@ function escapeRegExp(ch) {
   return /[|\\{}()[\]^$+?.]/.test(ch) ? `\\${ch}` : ch;
 }
 function globToRegExp(pattern) {
-  const normalized = pattern.replace(/\\/g, "/");
+  const normalized = normalizePathSeparators(pattern);
   let out = "^";
   for (let i = 0; i < normalized.length; i++) {
     const ch = normalized[i];
@@ -1348,7 +1714,7 @@ function globToRegExp(pattern) {
 function relativeToRoot(file, rootDir) {
   const root = normalizeRoot(rootDir);
   const normalizedFile = normalizeFileId(file);
-  return path.posix.relative(root, normalizedFile).replace(/\\/g, "/");
+  return normalizePathSeparators(path.posix.relative(root, normalizedFile));
 }
 function matchesPattern(id, pattern, rootDir) {
   const file = normalizeFileId(id);
@@ -1357,7 +1723,7 @@ function matchesPattern(id, pattern, rootDir) {
     pattern.lastIndex = 0;
     return pattern.test(file) || pattern.test(relative);
   }
-  const normalizedPattern = pattern.replace(/\\/g, "/");
+  const normalizedPattern = normalizePathSeparators(pattern);
   if (hasGlobMagic(normalizedPattern)) {
     const re = globToRegExp(normalizedPattern);
     return re.test(file) || re.test(relative);
@@ -1372,27 +1738,36 @@ function matchesAnyPattern(id, patterns, rootDir) {
   const list = Array.isArray(patterns) ? patterns : [patterns];
   return list.some((pattern) => matchesPattern(id, pattern, rootDir));
 }
+function collectDirectoryFiles(dir, files) {
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (!DEFAULT_IGNORED_DIRS.has(entry.name) && !entry.name.startsWith(".")) {
+        collectDirectoryFiles(full, files);
+      }
+    } else {
+      files.add(path.resolve(full));
+    }
+  }
+}
+function isExpandedPatternMatch(file, patterns, rootDir) {
+  return patterns.some((pattern) => {
+    if (hasGlobMagic(pattern)) {
+      return matchesPattern(file, pattern, rootDir);
+    }
+    const resolved = path.isAbsolute(pattern) ? pattern : path.join(rootDir, pattern);
+    return normalizeFileId(path.resolve(resolved)) === normalizeFileId(file);
+  });
+}
 function expandFilePatterns(rootDir, patterns) {
   const list = Array.isArray(patterns) ? patterns : [patterns];
   const files = /* @__PURE__ */ new Set();
-  const walk = (dir) => {
-    let entries;
-    try {
-      entries = fs.readdirSync(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      const full = path.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        if (!DEFAULT_IGNORED_DIRS.has(entry.name) && !entry.name.startsWith(".")) {
-          walk(full);
-        }
-      } else {
-        files.add(path.resolve(full));
-      }
-    }
-  };
   let needsWalk = false;
   for (const pattern of list) {
     const resolved = path.isAbsolute(pattern) ? pattern : path.join(rootDir, pattern);
@@ -1405,30 +1780,25 @@ function expandFilePatterns(rootDir, patterns) {
     }
   }
   if (needsWalk) {
-    walk(rootDir);
+    collectDirectoryFiles(rootDir, files);
     for (const file of Array.from(files)) {
-      if (!list.some(
-        (pattern) => hasGlobMagic(pattern) && matchesPattern(file, pattern, rootDir)
-      )) {
-        const isLiteralMatch = list.some((pattern) => {
-          if (hasGlobMagic(pattern)) {
-            return false;
-          }
-          const resolved = path.isAbsolute(pattern) ? pattern : path.join(rootDir, pattern);
-          return normalizeFileId(path.resolve(resolved)) === normalizeFileId(file);
-        });
-        if (!isLiteralMatch) {
-          files.delete(file);
-        }
+      if (!isExpandedPatternMatch(file, list, rootDir)) {
+        files.delete(file);
       }
     }
   }
   return sortStrings(files);
 }
 
+const LINE_SEPARATOR$1 = String.fromCodePoint(8232);
+const PARAGRAPH_SEPARATOR$1 = String.fromCodePoint(8233);
 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");
+  let escaped = replaceEveryLiteral(json, "<", unicodeEscape("003C"));
+  escaped = replaceEveryLiteral(escaped, ">", unicodeEscape("003E"));
+  escaped = replaceEveryLiteral(escaped, "&", unicodeEscape("0026"));
+  escaped = replaceEveryLiteral(escaped, LINE_SEPARATOR$1, unicodeEscape("2028"));
+  return replaceEveryLiteral(escaped, PARAGRAPH_SEPARATOR$1, unicodeEscape("2029"));
 }
 function injectHtmlOpeningAttr(html, attr) {
   const lower = html.toLowerCase();
@@ -1560,11 +1930,17 @@ function injectRecoveryManifest(html, manifest) {
   return html + scriptTag;
 }
 
+const LINE_SEPARATOR = String.fromCodePoint(8232);
+const PARAGRAPH_SEPARATOR = String.fromCodePoint(8233);
 function escapeJsonForInlineScript(json) {
-  return json.replace(/`/g, "\\u0060").replace(/\$/g, "\\u0024").replace(/</g, "\\u003c").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+  let escaped = replaceEveryLiteral(json, "`", unicodeEscape("0060"));
+  escaped = replaceEveryLiteral(escaped, "$", unicodeEscape("0024"));
+  escaped = replaceEveryLiteral(escaped, "<", unicodeEscape("003c"));
+  escaped = replaceEveryLiteral(escaped, LINE_SEPARATOR, unicodeEscape("2028"));
+  return replaceEveryLiteral(escaped, PARAGRAPH_SEPARATOR, unicodeEscape("2029"));
 }
 function escapeForDoubleQuotedString(value) {
-  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  return escapeDoubleQuotedString(value);
 }
 
 function isParserMode(value) {
@@ -1611,15 +1987,13 @@ 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 escapeTsString(value) {
-  return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\r/g, "\\r").replace(/\n/g, "\\n");
-}
 function generateThemeDts(opts) {
   const { theme, sourceFiles } = opts;
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-  const sources = sourceFiles.join(", ").replace(/[\r\n]/g, " ");
-  const toUnion = (tokens) => tokens.map((t) => `'${escapeTsString(t)}'`).join(" | ");
-  const quoteKey = (key) => /^[a-z_$][\w$]*$/i.test(key) ? key : `'${escapeTsString(key)}'`;
+  const withoutCarriageReturns = replaceEveryLiteral(sourceFiles.join(", "), "\r", " ");
+  const sources = replaceEveryLiteral(withoutCarriageReturns, "\n", " ");
+  const toUnion = (tokens) => tokens.map((t) => `'${escapeSingleQuotedString(t)}'`).join(" | ");
+  const quoteKey = (key) => /^[a-z_$][\w$]*$/i.test(key) ? key : `'${escapeSingleQuotedString(key)}'`;
   const entries = [];
   if (theme.colors.length > 0) {
     entries.push(`        colors: ${toUnion(theme.colors)};`);
@@ -1757,6 +2131,15 @@ function createThemeGroupsModule(tokens) {
   ].join("\n");
 }
 
+function registerWebpackAssetProcessor(compiler, processAssets) {
+  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 },
+      (assets) => processAssets(assets, compilation, compiler)
+    );
+  });
+}
 const CHECKSUM_PLACEHOLDER = "___CSSZYX_CHECKSUM___";
 const MANGLE_MAP_PLACEHOLDER = "___CSSZYX_MANGLE_MAP___";
 const VAR_MANGLE_MAP_PLACEHOLDER = "___CSSZYX_VAR_MANGLE_MAP___";
@@ -1768,7 +2151,6 @@ const TRANSFORM_MEMORY_CACHE_MAX_CODE_CHARS = 32e6;
 const MAX_SAFELIST_CLASSES = 1e5;
 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*)/;
 function findOpeningTag(source, tag) {
   const lower = source.toLowerCase();
   const marker = `<${tag}`;
@@ -1841,10 +2223,10 @@ function stripCssBlockComments(code) {
   let i = 0;
   const n = code.length;
   while (i < n) {
-    if (code.charCodeAt(i) === SLASH && code.charCodeAt(i + 1) === STAR) {
+    if (code.codePointAt(i) === SLASH && code.codePointAt(i + 1) === STAR) {
       out += code.slice(last, i);
       i += 2;
-      while (i < n && !(code.charCodeAt(i) === STAR && code.charCodeAt(i + 1) === SLASH)) {
+      while (i < n && !(code.codePointAt(i) === STAR && code.codePointAt(i + 1) === SLASH)) {
         i++;
       }
       i += 2;
@@ -1950,9 +2332,17 @@ function shouldEmitWarning(quiet, devOnly, isProduction) {
   return true;
 }
 function normalizeForMatch(p) {
-  const n = p.replace(/\\/g, "/");
+  const n = normalizePathSeparators(p);
   return n.length > 1 && n.endsWith("/") ? n.slice(0, -1) : n;
 }
+function findJsxExpressionEnd(code, bodyStart) {
+  return findBalancedCodeEnd(code, bodyStart);
+}
+function warnPrescanBudgetSkip(filePath) {
+  console.warn(
+    `[csszyx] prescan skipped ${filePath}: the file exceeds the AST node budget, so NONE of its classes reached the safelist and their CSS will not be generated. Raise \`build.astBudgetLimit\` in the csszyx plugin options, or split the file.`
+  );
+}
 function resolveCompileSourceDirs(root, sources, realpathDir = (p) => {
   try {
     const real = fs.realpathSync(p);
@@ -2005,6 +2395,9 @@ function fileMayContainSafelistableSz(content) {
   // engine-parity harness caught its classes missing on all engines.
   content.includes("dynamic(");
 }
+function mangleEligibleClasses(ownedClasses, authoredClasses) {
+  return sortStrings$1([...ownedClasses].filter((className) => !authoredClasses.has(className)));
+}
 function isPackagesSkippedSource(id, sourceDirs = []) {
   const p = normalizeForMatch(id);
   if (p.includes("node_modules")) {
@@ -2025,8 +2418,8 @@ ${list}
 Add the package directory to \`compileSources\` (or move the file out of packages/) \u2014 otherwise their \`sz\` produces no CSS.`;
 }
 function computeSafelistRelPath(rootDir, safelistFilename, cssId) {
-  const safelistPath = path.join(rootDir, safelistFilename).replace(/\\/g, "/");
-  const cssDir = path.dirname(cssId).replace(/\\/g, "/");
+  const safelistPath = normalizePathSeparators(path.join(rootDir, safelistFilename));
+  const cssDir = normalizePathSeparators(path.dirname(cssId));
   let relPath = path.posix.relative(cssDir, safelistPath);
   if (!relPath.startsWith(".")) {
     relPath = `./${relPath}`;
@@ -2200,7 +2593,10 @@ function normalizeGlobalVarAliasesForCache(aliases) {
   if (!aliases) {
     return [];
   }
-  const entries = aliases instanceof Map ? aliases.entries() : Array.isArray(aliases) ? aliases : Object.entries(aliases);
+  let entries;
+  if (aliases instanceof Map) entries = aliases.entries();
+  else if (Array.isArray(aliases)) entries = aliases;
+  else entries = Object.entries(aliases);
   const normalized = /* @__PURE__ */ new Map();
   for (const [original, alias] of entries) {
     if (original.startsWith("--") && alias.startsWith("--")) {
@@ -2405,7 +2801,7 @@ function findPackageVersionFromFile(file, fallback) {
   }
 }
 function normalizeSourceFilename(filename) {
-  return filename.replace(/\\/g, "/");
+  return normalizePathSeparators(filename);
 }
 const SCRIPT_ID_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx"];
 const SOURCE_MODULE_EXTENSIONS = [...SCRIPT_ID_EXTENSIONS, ".cts", ".mts", ".cjs", ".mjs"];
@@ -2413,11 +2809,26 @@ function matchesScriptExtension(id, extensions) {
   return extensions.some((ext) => id.endsWith(ext) || id.includes(`${ext}?`));
 }
 function insertRuntimeImport(code, importStmt) {
-  const directiveMatch = code.match(DIRECTIVE_PROLOGUE_PREFIX_RE);
-  if (!directiveMatch) {
-    return `${importStmt}${code}`;
+  return insertAfterUseDirective(code, importStmt);
+}
+function scanClassExpression(source, from) {
+  let depth = 0;
+  let index = from;
+  while (index < source.length) {
+    const char = source[index];
+    if (char === "(" || char === "[") {
+      depth++;
+    } else if (char === ")" || char === "]") {
+      if (depth === 0) {
+        break;
+      }
+      depth--;
+    } else if (depth === 0 && (char === "," || char === ";" || char === "\n" || char === "}")) {
+      break;
+    }
+    index++;
   }
-  return code.replace(directiveMatch[0], `${directiveMatch[1]}${directiveMatch[2]}${importStmt}`);
+  return index;
 }
 function mangleCodeClassesSync(code, mangleMap) {
   function mangleClassString(classString) {
@@ -2425,6 +2836,58 @@ function mangleCodeClassesSync(code, mangleMap) {
       return mangleMap[cls.replace(/\\(.)/g, "$1")] || cls;
     }).join(" ");
   }
+  function mangleClassTemplate(fullMatch, templateContent) {
+    let changed = false;
+    let output = "";
+    let cursor = 0;
+    while (cursor < templateContent.length) {
+      const interpolationStart = templateContent.indexOf("${", cursor);
+      const quasiEnd = interpolationStart === -1 ? templateContent.length : interpolationStart;
+      const quasi = mangleTemplateQuasi(templateContent.slice(cursor, quasiEnd));
+      output += quasi.value;
+      changed ||= quasi.changed;
+      if (interpolationStart === -1) break;
+      const interpolationEnd = findTemplateInterpolationEnd(
+        templateContent,
+        interpolationStart + 2
+      );
+      const inner = templateContent.slice(interpolationStart + 2, interpolationEnd - 1);
+      const interpolation = mangleTemplateInterpolation(inner);
+      output += `\${${interpolation.value}}`;
+      changed ||= interpolation.changed;
+      cursor = interpolationEnd;
+    }
+    return changed ? `className:\`${output}\`` : fullMatch;
+  }
+  function mangleTemplateQuasi(quasi) {
+    const trimmed = quasi.trim();
+    if (!trimmed) return { value: quasi, changed: false };
+    const mangled = mangleClassString(trimmed);
+    return {
+      value: mangled === trimmed ? quasi : quasi.replace(trimmed, mangled),
+      changed: mangled !== trimmed
+    };
+  }
+  function findTemplateInterpolationEnd(templateContent, bodyStart) {
+    let depth = 0;
+    for (let cursor = bodyStart; cursor < templateContent.length; cursor++) {
+      if (templateContent[cursor] === "{") depth++;
+      else if (templateContent[cursor] === "}" && depth-- === 0) return cursor + 1;
+    }
+    return templateContent.length;
+  }
+  function mangleTemplateInterpolation(inner) {
+    let changed = false;
+    const value = inner.replace(/"([^"]*)"/g, (quoted, classString) => {
+      const parts = classString.split(/\s+/).filter(Boolean);
+      if (parts.length === 0) return quoted;
+      const mangled = parts.map((className) => mangleMap[className] || className).join(" ");
+      if (mangled === classString) return quoted;
+      changed = true;
+      return `"${mangled}"`;
+    });
+    return { value, changed };
+  }
   let result = code.replace(/(?:class(?:Name)?|sz)[:=]\s*"((?:[^"\\]|\\.)*)"/g, (match, classes) => {
     const mangled = mangleClassString(classes);
     if (mangled === classes) {
@@ -2438,92 +2901,7 @@ function mangleCodeClassesSync(code, mangleMap) {
     }
     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;
-  });
-  function scanClassExpression(source, from) {
-    let depth = 0;
-    let j = from;
-    while (j < source.length) {
-      const ch = source[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++;
-    }
-    return j;
-  }
+  result = result.replace(/className:\s*`([^`]+)`/g, mangleClassTemplate);
   function mangleTernaryClassStrings(expr) {
     const qIdx = expr.indexOf("?");
     if (qIdx === -1 || !expr.slice(qIdx).includes(":")) {
@@ -2731,7 +3109,12 @@ function createCsszyxPlugins(options = {}) {
     }
     if (!_loggedActiveParsers.has(parserMode)) {
       _loggedActiveParsers.add(parserMode);
-      const detail = parserDegraded ? "oxc (degraded from default `rust`: no native binary for this platform)" : parserMode === "rust" ? "rust (native engine)" : parserMode;
+      let detail = parserMode;
+      if (parserDegraded) {
+        detail = "oxc (degraded from default `rust`: no native binary for this platform)";
+      } else if (parserMode === "rust") {
+        detail = "rust (native engine)";
+      }
       console.warn(`[csszyx] active parser: ${detail}`);
     }
   }
@@ -2752,6 +3135,7 @@ function createCsszyxPlugins(options = {}) {
     skipWarningEmitted: false,
     classesCapped: false,
     ownedClasses: /* @__PURE__ */ new Set(),
+    authoredClasses: /* @__PURE__ */ new Set(),
     mangleMap: {},
     varMangleEntriesByFile: /* @__PURE__ */ new Map(),
     varMangleMap: Object.fromEntries(earlyGlobalVarAliasEntries),
@@ -2868,53 +3252,76 @@ function createCsszyxPlugins(options = {}) {
     }
     const cacheKey = cacheEnabled ? createTransformCacheKey(cacheInput) : null;
     if (cacheEnabled && cacheKey) {
-      const memoryCached = transformMemoryCache.get(cacheKey.key);
-      if (memoryCached) {
-        transformMemoryCache.delete(cacheKey.key);
-        transformMemoryCache.set(cacheKey.key, memoryCached);
-        return memoryCached;
-      }
-      const cached = readTransformCache(cacheRoot, cacheInput, cacheKey);
-      if (cached) {
-        rememberTransformCacheEntry(cacheKey.key, cached);
-        return cached;
-      }
-      if (astBudget === void 0) {
-        const handoff = prescanResultHandoff.get(effectiveFilename);
-        if (handoff) {
-          prescanResultHandoff.delete(effectiveFilename);
-          if (handoff.inputSha256 === cacheKey.inputSha256) {
-            return handoff.result;
-          }
-        }
-      }
-    }
-    let result;
+      const cached = findConfiguredTransformCacheEntry(
+        cacheRoot,
+        cacheInput,
+        cacheKey,
+        effectiveFilename,
+        astBudget
+      );
+      if (cached) return cached;
+    }
+    const execution = runConfiguredParser(source, effectiveFilename, compilerOptions);
+    if (cacheEnabled && cacheKey && execution.cacheable) {
+      writeTransformCache(cacheRoot, cacheInput, execution.result, cacheKey);
+      rememberTransformCacheEntry(cacheKey.key, execution.result);
+    }
+    return execution.result;
+  }
+  function findConfiguredTransformCacheEntry(cacheRoot, cacheInput, cacheKey, effectiveFilename, astBudget) {
+    const memoryCached = transformMemoryCache.get(cacheKey.key);
+    if (memoryCached) {
+      transformMemoryCache.delete(cacheKey.key);
+      transformMemoryCache.set(cacheKey.key, memoryCached);
+      return memoryCached;
+    }
+    const diskCached = readTransformCache(cacheRoot, cacheInput, cacheKey);
+    if (diskCached) {
+      rememberTransformCacheEntry(cacheKey.key, diskCached);
+      return diskCached;
+    }
+    if (astBudget !== void 0) return null;
+    const handoff = prescanResultHandoff.get(effectiveFilename);
+    if (!handoff) return null;
+    prescanResultHandoff.delete(effectiveFilename);
+    return handoff.inputSha256 === cacheKey.inputSha256 ? handoff.result : null;
+  }
+  function runConfiguredParser(source, effectiveFilename, compilerOptions) {
     if (parserMode === "babel") {
-      result = transformSourceCode(source, effectiveFilename, compilerOptions);
-    } else if (parserMode === "rust") {
-      result = transformRust(source, effectiveFilename, compilerOptions);
-    } else {
-      try {
-        result = transformOxc(source, effectiveFilename, compilerOptions);
-      } catch (err) {
-        result = transformSourceCode(source, effectiveFilename, compilerOptions);
-        const reason = err instanceof Error ? err.message : String(err);
-        result.diagnostics.push(
-          `[csszyx] oxc parser fell back to Babel for ${effectiveFilename}: ${reason}`
-        );
-        if (!_babelFallbackFiles.has(effectiveFilename)) {
-          _babelFallbackFiles.add(effectiveFilename);
-          console.warn(
-            `[csszyx] oxc parser fell back to Babel for ${effectiveFilename}: ${reason} (${_babelFallbackFiles.size} file(s) so far). Output is still correct; this usually means the file uses a syntax the oxc lane does not yet handle.`
-          );
-        }
-        return result;
-      }
+      return {
+        result: transformSourceCode(source, effectiveFilename, compilerOptions),
+        cacheable: true
+      };
     }
-    if (cacheEnabled && cacheKey) {
-      writeTransformCache(cacheRoot, cacheInput, result, cacheKey);
-      rememberTransformCacheEntry(cacheKey.key, result);
+    if (parserMode === "rust") {
+      return {
+        result: transformRust(source, effectiveFilename, compilerOptions),
+        cacheable: true
+      };
+    }
+    try {
+      return {
+        result: transformOxc(source, effectiveFilename, compilerOptions),
+        cacheable: true
+      };
+    } catch (error) {
+      return {
+        result: runBabelFallback(source, effectiveFilename, compilerOptions, error),
+        cacheable: false
+      };
+    }
+  }
+  function runBabelFallback(source, effectiveFilename, compilerOptions, error) {
+    const result = transformSourceCode(source, effectiveFilename, compilerOptions);
+    const reason = error instanceof Error ? error.message : String(error);
+    result.diagnostics.push(
+      `[csszyx] oxc parser fell back to Babel for ${effectiveFilename}: ${reason}`
+    );
+    if (!_babelFallbackFiles.has(effectiveFilename)) {
+      _babelFallbackFiles.add(effectiveFilename);
+      console.warn(
+        `[csszyx] oxc parser fell back to Babel for ${effectiveFilename}: ${reason} (${_babelFallbackFiles.size} file(s) so far). Output is still correct; this usually means the file uses a syntax the oxc lane does not yet handle.`
+      );
     }
     return result;
   }
@@ -2953,11 +3360,19 @@ function createCsszyxPlugins(options = {}) {
     const compilerOptions = createCompilerOptions(prescanAstBudget);
     const cacheRoot = resolveTransformCacheDir(state.rootDir, options.build?.cacheDir);
     const results = /* @__PURE__ */ new Map();
-    const misses = [];
-    if (cacheEnabled) {
-      evictTransformCacheOnce();
-    }
+    if (cacheEnabled) evictTransformCacheOnce();
     ensureRustTransformAvailable();
+    const misses = collectRustPrescanMisses(files, compilerOptions, cacheRoot, results);
+    if (misses.length === 0) return orderPrescanResults(files, results);
+    try {
+      runRustPrescanBatch(misses, compilerOptions, cacheRoot, results);
+    } catch {
+      runRustPrescanFallback(misses, results);
+    }
+    return orderPrescanResults(files, results);
+  }
+  function collectRustPrescanMisses(files, compilerOptions, cacheRoot, results) {
+    const misses = [];
     for (const file of files) {
       const effectiveFilename = normalizeSourceFilename(file.filePath);
       const cacheInput = createConfiguredTransformCacheInput(
@@ -2966,79 +3381,54 @@ function createCsszyxPlugins(options = {}) {
         compilerOptions
       );
       const cacheKey = cacheEnabled ? createTransformCacheKey(cacheInput) : null;
-      if (cacheEnabled && cacheKey) {
-        const memoryCached = transformMemoryCache.get(cacheKey.key);
-        if (memoryCached) {
-          transformMemoryCache.delete(cacheKey.key);
-          transformMemoryCache.set(cacheKey.key, memoryCached);
-          results.set(file.filePath, memoryCached);
-          continue;
-        }
-        const cached = 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,
+      const cached = cacheKey ? findConfiguredTransformCacheEntry(
+        cacheRoot,
         cacheInput,
-        cacheKey
-      });
+        cacheKey,
+        effectiveFilename,
+        prescanAstBudget
+      ) : null;
+      if (cached) results.set(file.filePath, cached);
+      else misses.push({ ...file, effectiveFilename, 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);
+    return misses;
+  }
+  function runRustPrescanBatch(misses, compilerOptions, cacheRoot, results) {
+    const batchResults = 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;
+      cacheRustPrescanResult(miss, result, cacheRoot);
+      results.set(miss.filePath, result);
     }
-    try {
-      const batchResults = 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) {
-          writeTransformCache(cacheRoot, miss.cacheInput, result, miss.cacheKey);
-          rememberTransformCacheEntry(miss.cacheKey.key, result);
-        }
+  }
+  function cacheRustPrescanResult(miss, result, cacheRoot) {
+    if (!cacheEnabled || !miss.cacheKey) return;
+    writeTransformCache(cacheRoot, miss.cacheInput, result, miss.cacheKey);
+    rememberTransformCacheEntry(miss.cacheKey.key, result);
+  }
+  function runRustPrescanFallback(misses, results) {
+    for (const miss of misses) {
+      try {
+        const result = transformConfiguredSource(
+          miss.content,
+          miss.effectiveFilename,
+          prescanAstBudget
+        );
         results.set(miss.filePath, result);
-      }
-    } catch {
-      for (const miss of misses) {
-        try {
-          results.set(
-            miss.filePath,
-            transformConfiguredSource(
-              miss.content,
-              miss.effectiveFilename,
-              prescanAstBudget
-            )
-          );
-        } catch {
-        }
+      } catch {
       }
     }
-    return files.map((file) => {
-      const result = results.get(file.filePath);
-      return result ? { filePath: file.filePath, result } : null;
-    }).filter((entry) => entry !== null);
   }
-  function warnPrescanBudgetSkip(filePath) {
-    console.warn(
-      `[csszyx] prescan skipped ${filePath}: the file exceeds the AST node budget, so NONE of its classes reached the safelist and their CSS will not be generated. Raise \`build.astBudgetLimit\` in the csszyx plugin options, or split the file.`
-    );
+  function orderPrescanResults(files, results) {
+    return files.flatMap((file) => {
+      const result = results.get(file.filePath);
+      return result ? [{ filePath: file.filePath, result }] : [];
+    });
   }
   function transformPrescanSourcesIndividually(files) {
     const results = [];
@@ -3105,11 +3495,12 @@ function createCsszyxPlugins(options = {}) {
       return;
     }
     const safelistPath = path.join(state.rootDir, SAFELIST_FILENAME);
-    const classList = escapeHtmlAttribute(Array.from(classes).join(" "));
+    const classNames = Array.from(classes);
+    const classList = escapeHtmlAttribute(classNames.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>
-`;
+` + renderTailwindScannerCandidates(classNames);
     try {
       let existing = "";
       try {
@@ -3139,12 +3530,56 @@ function createCsszyxPlugins(options = {}) {
       state.skippedSzFiles.add(filePath);
     }
   }
+  function processPrescanTransform(filePath, content, result, discoveredClasses, rawDiscoveredClasses) {
+    const budgetExceeded = result.diagnostics.some(
+      (diagnostic) => diagnostic.includes("AST budget exceeded")
+    );
+    if (cacheEnabled && !budgetExceeded && content !== void 0) {
+      prescanResultHandoff.set(normalizeSourceFilename(filePath), {
+        inputSha256: createHash("sha256").update(content).digest("hex"),
+        result
+      });
+    }
+    if (budgetExceeded) {
+      warnPrescanBudgetSkip(filePath);
+      return;
+    }
+    const parseFailed = result.diagnostics.some(
+      (diagnostic) => diagnostic.includes("[csszyx] parse error in ")
+    );
+    if (result.classes.size === 0 && result.rawClassNames.size === 0 && parseFailed) {
+      console.warn(
+        `[csszyx] prescan skipped ${filePath}: the file failed to parse, so none of its classes reached the safelist. Fix the syntax error (or check the file extension matches its contents).`
+      );
+      return;
+    }
+    if (!result.transformed && result.classes.size === 0) {
+      return;
+    }
+    collectPrescanResult(result, filePath, discoveredClasses, rawDiscoveredClasses);
+  }
   function prescanAndWriteClasses() {
     refreshCompileSourceDirs();
     const prescanStarted = performance.now();
     const discoveredClasses = /* @__PURE__ */ new Set();
     const rawDiscoveredClasses = /* @__PURE__ */ new Set();
     const prescanSources = [];
+    function collectPrescanSource(filePath) {
+      if (!shouldProcessSource(filePath)) {
+        recordPackagesSkipIfSz(filePath);
+        return;
+      }
+      let content;
+      try {
+        content = fs.readFileSync(filePath, "utf-8");
+      } catch {
+        return;
+      }
+      recordAuthoredClasses(content);
+      if (fileMayContainSafelistableSz(content)) {
+        prescanSources.push({ filePath, content });
+      }
+    }
     function scanDir(dir) {
       let entries;
       try {
@@ -3157,22 +3592,10 @@ function createCsszyxPlugins(options = {}) {
           if (!IGNORE_DIRS.has(entry.name) && !entry.name.startsWith(".")) {
             scanDir(path.join(dir, entry.name));
           }
-        } else if (SOURCE_EXTENSIONS.has(path.extname(entry.name))) {
-          const filePath = path.join(dir, entry.name);
-          if (!shouldProcessSource(filePath)) {
-            recordPackagesSkipIfSz(filePath);
-            continue;
-          }
-          let content;
-          try {
-            content = fs.readFileSync(filePath, "utf-8");
-          } catch {
-            continue;
-          }
-          if (!fileMayContainSafelistableSz(content)) {
-            continue;
-          }
-          prescanSources.push({ filePath, content });
+          continue;
+        }
+        if (SOURCE_EXTENSIONS.has(path.extname(entry.name))) {
+          collectPrescanSource(path.join(dir, entry.name));
         }
       }
     }
@@ -3188,29 +3611,13 @@ function createCsszyxPlugins(options = {}) {
       prescanSources.map((file) => [file.filePath, file.content])
     );
     for (const { filePath, result } of transformPrescanSources(prescanSources)) {
-      if (cacheEnabled && !result.diagnostics.some((d) => d.includes("AST budget exceeded"))) {
-        const content = prescanContentByPath.get(filePath);
-        if (content !== void 0) {
-          prescanResultHandoff.set(normalizeSourceFilename(filePath), {
-            inputSha256: createHash("sha256").update(content).digest("hex"),
-            result
-          });
-        }
-      }
-      if (result.diagnostics.some((d) => d.includes("AST budget exceeded"))) {
-        warnPrescanBudgetSkip(filePath);
-        continue;
-      }
-      if (result.classes.size === 0 && result.rawClassNames.size === 0 && result.diagnostics.some((d) => d.includes("[csszyx] parse error in "))) {
-        console.warn(
-          `[csszyx] prescan skipped ${filePath}: the file failed to parse, so none of its classes reached the safelist. Fix the syntax error (or check the file extension matches its contents).`
-        );
-        continue;
-      }
-      if (!result.transformed && result.classes.size === 0) {
-        continue;
-      }
-      collectPrescanResult(result, filePath, discoveredClasses, rawDiscoveredClasses);
+      processPrescanTransform(
+        filePath,
+        prescanContentByPath.get(filePath),
+        result,
+        discoveredClasses,
+        rawDiscoveredClasses
+      );
     }
     for (const cls of discoveredClasses) {
       addSafelistClass(cls);
@@ -3271,7 +3678,7 @@ function createCsszyxPlugins(options = {}) {
     for (const kv of objStr.matchAll(numKv)) {
       try {
         collectTransformClasses(
-          transform({ [kv[1]]: parseFloat(kv[2]) }),
+          transform({ [kv[1]]: Number.parseFloat(kv[2]) }),
           discoveredClasses
         );
       } catch {
@@ -3295,51 +3702,51 @@ function createCsszyxPlugins(options = {}) {
       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) {
-          addSafelistClass(cls);
-        }
-      }
+  function addSafelistClasses(value) {
+    for (const className of value.split(/\s+/).filter(Boolean)) {
+      addSafelistClass(className);
     }
-    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++;
+  }
+  function collectQuotedAttributeClasses(code) {
+    const patterns = [
+      /(?:class(?:Name)?|sz)[:=]\s*"([^"]*)"/g,
+      /(?:class(?:Name)?|sz)[:=]\s*'([^']*)'/g
+    ];
+    for (const pattern of patterns) {
+      for (const match of code.matchAll(pattern)) {
+        addSafelistClasses(match[1] ?? "");
       }
-      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) {
-          addSafelistClass(cls);
-        }
+    }
+  }
+  function collectExpressionClasses(code) {
+    for (const match of code.matchAll(/className=\{/g)) {
+      const bodyStart = (match.index ?? 0) + match[0].length;
+      const expression = code.slice(bodyStart, findJsxExpressionEnd(code, bodyStart));
+      for (const stringMatch of expression.matchAll(/"([^"]+)"|'([^']+)'/g)) {
+        addSafelistClasses(stringMatch[1] ?? stringMatch[2] ?? "");
       }
     }
   }
+  function extractClasses(code) {
+    collectQuotedAttributeClasses(code);
+    collectExpressionClasses(code);
+  }
+  function recordAuthoredClasses(code) {
+    for (const className of collectAuthoredClassNames(code)) {
+      addSafelistClass(className);
+      state.authoredClasses.add(className);
+    }
+  }
   function finalizeMangleMap() {
-    const sortedClasses = Array.from(state.ownedClasses);
     const newMap = {};
     let tokenIndex = 0;
-    for (let i = 0; i < sortedClasses.length; i++) {
+    for (const className of mangleEligibleClasses(state.ownedClasses, state.authoredClasses)) {
       let token = encode(tokenIndex);
-      while (mangleReserved.has(token)) {
+      while (mangleReserved.has(token) || state.authoredClasses.has(token)) {
         tokenIndex++;
         token = encode(tokenIndex);
       }
-      newMap[sortedClasses[i]] = token;
+      newMap[className] = token;
       tokenIndex++;
     }
     state.mangleMap = newMap;
@@ -3352,6 +3759,24 @@ function createCsszyxPlugins(options = {}) {
   function mangleCodeClasses(code) {
     return mangleCodeClassesSync(code, state.mangleMap);
   }
+  function mangleHtmlClassList(classes) {
+    const output = [];
+    for (const className of classes.split(/\s+/)) {
+      if (className) output.push(state.mangleMap[className] || className);
+    }
+    return output.join(" ");
+  }
+  function replaceDoubleQuotedHtmlClass(match, classes) {
+    const output = mangleHtmlClassList(classes);
+    return output !== classes ? `class="${output}"` : match;
+  }
+  function replaceSingleQuotedHtmlClass(match, classes) {
+    const output = mangleHtmlClassList(classes);
+    return output !== classes ? `class='${output}'` : match;
+  }
+  function mangleHtmlClasses(source) {
+    return source.replace(/\bclass="([^"]*)"/g, replaceDoubleQuotedHtmlClass).replace(/\bclass='([^']*)'/g, replaceSingleQuotedHtmlClass);
+  }
   function replacePlaceholders(code) {
     let result = code;
     if (result.includes(CHECKSUM_PLACEHOLDER)) {
@@ -3369,6 +3794,147 @@ function createCsszyxPlugins(options = {}) {
     }
     return result;
   }
+  function unchangedPreTransform(code) {
+    return {
+      code,
+      transformed: false,
+      usesRuntime: false,
+      usesMerge: false,
+      usesSzcn: false,
+      usesSzPart: false,
+      usesColorVar: false,
+      usesSpacingVar: false,
+      usesUnitVar: false
+    };
+  }
+  function transformTailwindCssEntry(code, id) {
+    state.sawAnyCss = true;
+    if (!cssImportsTailwind(code)) return null;
+    state.sawTailwindEntry = true;
+    if (cssHasContentScope(code)) state.tailwindEntryScoped = true;
+    if (!hasInjectableTailwindCandidate(state.classes)) return null;
+    const relPath = computeSafelistRelPath(state.rootDir, SAFELIST_FILENAME, id);
+    const transformed = appendTailwindSourceDirective(code, relPath);
+    return transformed === null ? null : { code: transformed, map: null };
+  }
+  function reportTransformDiagnostics(result, id, warn) {
+    for (const message of result.diagnostics) {
+      if (message.includes("unresolvable sz spread")) {
+        state.spreadWarnings.add(`${id}
+  ${message}`);
+      } else if (message.includes("AST budget exceeded")) {
+        console.warn(`[csszyx] ${id}
+  ${message}`);
+      }
+    }
+    if (quiet || result.diagnostics.length === 0 || process.env.NODE_ENV === "production") {
+      return;
+    }
+    for (const message of result.diagnostics) {
+      if (message.includes("unresolvable sz spread") || message.includes("AST budget exceeded")) {
+        continue;
+      }
+      warn(`[csszyx] ${id}
+  ${message}`);
+    }
+  }
+  function compilerPreTransformOutput(result) {
+    return {
+      code: result.code,
+      transformed: result.transformed,
+      usesRuntime: result.usesRuntime,
+      usesMerge: result.usesMerge,
+      usesSzcn: result.usesSzcn,
+      usesSzPart: result.usesSzPart,
+      usesColorVar: result.usesColorVar,
+      usesSpacingVar: result.usesSpacingVar,
+      usesUnitVar: result.usesUnitVar,
+      szClasses: result.classes
+    };
+  }
+  function transformSzSource(code, id, warn) {
+    if (id.endsWith(".vue")) {
+      const result2 = preprocess(code, options);
+      return { ...unchangedPreTransform(result2.code), transformed: result2.transformed };
+    }
+    if (id.endsWith(".svelte")) {
+      const result2 = preprocess$1(code, options);
+      return result2 ? { ...unchangedPreTransform(result2.code), transformed: true } : unchangedPreTransform(code);
+    }
+    const transformStarted = performance.now();
+    const result = transformConfiguredSource(code, id);
+    traceBenchTiming("transform-hook", id, performance.now() - transformStarted);
+    recordFileVarMangleEntries(state, id, cssVariableEntries(result));
+    recordFileCSSVariableMetrics(state, id, result.code);
+    reportTransformDiagnostics(result, id, warn);
+    for (const [token, data] of result.recoveryTokens) state.recoveryTokens.set(token, data);
+    return compilerPreTransformOutput(result);
+  }
+  function injectLayoutHydration(code, id) {
+    if (!code.includes("<html") || !/(?:layout|Root|Document|app)\.tsx?$/i.test(id)) {
+      return null;
+    }
+    let transformedCode = code;
+    const attrName = options.production?.minify ? "data-sz-cs" : "data-sz-checksum";
+    const htmlTag = findOpeningTag(transformedCode, "html");
+    if (htmlTag) {
+      transformedCode = `${transformedCode.slice(0, htmlTag.close)} ${attrName}="${CHECKSUM_PLACEHOLDER}"${transformedCode.slice(htmlTag.close)}`;
+    }
+    const debugScript = `<script dangerouslySetInnerHTML={{__html: \`(function(){var m=${MANGLE_MAP_PLACEHOLDER};var vm=${VAR_MANGLE_MAP_PLACEHOLDER};var gp=decodeURIComponent(${escapeJsonForInlineScript(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})}}})()\`}} />`;
+    const bodyTag = findOpeningTag(transformedCode, "body");
+    if (bodyTag) {
+      transformedCode = `${transformedCode.slice(0, bodyTag.close + 1)}${debugScript}${transformedCode.slice(bodyTag.close + 1)}`;
+    }
+    return transformedCode;
+  }
+  function requiredRuntimeHelpers(output) {
+    const helpers = [];
+    if (output.usesRuntime) helpers.push("_sz");
+    if (output.usesMerge) helpers.push("_szMerge");
+    if (output.usesSzcn) helpers.push("_szcn");
+    if (output.usesSzPart) helpers.push("_szPart");
+    if (output.usesColorVar) helpers.push("__szColorVar");
+    if (output.usesSpacingVar) helpers.push("__szSpacingVar");
+    if (output.usesUnitVar) helpers.push("__szUnitVar");
+    return helpers;
+  }
+  function injectRuntimeHelpers(code, output) {
+    const imports = requiredRuntimeHelpers(output);
+    const hasRuntimeImport = imports.length > 0 && code.includes("@csszyx/runtime");
+    const needed = hasRuntimeImport ? imports.filter((name) => !importsRuntimeHelper(code, name)) : imports;
+    if (needed.length === 0) return null;
+    const existingImport = findRuntimeImportClause(code);
+    if (existingImport) {
+      return code.replace(
+        existingImport.statement,
+        `${existingImport.prefixWithBody}, ${needed.join(", ")} } from '@csszyx/runtime'`
+      );
+    }
+    const importStatement = `import { ${needed.join(", ")} } from '@csszyx/runtime';
+`;
+    return insertRuntimeImport(code, importStatement);
+  }
+  function injectThemeGroups(code, transformedCode, id, usesSzcn) {
+    if (!usesSzcn && !/\bszcn\s*\(/.test(code) || transformedCode.includes(THEME_GROUPS_VIRTUAL_ID) || !shouldProcessSource(id)) {
+      return null;
+    }
+    return `import '${THEME_GROUPS_VIRTUAL_ID}';
+${transformedCode}`;
+  }
+  function collectPreTransformClasses(output) {
+    if (!output.transformed && !output.code.includes("class=") && !output.code.includes("className=")) {
+      return null;
+    }
+    if (output.szClasses) {
+      for (const className of output.szClasses) {
+        addSafelistClass(className);
+        state.ownedClasses.add(className);
+      }
+    } else {
+      extractClasses(output.code);
+    }
+    return { code: output.code, map: null };
+  }
   const prePlugin = createUnplugin(
     (_pluginOptions) => ({
       name: "csszyx:pre",
@@ -3455,166 +4021,41 @@ function createCsszyxPlugins(options = {}) {
         }
         if (shouldProcessSource(id)) {
           trackGlobalVarSourceFile(id, code);
+          recordAuthoredClasses(code);
         }
         if (matchesScriptExtension(id, SCRIPT_ID_EXTENSIONS)) {
           assertNoRSCBoundaryViolation(code, id);
         }
         if (matchesScriptExtension(id, [".css"])) {
-          state.sawAnyCss = true;
-          if (cssImportsTailwind(code)) {
-            state.sawTailwindEntry = true;
-            if (cssHasContentScope(code)) {
-              state.tailwindEntryScoped = true;
-            }
-            if (hasInjectableTailwindCandidate(state.classes)) {
-              const relPath = computeSafelistRelPath(
-                state.rootDir,
-                SAFELIST_FILENAME,
-                id
-              );
-              const transformed2 = appendTailwindSourceDirective(code, relPath);
-              if (transformed2 !== null) {
-                return { code: transformed2, map: null };
-              }
-            }
-          }
-          return null;
+          return transformTailwindCssEntry(code, id);
         }
-        let transformedCode = code;
-        let usesRuntime = false;
-        let usesMerge = false;
-        let usesSzcn = false;
-        let usesSzPart = false;
-        let usesColorVar = false;
-        let transformed = false;
-        let szClasses;
         const hasSzProp = code.includes("sz=") || code.includes("szs=") || /\bsz\s*:\s*["'{]/.test(code) || code.includes('sz: "');
-        if (hasSzProp) {
-          if (id.endsWith(".vue")) {
-            const result = preprocess(code, options);
-            if (result.transformed) {
-              transformedCode = result.code;
-              transformed = true;
-            }
-          } else if (id.endsWith(".svelte")) {
-            const result = preprocess$1(code, options);
-            if (result) {
-              transformedCode = result.code;
-              transformed = true;
-            }
-          } else {
-            const transformStarted = performance.now();
-            const result = transformConfiguredSource(code, id);
-            traceBenchTiming(
-              "transform-hook",
-              id,
-              performance.now() - transformStarted
-            );
-            transformedCode = result.code;
-            usesRuntime = result.usesRuntime;
-            usesMerge = result.usesMerge;
-            usesSzcn = result.usesSzcn;
-            usesSzPart = result.usesSzPart;
-            usesColorVar = result.usesColorVar;
-            transformed = result.transformed;
-            szClasses = result.classes;
-            recordFileVarMangleEntries(state, id, cssVariableEntries(result));
-            recordFileCSSVariableMetrics(state, id, result.code);
-            for (const msg of result.diagnostics) {
-              if (msg.includes("unresolvable sz spread")) {
-                state.spreadWarnings.add(`${id}
-  ${msg}`);
-              } else if (msg.includes("AST budget exceeded")) {
-                console.warn(`[csszyx] ${id}
-  ${msg}`);
-              }
-            }
-            if (!quiet && result.diagnostics.length > 0 && process.env.NODE_ENV !== "production") {
-              for (const msg of result.diagnostics) {
-                if (msg.includes("unresolvable sz spread") || msg.includes("AST budget exceeded")) {
-                  continue;
-                }
-                this.warn(`[csszyx] ${id}
-  ${msg}`);
-              }
-            }
-            for (const [token, data] of result.recoveryTokens) {
-              state.recoveryTokens.set(token, data);
-            }
-          }
-        } else if (shouldProcessSource(id)) {
+        const output = hasSzProp ? transformSzSource(code, id, (message) => this.warn(message)) : unchangedPreTransform(code);
+        if (!hasSzProp && 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";
-          const htmlTag = findOpeningTag(transformedCode, "html");
-          if (htmlTag) {
-            transformedCode = `${transformedCode.slice(0, htmlTag.close)} ${attrName}="${CHECKSUM_PLACEHOLDER}"${transformedCode.slice(htmlTag.close)}`;
-          }
-          const debugScript = `<script dangerouslySetInnerHTML={{__html: \`(function(){var m=${MANGLE_MAP_PLACEHOLDER};var vm=${VAR_MANGLE_MAP_PLACEHOLDER};var gp=decodeURIComponent(${escapeJsonForInlineScript(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})}}})()\`}} />`;
-          const bodyTag = findOpeningTag(transformedCode, "body");
-          if (bodyTag) {
-            transformedCode = `${transformedCode.slice(0, bodyTag.close + 1)}${debugScript}${transformedCode.slice(bodyTag.close + 1)}`;
-          }
-          transformed = true;
+        const layoutCode = injectLayoutHydration(output.code, id);
+        if (layoutCode !== null) {
+          output.code = layoutCode;
+          output.transformed = true;
         }
-        {
-          const imports = [];
-          if (usesRuntime) {
-            imports.push("_sz");
-          }
-          if (usesMerge) {
-            imports.push("_szMerge");
-          }
-          if (usesSzcn) {
-            imports.push("_szcn");
-          }
-          if (usesSzPart) {
-            imports.push("_szPart");
-          }
-          if (usesColorVar) {
-            imports.push("__szColorVar");
-          }
-          const hasRuntimeImport = imports.length > 0 && transformedCode.includes("@csszyx/runtime");
-          const needed = hasRuntimeImport ? imports.filter((name) => !importsRuntimeHelper(transformedCode, name)) : imports;
-          if (needed.length > 0) {
-            const existingImport = findRuntimeImportClause(transformedCode);
-            if (existingImport) {
-              transformedCode = transformedCode.replace(
-                existingImport.statement,
-                `${existingImport.prefixWithBody}, ${needed.join(", ")} } from '@csszyx/runtime'`
-              );
-            } else {
-              const importStmt = `import { ${needed.join(", ")} } from '@csszyx/runtime';
-`;
-              transformedCode = insertRuntimeImport(transformedCode, importStmt);
-            }
-            transformed = true;
-          }
+        const runtimeCode = injectRuntimeHelpers(output.code, output);
+        if (runtimeCode !== null) {
+          output.code = runtimeCode;
+          output.transformed = true;
         }
-        if ((usesSzcn || /\bszcn\s*\(/.test(code)) && !transformedCode.includes(THEME_GROUPS_VIRTUAL_ID) && shouldProcessSource(id)) {
-          transformedCode = `import '${THEME_GROUPS_VIRTUAL_ID}';
-${transformedCode}`;
-          transformed = true;
+        const themedCode = injectThemeGroups(code, output.code, id, output.usesSzcn);
+        if (themedCode !== null) {
+          output.code = themedCode;
+          output.transformed = true;
         }
         if (matchesScriptExtension(id, SCRIPT_ID_EXTENSIONS)) {
-          assertNoRSCBoundaryViolation(transformedCode, id);
-          const record = createRSCModuleRecord(transformedCode, id);
+          assertNoRSCBoundaryViolation(output.code, id);
+          const record = createRSCModuleRecord(output.code, id);
           state.rscModules.set(record.id, record);
         }
-        if (transformed || transformedCode.includes("class=") || transformedCode.includes("className=")) {
-          if (szClasses !== void 0) {
-            for (const cls of szClasses) {
-              addSafelistClass(cls);
-              state.ownedClasses.add(cls);
-            }
-          } else {
-            extractClasses(transformedCode);
-          }
-          return { code: transformedCode, map: null };
-        }
-        return null;
+        return collectPreTransformClasses(output);
       },
       /** Finalizes the mangle map after all source modules have been processed. */
       buildEnd() {
@@ -3823,6 +4264,166 @@ ${transformedCode}`;
       }
     })
   );
+  function createBundleManifest(includeMangleMap) {
+    const manifest = {
+      version: "0.4.0",
+      buildId: state.checksum,
+      classes: Object.keys(state.mangleMap)
+    };
+    if (includeMangleMap && Object.keys(state.mangleMap).length > 0) {
+      manifest.mangleMap = state.mangleMap;
+    }
+    if (Object.keys(state.varMangleMap).length > 0) {
+      manifest.varMangleMap = state.varMangleMap;
+    }
+    const globalVarAliases = extractGlobalVarAliasesForManifest(
+      state.varMangleMap,
+      globalVarAliasPrefix,
+      state.globalVarValidationResult
+    );
+    if (Object.keys(globalVarAliases).length > 0) {
+      manifest.globalVarAliases = globalVarAliases;
+    }
+    if (hasCSSVariableMetrics(state.cssVarMetrics)) {
+      manifest.cssVarMetrics = state.cssVarMetrics;
+    }
+    return manifest;
+  }
+  function isCssSyntaxError(error) {
+    return !!error && typeof error === "object" && "name" in error && error.name === "CssSyntaxError";
+  }
+  function rewriteOutputCss(source, file, shouldMangle, mangledSources, externalClasses) {
+    let css = rewriteCssWithValidatedGlobalVarPlan(
+      source,
+      file,
+      state.globalVarValidationResult
+    );
+    if (!shouldMangle) return css;
+    try {
+      const result = mangleCSSSync(css, state.mangleMap, {
+        debug: options.development?.debug,
+        from: file
+      });
+      for (const className of result.mangledClasses) mangledSources.add(className);
+      for (const className of result.unmangledClasses) externalClasses.add(className);
+      if (result.transformedCount > 0) css = result.css;
+      return css;
+    } catch (error) {
+      if (isCssSyntaxError(error)) return css;
+      throw error;
+    }
+  }
+  function reportOutputMangleHazards(shouldMangle, mangledSources, externalClasses) {
+    if (!shouldMangle) return;
+    const message = mangleHybridHazardMessage(
+      collectMangleHybridHazards(state.mangleMap, mangledSources, externalClasses)
+    );
+    if (message) console.warn(message);
+  }
+  function rewriteWebpackCodeAsset(file, source, shouldMangle, compilation, compiler) {
+    if (shouldMangle && file.endsWith(".html")) {
+      const mangledHtml = mangleHtmlClasses(source);
+      if (mangledHtml !== source) {
+        compilation.updateAsset(file, new compiler.webpack.sources.RawSource(mangledHtml));
+      }
+      return;
+    }
+    if (!file.endsWith(".js")) return;
+    const rewritten = shouldMangle ? replacePlaceholders(mangleCodeClasses(source)) : replacePlaceholders(source);
+    if (rewritten !== source) {
+      compilation.updateAsset(file, new compiler.webpack.sources.RawSource(rewritten));
+    }
+  }
+  function processWebpackAssets(assets, compilation, compiler) {
+    finalizeMangleMap();
+    state.globalVarValidationResult = validateGlobalVarBundleInputs(
+      collectWebpackGlobalVarCssAssets(assets)
+    );
+    const shouldMangle = manglingEnabled && compiler.options.mode !== "development" && Object.keys(state.mangleMap).length > 0;
+    const manifest = createBundleManifest(shouldMangle);
+    compilation.emitAsset(
+      "csszyx-manifest.json",
+      new compiler.webpack.sources.RawSource(JSON.stringify(manifest))
+    );
+    if (shouldEmitGlobalVarMapAsset(globalVarMangleConfig)) {
+      const globalVarMap = createGlobalVarMapAssetSource(
+        state.varMangleMap,
+        globalVarAliasPrefix,
+        state.globalVarValidationResult
+      );
+      if (globalVarMap) {
+        compilation.emitAsset(
+          ".csszyx/global-var-map.json",
+          new compiler.webpack.sources.RawSource(globalVarMap)
+        );
+      }
+    }
+    const mangledSources = /* @__PURE__ */ new Set();
+    const externalClasses = /* @__PURE__ */ new Set();
+    for (const file in assets) {
+      const source = assets[file].source().toString();
+      if (file.endsWith(".css")) {
+        const css = rewriteOutputCss(
+          source,
+          file,
+          shouldMangle,
+          mangledSources,
+          externalClasses
+        );
+        if (css !== source) {
+          compilation.updateAsset(file, new compiler.webpack.sources.RawSource(css));
+        }
+      } else {
+        rewriteWebpackCodeAsset(file, source, shouldMangle, compilation, compiler);
+      }
+    }
+    reportOutputMangleHazards(shouldMangle, mangledSources, externalClasses);
+  }
+  function rewriteViteBundleEntry(chunk, file, shouldMangle, mangledSources, externalClasses) {
+    if (chunk.type === "asset" && chunk.fileName.endsWith(".css") && chunk.source !== void 0) {
+      const originalCss = chunk.source.toString();
+      const css = rewriteOutputCss(
+        originalCss,
+        file,
+        shouldMangle,
+        mangledSources,
+        externalClasses
+      );
+      if (css !== originalCss) chunk.source = css;
+      return;
+    }
+    if (chunk.type !== "chunk" || chunk.code === void 0) return;
+    const rewritten = shouldMangle ? replacePlaceholders(mangleCodeClasses(chunk.code)) : replacePlaceholders(chunk.code);
+    if (rewritten !== chunk.code) chunk.code = rewritten;
+  }
+  function processRollupBundle(bundle, emitAsset) {
+    finalizeMangleMap();
+    state.globalVarValidationResult = validateGlobalVarBundleInputs(
+      collectRollupGlobalVarCssAssets(bundle)
+    );
+    const shouldMangle = manglingEnabled && Object.keys(state.mangleMap).length > 0;
+    emitAsset("csszyx-manifest.json", JSON.stringify(createBundleManifest(shouldMangle)));
+    if (shouldEmitGlobalVarMapAsset(globalVarMangleConfig)) {
+      const globalVarMap = createGlobalVarMapAssetSource(
+        state.varMangleMap,
+        globalVarAliasPrefix,
+        state.globalVarValidationResult
+      );
+      if (globalVarMap) emitAsset(".csszyx/global-var-map.json", globalVarMap);
+    }
+    const mangledSources = /* @__PURE__ */ new Set();
+    const externalClasses = /* @__PURE__ */ new Set();
+    for (const file in bundle) {
+      rewriteViteBundleEntry(
+        bundle[file],
+        file,
+        shouldMangle,
+        mangledSources,
+        externalClasses
+      );
+    }
+    reportOutputMangleHazards(shouldMangle, mangledSources, externalClasses);
+  }
   const postPlugin = createUnplugin(() => ({
     name: "csszyx:post",
     enforce: "post",
@@ -3833,278 +4434,20 @@ ${transformedCode}`;
      * @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)
-                );
-              }
-            }
-            const mangledSources = /* @__PURE__ */ new Set();
-            const externalClasses = /* @__PURE__ */ new Set();
-            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 = mangleCSSSync(css, state.mangleMap, {
-                      debug: options.development?.debug,
-                      from: file
-                    });
-                    for (const c of result.mangledClasses) {
-                      mangledSources.add(c);
-                    }
-                    for (const c of result.unmangledClasses) {
-                      externalClasses.add(c);
-                    }
-                    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)
-                  );
-                }
-              }
-            }
-            if (manglingEnabled && !isWebpackDevMode && Object.keys(state.mangleMap).length > 0) {
-              const hazardMessage = mangleHybridHazardMessage(
-                collectMangleHybridHazards(
-                  state.mangleMap,
-                  mangledSources,
-                  externalClasses
-                )
-              );
-              if (hazardMessage) {
-                console.warn(hazardMessage);
-              }
-            }
-          }
-        );
-      });
+      registerWebpackAssetProcessor(compiler, processWebpackAssets);
     },
-    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
-            });
-          }
-        }
-        const mangledSources = /* @__PURE__ */ new Set();
-        const externalClasses = /* @__PURE__ */ new Set();
-        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 = mangleCSSSync(css, state.mangleMap, {
-                  debug: options.development?.debug,
-                  from: file
-                });
-                for (const c of result.mangledClasses) {
-                  mangledSources.add(c);
-                }
-                for (const c of result.unmangledClasses) {
-                  externalClasses.add(c);
-                }
-                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;
-            }
-          }
-        }
-        if (manglingEnabled && Object.keys(state.mangleMap).length > 0) {
-          const hazardMessage = mangleHybridHazardMessage(
-            collectMangleHybridHazards(
-              state.mangleMap,
-              mangledSources,
-              externalClasses
-            )
-          );
-          if (hazardMessage) {
-            console.warn(hazardMessage);
-          }
-        }
-      }
+    /**
+     * Rollup-compatible hook used by both pure Rollup and Vite adapters.
+     *
+     * @param this Rollup-compatible output hook context.
+     * @param this.emitFile Output asset emitter.
+     * @param _options Output options (unused).
+     * @param bundle Complete Rollup output bundle.
+     */
+    generateBundle(_options, bundle) {
+      processRollupBundle(bundle, (fileName, source) => {
+        this.emitFile({ type: "asset", fileName, source });
+      });
     }
   }));
   return { prePlugin, postPlugin };
@@ -4136,7 +4479,16 @@ const rollupPlugin = (options = {}) => {
   ];
 };
 const esbuildPlugin = (options = {}) => {
-  const { prePlugin, postPlugin } = createCsszyxPlugins(options);
+  if (options.production?.mangle === true) {
+    console.warn(
+      "[csszyx] production.mangle is not supported by the esbuild adapter; class mangling is disabled so emitted JS and CSS keep matching names."
+    );
+  }
+  const safeOptions = {
+    ...options,
+    production: { ...options.production, mangle: false }
+  };
+  const { prePlugin, postPlugin } = createCsszyxPlugins(safeOptions);
   return {
     name: "csszyx",
     /**
@@ -4145,10 +4497,10 @@ const esbuildPlugin = (options = {}) => {
      */
     setup(build) {
       const b = build;
-      prePlugin.esbuild(options).setup(b);
-      postPlugin.esbuild(options).setup(b);
+      prePlugin.esbuild(safeOptions).setup(b);
+      postPlugin.esbuild(safeOptions).setup(b);
     }
   };
 };
 
-export { webpackPlugin as $, isPackagesSkippedSource as A, isRSCServerModule as B, isTailwindReservedGlobalVar as C, mangleCodeClassesSync as D, mangleHybridHazardMessage as E, mergeThemes as F, missingTailwindEntryMessage as G, normalizeGlobalVarAliasesForCache as H, parseThemeBlocks as I, planGlobalVarAliases as J, readGlobalVarScanCache as K, recordGlobalVarSourceFile as L, resolveCompileSourceDirs as M, resolveGlobalVarScanCacheDir as N, resolveNativeCacheIdentity as O, rewriteGlobalVarCssAliases as P, rollupPlugin as Q, scanCustomPropertyNames as R, scanGlobalVarCss as S, shouldEmitWarning as T, shouldTrackGlobalVarSources as U, shouldWarnMissingTailwindEntry as V, shouldWarnUnscopedMonorepo as W, skippedSzFilesMessage as X, unscopedMonorepoMessage as Y, validateGlobalVarAliasInputs as Z, vitePlugin as _, appendTailwindSourceDirective as a, writeGlobalVarScanCache as a0, assertNoRSCBoundaryViolation as b, assertNoRSCGraphViolation as c, collectMangleHybridHazards as d, computeSafelistRelPath as e, createGlobalVarAliasValidationOptions as f, createGlobalVarMapAssetSource as g, createGlobalVarScanCacheKey as h, createRSCModuleRecord as i, cssHasContentScope as j, cssImportsTailwind as k, deleteRSCModuleRecord as l, esbuildPlugin as m, extractGlobalVarAliasesForManifest as n, fileMayContainSafelistableSz as o, findLocalImportSources as p, findRSCBoundaryViolation as q, findRSCGraphViolation as r, hasInjectableTailwindCandidate as s, hasTokens as t, unplugin as u, hasUseClientDirective as v, hasUseServerDirective as w, isCompileSourceOptedIn as x, isHardIgnoredPath as y, isMonorepoPackage as z };
+export { vitePlugin as $, isPackagesSkippedSource as A, isRSCServerModule as B, isTailwindReservedGlobalVar as C, mangleCodeClassesSync as D, mangleEligibleClasses as E, mangleHybridHazardMessage as F, mergeThemes as G, missingTailwindEntryMessage as H, normalizeGlobalVarAliasesForCache as I, parseThemeBlocks as J, planGlobalVarAliases as K, readGlobalVarScanCache as L, recordGlobalVarSourceFile as M, resolveCompileSourceDirs as N, resolveGlobalVarScanCacheDir as O, resolveNativeCacheIdentity as P, rewriteGlobalVarCssAliases as Q, rollupPlugin as R, scanCustomPropertyNames as S, scanGlobalVarCss as T, shouldEmitWarning as U, shouldTrackGlobalVarSources as V, shouldWarnMissingTailwindEntry as W, shouldWarnUnscopedMonorepo as X, skippedSzFilesMessage as Y, unscopedMonorepoMessage as Z, validateGlobalVarAliasInputs as _, appendTailwindSourceDirective as a, webpackPlugin as a0, writeGlobalVarScanCache as a1, assertNoRSCBoundaryViolation as b, assertNoRSCGraphViolation as c, collectMangleHybridHazards as d, computeSafelistRelPath as e, createGlobalVarAliasValidationOptions as f, createGlobalVarMapAssetSource as g, createGlobalVarScanCacheKey as h, createRSCModuleRecord as i, cssHasContentScope as j, cssImportsTailwind as k, deleteRSCModuleRecord as l, esbuildPlugin as m, extractGlobalVarAliasesForManifest as n, fileMayContainSafelistableSz as o, findLocalImportSources as p, findRSCBoundaryViolation as q, findRSCGraphViolation as r, hasInjectableTailwindCandidate as s, hasTokens as t, unplugin as u, hasUseClientDirective as v, hasUseServerDirective as w, isCompileSourceOptedIn as x, isHardIgnoredPath as y, isMonorepoPackage as z };