tailwindcss-patch 2.0.5 → 2.1.1

package/dist/{chunk-PZNRLYGX.mjs → index.cjs}

@@ -1,41 +1,52 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined")
-    return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-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 });
+'use strict';
+
+const fs$1 = require('node:fs/promises');
+const path = require('node:path');
+const fs = require('node:fs');
+const pkg = require('resolve');
+const semver = require('semver');
+const t = require('@babel/types');
+const generate = require('@babel/generator');
+const traverse = require('@babel/traverse');
+const parser = require('@babel/parser');
+const postcss = require('postcss');
+const lilconfig = require('lilconfig');
+const createJiti = require('jiti');
+const config = require('@tailwindcss-mangle/config');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+function _interopNamespaceCompat(e) {
+  if (e && typeof e === 'object' && 'default' in e) return e;
+  const n = Object.create(null);
+  if (e) {
+    for (const k in e) {
+      n[k] = e[k];
+    }
   }
-  return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+  n.default = e;
+  return n;
+}
+
+const fs__default$1 = /*#__PURE__*/_interopDefaultCompat(fs$1);
+const path__default = /*#__PURE__*/_interopDefaultCompat(path);
+const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+const pkg__default = /*#__PURE__*/_interopDefaultCompat(pkg);
+const t__namespace = /*#__PURE__*/_interopNamespaceCompat(t);
+const generate__default = /*#__PURE__*/_interopDefaultCompat(generate);
+const traverse__default = /*#__PURE__*/_interopDefaultCompat(traverse);
+const postcss__default = /*#__PURE__*/_interopDefaultCompat(postcss);
+const createJiti__default = /*#__PURE__*/_interopDefaultCompat(createJiti);
 
