@csszyx/unplugin 0.11.6 → 0.11.8

package/dist/shared/{unplugin.CP2cz9bA.cjs → unplugin.DtPQz8Kg.cjs}

@@ -14,9 +14,9 @@ const types = require('@csszyx/types');
 const vueAdapter = require('@csszyx/vue-adapter');
 const unplugin$1 = require('unplugin');
 const cssMangler = require('../css-mangler.cjs');
-const htmlEscape = require('./unplugin.BCwRIUs_.cjs');
-const runtimeImportScan = require('./unplugin.Rov-j_Wm.cjs');
-const transformCache = require('./unplugin.D0N9bprz.cjs');
+const runtimeImportScan = require('./unplugin.DmuOKVS4.cjs');
+const transformCache = require('./unplugin.DVCQC5wq.cjs');
+const htmlEscape = require('./unplugin.CcA7jP1r.cjs');
 const postcss = require('postcss');
 const valueParser = require('postcss-value-parser');
 
@@ -116,7 +116,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;
@@ -389,7 +390,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);
@@ -539,8 +540,8 @@ function createRSCModuleRecord(code, id) {
 }
 function deleteRSCModuleRecord(records, id) {
   const normalized = normalizeModuleId(id);
-  const clean = id.split("?")[0]?.replace(/\\/g, "/") ?? id;
-  const resolved = path__namespace.resolve(clean).replace(/\\/g, "/");
+  const clean = transformCache.normalizePathSeparators(id.split("?")[0] ?? id);
+  const resolved = transformCache.normalizePathSeparators(path__namespace.resolve(clean));
   pruneRSCModulePathCaches(/* @__PURE__ */ new Set([normalized, resolved, clean]));
   let deleted = records.delete(normalized);
   if (resolved !== normalized) {
@@ -586,7 +587,7 @@ const APP_ROUTER_ENTRIES = /* @__PURE__ */ new Set([
   "route"
 ]);
 function isNextAppRouterEntry(id) {
-  const clean = id.split("?")[0]?.replace(/\\/g, "/") ?? id;
+  const clean = transformCache.normalizePathSeparators(id.split("?")[0] ?? id);
   if (!clean.includes("/app/") && !clean.startsWith("app/")) return false;
   const basename = clean.split("/").pop() ?? "";
   const dotIdx = basename.indexOf(".");
@@ -635,38 +636,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;
   }
@@ -722,55 +726,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 !== "'") {
@@ -798,7 +797,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;
     }
@@ -943,9 +942,9 @@ function normalizeModuleId(id) {
   }
   let normalized;
   try {
-    normalized = fs__namespace.realpathSync.native(clean).replace(/\\/g, "/");
+    normalized = transformCache.normalizePathSeparators(fs__namespace.realpathSync.native(clean));
   } catch {
-    normalized = path__namespace.resolve(clean).replace(/\\/g, "/");
+    normalized = transformCache.normalizePathSeparators(path__namespace.resolve(clean));
   }
   normalizedModuleIdCache.set(clean, normalized);
   return normalized;
@@ -991,7 +990,7 @@ function resolveLocalModule(importer, source) {
 }
 function pruneRSCModulePathCaches(moduleIds) {
   for (const [key, value] of normalizedModuleIdCache) {
-    const normalizedKey = key.replace(/\\/g, "/");
+    const normalizedKey = transformCache.normalizePathSeparators(key);
     if (moduleIds.has(value) || moduleIds.has(normalizedKey)) {
       normalizedModuleIdCache.delete(key);
     }
@@ -1002,43 +1001,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;
     }
@@ -1048,11 +1048,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) {
@@ -1075,13 +1078,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;
     }
@@ -1092,28 +1089,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;
@@ -1121,6 +1105,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: [],
@@ -1132,6 +1141,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;
@@ -1147,26 +1170,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;
 }
