@csszyx/unplugin 0.1.0

package/dist/chunk-JKM7IRGZ.js

@@ -0,0 +1,663 @@
+import {
+  mangleCSSSync
+} from "./chunk-4M7CPGP7.js";
+
+// src/unplugin.ts
+import * as fs from "fs";
+import * as path from "path";
+import { transform, transformSourceCode } from "@csszyx/compiler";
+import { compute_mangle_checksum, encode } from "@csszyx/core";
+import { preprocess as sveltePreprocess } from "@csszyx/svelte-adapter";
+import { preprocess as vuePreprocess } from "@csszyx/vue-adapter";
+import { createUnplugin } from "unplugin";
+
+// src/html-transformer.ts
+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 = 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 = transform({ [kv[1]]: val });
+                    for (const c of r.className.split(/\s+/).filter(Boolean)) {
+                      discoveredClasses.add(c);
+                    }
+                  } catch {
+                  }
+                }
+                const numKv = /(\w+)\s*:\s*(-?\d+(?:\.\d+)?)\s*(?=[,}\n])/g;
+                while ((kv = numKv.exec(objStr)) !== null) {
+                  try {
+                    const r = transform({ [kv[1]]: parseFloat(kv[2]) });
+                    for (const c of r.className.split(/\s+/).filter(Boolean)) {
+                      discoveredClasses.add(c);
+                    }
+                  } catch {
+                  }
+                }
+                const boolKv = /(\w+)\s*:\s*(true|false)\s*(?=[,}\n])/g;
+                while ((kv = boolKv.exec(objStr)) !== null) {
+                  try {
+                    const r = transform({ [kv[1]]: kv[2] === "true" });
+                    for (const c of r.className.split(/\s+/).filter(Boolean)) {
+                      discoveredClasses.add(c);
+                    }
+                  } catch {
+                  }
+                }
+              }
+            }
+          } catch {
+          }
+        }
+      }
+    }
+    scanDir(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]] = encode(i);
+    }
+    state.mangleMap = newMap;
+    state.checksum = 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 = 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 = vuePreprocess(code, options);
+          if (result.transformed) {
+            transformedCode = result.code;
+            transformed = true;
+          }
+        } else if (id.endsWith(".svelte")) {
+          const result = sveltePreprocess(code, options);
+          if (result) {
+            transformedCode = result.code;
+            transformed = true;
+          }
+        } else {
+          const result = transformSourceCode(code);
+          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 = 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);
+    }
+  };
+};
+
+export {
+  unplugin,
+  vitePlugin,
+  webpackPlugin,
+  rollupPlugin,
+  esbuildPlugin
+};