@csszyx/unplugin 0.1.0

package/dist/index.cjs

@@ -0,0 +1,905 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createPostCSSPlugin: () => createPostCSSPlugin,
+  default: () => unplugin,
+  esbuildPlugin: () => esbuildPlugin,
+  escapeCSSClassName: () => escapeCSSClassName,
+  mangleCSS: () => mangleCSS,
+  mangleCSSSync: () => mangleCSSSync,
+  rollupPlugin: () => rollupPlugin,
+  unescapeTailwindClass: () => unescapeTailwindClass,
+  unplugin: () => unplugin,
+  vitePlugin: () => vitePlugin,
+  webpackPlugin: () => webpackPlugin
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/css-mangler.ts
+var import_postcss = __toESM(require("postcss"), 1);
+var import_postcss_selector_parser = __toESM(require("postcss-selector-parser"), 1);
+function unescapeTailwindClass(escapedName) {
+  let result = "";
+  let i = 0;
+  while (i < escapedName.length) {
+    if (escapedName[i] === "\\") {
+      i++;
+      if (i >= escapedName.length) {
+        break;
+      }
+      const char = escapedName[i];
+      if (/[0-9a-fA-F]/.test(char)) {
+        let hexStr = "";
+        while (i < escapedName.length && /[0-9a-fA-F]/.test(escapedName[i]) && hexStr.length < 6) {
+          hexStr += escapedName[i];
+          i++;
+        }
+        if (i < escapedName.length && escapedName[i] === " ") {
+          i++;
+        }
+        const codePoint = parseInt(hexStr, 16);
+        if (codePoint > 0) {
+          result += String.fromCodePoint(codePoint);
+        }
+        continue;
+      }
+      result += char;
+      i++;
+    } else {
+      result += escapedName[i];
+      i++;
+    }
+  }
+  return result;
+}
+function escapeCSSClassName(className) {
+  let result = "";
+  for (let i = 0; i < className.length; i++) {
+    const char = className[i];
+    const code = char.charCodeAt(0);
+    if (i === 0) {
+      if (/[0-9]/.test(char)) {
+        result += "\\3" + char + " ";
+        continue;
+      }
+      if (char === "-" && i + 1 < className.length) {
+        const next = className[i + 1];
+        if (/[0-9]/.test(next) || next === "-") {
+          result += "\\-";
+          continue;
+        }
+      }
+    }
+    if (/[!"#$%&'()*+,./:;<=>?@[\\\]^`{|}~]/.test(char)) {
+      result += "\\" + char;
+    } else if (code >= 128) {
+      result += char;
+    } else {
+      result += char;
+    }
+  }
+  return result;
+}
+function createSelectorProcessor(mangleMap, mangledClasses, unmangledClasses) {
+  return (0, import_postcss_selector_parser.default)((selectors) => {
+    selectors.walkClasses((classNode) => {
+      const originalValue = classNode.value;
+      const unescapedValue = unescapeTailwindClass(originalValue);
+      let mangledValue, matchedKey;
+      if (mangleMap[unescapedValue]) {
+        mangledValue = mangleMap[unescapedValue];
+        matchedKey = unescapedValue;
+      } else if (mangleMap[originalValue]) {
+        mangledValue = mangleMap[originalValue];
+        matchedKey = originalValue;
+      }
+      if (mangledValue && matchedKey) {
+        classNode.value = mangledValue;
+        mangledClasses.add(matchedKey);
+      } else {
+        unmangledClasses.add(originalValue);
+      }
+    });
+  });
+}
+async function mangleCSS(css, mangleMap, options = {}) {
+  const mangledClasses = /* @__PURE__ */ new Set();
+  const unmangledClasses = /* @__PURE__ */ new Set();
+  let transformedCount = 0;
+  const selectorProcessor = createSelectorProcessor(
+    mangleMap,
+    mangledClasses,
+    unmangledClasses
+  );
+  const csszyxManglerPlugin = {
+    postcssPlugin: "csszyx-css-mangler",
+    Rule(rule) {
+      try {
+        const originalSelector = rule.selector;
+        const newSelector = selectorProcessor.processSync(originalSelector);
+        if (newSelector !== originalSelector) {
+          rule.selector = newSelector;
+          transformedCount++;
+        }
+      } catch (error) {
+        if (options.debug) {
+          console.warn(`[csszyx] Failed to process selector: ${rule.selector}`, error);
+        }
+      }
+    }
+  };
+  const result = await (0, import_postcss.default)([csszyxManglerPlugin]).process(css, {
+    from: options.from
+  });
+  if (options.debug) {
+    console.log(`[csszyx] CSS Mangler: ${transformedCount} selectors transformed`);
+    console.log(`[csszyx] Mangled classes: ${mangledClasses.size}`);
+    console.log(`[csszyx] Unmangled classes: ${unmangledClasses.size}`);
+  }
+  return {
+    css: result.css,
+    transformedCount,
+    mangledClasses: Array.from(mangledClasses),
+    unmangledClasses: Array.from(unmangledClasses)
+  };
+}
+function mangleCSSSync(css, mangleMap, options = {}) {
+  const mangledClasses = /* @__PURE__ */ new Set();
+  const unmangledClasses = /* @__PURE__ */ new Set();
+  let transformedCount = 0;
+  const selectorProcessor = createSelectorProcessor(
+    mangleMap,
+    mangledClasses,
+    unmangledClasses
+  );
+  const root = import_postcss.default.parse(css, { from: options.from });
+  root.walkRules((rule) => {
+    try {
+      const originalSelector = rule.selector;
+      const newSelector = selectorProcessor.processSync(originalSelector);
+      if (newSelector !== originalSelector) {
+        rule.selector = newSelector;
+        transformedCount++;
+      }
+    } catch (error) {
+      if (options.debug) {
+        console.warn(`[csszyx] Failed to process selector: ${rule.selector}`, error);
+      }
+    }
+  });
+  if (options.debug) {
+    console.log(`[csszyx] CSS Mangler: ${transformedCount} selectors transformed`);
+    console.log(`[csszyx] Mangled classes: ${mangledClasses.size}`);
+    console.log(`[csszyx] Unmangled classes: ${unmangledClasses.size}`);
+  }
+  return {
+    css: root.toString(),
+    transformedCount,
+    mangledClasses: Array.from(mangledClasses),
+    unmangledClasses: Array.from(unmangledClasses)
+  };
+}
+function createPostCSSPlugin(mangleMap, options = {}) {
+  const mangledClasses = /* @__PURE__ */ new Set();
+  const unmangledClasses = /* @__PURE__ */ new Set();
+  const selectorProcessor = createSelectorProcessor(
+    mangleMap,
+    mangledClasses,
+    unmangledClasses
+  );
+  return {
+    postcssPlugin: "csszyx-css-mangler",
+    Rule(rule) {
+      try {
+        const originalSelector = rule.selector;
+        const newSelector = selectorProcessor.processSync(originalSelector);
+        if (newSelector !== originalSelector) {
+          rule.selector = newSelector;
+        }
+      } catch (error) {
+        if (options.debug) {
+          console.warn(`[csszyx] Failed to process selector: ${rule.selector}`, error);
+        }
+      }
+    },
+    OnceExit() {
+      if (options.debug) {
+        console.log(`[csszyx] Mangled ${mangledClasses.size} unique classes`);
+      }
+    }
+  };
+}
+
+// src/unplugin.ts
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+var import_compiler = require("@csszyx/compiler");
+var import_core = require("@csszyx/core");
+var import_svelte_adapter = require("@csszyx/svelte-adapter");
+var import_vue_adapter = require("@csszyx/vue-adapter");
+var import_unplugin = require("unplugin");
+
+// src/html-transformer.ts
+function injectChecksum(html, checksum, minify = false) {
+  const attrName = minify ? "data-sz-cs" : "data-sz-checksum";
+  const htmlTagPattern = /<html([^>]*)>/i;
+  const match = html.match(htmlTagPattern);
+  if (!match) {
+    return html;
+  }
+  const existingAttrs = match[1];
+  const checksumAttr = ` ${attrName}="${checksum}"`;
+  return html.replace(
+    htmlTagPattern,
+    `<html${checksumAttr}${existingAttrs}>`
+  );
+}
+function injectMangleMapScript(html, mangleMap, options = {}) {
+  const { prettyPrint = false } = options;
+  const jsonContent = prettyPrint ? JSON.stringify(mangleMap, null, 2) : JSON.stringify(mangleMap);
+  const scriptTag = `<script id="__CSSZYX_MANGLE_MAP__" type="application/json">${jsonContent}</script>`;
+  const debugScript = `<script>(function(){var m=${jsonContent};var r={};for(var k in m)r[m[k]]=k;var cs=document.documentElement.getAttribute("data-sz-checksum")||"";window.__csszyx={mangleMap:m,checksum:cs,decode:function(c){return r[c]},encode:function(c){return m[c]},decodeAll:function(el){return(el.className||"").split(" ").map(function(c){return r[c]||c})}}})()</script>`;
+  const combined = `${scriptTag}
+${debugScript}`;
+  if (html.includes("</head>")) {
+    return html.replace("</head>", `${combined}
+</head>`);
+  } else if (html.includes("</html>")) {
+    return html.replace("</html>", `${combined}
+</html>`);
+  }
+  return html + combined;
+}
+function injectMangleMapAttribute(html, mangleMap, minify = false) {
+  const attrName = minify ? "data-sz-m" : "data-sz-map";
+  const jsonContent = JSON.stringify(mangleMap);
+  const htmlTagPattern = /<html([^>]*)>/i;
+  const match = html.match(htmlTagPattern);
+  if (!match) {
+    return html;
+  }
+  const existingAttrs = match[1];
+  const mapAttr = ` ${attrName}='${jsonContent}'`;
+  return html.replace(htmlTagPattern, `<html${mapAttr}${existingAttrs}>`);
+}
+function injectHydrationData(html, mangleMap, checksum, options = {}) {
+  const { mode = "script", minify = false } = options;
+  let result = html;
+  result = injectChecksum(result, checksum, minify);
+  if (mode === "inline") {
+    result = injectMangleMapAttribute(result, mangleMap, minify);
+  } else if (mode === "script") {
+    result = injectMangleMapScript(result, mangleMap, options);
+  } else if (mode === "both") {
+    result = injectMangleMapAttribute(result, mangleMap, minify);
+    result = injectMangleMapScript(result, mangleMap, options);
+  }
+  return result;
+}
+function transformIndexHtml(html, mangleMap, checksum, options = {}) {
+  return injectHydrationData(html, mangleMap, checksum, options);
+}
+
+// src/virtual-modules.ts
+var VIRTUAL_MODULE_ID = "virtual:csszyx/mangle-map";
+var RESOLVED_VIRTUAL_MODULE_ID = "\0" + VIRTUAL_MODULE_ID;
+var VIRTUAL_CHECKSUM_ID = "virtual:csszyx/checksum";
+var RESOLVED_VIRTUAL_CHECKSUM_ID = "\0" + VIRTUAL_CHECKSUM_ID;
+function createMangleMapModule(mangleMap, checksum) {
+  return `/**
+ * Auto-generated mangle map for csszyx.
+ * This module is generated at build time and contains the mapping
+ * from original class names to mangled class names.
+ *
+ * @generated
+ */
+
+export const mangleMap = ${JSON.stringify(mangleMap, null, 2)};
+
+export const checksum = ${JSON.stringify(checksum)};
+
+export default {
+  mangleMap,
+  checksum,
+};
+`;
+}
+function createChecksumModule(checksum) {
+  return `/**
+ * Auto-generated checksum for csszyx mangle map.
+ *
+ * @generated
+ */
+
+export const checksum = ${JSON.stringify(checksum)};
+
+export default checksum;
+`;
+}
+function isVirtualModule(id) {
+  return id === VIRTUAL_MODULE_ID || id === VIRTUAL_CHECKSUM_ID;
+}
+function resolveVirtualModule(id) {
+  if (id === VIRTUAL_MODULE_ID) {
+    return RESOLVED_VIRTUAL_MODULE_ID;
+  }
+  if (id === VIRTUAL_CHECKSUM_ID) {
+    return RESOLVED_VIRTUAL_CHECKSUM_ID;
+  }
+  return void 0;
+}
+
+// src/unplugin.ts
+var CHECKSUM_PLACEHOLDER = "___CSSZYX_CHECKSUM___";
+var MANGLE_MAP_PLACEHOLDER = "___CSSZYX_MANGLE_MAP___";
+function createCsszyxPlugins(options = {}) {
+  const manglingEnabled = options.production?.mangle !== false;
+  const state = {
+    classes: /* @__PURE__ */ new Set(),
+    mangleMap: {},
+    checksum: "",
+    finalized: false
+  };
+  const SAFELIST_FILENAME = "csszyx-classes.js";
+  const SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".tsx", ".jsx", ".ts", ".js"]);
+  const IGNORE_DIRS = /* @__PURE__ */ new Set(["node_modules", ".next", ".git", "dist", "build", ".turbo"]);
+  function prescanAndWriteClasses(rootDir) {
+    const discoveredClasses = /* @__PURE__ */ new Set();
+    function scanDir(dir) {
+      let entries;
+      try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          if (!IGNORE_DIRS.has(entry.name) && !entry.name.startsWith(".")) {
+            scanDir(path.join(dir, entry.name));
+          }
+        } else if (SOURCE_EXTENSIONS.has(path.extname(entry.name))) {
+          const filePath = path.join(dir, entry.name);
+          try {
+            const content = fs.readFileSync(filePath, "utf-8");
+            if (!content.includes("sz=") && !content.includes("sz:")) {
+              continue;
+            }
+            const result = (0, import_compiler.transformSourceCode)(content);
+            if (!result.transformed) {
+              continue;
+            }
+            const classPattern = /class(?:Name)?=["']([^"']*)["']/g;
+            let match;
+            while ((match = classPattern.exec(result.code)) !== null) {
+              for (const cls of match[1].split(/\s+/).filter(Boolean)) {
+                discoveredClasses.add(cls);
+              }
+            }
+            const exprPattern = /className=\{/g;
+            while ((match = exprPattern.exec(result.code)) !== null) {
+              let depth = 1;
+              let i = match.index + match[0].length;
+              while (i < result.code.length && depth > 0) {
+                if (result.code[i] === "{") {
+                  depth++;
+                } else if (result.code[i] === "}") {
+                  depth--;
+                }
+                i++;
+              }
+              const expr = result.code.slice(match.index + match[0].length, i - 1);
+              const strPattern = /"([^"]+)"|'([^']+)'/g;
+              let strMatch;
+              while ((strMatch = strPattern.exec(expr)) !== null) {
+                const str = strMatch[1] || strMatch[2];
+                for (const cls of str.split(/\s+/).filter(Boolean)) {
+                  discoveredClasses.add(cls);
+                }
+              }
+            }
+            if (result.usesRuntime) {
+              const szCallRe = /_sz\(\s*\{/g;
+              let szMatch;
+              while ((szMatch = szCallRe.exec(result.code)) !== null) {
+                let depth = 1;
+                let idx = szMatch.index + szMatch[0].length;
+                while (idx < result.code.length && depth > 0) {
+                  if (result.code[idx] === "{") {
+                    depth++;
+                  } else if (result.code[idx] === "}") {
+                    depth--;
+                  }
+                  idx++;
+                }
+                const objStr = result.code.slice(szMatch.index + szMatch[0].length, idx - 1);
+                const strKv = /(\w+)\s*:\s*(?:"([^"]*)"|'([^']*)')/g;
+                let kv;
+                while ((kv = strKv.exec(objStr)) !== null) {
+                  try {
+                    const val = kv[2] ?? kv[3];
+                    const r = (0, import_compiler.transform)({ [kv[1]]: val });
+                    for (const c of r.className.split(/\s+/).filter(Boolean)) {
+                      discoveredClasses.add(c);
+                    }
+                  } catch {
+                  }
+                }
+                const numKv = /(\w+)\s*:\s*(-?\d+(?:\.\d+)?)\s*(?=[,}\n])/g;
+                while ((kv = numKv.exec(objStr)) !== null) {
+                  try {
+                    const r = (0, import_compiler.transform)({ [kv[1]]: parseFloat(kv[2]) });
+                    for (const c of r.className.split(/\s+/).filter(Boolean)) {
+                      discoveredClasses.add(c);
+                    }
+                  } catch {
+                  }
+                }
+                const boolKv = /(\w+)\s*:\s*(true|false)\s*(?=[,}\n])/g;
+                while ((kv = boolKv.exec(objStr)) !== null) {
+                  try {
+                    const r = (0, import_compiler.transform)({ [kv[1]]: kv[2] === "true" });
+                    for (const c of r.className.split(/\s+/).filter(Boolean)) {
+                      discoveredClasses.add(c);
+                    }
+                  } catch {
+                  }
+                }
+              }
+            }
+          } catch {
+          }
+        }
+      }
+    }
+    scanDir(rootDir);
+    for (const cls of discoveredClasses) {
+      state.classes.add(cls);
+    }
+    if (discoveredClasses.size > 0) {
+      const safelistPath = path.join(rootDir, SAFELIST_FILENAME);
+      const content = '// Auto-generated by csszyx \u2014 DO NOT EDIT\n// Tailwind CSS scans this file for class name detection\nexport default "' + Array.from(discoveredClasses).join(" ") + '";\n';
+      try {
+        const existing = fs.existsSync(safelistPath) ? fs.readFileSync(safelistPath, "utf-8") : "";
+        if (existing !== content) {
+          fs.writeFileSync(safelistPath, content);
+        }
+      } catch {
+      }
+    }
+  }
+  function extractClasses(code) {
+    const classPattern = /(?:class(?:Name)?|sz)[:=]\s*["']([^"']*)["']/g;
+    let match;
+    while ((match = classPattern.exec(code)) !== null) {
+      const classes = match[1].split(/\s+/).filter(Boolean);
+      for (const cls of classes) {
+        state.classes.add(cls);
+      }
+    }
+    const exprStart = /className=\{/g;
+    while ((match = exprStart.exec(code)) !== null) {
+      let depth = 1;
+      let i = match.index + match[0].length;
+      while (i < code.length && depth > 0) {
+        if (code[i] === "{") {
+          depth++;
+        } else if (code[i] === "}") {
+          depth--;
+        }
+        i++;
+      }
+      const expr = code.slice(match.index + match[0].length, i - 1);
+      const strPattern = /"([^"]+)"|'([^']+)'/g;
+      let strMatch;
+      while ((strMatch = strPattern.exec(expr)) !== null) {
+        const str = strMatch[1] || strMatch[2];
+        const classes = str.split(/\s+/).filter(Boolean);
+        for (const cls of classes) {
+          state.classes.add(cls);
+        }
+      }
+    }
+  }
+  function finalizeMangleMap() {
+    const sortedClasses = Array.from(state.classes);
+    const newMap = {};
+    for (let i = 0; i < sortedClasses.length; i++) {
+      newMap[sortedClasses[i]] = (0, import_core.encode)(i);
+    }
+    state.mangleMap = newMap;
+    state.checksum = (0, import_core.compute_mangle_checksum)(state.mangleMap);
+    state.finalized = true;
+  }
+  function mangleClassString(classString) {
+    return classString.split(/\s+/).map((cls) => state.mangleMap[cls] || cls).join(" ");
+  }
+  function mangleCodeClasses(code) {
+    let result = code.replace(/(?:class(?:Name)?|sz)[:=]\s*["']([^"']*)["']/g, (match, classes) => {
+      const mangled = mangleClassString(classes);
+      if (mangled === classes) {
+        return match;
+      }
+      return match.replace(classes, mangled);
+    });
+    result = result.replace(/className:([^,;}\])\n]+)/g, (fullMatch, expr) => {
+      let changed = false;
+      const mangled = expr.replace(/"([^"]*)"/g, (qm, inner) => {
+        const parts = inner.split(/\s+/).filter(Boolean);
+        if (parts.length === 0) {
+          return qm;
+        }
+        const mangledStr = parts.map((p) => state.mangleMap[p] || p).join(" ");
+        if (mangledStr !== inner) {
+          changed = true;
+          return '"' + mangledStr + '"';
+        }
+        return qm;
+      });
+      if (changed) {
+        return "className:" + mangled;
+      }
+      return fullMatch;
+    });
+    return result;
+  }
+  function replacePlaceholders(code) {
+    let result = code;
+    if (result.includes(CHECKSUM_PLACEHOLDER)) {
+      result = result.split(CHECKSUM_PLACEHOLDER).join(state.checksum);
+    }
+    if (result.includes(MANGLE_MAP_PLACEHOLDER)) {
+      result = result.split(MANGLE_MAP_PLACEHOLDER).join(JSON.stringify(state.mangleMap));
+    }
+    return result;
+  }
+  const prePlugin = (0, import_unplugin.createUnplugin)((_pluginOptions) => ({
+    name: "csszyx:pre",
+    enforce: "pre",
+    /**
+     * Resolves virtual module IDs for csszyx mangle-map and checksum modules.
+     * @param id - the module ID to resolve
+     * @returns resolved ID if virtual, null otherwise
+     */
+    resolveId(id) {
+      if (isVirtualModule(id)) {
+        return resolveVirtualModule(id);
+      }
+      return null;
+    },
+    /**
+     * Loads virtual module content — generates mangle map or checksum module code.
+     * @param id - the resolved module ID to load
+     * @returns generated module source if virtual, null otherwise
+     */
+    load(id) {
+      if (id === RESOLVED_VIRTUAL_MODULE_ID) {
+        finalizeMangleMap();
+        return createMangleMapModule(state.mangleMap, state.checksum);
+      }
+      if (id === RESOLVED_VIRTUAL_CHECKSUM_ID) {
+        finalizeMangleMap();
+        return createChecksumModule(state.checksum);
+      }
+      return null;
+    },
+    /**
+     * Filters files for the pre-transform phase — only source files outside node_modules.
+     * @param id - the file path to check for inclusion
+     * @returns true if the file should be transformed, false otherwise
+     */
+    transformInclude(id) {
+      if (id.includes("node_modules") || id.includes("/packages/") || id.includes(".next") && !id.includes("static")) {
+        return false;
+      }
+      return /\.[tj]sx?$/.test(id) || id.endsWith(".vue") || id.endsWith(".svelte");
+    },
+    /**
+     * Core transform: detects sz prop, compiles to className, injects runtime, collects classes.
+     * @param code - the source code to transform
+     * @param id - the file path of the module being transformed
+     * @returns transformed code with source map, or null if no changes were made
+     */
+    transform(code, id) {
+      let transformedCode = code;
+      let usesRuntime = false;
+      let usesColorVar = false;
+      let transformed = false;
+      const hasSzProp = code.includes("sz=") || /\bsz\s*:\s*["'{]/.test(code) || code.includes('sz: "');
+      if (hasSzProp) {
+        if (id.endsWith(".vue")) {
+          const result = (0, import_vue_adapter.preprocess)(code, options);
+          if (result.transformed) {
+            transformedCode = result.code;
+            transformed = true;
+          }
+        } else if (id.endsWith(".svelte")) {
+          const result = (0, import_svelte_adapter.preprocess)(code, options);
+          if (result) {
+            transformedCode = result.code;
+            transformed = true;
+          }
+        } else {
+          const result = (0, import_compiler.transformSourceCode)(code);
+          transformedCode = result.code;
+          usesRuntime = result.usesRuntime;
+          usesColorVar = result.usesColorVar;
+          transformed = result.transformed;
+        }
+      }
+      if (transformedCode.includes("<html") && /layout|Root|Document|app\\.tsx?$/i.test(id)) {
+        const attrName = options.production?.minify ? "data-sz-cs" : "data-sz-checksum";
+        transformedCode = transformedCode.replace(/<html([^>]*)>/i, `<html$1 ${attrName}="${CHECKSUM_PLACEHOLDER}">`);
+        const debugScript = `<script dangerouslySetInnerHTML={{__html: \`(function(){var m=${MANGLE_MAP_PLACEHOLDER};var r={};for(var k in m)r[m[k]]=k;window.__csszyx={mangleMap:m,checksum:"${CHECKSUM_PLACEHOLDER}",decode:function(c){return r[c]},encode:function(c){return m[c]},decodeAll:function(el){return(el.className||"").split(" ").map(function(c){return r[c]||c})}}})()\`}} />`;
+        if (transformedCode.includes("<body")) {
+          transformedCode = transformedCode.replace(
+            /(<body[^>]*>)/i,
+            `$1${debugScript}`
+          );
+        }
+        transformed = true;
+      }
+      {
+        const imports = [];
+        if (usesRuntime) {
+          imports.push("_sz");
+        }
+        if (usesColorVar) {
+          imports.push("__szColorVar");
+        }
+        if (imports.length > 0 && !transformedCode.includes("from 'csszyx/lite'")) {
+          const importStmt = `import { ${imports.join(", ")} } from 'csszyx/lite';
+`;
+          const directiveMatch = transformedCode.match(/^['"]use (client|server)['"];?\s*/);
+          if (directiveMatch) {
+            const directive = directiveMatch[0];
+            transformedCode = transformedCode.replace(directive, `${directive}${importStmt}`);
+          } else {
+            transformedCode = `${importStmt}${transformedCode}`;
+          }
+          transformed = true;
+        }
+      }
+      if (transformed || transformedCode.includes("class=") || transformedCode.includes("className=")) {
+        extractClasses(transformedCode);
+        return { code: transformedCode, map: null };
+      }
+      return null;
+    },
+    /** Finalizes the mangle map after all source modules have been processed. */
+    buildEnd() {
+      finalizeMangleMap();
+    },
+    /**
+     * Webpack hook: pre-scans source files before compilation for Tailwind class discovery.
+     * @param compiler - the Webpack compiler instance
+     */
+    webpack(compiler) {
+      compiler.hooks.beforeCompile.tap("csszyx:prescan", () => {
+        if (state.classes.size === 0) {
+          prescanAndWriteClasses(compiler.context || process.cwd());
+        }
+      });
+    },
+    vite: {
+      /**
+       * Vite hook: pre-scans source files when config is resolved.
+       * @param config - the resolved Vite configuration object
+       */
+      configResolved(config) {
+        prescanAndWriteClasses(config.root || process.cwd());
+      },
+      transformIndexHtml: {
+        order: "pre",
+        /**
+         * Injects hydration data (mangle map + checksum) into the HTML document.
+         * @param html - the raw HTML string to transform
+         * @returns transformed HTML with injected hydration data
+         */
+        handler(html) {
+          finalizeMangleMap();
+          return transformIndexHtml(html, state.mangleMap, state.checksum, {
+            mode: options.production?.injectChecksum === false ? "script" : "script",
+            minify: process.env.NODE_ENV === "production"
+          });
+        }
+      }
+    }
+  }));
+  const postPlugin = (0, import_unplugin.createUnplugin)(() => ({
+    name: "csszyx:post",
+    enforce: "post",
+    // No transform hook — all mangling is deferred to asset processing
+    // where the complete mangle map is available.
+    /**
+     * Webpack hook: mangles CSS/JS class names in processAssets after compilation.
+     * @param compiler - the Webpack compiler instance
+     */
+    webpack(compiler) {
+      compiler.hooks.compilation.tap("csszyx:post", (compilation) => {
+        const stage = compiler.webpack?.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE || // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        compilation.constructor.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE;
+        compilation.hooks.processAssets.tap(
+          {
+            name: "csszyx:post",
+            stage: stage || 400
+            // Fallback integer
+          },
+          (assets) => {
+            finalizeMangleMap();
+            for (const file in assets) {
+              const asset = assets[file];
+              const source = asset.source().toString();
+              if (manglingEnabled && Object.keys(state.mangleMap).length > 0) {
+                if (file.endsWith(".css")) {
+                  try {
+                    const result = mangleCSSSync(source, state.mangleMap, {
+                      debug: options.development?.debug,
+                      from: file
+                    });
+                    if (result.transformedCount > 0) {
+                      compilation.updateAsset(
+                        file,
+                        new compiler.webpack.sources.RawSource(result.css)
+                      );
+                      continue;
+                    }
+                  } catch (e) {
+                    if (e && typeof e === "object" && "name" in e && e.name === "CssSyntaxError") {
+                    } else {
+                      throw e;
+                    }
+                  }
+                } else if (file.endsWith(".js")) {
+                  let mangled = mangleCodeClasses(source);
+                  mangled = replacePlaceholders(mangled);
+                  if (mangled !== source) {
+                    compilation.updateAsset(
+                      file,
+                      new compiler.webpack.sources.RawSource(mangled)
+                    );
+                    continue;
+                  }
+                }
+              }
+              if (file.endsWith(".js") && (source.includes(CHECKSUM_PLACEHOLDER) || source.includes(MANGLE_MAP_PLACEHOLDER))) {
+                const replaced = replacePlaceholders(source);
+                if (replaced !== source) {
+                  compilation.updateAsset(
+                    file,
+                    new compiler.webpack.sources.RawSource(replaced)
+                  );
+                }
+              }
+            }
+          }
+        );
+      });
+    },
+    vite: {
+      /**
+       * Vite hook: mangles CSS selectors and JS class strings in the final bundle.
+       * @param _options - the output options (unused)
+       * @param bundle - the output bundle containing chunks and assets to process
+       */
+      generateBundle(_options, bundle) {
+        finalizeMangleMap();
+        for (const file in bundle) {
+          const chunk = bundle[file];
+          if (manglingEnabled && Object.keys(state.mangleMap).length > 0) {
+            if (chunk.type === "asset" && chunk.fileName.endsWith(".css")) {
+              const css = chunk.source.toString();
+              try {
+                const result = mangleCSSSync(css, state.mangleMap, {
+                  debug: options.development?.debug,
+                  from: file
+                });
+                if (result.transformedCount > 0) {
+                  chunk.source = result.css;
+                }
+              } catch (e) {
+                if (e && typeof e === "object" && "name" in e && e.name === "CssSyntaxError") {
+                } else {
+                  throw e;
+                }
+              }
+              continue;
+            } else if (chunk.type === "chunk") {
+              let mangledCode = mangleCodeClasses(chunk.code);
+              mangledCode = replacePlaceholders(mangledCode);
+              if (mangledCode !== chunk.code) {
+                chunk.code = mangledCode;
+              }
+              continue;
+            }
+          }
+          if (chunk.type === "chunk" && (chunk.code.includes(CHECKSUM_PLACEHOLDER) || chunk.code.includes(MANGLE_MAP_PLACEHOLDER))) {
+            const replaced = replacePlaceholders(chunk.code);
+            if (replaced !== chunk.code) {
+              chunk.code = replaced;
+            }
+          }
+        }
+      }
+    }
+  }));
+  return { prePlugin, postPlugin };
+}
+var defaultInstance = createCsszyxPlugins();
+var unplugin = defaultInstance.prePlugin;
+var vitePlugin = (options = {}) => {
+  const { prePlugin, postPlugin } = createCsszyxPlugins(options);
+  return [prePlugin.vite(options), postPlugin.vite(options)];
+};
+var webpackPlugin = (options = {}) => {
+  const { prePlugin, postPlugin } = createCsszyxPlugins(options);
+  return {
+    /**
+     * Applies both pre and post plugins to the Webpack compiler.
+     * @param compiler - the Webpack compiler instance to apply plugins to
+     */
+    apply(compiler) {
+      prePlugin.webpack(options).apply(compiler);
+      postPlugin.webpack(options).apply(compiler);
+    }
+  };
+};
+var rollupPlugin = (options = {}) => {
+  const { prePlugin, postPlugin } = createCsszyxPlugins(options);
+  return [prePlugin.rollup(options), postPlugin.rollup(options)];
+};
+var esbuildPlugin = (options = {}) => {
+  const { prePlugin, postPlugin } = createCsszyxPlugins(options);
+  return {
+    name: "csszyx",
+    /**
+     * Registers both pre and post plugin setup hooks with the esbuild build.
+     * @param build - the esbuild plugin build context
+     */
+    setup(build) {
+      prePlugin.esbuild(options).setup(build);
+      postPlugin.esbuild(options).setup(build);
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createPostCSSPlugin,
+  esbuildPlugin,
+  escapeCSSClassName,
+  mangleCSS,
+  mangleCSSSync,
+  rollupPlugin,
+  unescapeTailwindClass,
+  unplugin,
+  vitePlugin,
+  webpackPlugin
+});