-// src/utils.ts
-import fss from "node:fs";
-import fs from "node:fs/promises";
-import pkg from "resolve";
-var { sync } = pkg;
+const { sync } = pkg__default;
 function ensureFileContent(filepaths) {
   if (typeof filepaths === "string") {
     filepaths = [filepaths];
   }
   let content;
   for (const filepath of filepaths) {
-    if (fss.existsSync(filepath)) {
-      content = fss.readFileSync(filepath, {
+    if (fs__default.existsSync(filepath)) {
+      content = fs__default.readFileSync(filepath, {
         encoding: "utf8"
       });
       break;
@@ -48,28 +59,25 @@ function requireResolve(id, opts) {
 }
 async function ensureDir(p) {
   try {
-    await fs.access(p);
+    await fs__default$1.access(p);
   } catch {
-    await fs.mkdir(p, {
+    await fs__default$1.mkdir(p, {
       recursive: true
     });
   }
 }
 
-// src/core/exposeContext.ts
-import path from "node:path";
-import fs2 from "node:fs";
 function getTailwindcssEntry(basedir = process.cwd()) {
   return requireResolve("tailwindcss");
 }
 function getContexts(basedir) {
   const twPath = getTailwindcssEntry(basedir);
-  const distPath = path.dirname(twPath);
-  let injectFilePath = path.join(distPath, "plugin.js");
-  if (!fs2.existsSync(injectFilePath)) {
-    injectFilePath = path.join(distPath, "index.js");
+  const distPath = path__default.dirname(twPath);
+  let injectFilePath = path__default.join(distPath, "plugin.js");
+  if (!fs__default.existsSync(injectFilePath)) {
+    injectFilePath = path__default.join(distPath, "index.js");
   }
-  const mo = __require(injectFilePath);
+  const mo = require(injectFilePath);
   if (mo.contextRef) {
     return mo.contextRef.value;
   }
@@ -95,19 +103,12 @@ function getClassCacheSet(basedir, options) {
   return classSet;
 }
 
-// src/core/cache.ts
-import fs3 from "node:fs";
-import path2 from "node:path";
+const pkgName = "tailwindcss-patch";
 
-// src/constants.ts
-var pkgName = "tailwindcss-patch";
-
-// src/logger.ts
 function log(message, ...optionalParams) {
   return console.log(`[${pkgName}]:` + message, ...optionalParams);
 }
 
-// src/core/cache.ts
 function getCacheOptions(options) {
   let cache;
   switch (typeof options) {
@@ -130,15 +131,14 @@ function getCacheOptions(options) {
   }
   return cache;
 }
-var CacheManager = class {
-  options;
+class CacheManager {
   constructor(options = {}) {
     this.options = this.getOptions(options);
   }
   mkdir(cacheDirectory) {
-    const exists = fs3.existsSync(cacheDirectory);
+    const exists = fs__default.existsSync(cacheDirectory);
     if (!exists) {
-      fs3.mkdirSync(cacheDirectory, {
+      fs__default.mkdirSync(cacheDirectory, {
         recursive: true
       });
     }
@@ -146,9 +146,9 @@ var CacheManager = class {
   }
   getOptions(options = {}) {
     const cwd = options.cwd ?? process.cwd();
-    const dir = options.dir ?? path2.resolve(cwd, "node_modules/.cache", pkgName);
+    const dir = options.dir ?? path__default.resolve(cwd, "node_modules/.cache", pkgName);
     const file = options.file ?? "index.json";
-    const filename = path2.resolve(dir, file);
+    const filename = path__default.resolve(dir, file);
     return {
       cwd,
       dir,
@@ -161,7 +161,7 @@ var CacheManager = class {
     try {
       const { dir, filename } = this.options;
       this.mkdir(dir);
-      fs3.writeFileSync(filename, JSON.stringify([...data], void 0, 2), "utf8");
+      fs__default.writeFileSync(filename, JSON.stringify([...data], void 0, 2), "utf8");
       return filename;
     } catch {
       log("write cache file fail!");
@@ -170,44 +170,77 @@ var CacheManager = class {
   read() {
     const { filename } = this.options;
     try {
-      if (fs3.existsSync(filename)) {
-        const data = fs3.readFileSync(filename, "utf8");
+      if (fs__default.existsSync(filename)) {
+        const data = fs__default.readFileSync(filename, "utf8");
         return new Set(JSON.parse(data));
       }
     } catch {
       log("parse cache content fail! path:" + filename);
       try {
-        fs3.unlinkSync(filename);
+        fs__default.unlinkSync(filename);
       } catch {
         log("delete cache file fail! path:" + filename);
       }
     }
   }
-};
-
-// src/core/inspector.ts
-import * as t from "@babel/types";
+}
 
-// src/babel/index.ts
-import { default as default2 } from "@babel/generator";
-import { default as default3 } from "@babel/traverse";
-import { parse } from "@babel/parser";
+function isObject(value) {
+  return value !== null && typeof value === "object";
+}
+function _defu(baseObject, defaults, namespace = ".", merger) {
+  if (!isObject(defaults)) {
+    return _defu(baseObject, {}, namespace, merger);
+  }
+  const object = Object.assign({}, defaults);
+  for (const key in baseObject) {
+    if (key === "__proto__" || key === "constructor") {
+      continue;
+    }
+    const value = baseObject[key];
+    if (value === null || value === void 0) {
+      continue;
+    }
+    if (merger && merger(object, key, value, namespace)) {
+      continue;
+    }
+    if (Array.isArray(value) && Array.isArray(object[key])) {
+      object[key] = [...value, ...object[key]];
+    } else if (isObject(value) && isObject(object[key])) {
+      object[key] = _defu(
+        value,
+        object[key],
+        (namespace ? `${namespace}.` : "") + key.toString(),
+        merger
+      );
+    } else {
+      object[key] = value;
+    }
+  }
+  return object;
+}
+function createDefu(merger) {
+  return (...arguments_) => (
+    // eslint-disable-next-line unicorn/no-array-reduce
+    arguments_.reduce((p, c) => _defu(p, c, "", merger), {})
+  );
+}
+const defu = createDefu();
 
-// src/core/inspector.ts
 function inspectProcessTailwindFeaturesReturnContext(content) {
-  const ast = parse(content);
+  const ast = parser.parse(content);
   let hasPatched = false;
-  default3(ast, {
+  traverse__default(ast, {
     FunctionDeclaration(p) {
       const n = p.node;
-      if (n.id?.name === "processTailwindFeatures" && n.body.body.length === 1 && t.isReturnStatement(n.body.body[0])) {
+      if (n.id?.name === "processTailwindFeatures" && n.body.body.length === 1 && t__namespace.isReturnStatement(n.body.body[0])) {
         const rts = n.body.body[0];
-        if (t.isFunctionExpression(rts.argument)) {
+        if (t__namespace.isFunctionExpression(rts.argument)) {
           const body = rts.argument.body.body;
           const lastStatement = body.at(-1);
-          hasPatched = t.isReturnStatement(lastStatement) && t.isIdentifier(lastStatement.argument) && lastStatement.argument.name === "context";
+          hasPatched = t__namespace.isReturnStatement(lastStatement) && t__namespace.isIdentifier(lastStatement.argument) && lastStatement.argument.name === "context";
           if (!hasPatched) {
-            const rts2 = t.returnStatement(t.identifier("context"));
+            const rts2 = t__namespace.returnStatement(t__namespace.identifier("context"));
             body.push(rts2);
           }
         }
@@ -215,39 +248,39 @@ function inspectProcessTailwindFeaturesReturnContext(content) {
     }
   });
   return {
-    code: hasPatched ? content : default2(ast).code,
+    code: hasPatched ? content : generate__default(ast).code,
     hasPatched
   };
 }
 function inspectPostcssPlugin(content) {
-  const ast = parse(content);
+  const ast = parser.parse(content);
   const exportKey = "contextRef";
   const variableName = "contextRef";
   const valueKey = "value";
   let hasPatched = false;
-  default3(ast, {
+  traverse__default(ast, {
     Program(p) {
       const n = p.node;
       const idx = n.body.findIndex((x) => {
-        return t.isExpressionStatement(x) && t.isAssignmentExpression(x.expression) && t.isMemberExpression(x.expression.left) && t.isFunctionExpression(x.expression.right) && x.expression.right.id?.name === "tailwindcss";
+        return t__namespace.isExpressionStatement(x) && t__namespace.isAssignmentExpression(x.expression) && t__namespace.isMemberExpression(x.expression.left) && t__namespace.isFunctionExpression(x.expression.right) && x.expression.right.id?.name === "tailwindcss";
       });
       if (idx > -1) {
         const prevStatement = n.body[idx - 1];
         const lastStatement = n.body.at(-1);
-        const hasPatchedCondition0 = prevStatement && t.isVariableDeclaration(prevStatement) && prevStatement.declarations.length === 1 && t.isIdentifier(prevStatement.declarations[0].id) && prevStatement.declarations[0].id.name === variableName;
-        const hasPatchedCondition1 = t.isExpressionStatement(lastStatement) && t.isAssignmentExpression(lastStatement.expression) && t.isIdentifier(lastStatement.expression.right) && lastStatement.expression.right.name === variableName;
+        const hasPatchedCondition0 = prevStatement && t__namespace.isVariableDeclaration(prevStatement) && prevStatement.declarations.length === 1 && t__namespace.isIdentifier(prevStatement.declarations[0].id) && prevStatement.declarations[0].id.name === variableName;
+        const hasPatchedCondition1 = t__namespace.isExpressionStatement(lastStatement) && t__namespace.isAssignmentExpression(lastStatement.expression) && t__namespace.isIdentifier(lastStatement.expression.right) && lastStatement.expression.right.name === variableName;
         hasPatched = hasPatchedCondition0 || hasPatchedCondition1;
         if (!hasPatched) {
-          const statement = t.variableDeclaration("const", [
-            t.variableDeclarator(t.identifier(variableName), t.objectExpression([t.objectProperty(t.identifier(valueKey), t.arrayExpression())]))
+          const statement = t__namespace.variableDeclaration("const", [
+            t__namespace.variableDeclarator(t__namespace.identifier(variableName), t__namespace.objectExpression([t__namespace.objectProperty(t__namespace.identifier(valueKey), t__namespace.arrayExpression())]))
           ]);
           n.body.splice(idx, 0, statement);
           n.body.push(
-            t.expressionStatement(
-              t.assignmentExpression(
+            t__namespace.expressionStatement(
+              t__namespace.assignmentExpression(
                 "=",
-                t.memberExpression(t.memberExpression(t.identifier("module"), t.identifier("exports")), t.identifier(exportKey)),
-                t.identifier(variableName)
+                t__namespace.memberExpression(t__namespace.memberExpression(t__namespace.identifier("module"), t__namespace.identifier("exports")), t__namespace.identifier(exportKey)),
+                t__namespace.identifier(variableName)
               )
             )
           );
@@ -259,41 +292,41 @@ function inspectPostcssPlugin(content) {
         return;
       }
       const n = p.node;
-      if (n.id?.name === "tailwindcss" && n.body.body.length === 1 && t.isReturnStatement(n.body.body[0])) {
-        const returnStatement2 = n.body.body[0];
-        if (t.isObjectExpression(returnStatement2.argument) && returnStatement2.argument.properties.length === 2) {
-          const properties = returnStatement2.argument.properties;
-          if (t.isObjectProperty(properties[0]) && t.isObjectProperty(properties[1])) {
-            const keyMatched = t.isIdentifier(properties[0].key) && properties[0].key.name === "postcssPlugin";
-            const pluginsMatched = t.isIdentifier(properties[1].key) && properties[1].key.name === "plugins";
-            if (pluginsMatched && keyMatched && t.isCallExpression(properties[1].value) && t.isMemberExpression(properties[1].value.callee) && t.isArrayExpression(properties[1].value.callee.object)) {
+      if (n.id?.name === "tailwindcss" && n.body.body.length === 1 && t__namespace.isReturnStatement(n.body.body[0])) {
+        const returnStatement = n.body.body[0];
+        if (t__namespace.isObjectExpression(returnStatement.argument) && returnStatement.argument.properties.length === 2) {
+          const properties = returnStatement.argument.properties;
+          if (t__namespace.isObjectProperty(properties[0]) && t__namespace.isObjectProperty(properties[1])) {
+            const keyMatched = t__namespace.isIdentifier(properties[0].key) && properties[0].key.name === "postcssPlugin";
+            const pluginsMatched = t__namespace.isIdentifier(properties[1].key) && properties[1].key.name === "plugins";
+            if (pluginsMatched && keyMatched && t__namespace.isCallExpression(properties[1].value) && t__namespace.isMemberExpression(properties[1].value.callee) && t__namespace.isArrayExpression(properties[1].value.callee.object)) {
               const pluginsCode = properties[1].value.callee.object.elements;
-              if (pluginsCode[1] && t.isFunctionExpression(pluginsCode[1])) {
+              if (pluginsCode[1] && t__namespace.isFunctionExpression(pluginsCode[1])) {
                 const targetBlockStatement = pluginsCode[1].body;
                 const lastStatement = targetBlockStatement.body.at(-1);
-                if (t.isExpressionStatement(lastStatement)) {
-                  const newExpressionStatement = t.expressionStatement(
-                    t.callExpression(
-                      t.memberExpression(
-                        t.memberExpression(t.identifier(variableName), t.identifier("value")),
-                        t.identifier("push")
+                if (t__namespace.isExpressionStatement(lastStatement)) {
+                  const newExpressionStatement = t__namespace.expressionStatement(
+                    t__namespace.callExpression(
+                      t__namespace.memberExpression(
+                        t__namespace.memberExpression(t__namespace.identifier(variableName), t__namespace.identifier("value")),
+                        t__namespace.identifier("push")
                       ),
                       [lastStatement.expression]
                     )
                   );
                   targetBlockStatement.body[targetBlockStatement.body.length - 1] = newExpressionStatement;
                 }
-                const ifIdx = targetBlockStatement.body.findIndex((x) => t.isIfStatement(x));
+                const ifIdx = targetBlockStatement.body.findIndex((x) => t__namespace.isIfStatement(x));
                 if (ifIdx > -1) {
                   const ifRoot = targetBlockStatement.body[ifIdx];
-                  if (t.isBlockStatement(ifRoot.consequent) && ifRoot.consequent.body[1] && t.isForOfStatement(ifRoot.consequent.body[1])) {
+                  if (t__namespace.isBlockStatement(ifRoot.consequent) && ifRoot.consequent.body[1] && t__namespace.isForOfStatement(ifRoot.consequent.body[1])) {
                     const forOf = ifRoot.consequent.body[1];
-                    if (t.isBlockStatement(forOf.body) && forOf.body.body.length === 1 && t.isIfStatement(forOf.body.body[0])) {
+                    if (t__namespace.isBlockStatement(forOf.body) && forOf.body.body.length === 1 && t__namespace.isIfStatement(forOf.body.body[0])) {
                       const if2 = forOf.body.body[0];
-                      if (t.isBlockStatement(if2.consequent) && if2.consequent.body.length === 1 && t.isExpressionStatement(if2.consequent.body[0])) {
+                      if (t__namespace.isBlockStatement(if2.consequent) && if2.consequent.body.length === 1 && t__namespace.isExpressionStatement(if2.consequent.body[0])) {
                         const target = if2.consequent.body[0];
-                        const newExpressionStatement = t.expressionStatement(
-                          t.callExpression(t.memberExpression(t.memberExpression(t.identifier(variableName), t.identifier("value")), t.identifier("push")), [target.expression])
+                        const newExpressionStatement = t__namespace.expressionStatement(
+                          t__namespace.callExpression(t__namespace.memberExpression(t__namespace.memberExpression(t__namespace.identifier(variableName), t__namespace.identifier("value")), t__namespace.identifier("push")), [target.expression])
                         );
                         if2.consequent.body[0] = newExpressionStatement;
                       }
@@ -304,11 +337,11 @@ function inspectPostcssPlugin(content) {
                   // contentRef.value = []
                   // t.expressionStatement(t.assignmentExpression('=', t.memberExpression(t.identifier(variableName), t.identifier(valueKey)), t.arrayExpression()))
                   // contentRef.value.length = 0
-                  t.expressionStatement(
-                    t.assignmentExpression(
+                  t__namespace.expressionStatement(
+                    t__namespace.assignmentExpression(
                       "=",
-                      t.memberExpression(t.memberExpression(t.identifier(variableName), t.identifier(valueKey)), t.identifier("length")),
-                      t.numericLiteral(0)
+                      t__namespace.memberExpression(t__namespace.memberExpression(t__namespace.identifier(variableName), t__namespace.identifier(valueKey)), t__namespace.identifier("length")),
+                      t__namespace.numericLiteral(0)
                     )
                   )
                 );
@@ -326,79 +359,17 @@ function inspectPostcssPlugin(content) {
     // }
   });
   return {
-    code: hasPatched ? content : default2(ast).code,
+    code: hasPatched ? content : generate__default(ast).code,
     hasPatched
   };
 }
 
-// src/core/runtime-patcher.ts
-import path3 from "node:path";
-import fs4 from "node:fs";
-import { gte } from "semver";
-
-// ../../node_modules/.pnpm/defu@6.1.2/node_modules/defu/dist/defu.mjs
-function isObject(value) {
-  return value !== null && typeof value === "object";
-}
-function _defu(baseObject, defaults, namespace = ".", merger) {
-  if (!isObject(defaults)) {
-    return _defu(baseObject, {}, namespace, merger);
-  }
-  const object = Object.assign({}, defaults);
-  for (const key in baseObject) {
-    if (key === "__proto__" || key === "constructor") {
-      continue;
-    }
-    const value = baseObject[key];
-    if (value === null || value === void 0) {
-      continue;
-    }
-    if (merger && merger(object, key, value, namespace)) {
-      continue;
-    }
-    if (Array.isArray(value) && Array.isArray(object[key])) {
-      object[key] = [...value, ...object[key]];
-    } else if (isObject(value) && isObject(object[key])) {
-      object[key] = _defu(
-        value,
-        object[key],
-        (namespace ? `${namespace}.` : "") + key.toString(),
-        merger
-      );
-    } else {
-      object[key] = value;
-    }
-  }
-  return object;
-}
-function createDefu(merger) {
-  return (...arguments_) => (
-    // eslint-disable-next-line unicorn/no-array-reduce
-    arguments_.reduce((p, c) => _defu(p, c, "", merger), {})
-  );
-}
-var defu = createDefu();
-var defuFn = createDefu((object, key, currentValue) => {
-  if (typeof object[key] !== "undefined" && typeof currentValue === "function") {
-    object[key] = currentValue(object[key]);
-    return true;
-  }
-});
-var defuArrayFn = createDefu((object, key, currentValue) => {
-  if (Array.isArray(object[key]) && typeof currentValue === "function") {
-    object[key] = currentValue(object[key]);
-    return true;
-  }
-});
-
-// src/defaults.ts
 function getDefaultPatchOptions() {
   return {
     overwrite: true
   };
 }
 
-// src/core/runtime-patcher.ts
 function getInstalledPkgJsonPath(options = {}) {
   try {
     const tmpJsonPath = requireResolve(`tailwindcss/package.json`, {
@@ -431,26 +402,26 @@ function createPatch(opt) {
   };
 }
 function monkeyPatchForExposingContext(twDir, opt) {
-  const processTailwindFeaturesFilePath = path3.resolve(twDir, "lib/processTailwindFeatures.js");
+  const processTailwindFeaturesFilePath = path__default.resolve(twDir, "lib/processTailwindFeatures.js");
   const processTailwindFeaturesContent = ensureFileContent(processTailwindFeaturesFilePath);
   const result = {};
   if (processTailwindFeaturesContent) {
     const { code, hasPatched } = inspectProcessTailwindFeaturesReturnContext(processTailwindFeaturesContent);
     if (!hasPatched && opt.overwrite) {
-      fs4.writeFileSync(processTailwindFeaturesFilePath, code, {
+      fs__default.writeFileSync(processTailwindFeaturesFilePath, code, {
         encoding: "utf8"
       });
       console.log("patch tailwindcss processTailwindFeatures for return content successfully!");
     }
     result.processTailwindFeatures = code;
   }
-  const pluginFilePath = path3.resolve(twDir, "lib/plugin.js");
-  const indexFilePath = path3.resolve(twDir, "lib/index.js");
+  const pluginFilePath = path__default.resolve(twDir, "lib/plugin.js");
+  const indexFilePath = path__default.resolve(twDir, "lib/index.js");
   const pluginContent = ensureFileContent([pluginFilePath, indexFilePath]);
   if (pluginContent) {
     const { code, hasPatched } = inspectPostcssPlugin(pluginContent);
     if (!hasPatched && opt.overwrite) {
-      fs4.writeFileSync(pluginFilePath, code, {
+      fs__default.writeFileSync(pluginFilePath, code, {
         encoding: "utf8"
       });
       console.log("patch tailwindcss for expose runtime content successfully!");
@@ -462,9 +433,9 @@ function monkeyPatchForExposingContext(twDir, opt) {
 }
 function internalPatch(pkgJsonPath, options) {
   if (pkgJsonPath) {
-    const pkgJson = __require(pkgJsonPath);
-    const twDir = path3.dirname(pkgJsonPath);
-    if (gte(pkgJson.version, "3.0.0")) {
+    const pkgJson = require(pkgJsonPath);
+    const twDir = path__default.dirname(pkgJsonPath);
+    if (semver.gte(pkgJson.version, "3.0.0")) {
       options.version = pkgJson.version;
       const result = monkeyPatchForExposingContext(twDir, options);
       return result;
@@ -472,22 +443,13 @@ function internalPatch(pkgJsonPath, options) {
   }
 }
 
-// src/core/tw-patcher.ts
-import fs5 from "node:fs/promises";
-import { dirname } from "node:path";
-
-// src/core/postcss.ts
-import path4 from "node:path";
-import postcss from "postcss";
-import { lilconfig } from "lilconfig";
-import createJiti from "jiti";
-var jiti = createJiti(__filename);
+const jiti = createJiti__default(__filename);
 async function processTailwindcss(options) {
   options.cwd = options.cwd ?? process.cwd();
   let config = options.config;
-  if (!(typeof options.config === "string" && path4.isAbsolute(options.config))) {
+  if (!(typeof options.config === "string" && path__default.isAbsolute(options.config))) {
     const moduleName = "tailwind";
-    const result = await lilconfig("tailwindcss", {
+    const result = await lilconfig.lilconfig("tailwindcss", {
       searchPlaces: [`${moduleName}.config.js`, `${moduleName}.config.cjs`],
       loaders: {
         // 默认支持 js 和 cjs 2种格式
@@ -502,8 +464,8 @@ async function processTailwindcss(options) {
     }
     config = result.filepath;
   }
-  return await postcss([
-    __require("tailwindcss")({
+  return await postcss__default([
+    require("tailwindcss")({
       config
     })
   ]).process("@tailwind base;@tailwind components;@tailwind utilities;", {
@@ -511,13 +473,7 @@ async function processTailwindcss(options) {
   });
 }
 
-// src/core/tw-patcher.ts
-var TailwindcssPatcher = class {
-  rawOptions;
-  cacheOptions;
-  patchOptions;
-  patch;
-  cacheManager;
+class TailwindcssPatcher {
   constructor(options = {}) {
     this.rawOptions = options;
     this.cacheOptions = getCacheOptions(options.cache);
@@ -572,61 +528,32 @@ var TailwindcssPatcher = class {
         removeUniversalSelector
       });
       if (filename) {
-        await ensureDir(dirname(filename));
+        await ensureDir(path.dirname(filename));
         const classList = [...set];
-        await fs5.writeFile(filename, JSON.stringify(classList, null, loose ? 2 : void 0), "utf8");
+        await fs__default$1.writeFile(filename, JSON.stringify(classList, null, loose ? 2 : void 0), "utf8");
         return filename;
       }
     }
   }
-};
+}
 
-// src/core/index.ts
-var core_exports = {};
-__export(core_exports, {
-  CacheManager: () => CacheManager,
-  TailwindcssPatcher: () => TailwindcssPatcher,
-  createPatch: () => createPatch,
-  getCacheOptions: () => getCacheOptions,
-  getClassCacheSet: () => getClassCacheSet,
-  getClassCaches: () => getClassCaches,
-  getContexts: () => getContexts,
-  getInstalledPkgJsonPath: () => getInstalledPkgJsonPath,
-  getPatchOptions: () => getPatchOptions,
-  getTailwindcssEntry: () => getTailwindcssEntry,
-  inspectPostcssPlugin: () => inspectPostcssPlugin,
-  inspectProcessTailwindFeaturesReturnContext: () => inspectProcessTailwindFeaturesReturnContext,
-  internalPatch: () => internalPatch,
-  monkeyPatchForExposingContext: () => monkeyPatchForExposingContext
+exports.CacheManager = CacheManager;
+exports.TailwindcssPatcher = TailwindcssPatcher;
+exports.createPatch = createPatch;
+exports.ensureDir = ensureDir;
+exports.ensureFileContent = ensureFileContent;
+exports.getCacheOptions = getCacheOptions;
+exports.getClassCacheSet = getClassCacheSet;
+exports.getClassCaches = getClassCaches;
+exports.getContexts = getContexts;
+exports.getInstalledPkgJsonPath = getInstalledPkgJsonPath;
+exports.getPatchOptions = getPatchOptions;
+exports.getTailwindcssEntry = getTailwindcssEntry;
+exports.inspectPostcssPlugin = inspectPostcssPlugin;
+exports.inspectProcessTailwindFeaturesReturnContext = inspectProcessTailwindFeaturesReturnContext;
+exports.internalPatch = internalPatch;
+exports.monkeyPatchForExposingContext = monkeyPatchForExposingContext;
+exports.requireResolve = requireResolve;
+Object.keys(config).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = config[k];
 });
-
-// src/core/config.ts
-var config_exports = {};
-__reExport(config_exports, config_star);
-import * as config_star from "@tailwindcss-mangle/config";
-
-// src/core/index.ts
-__reExport(core_exports, config_exports);
-
-export {
-  __export,
-  __reExport,
-  ensureFileContent,
-  requireResolve,
-  ensureDir,
-  getTailwindcssEntry,
-  getContexts,
-  getClassCaches,
-  getClassCacheSet,
-  getCacheOptions,
-  CacheManager,
-  inspectProcessTailwindFeaturesReturnContext,
-  inspectPostcssPlugin,
-  getInstalledPkgJsonPath,
-  getPatchOptions,
-  createPatch,
-  monkeyPatchForExposingContext,
-  internalPatch,
-  TailwindcssPatcher,
-  core_exports
-};