@@ -1175,20 +1185,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;
@@ -1287,6 +1286,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;
@@ -1295,48 +1317,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 transformCache.normalizePathSeparators(id.split(/[?#]/, 1)[0]);
 }
 function normalizeRoot(rootDir) {
-  return path__namespace.resolve(rootDir).replace(/\\/g, "/");
+  return transformCache.normalizePathSeparators(path__namespace.resolve(rootDir));
 }
 function hasGlobMagic(pattern) {
   return GLOB_MAGIC_RE.test(pattern);
@@ -1345,7 +1711,7 @@ function escapeRegExp(ch) {
   return /[|\\{}()[\]^$+?.]/.test(ch) ? `\\${ch}` : ch;
 }
 function globToRegExp(pattern) {
-  const normalized = pattern.replace(/\\/g, "/");
+  const normalized = transformCache.normalizePathSeparators(pattern);
   let out = "^";
   for (let i = 0; i < normalized.length; i++) {
     const ch = normalized[i];
@@ -1368,7 +1734,7 @@ function globToRegExp(pattern) {
 function relativeToRoot(file, rootDir) {
   const root = normalizeRoot(rootDir);
   const normalizedFile = normalizeFileId(file);
-  return path__namespace.posix.relative(root, normalizedFile).replace(/\\/g, "/");
+  return transformCache.normalizePathSeparators(path__namespace.posix.relative(root, normalizedFile));
 }
 function matchesPattern(id, pattern, rootDir) {
   const file = normalizeFileId(id);
@@ -1377,7 +1743,7 @@ function matchesPattern(id, pattern, rootDir) {
     pattern.lastIndex = 0;
     return pattern.test(file) || pattern.test(relative);
   }
-  const normalizedPattern = pattern.replace(/\\/g, "/");
+  const normalizedPattern = transformCache.normalizePathSeparators(pattern);
   if (hasGlobMagic(normalizedPattern)) {
     const re = globToRegExp(normalizedPattern);
     return re.test(file) || re.test(relative);
@@ -1392,27 +1758,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__namespace.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const full = path__namespace.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (!DEFAULT_IGNORED_DIRS.has(entry.name) && !entry.name.startsWith(".")) {
+        collectDirectoryFiles(full, files);
+      }
+    } else {
+      files.add(path__namespace.resolve(full));
+    }
+  }
+}
+function isExpandedPatternMatch(file, patterns, rootDir) {
+  return patterns.some((pattern) => {
+    if (hasGlobMagic(pattern)) {
+      return matchesPattern(file, pattern, rootDir);
+    }
+    const resolved = path__namespace.isAbsolute(pattern) ? pattern : path__namespace.join(rootDir, pattern);
+    return normalizeFileId(path__namespace.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__namespace.readdirSync(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      const full = path__namespace.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        if (!DEFAULT_IGNORED_DIRS.has(entry.name) && !entry.name.startsWith(".")) {
-          walk(full);
-        }
-      } else {
-        files.add(path__namespace.resolve(full));
-      }
-    }
-  };
   let needsWalk = false;
   for (const pattern of list) {
     const resolved = path__namespace.isAbsolute(pattern) ? pattern : path__namespace.join(rootDir, pattern);
@@ -1425,30 +1800,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__namespace.isAbsolute(pattern) ? pattern : path__namespace.join(rootDir, pattern);
-          return normalizeFileId(path__namespace.resolve(resolved)) === normalizeFileId(file);
-        });
-        if (!isLiteralMatch) {
-          files.delete(file);
-        }
+      if (!isExpandedPatternMatch(file, list, rootDir)) {
+        files.delete(file);
       }
     }
   }
   return htmlEscape.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 = htmlEscape.replaceEveryLiteral(json, "<", htmlEscape.unicodeEscape("003C"));
+  escaped = htmlEscape.replaceEveryLiteral(escaped, ">", htmlEscape.unicodeEscape("003E"));
+  escaped = htmlEscape.replaceEveryLiteral(escaped, "&", htmlEscape.unicodeEscape("0026"));
+  escaped = htmlEscape.replaceEveryLiteral(escaped, LINE_SEPARATOR$1, htmlEscape.unicodeEscape("2028"));
+  return htmlEscape.replaceEveryLiteral(escaped, PARAGRAPH_SEPARATOR$1, htmlEscape.unicodeEscape("2029"));
 }
 function injectHtmlOpeningAttr(html, attr) {
   const lower = html.toLowerCase();
@@ -1580,11 +1950,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 = htmlEscape.replaceEveryLiteral(json, "`", htmlEscape.unicodeEscape("0060"));
+  escaped = htmlEscape.replaceEveryLiteral(escaped, "$", htmlEscape.unicodeEscape("0024"));
+  escaped = htmlEscape.replaceEveryLiteral(escaped, "<", htmlEscape.unicodeEscape("003c"));
+  escaped = htmlEscape.replaceEveryLiteral(escaped, LINE_SEPARATOR, htmlEscape.unicodeEscape("2028"));
+  return htmlEscape.replaceEveryLiteral(escaped, PARAGRAPH_SEPARATOR, htmlEscape.unicodeEscape("2029"));
 }
 function escapeForDoubleQuotedString(value) {
-  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  return htmlEscape.escapeDoubleQuotedString(value);
 }
 
 function isParserMode(value) {
@@ -1631,15 +2007,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 = htmlEscape.replaceEveryLiteral(sourceFiles.join(", "), "\r", " ");
+  const sources = htmlEscape.replaceEveryLiteral(withoutCarriageReturns, "\n", " ");
+  const toUnion = (tokens) => tokens.map((t) => `'${htmlEscape.escapeSingleQuotedString(t)}'`).join(" | ");
+  const quoteKey = (key) => /^[a-z_$][\w$]*$/i.test(key) ? key : `'${htmlEscape.escapeSingleQuotedString(key)}'`;
   const entries = [];
   if (theme.colors.length > 0) {
     entries.push(`        colors: ${toUnion(theme.colors)};`);
@@ -1777,6 +2151,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___";
@@ -1788,7 +2171,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}`;
@@ -1814,9 +2196,9 @@ let _hasWarnedTransformCacheVersion = false;
 let _hasWarnedNativeFallback = false;
 const _loggedActiveParsers = /* @__PURE__ */ new Set();
 const _babelFallbackFiles = /* @__PURE__ */ new Set();
-const requireFromHere = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('shared/unplugin.CP2cz9bA.cjs', document.baseURI).href)));
+const requireFromHere = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('shared/unplugin.DtPQz8Kg.cjs', document.baseURI).href)));
 const PLUGIN_VERSION = findPackageVersionFromFile(
-  node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('shared/unplugin.CP2cz9bA.cjs', document.baseURI).href))),
+  node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('shared/unplugin.DtPQz8Kg.cjs', document.baseURI).href))),
   UNKNOWN_PACKAGE_VERSION
 );
 const COMPILER_VERSION = findPackageVersionFromModule("@csszyx/compiler", UNKNOWN_PACKAGE_VERSION);
@@ -1861,10 +2243,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;
@@ -1970,9 +2352,17 @@ function shouldEmitWarning(quiet, devOnly, isProduction) {
   return true;
 }
 function normalizeForMatch(p) {
-  const n = p.replace(/\\/g, "/");
+  const n = transformCache.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__namespace.realpathSync(p);
@@ -2025,6 +2415,9 @@ function fileMayContainSafelistableSz(content) {
   // engine-parity harness caught its classes missing on all engines.
   content.includes("dynamic(");
 }
+function mangleEligibleClasses(ownedClasses, authoredClasses) {
+  return compiler.sortStrings([...ownedClasses].filter((className) => !authoredClasses.has(className)));
+}
 function isPackagesSkippedSource(id, sourceDirs = []) {
   const p = normalizeForMatch(id);
   if (p.includes("node_modules")) {
@@ -2045,8 +2438,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__namespace.join(rootDir, safelistFilename).replace(/\\/g, "/");
-  const cssDir = path__namespace.dirname(cssId).replace(/\\/g, "/");
+  const safelistPath = transformCache.normalizePathSeparators(path__namespace.join(rootDir, safelistFilename));
+  const cssDir = transformCache.normalizePathSeparators(path__namespace.dirname(cssId));
   let relPath = path__namespace.posix.relative(cssDir, safelistPath);
   if (!relPath.startsWith(".")) {
     relPath = `./${relPath}`;
@@ -2220,7 +2613,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("--")) {
@@ -2425,7 +2821,7 @@ function findPackageVersionFromFile(file, fallback) {
   }
 }
 function normalizeSourceFilename(filename) {
-  return filename.replace(/\\/g, "/");
+  return transformCache.normalizePathSeparators(filename);
 }
 const SCRIPT_ID_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx"];
 const SOURCE_MODULE_EXTENSIONS = [...SCRIPT_ID_EXTENSIONS, ".cts", ".mts", ".cjs", ".mjs"];
@@ -2433,11 +2829,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 runtimeImportScan.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) {
@@ -2445,6 +2856,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) {
@@ -2458,92 +2921,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(":")) {
@@ -2751,7 +3129,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}`);
     }
   }
@@ -2772,6 +3155,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),
@@ -2888,53 +3272,76 @@ function createCsszyxPlugins(options = {}) {
     }
     const cacheKey = cacheEnabled ? transformCache.createTransformCacheKey(cacheInput) : null;
     if (cacheEnabled && cacheKey) {
-      const memoryCached = transformMemoryCache.get(cacheKey.key);
-      if (memoryCached) {
-        transformMemoryCache.delete(cacheKey.key);
-        transformMemoryCache.set(cacheKey.key, memoryCached);
-        return memoryCached;
-      }
-      const cached = transformCache.readTransformCache(cacheRoot, cacheInput, cacheKey);
-      if (cached) {
-        rememberTransformCacheEntry(cacheKey.key, cached);
-        return cached;
-      }
-      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) {
+      transformCache.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 = transformCache.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 = compiler.transformSourceCode(source, effectiveFilename, compilerOptions);
-    } else if (parserMode === "rust") {
-      result = compiler.transformRust(source, effectiveFilename, compilerOptions);
-    } else {
-      try {
-        result = compiler.transformOxc(source, effectiveFilename, compilerOptions);
-      } catch (err) {
-        result = compiler.transformSourceCode(source, effectiveFilename, compilerOptions);
-        const reason = err instanceof Error ? err.message : String(err);
-        result.diagnostics.push(
-          `[csszyx] oxc parser fell back to Babel for ${effectiveFilename}: ${reason}`
-        );
-        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: compiler.transformSourceCode(source, effectiveFilename, compilerOptions),
+        cacheable: true
+      };
     }
-    if (cacheEnabled && cacheKey) {
-      transformCache.writeTransformCache(cacheRoot, cacheInput, result, cacheKey);
-      rememberTransformCacheEntry(cacheKey.key, result);
+    if (parserMode === "rust") {
+      return {
+        result: compiler.transformRust(source, effectiveFilename, compilerOptions),
+        cacheable: true
+      };
+    }
+    try {
+      return {
+        result: compiler.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 = compiler.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;
   }
@@ -2973,11 +3380,19 @@ function createCsszyxPlugins(options = {}) {
     const compilerOptions = createCompilerOptions(prescanAstBudget);
     const cacheRoot = transformCache.resolveTransformCacheDir(state.rootDir, options.build?.cacheDir);
     const results = /* @__PURE__ */ new Map();
-    const misses = [];
-    if (cacheEnabled) {
-      evictTransformCacheOnce();
-    }
+    if (cacheEnabled) evictTransformCacheOnce();
     compiler.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(
@@ -2986,79 +3401,54 @@ function createCsszyxPlugins(options = {}) {
         compilerOptions
       );
       const cacheKey = cacheEnabled ? transformCache.createTransformCacheKey(cacheInput) : null;
-      if (cacheEnabled && cacheKey) {
-        const memoryCached = transformMemoryCache.get(cacheKey.key);
-        if (memoryCached) {
-          transformMemoryCache.delete(cacheKey.key);
-          transformMemoryCache.set(cacheKey.key, memoryCached);
-          results.set(file.filePath, memoryCached);
-          continue;
-        }
-        const cached = transformCache.readTransformCache(cacheRoot, cacheInput, cacheKey);
-        if (cached) {
-          rememberTransformCacheEntry(cacheKey.key, cached);
-          results.set(file.filePath, cached);
-          continue;
-        }
-      }
-      misses.push({
-        filePath: file.filePath,
-        effectiveFilename,
-        content: file.content,
+      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 = compiler.transformRustBatch(
+      misses.map((file) => ({ filename: file.effectiveFilename, source: file.content })),
+      compilerOptions
+    );
+    for (let index = 0; index < misses.length; index++) {
+      const miss = misses[index];
+      const result = batchResults[index];
+      if (!miss || !result) continue;
+      cacheRustPrescanResult(miss, result, cacheRoot);
+      results.set(miss.filePath, result);
     }
-    try {
-      const batchResults = compiler.transformRustBatch(
-        misses.map((file) => ({
-          filename: file.effectiveFilename,
-          source: file.content
-        })),
-        compilerOptions
-      );
-      for (let index = 0; index < misses.length; index++) {
-        const miss = misses[index];
-        const result = batchResults[index];
-        if (!miss || !result) {
-          continue;
-        }
-        if (cacheEnabled && miss.cacheKey) {
-          transformCache.writeTransformCache(cacheRoot, miss.cacheInput, result, miss.cacheKey);
-          rememberTransformCacheEntry(miss.cacheKey.key, result);
-        }
+  }
+  function cacheRustPrescanResult(miss, result, cacheRoot) {
+    if (!cacheEnabled || !miss.cacheKey) return;
+    transformCache.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 = [];
@@ -3125,11 +3515,12 @@ function createCsszyxPlugins(options = {}) {
       return;
     }
     const safelistPath = path__namespace.join(state.rootDir, SAFELIST_FILENAME);
-    const classList = htmlEscape.escapeHtmlAttribute(Array.from(classes).join(" "));
+    const classNames = Array.from(classes);
+    const classList = htmlEscape.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>
-`;
+` + htmlEscape.renderTailwindScannerCandidates(classNames);
     try {
       let existing = "";
       try {
@@ -3159,12 +3550,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: node_crypto.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 = node_perf_hooks.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__namespace.readFileSync(filePath, "utf-8");
+      } catch {
+        return;
+      }
+      recordAuthoredClasses(content);
+      if (fileMayContainSafelistableSz(content)) {
+        prescanSources.push({ filePath, content });
+      }
+    }
     function scanDir(dir) {
       let entries;
       try {
@@ -3177,22 +3612,10 @@ function createCsszyxPlugins(options = {}) {
           if (!IGNORE_DIRS.has(entry.name) && !entry.name.startsWith(".")) {
             scanDir(path__namespace.join(dir, entry.name));
           }
-        } else if (SOURCE_EXTENSIONS.has(path__namespace.extname(entry.name))) {
-          const filePath = path__namespace.join(dir, entry.name);
-          if (!shouldProcessSource(filePath)) {
-            recordPackagesSkipIfSz(filePath);
-            continue;
-          }
-          let content;
-          try {
-            content = fs__namespace.readFileSync(filePath, "utf-8");
-          } catch {
-            continue;
-          }
-          if (!fileMayContainSafelistableSz(content)) {
-            continue;
-          }
-          prescanSources.push({ filePath, content });
+          continue;
+        }
+        if (SOURCE_EXTENSIONS.has(path__namespace.extname(entry.name))) {
+          collectPrescanSource(path__namespace.join(dir, entry.name));
         }
       }
     }
@@ -3208,29 +3631,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: node_crypto.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);
@@ -3291,7 +3698,7 @@ function createCsszyxPlugins(options = {}) {
     for (const kv of objStr.matchAll(numKv)) {
       try {
         collectTransformClasses(
-          compiler.transform({ [kv[1]]: parseFloat(kv[2]) }),
+          compiler.transform({ [kv[1]]: Number.parseFloat(kv[2]) }),
           discoveredClasses
         );
       } catch {
@@ -3315,51 +3722,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 = core.encode(tokenIndex);
-      while (mangleReserved.has(token)) {
+      while (mangleReserved.has(token) || state.authoredClasses.has(token)) {
         tokenIndex++;
         token = core.encode(tokenIndex);
       }
-      newMap[sortedClasses[i]] = token;
+      newMap[className] = token;
       tokenIndex++;
     }
     state.mangleMap = newMap;
@@ -3372,6 +3779,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)) {
@@ -3389,6 +3814,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 = vueAdapter.preprocess(code, options);
+      return { ...unchangedPreTransform(result2.code), transformed: result2.transformed };
+    }
+    if (id.endsWith(".svelte")) {
+      const result2 = svelteAdapter.preprocess(code, options);
+      return result2 ? { ...unchangedPreTransform(result2.code), transformed: true } : unchangedPreTransform(code);
+    }
+    const transformStarted = node_perf_hooks.performance.now();
+    const result = transformConfiguredSource(code, id);
+    traceBenchTiming("transform-hook", id, node_perf_hooks.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) => !runtimeImportScan.importsRuntimeHelper(code, name)) : imports;
+    if (needed.length === 0) return null;
+    const existingImport = runtimeImportScan.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 = unplugin$1.createUnplugin(
     (_pluginOptions) => ({
       name: "csszyx:pre",
@@ -3475,166 +4041,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 = vueAdapter.preprocess(code, options);
-            if (result.transformed) {
-              transformedCode = result.code;
-              transformed = true;
-            }
-          } else if (id.endsWith(".svelte")) {
-            const result = svelteAdapter.preprocess(code, options);
-            if (result) {
-              transformedCode = result.code;
-              transformed = true;
-            }
-          } else {
-            const transformStarted = node_perf_hooks.performance.now();
-            const result = transformConfiguredSource(code, id);
-            traceBenchTiming(
-              "transform-hook",
-              id,
-              node_perf_hooks.performance.now() - transformStarted
-            );
-            transformedCode = result.code;
-            usesRuntime = result.usesRuntime;
-            usesMerge = result.usesMerge;
-            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) => !runtimeImportScan.importsRuntimeHelper(transformedCode, name)) : imports;
-          if (needed.length > 0) {
-            const existingImport = runtimeImportScan.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() {
@@ -3843,6 +4284,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 = cssMangler.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 = unplugin$1.createUnplugin(() => ({
     name: "csszyx:post",
     enforce: "post",
@@ -3853,278 +4454,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 = cssMangler.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 = cssMangler.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 };
@@ -4156,7 +4499,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",
     /**
@@ -4165,8 +4517,8 @@ 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);
     }
   };
 };
@@ -4200,6 +4552,7 @@ exports.isPackagesSkippedSource = isPackagesSkippedSource;
 exports.isRSCServerModule = isRSCServerModule;
 exports.isTailwindReservedGlobalVar = isTailwindReservedGlobalVar;
 exports.mangleCodeClassesSync = mangleCodeClassesSync;
+exports.mangleEligibleClasses = mangleEligibleClasses;
 exports.mangleHybridHazardMessage = mangleHybridHazardMessage;
 exports.mergeThemes = mergeThemes;
 exports.missingTailwindEntryMessage = missingTailwindEntryMessage;