tailwindcss-patch 5.0.0-alpha.0 → 5.0.1-alpha.0

package/dist/cli.cjs

@@ -0,0 +1,960 @@
+"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 __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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+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
+));
+
+// ../../node_modules/.pnpm/tsup@8.3.5_jiti@2.3.3_postcss@8.4.47_tsx@4.19.2_typescript@5.6.3_yaml@2.6.0/node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.src || new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+
+// src/cli.ts
+var import_node_process4 = __toESM(require("process"), 1);
+var import_cac = __toESM(require("cac"), 1);
+
+// src/config.ts
+var config_exports = {};
+__reExport(config_exports, require("@tailwindcss-mangle/config"));
+
+// src/core/cache.ts
+var import_node_process = __toESM(require("process"), 1);
+var import_fs_extra = __toESM(require("fs-extra"), 1);
+var import_pathe = __toESM(require("pathe"), 1);
+
+// src/constants.ts
+var pkgName = "tailwindcss-patch";
+
+// src/logger.ts
+var import_consola = require("consola");
+var logger = (0, import_consola.createConsola)();
+var logger_default = logger;
+
+// src/core/cache.ts
+function getCacheOptions(options) {
+  let cache;
+  switch (typeof options) {
+    case "undefined": {
+      cache = {
+        enable: false
+      };
+      break;
+    }
+    case "boolean": {
+      cache = {
+        enable: options
+      };
+      break;
+    }
+    case "object": {
+      cache = { ...options, enable: true };
+      break;
+    }
+  }
+  return cache;
+}
+var CacheManager = class {
+  options;
+  constructor(options = {}) {
+    this.options = this.getOptions(options);
+  }
+  getOptions(options = {}) {
+    const cwd = options.cwd ?? import_node_process.default.cwd();
+    const dir = options.dir ?? import_pathe.default.resolve(cwd, "node_modules/.cache", pkgName);
+    const file = options.file ?? "index.json";
+    const filename = import_pathe.default.resolve(dir, file);
+    return {
+      cwd,
+      dir,
+      file,
+      filename,
+      strategy: "merge"
+    };
+  }
+  write(data) {
+    try {
+      const { dir, filename } = this.options;
+      import_fs_extra.default.ensureDirSync(dir);
+      import_fs_extra.default.outputFileSync(filename, JSON.stringify([...data], void 0, 2), "utf8");
+      return filename;
+    } catch {
+      logger_default.error("write cache file fail!");
+    }
+  }
+  read() {
+    const { filename } = this.options;
+    try {
+      if (import_fs_extra.default.existsSync(filename)) {
+        const data = import_fs_extra.default.readFileSync(filename, "utf8");
+        return new Set(JSON.parse(data));
+      }
+    } catch {
+      logger_default.error(`parse cache content fail! path:${filename}`);
+      try {
+        import_fs_extra.default.unlinkSync(filename);
+      } catch {
+        logger_default.error(`delete cache file fail! path:${filename}`);
+      }
+    }
+  }
+};
+
+// src/core/patcher.ts
+var import_node_module3 = require("module");
+var import_fs_extra5 = __toESM(require("fs-extra"), 1);
+var import_pathe7 = __toESM(require("pathe"), 1);
+
+// src/defaults.ts
+var import_node_process2 = __toESM(require("process"), 1);
+
+// ../../node_modules/.pnpm/defu@6.1.4/node_modules/defu/dist/defu.mjs
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== null && prototype !== Object.prototype && Object.getPrototypeOf(prototype) !== null) {
+    return false;
+  }
+  if (Symbol.iterator in value) {
+    return false;
+  }
+  if (Symbol.toStringTag in value) {
+    return Object.prototype.toString.call(value) === "[object Module]";
+  }
+  return true;
+}
+function _defu(baseObject, defaults, namespace = ".", merger) {
+  if (!isPlainObject(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 (isPlainObject(value) && isPlainObject(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 (object[key] !== void 0 && 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;
+  }
+});
+
+// ../shared/src/utils.ts
+var defuOverrideArray = createDefu((obj, key, value) => {
+  if (Array.isArray(obj[key]) && Array.isArray(value)) {
+    obj[key] = value;
+    return true;
+  }
+});
+var preserveClassNames = [
+  // https://tailwindcss.com/docs/transition-timing-function start
+  // https://github.com/sonofmagic/tailwindcss-mangle/issues/21
+  "ease-out",
+  "ease-linear",
+  "ease-in",
+  "ease-in-out"
+  // https://tailwindcss.com/docs/transition-timing-function end
+];
+var preserveClassNamesMap = preserveClassNames.reduce((acc, cur) => {
+  acc[cur] = true;
+  return acc;
+}, {});
+var acceptChars = [..."abcdefghijklmnopqrstuvwxyz"];
+
+// src/defaults.ts
+function getDefaultPatchOptions() {
+  return {
+    applyPatches: {
+      exportContext: true,
+      extendLengthUnits: false
+    },
+    overwrite: true
+  };
+}
+function getPatchOptions(options) {
+  return defu(
+    options,
+    {
+      basedir: import_node_process2.default.cwd()
+    },
+    getDefaultPatchOptions()
+  );
+}
+
+// src/utils.ts
+var import_fs_extra2 = __toESM(require("fs-extra"), 1);
+var import_pathe2 = __toESM(require("pathe"), 1);
+var import_resolve = __toESM(require("resolve"), 1);
+var { sync } = import_resolve.default;
+function requireResolve(id, opts) {
+  return sync(id, opts);
+}
+function searchPackageJSON(dir) {
+  let packageJsonPath;
+  while (true) {
+    if (!dir) {
+      return;
+    }
+    const newDir = import_pathe2.default.dirname(dir);
+    if (newDir === dir) {
+      return;
+    }
+    dir = newDir;
+    packageJsonPath = import_pathe2.default.join(dir, "package.json");
+    if (import_fs_extra2.default.existsSync(packageJsonPath)) {
+      break;
+    }
+  }
+  return packageJsonPath;
+}
+function getTailwindcssEntry(name = "tailwindcss", opts) {
+  return requireResolve(name, opts);
+}
+function getPackageJsonPath(name, options = {}) {
+  const entry = getTailwindcssEntry(name, options);
+  if (!entry) {
+    return;
+  }
+  return searchPackageJSON(entry);
+}
+function getPackageInfoSync(name, options = {}) {
+  const packageJsonPath = getPackageJsonPath(name, options);
+  if (!packageJsonPath) {
+    return;
+  }
+  const packageJson = JSON.parse(import_fs_extra2.default.readFileSync(packageJsonPath, "utf8"));
+  return {
+    name,
+    version: packageJson.version,
+    rootPath: import_pathe2.default.dirname(packageJsonPath),
+    packageJsonPath,
+    packageJson
+  };
+}
+function isObject(val) {
+  return val !== null && typeof val === "object" && Array.isArray(val) === false;
+}
+
+// src/core/postcss.ts
+var import_node_module = require("module");
+var import_node_process3 = __toESM(require("process"), 1);
+var import_lilconfig = require("lilconfig");
+var import_pathe3 = __toESM(require("pathe"), 1);
+var import_postcss = __toESM(require("postcss"), 1);
+var require2 = (0, import_node_module.createRequire)(importMetaUrl);
+async function processTailwindcss(options) {
+  const { config: userConfig, cwd } = defu(options, {
+    cwd: import_node_process3.default.cwd()
+  });
+  let config = userConfig;
+  if (!(typeof config === "string" && import_pathe3.default.isAbsolute(config))) {
+    const moduleName = "tailwind";
+    const tsx = (await import("tsx/cjs/api")).require;
+    const result = await (0, import_lilconfig.lilconfig)("tailwindcss", {
+      searchPlaces: [
+        `${moduleName}.config.js`,
+        `${moduleName}.config.cjs`,
+        `${moduleName}.config.mjs`,
+        `${moduleName}.config.ts`,
+        `${moduleName}.config.cts`,
+        `${moduleName}.config.mts`
+      ],
+      loaders: {
+        // 默认支持 js 和 cjs 2种格式
+        ".js": tsx,
+        ".cjs": tsx,
+        ".mjs": tsx,
+        ".ts": tsx,
+        ".cts": tsx,
+        ".mts": tsx
+      }
+    }).search(cwd);
+    if (!result) {
+      throw new Error(`No TailwindCSS Config found in: ${cwd}`);
+    }
+    config = result.filepath;
+  }
+  const id = requireResolve("tailwindcss", {
+    basedir: cwd
+  });
+  return await (0, import_postcss.default)([
+    require2(id)({
+      config
+    })
+  ]).process("@tailwind base;@tailwind components;@tailwind utilities;", {
+    from: void 0
+  });
+}
+
+// src/core/runtime.ts
+var import_node_module2 = require("module");
+var import_pathe6 = __toESM(require("pathe"), 1);
+var import_semver = require("semver");
+
+// src/core/patches/exportContext/index.ts
+var import_fs_extra3 = __toESM(require("fs-extra"), 1);
+var import_pathe4 = __toESM(require("pathe"), 1);
+
+// src/core/patches/exportContext/postcss-v2.ts
+var t = __toESM(require("@babel/types"), 1);
+
+// src/babel/index.ts
+var import_generator = __toESM(require("@babel/generator"), 1);
+var import_traverse = __toESM(require("@babel/traverse"), 1);
+var import_parser = require("@babel/parser");
+function _interopDefaultCompat(e) {
+  return e && typeof e === "object" && "default" in e ? e.default : e;
+}
+var generate = _interopDefaultCompat(import_generator.default);
+var traverse = _interopDefaultCompat(import_traverse.default);
+
+// src/core/patches/exportContext/postcss-v2.ts
+function inspectProcessTailwindFeaturesReturnContext(content) {
+  const ast = (0, import_parser.parse)(content, {
+    sourceType: "unambiguous"
+  });
+  let hasPatched = false;
+  traverse(ast, {
+    FunctionDeclaration(p) {
+      const n = p.node;
+      if (n.id?.name === "processTailwindFeatures" && n.body.body.length === 1 && t.isReturnStatement(n.body.body[0])) {
+        const rts = n.body.body[0];
+        if (t.isFunctionExpression(rts.argument)) {
+          const body = rts.argument.body.body;
+          const lastStatement = body[body.length - 1];
+          hasPatched = t.isReturnStatement(lastStatement) && t.isIdentifier(lastStatement.argument) && lastStatement.argument.name === "context";
+          if (!hasPatched) {
+            const rts2 = t.returnStatement(t.identifier("context"));
+            body.push(rts2);
+          }
+        }
+      }
+    }
+  });
+  return {
+    code: hasPatched ? content : generate(ast).code,
+    hasPatched
+  };
+}
+function inspectPostcssPlugin(content) {
+  const ast = (0, import_parser.parse)(content);
+  const exportKey = "contextRef";
+  const variableName = "contextRef";
+  const valueKey = "value";
+  let hasPatched = false;
+  traverse(ast, {
+    Program(p) {
+      const n = p.node;
+      const idx = n.body.findIndex((x) => {
+        return t.isFunctionDeclaration(x) && x.id?.name === "_default";
+      });
+      if (idx > -1) {
+        const prevStatement = n.body[idx - 1];
+        const lastStatement = n.body[idx - 2];
+        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;
+        hasPatched = hasPatchedCondition0 || hasPatchedCondition1;
+        if (!hasPatched) {
+          const statement = t.variableDeclaration("var", [
+            t.variableDeclarator(t.identifier(variableName), t.objectExpression([t.objectProperty(t.identifier(valueKey), t.arrayExpression())]))
+          ]);
+          n.body.splice(
+            idx,
+            0,
+            statement,
+            // exports.contextRef = contextRef;
+            t.expressionStatement(
+              t.assignmentExpression(
+                "=",
+                t.memberExpression(t.identifier("exports"), t.identifier(exportKey)),
+                t.identifier(variableName)
+              )
+            )
+          );
+        }
+      }
+    },
+    FunctionDeclaration(p) {
+      if (hasPatched) {
+        return;
+      }
+      const n = p.node;
+      if (n.id?.name === "_default" && n.body.body.length === 1 && t.isReturnStatement(n.body.body[0])) {
+        const returnStatement3 = n.body.body[0];
+        if (t.isCallExpression(returnStatement3.argument) && t.isMemberExpression(returnStatement3.argument.callee) && t.isArrayExpression(returnStatement3.argument.callee.object)) {
+          const targetFn = returnStatement3.argument.callee.object.elements[1];
+          if (t.isFunctionExpression(targetFn)) {
+            const targetBlockStatement = targetFn.body;
+            if (t.isExpressionStatement(targetBlockStatement.body[0]) && t.isAssignmentExpression(targetBlockStatement.body[0].expression) && t.isNumericLiteral(targetBlockStatement.body[0].expression.right)) {
+              hasPatched = true;
+              return;
+            }
+            const lastStatement = targetBlockStatement.body[targetBlockStatement.body.length - 1];
+            if (t.isExpressionStatement(lastStatement)) {
+              const newExpressionStatement = t.expressionStatement(
+                t.callExpression(
+                  t.memberExpression(
+                    t.memberExpression(t.identifier(variableName), t.identifier("value")),
+                    t.identifier("push")
+                  ),
+                  [lastStatement.expression]
+                )
+              );
+              targetBlockStatement.body[targetBlockStatement.body.length - 1] = newExpressionStatement;
+            }
+            const ifIdx = targetBlockStatement.body.findIndex((x) => t.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])) {
+                const forOf = ifRoot.consequent.body[1];
+                if (t.isBlockStatement(forOf.body) && forOf.body.body.length === 1 && t.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])) {
+                    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])
+                    );
+                    if2.consequent.body[0] = newExpressionStatement;
+                  }
+                }
+              }
+            }
+            targetBlockStatement.body.unshift(
+              // 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.memberExpression(t.memberExpression(t.identifier(variableName), t.identifier(valueKey)), t.identifier("length")),
+                  t.numericLiteral(0)
+                )
+              )
+            );
+          }
+        }
+      }
+    }
+  });
+  return {
+    code: hasPatched ? content : generate(ast).code,
+    hasPatched
+  };
+}
+
+// src/core/patches/exportContext/postcss-v3.ts
+var t2 = __toESM(require("@babel/types"), 1);
+function inspectProcessTailwindFeaturesReturnContext2(content) {
+  const ast = (0, import_parser.parse)(content);
+  let hasPatched = false;
+  traverse(ast, {
+    FunctionDeclaration(p) {
+      const n = p.node;
+      if (n.id?.name === "processTailwindFeatures" && n.body.body.length === 1 && t2.isReturnStatement(n.body.body[0])) {
+        const rts = n.body.body[0];
+        if (t2.isFunctionExpression(rts.argument)) {
+          const body = rts.argument.body.body;
+          const lastStatement = body[body.length - 1];
+          hasPatched = t2.isReturnStatement(lastStatement) && t2.isIdentifier(lastStatement.argument) && lastStatement.argument.name === "context";
+          if (!hasPatched) {
+            const rts2 = t2.returnStatement(t2.identifier("context"));
+            body.push(rts2);
+          }
+        }
+      }
+    }
+  });
+  return {
+    code: hasPatched ? content : generate(ast).code,
+    hasPatched
+  };
+}
+function inspectPostcssPlugin2(content) {
+  const ast = (0, import_parser.parse)(content);
+  const exportKey = "contextRef";
+  const variableName = "contextRef";
+  const valueKey = "value";
+  let hasPatched = false;
+  traverse(ast, {
+    Program(p) {
+      const n = p.node;
+      const idx = n.body.findIndex((x) => {
+        return t2.isExpressionStatement(x) && t2.isAssignmentExpression(x.expression) && t2.isMemberExpression(x.expression.left) && t2.isFunctionExpression(x.expression.right) && x.expression.right.id?.name === "tailwindcss";
+      });
+      if (idx > -1) {
+        const prevStatement = n.body[idx - 1];
+        const lastStatement = n.body[n.body.length - 1];
+        const hasPatchedCondition0 = prevStatement && t2.isVariableDeclaration(prevStatement) && prevStatement.declarations.length === 1 && t2.isIdentifier(prevStatement.declarations[0].id) && prevStatement.declarations[0].id.name === variableName;
+        const hasPatchedCondition1 = t2.isExpressionStatement(lastStatement) && t2.isAssignmentExpression(lastStatement.expression) && t2.isIdentifier(lastStatement.expression.right) && lastStatement.expression.right.name === variableName;
+        hasPatched = hasPatchedCondition0 || hasPatchedCondition1;
+        if (!hasPatched) {
+          const statement = t2.variableDeclaration("const", [
+            t2.variableDeclarator(t2.identifier(variableName), t2.objectExpression([t2.objectProperty(t2.identifier(valueKey), t2.arrayExpression())]))
+          ]);
+          n.body.splice(idx, 0, statement);
+          n.body.push(
+            t2.expressionStatement(
+              t2.assignmentExpression(
+                "=",
+                t2.memberExpression(t2.memberExpression(t2.identifier("module"), t2.identifier("exports")), t2.identifier(exportKey)),
+                t2.identifier(variableName)
+              )
+            )
+          );
+        }
+      }
+    },
+    FunctionExpression(p) {
+      if (hasPatched) {
+        return;
+      }
+      const n = p.node;
+      if (n.id?.name === "tailwindcss" && n.body.body.length === 1 && t2.isReturnStatement(n.body.body[0])) {
+        const returnStatement3 = n.body.body[0];
+        if (t2.isObjectExpression(returnStatement3.argument) && returnStatement3.argument.properties.length === 2) {
+          const properties = returnStatement3.argument.properties;
+          if (t2.isObjectProperty(properties[0]) && t2.isObjectProperty(properties[1])) {
+            const keyMatched = t2.isIdentifier(properties[0].key) && properties[0].key.name === "postcssPlugin";
+            const pluginsMatched = t2.isIdentifier(properties[1].key) && properties[1].key.name === "plugins";
+            if (pluginsMatched && keyMatched && t2.isCallExpression(properties[1].value) && t2.isMemberExpression(properties[1].value.callee) && t2.isArrayExpression(properties[1].value.callee.object)) {
+              const pluginsCode = properties[1].value.callee.object.elements;
+              if (pluginsCode[1] && t2.isFunctionExpression(pluginsCode[1])) {
+                const targetBlockStatement = pluginsCode[1].body;
+                const lastStatement = targetBlockStatement.body[targetBlockStatement.body.length - 1];
+                if (t2.isExpressionStatement(lastStatement)) {
+                  const newExpressionStatement = t2.expressionStatement(
+                    t2.callExpression(
+                      t2.memberExpression(
+                        t2.memberExpression(t2.identifier(variableName), t2.identifier("value")),
+                        t2.identifier("push")
+                      ),
+                      [lastStatement.expression]
+                    )
+                  );
+                  targetBlockStatement.body[targetBlockStatement.body.length - 1] = newExpressionStatement;
+                }
+                const ifIdx = targetBlockStatement.body.findIndex((x) => t2.isIfStatement(x));
+                if (ifIdx > -1) {
+                  const ifRoot = targetBlockStatement.body[ifIdx];
+                  if (t2.isBlockStatement(ifRoot.consequent) && ifRoot.consequent.body[1] && t2.isForOfStatement(ifRoot.consequent.body[1])) {
+                    const forOf = ifRoot.consequent.body[1];
+                    if (t2.isBlockStatement(forOf.body) && forOf.body.body.length === 1 && t2.isIfStatement(forOf.body.body[0])) {
+                      const if2 = forOf.body.body[0];
+                      if (t2.isBlockStatement(if2.consequent) && if2.consequent.body.length === 1 && t2.isExpressionStatement(if2.consequent.body[0])) {
+                        const target = if2.consequent.body[0];
+                        const newExpressionStatement = t2.expressionStatement(
+                          t2.callExpression(t2.memberExpression(t2.memberExpression(t2.identifier(variableName), t2.identifier("value")), t2.identifier("push")), [target.expression])
+                        );
+                        if2.consequent.body[0] = newExpressionStatement;
+                      }
+                    }
+                  }
+                }
+                targetBlockStatement.body.unshift(
+                  // contentRef.value = []
+                  // t.expressionStatement(t.assignmentExpression('=', t.memberExpression(t.identifier(variableName), t.identifier(valueKey)), t.arrayExpression()))
+                  // contentRef.value.length = 0
+                  t2.expressionStatement(
+                    t2.assignmentExpression(
+                      "=",
+                      t2.memberExpression(t2.memberExpression(t2.identifier(variableName), t2.identifier(valueKey)), t2.identifier("length")),
+                      t2.numericLiteral(0)
+                    )
+                  )
+                );
+              }
+            }
+          }
+        }
+      }
+    }
+    // BlockStatement(p) {
+    //   const n = p.node
+    //   if (start && p.parent.type === 'FunctionExpression' && !p.parent.id) {
+    //     n.body.unshift(t.expressionStatement(t.assignmentExpression('=', t.memberExpression(t.identifier(variableName), t.identifier(valueKey)), t.arrayExpression())))
+    //   }
+    // }
+  });
+  return {
+    code: hasPatched ? content : generate(ast).code,
+    hasPatched
+  };
+}
+
+// src/core/patches/exportContext/index.ts
+function monkeyPatchForExposingContextV3(twDir, opt) {
+  const k0 = "lib/processTailwindFeatures.js";
+  const processTailwindFeaturesFilePath = import_pathe4.default.resolve(twDir, k0);
+  const processTailwindFeaturesContent = import_fs_extra3.default.readFileSync(processTailwindFeaturesFilePath, "utf8");
+  const result = {};
+  if (processTailwindFeaturesContent) {
+    const { code, hasPatched } = inspectProcessTailwindFeaturesReturnContext2(processTailwindFeaturesContent);
+    if (!hasPatched && opt.overwrite) {
+      import_fs_extra3.default.writeFileSync(processTailwindFeaturesFilePath, code, {
+        encoding: "utf8"
+      });
+      logger_default.success("patch tailwindcss processTailwindFeatures for return context successfully!");
+    }
+    result[k0] = code;
+  }
+  let injectFilepath;
+  let k1;
+  const try0 = "lib/plugin.js";
+  const try1 = "lib/index.js";
+  const pluginFilePath = import_pathe4.default.resolve(twDir, try0);
+  const indexFilePath = import_pathe4.default.resolve(twDir, try1);
+  if (import_fs_extra3.default.existsSync(pluginFilePath)) {
+    k1 = try0;
+    injectFilepath = pluginFilePath;
+  } else if (import_fs_extra3.default.existsSync(indexFilePath)) {
+    k1 = try1;
+    injectFilepath = indexFilePath;
+  }
+  if (injectFilepath && k1) {
+    const pluginContent = import_fs_extra3.default.readFileSync(injectFilepath, "utf8");
+    if (pluginContent) {
+      const { code, hasPatched } = inspectPostcssPlugin2(pluginContent);
+      if (!hasPatched && opt.overwrite) {
+        import_fs_extra3.default.writeFileSync(injectFilepath, code, {
+          encoding: "utf8"
+        });
+        logger_default.success("patch tailwindcss for expose runtime context successfully!");
+      }
+      result[k1] = code;
+    }
+    return result;
+  }
+}
+function monkeyPatchForExposingContextV2(twDir, opt) {
+  const k0 = "lib/jit/processTailwindFeatures.js";
+  const processTailwindFeaturesFilePath = import_pathe4.default.resolve(twDir, k0);
+  const processTailwindFeaturesContent = import_fs_extra3.default.readFileSync(processTailwindFeaturesFilePath, "utf8");
+  const result = {};
+  if (processTailwindFeaturesContent) {
+    const { code, hasPatched } = inspectProcessTailwindFeaturesReturnContext(processTailwindFeaturesContent);
+    if (!hasPatched && opt.overwrite) {
+      import_fs_extra3.default.writeFileSync(processTailwindFeaturesFilePath, code, {
+        encoding: "utf8"
+      });
+      logger_default.success("patch tailwindcss processTailwindFeatures for return content successfully!");
+    }
+    result[k0] = code;
+  }
+  const k1 = "lib/jit/index.js";
+  const indexFilePath = import_pathe4.default.resolve(twDir, k1);
+  const pluginContent = import_fs_extra3.default.readFileSync(indexFilePath, "utf8");
+  if (pluginContent) {
+    const { code, hasPatched } = inspectPostcssPlugin(pluginContent);
+    if (!hasPatched && opt.overwrite) {
+      import_fs_extra3.default.writeFileSync(indexFilePath, code, {
+        encoding: "utf8"
+      });
+      logger_default.success("patch tailwindcss for expose runtime content successfully!");
+    }
+    result[k1] = code;
+  }
+  return result;
+}
+
+// src/core/patches/supportCustomUnits/index.ts
+var t3 = __toESM(require("@babel/types"), 1);
+var import_fs_extra4 = __toESM(require("fs-extra"), 1);
+var import_pathe5 = __toESM(require("pathe"), 1);
+function findAstNode(content, options) {
+  const { variableName, units } = options;
+  const ast = (0, import_parser.parse)(content);
+  let arrayRef;
+  let changed = false;
+  traverse(ast, {
+    Identifier(path8) {
+      if (path8.node.name === variableName && t3.isVariableDeclarator(path8.parent) && t3.isArrayExpression(path8.parent.init)) {
+        arrayRef = path8.parent.init;
+        const set = new Set(path8.parent.init.elements.map((x) => x.value));
+        for (let i = 0; i < units.length; i++) {
+          const unit = units[i];
+          if (!set.has(unit)) {
+            path8.parent.init.elements = path8.parent.init.elements.map((x) => {
+              if (t3.isStringLiteral(x)) {
+                return {
+                  type: x?.type,
+                  value: x?.value
+                };
+              }
+              return x;
+            });
+            path8.parent.init.elements.push({
+              type: "StringLiteral",
+              value: unit
+            });
+            changed = true;
+          }
+        }
+      }
+    }
+  });
+  return {
+    arrayRef,
+    changed
+  };
+}
+function monkeyPatchForSupportingCustomUnit(rootDir, options) {
+  const opts = defuOverrideArray(options, {
+    units: ["rpx"],
+    lengthUnitsFilePath: "lib/util/dataTypes.js",
+    variableName: "lengthUnits",
+    overwrite: true
+  });
+  const { lengthUnitsFilePath, overwrite, destPath } = opts;
+  const dataTypesFilePath = import_pathe5.default.resolve(rootDir, lengthUnitsFilePath);
+  const dataTypesFileContent = import_fs_extra4.default.readFileSync(dataTypesFilePath, {
+    encoding: "utf8"
+  });
+  const { arrayRef, changed } = findAstNode(dataTypesFileContent, opts);
+  if (arrayRef && changed) {
+    const { code } = generate(arrayRef, {
+      jsescOption: {
+        quotes: "single"
+      }
+    });
+    if (arrayRef.start && arrayRef.end) {
+      const prev = dataTypesFileContent.slice(0, arrayRef.start);
+      const next = dataTypesFileContent.slice(arrayRef.end);
+      const newCode = prev + code + next;
+      if (overwrite) {
+        import_fs_extra4.default.writeFileSync(destPath ?? dataTypesFilePath, newCode, {
+          encoding: "utf8"
+        });
+        logger_default.success("patch tailwindcss for custom length unit successfully!");
+      }
+    }
+    return {
+      [opts.lengthUnitsFilePath]: code
+    };
+  }
+}
+
+// src/core/runtime.ts
+var require3 = (0, import_node_module2.createRequire)(importMetaUrl);
+function internalPatch(pkgJsonPath, options) {
+  if (pkgJsonPath) {
+    const pkgJson = require3(pkgJsonPath);
+    const twDir = import_pathe6.default.dirname(pkgJsonPath);
+    options.version = pkgJson.version;
+    if ((0, import_semver.gte)(pkgJson.version, "3.0.0")) {
+      let result = {};
+      if (options.applyPatches?.exportContext) {
+        result = monkeyPatchForExposingContextV3(twDir, options);
+      }
+      if (options.applyPatches?.extendLengthUnits) {
+        try {
+          Object.assign(result ?? {}, monkeyPatchForSupportingCustomUnit(twDir, defu(options.applyPatches.extendLengthUnits === true ? void 0 : options.applyPatches.extendLengthUnits, {
+            overwrite: options.overwrite
+          })));
+        } catch {
+        }
+      }
+      return result;
+    } else if ((0, import_semver.gte)(pkgJson.version, "2.0.0")) {
+      if (options.applyPatches?.exportContext) {
+        return monkeyPatchForExposingContextV2(twDir, options);
+      }
+    }
+  }
+}
+
+// src/core/patcher.ts
+var require4 = (0, import_node_module3.createRequire)(importMetaUrl);
+var TailwindcssPatcher = class {
+  rawOptions;
+  cacheOptions;
+  patchOptions;
+  patch;
+  cacheManager;
+  packageInfo;
+  majorVersion;
+  constructor(options = {}) {
+    this.rawOptions = options;
+    this.cacheOptions = getCacheOptions(options.cache);
+    this.patchOptions = getPatchOptions(options.patch);
+    this.cacheManager = new CacheManager(this.cacheOptions);
+    this.packageInfo = getPackageInfoSync("tailwindcss", { basedir: this.patchOptions.basedir });
+    if (this.packageInfo && this.packageInfo.version) {
+      this.majorVersion = Number.parseInt(this.packageInfo.version[0]);
+    }
+    this.patch = () => {
+      try {
+        return internalPatch(this.packageInfo?.packageJsonPath, this.patchOptions);
+      } catch (error) {
+        logger_default.error(`patch tailwindcss failed: ${error.message}`);
+      }
+    };
+  }
+  setCache(set) {
+    if (this.cacheOptions.enable) {
+      return this.cacheManager.write(set);
+    }
+  }
+  getCache() {
+    return this.cacheManager.read();
+  }
+  getContexts() {
+    if (this.packageInfo) {
+      const distPath = import_pathe7.default.join(this.packageInfo.rootPath, "lib");
+      let injectFilePath;
+      if (this.majorVersion === 2) {
+        injectFilePath = import_pathe7.default.join(distPath, "jit/index.js");
+      } else {
+        injectFilePath = import_pathe7.default.join(distPath, "plugin.js");
+        if (!import_fs_extra5.default.existsSync(injectFilePath)) {
+          injectFilePath = import_pathe7.default.join(distPath, "index.js");
+        }
+      }
+      if (injectFilePath) {
+        const mo = require4(injectFilePath);
+        if (mo.contextRef) {
+          return mo.contextRef.value;
+        }
+      }
+    }
+    return [];
+  }
+  getClassCaches() {
+    const contexts = this.getContexts();
+    return contexts.filter((x) => isObject(x)).map((x) => x.classCache);
+  }
+  getClassCacheSet(options) {
+    const classCaches = this.getClassCaches();
+    const classSet = /* @__PURE__ */ new Set();
+    for (const classCacheMap of classCaches) {
+      const keys = classCacheMap.keys();
+      for (const key of keys) {
+        const v = key.toString();
+        if (options?.removeUniversalSelector && v === "*") {
+          continue;
+        }
+        classSet.add(v);
+      }
+    }
+    return classSet;
+  }
+  /**
+   * @description 在多个 tailwindcss 上下文时，这个方法将被执行多次，所以策略上应该使用 append
+   */
+  getClassSet(options) {
+    const { cacheStrategy = this.cacheOptions.strategy ?? "merge", removeUniversalSelector = true } = options ?? {};
+    const set = this.getClassCacheSet({
+      removeUniversalSelector
+    });
+    if (cacheStrategy === "overwrite") {
+      set.size > 0 && this.setCache(set);
+    } else if (cacheStrategy === "merge") {
+      const cacheSet = this.getCache();
+      if (cacheSet) {
+        for (const x of cacheSet) {
+          set.add(x);
+        }
+      }
+      this.setCache(set);
+    }
+    return set;
+  }
+  async extract(options) {
+    const { output, tailwindcss } = options ?? {};
+    if (output && tailwindcss) {
+      const { removeUniversalSelector, filename, loose } = output;
+      await processTailwindcss(tailwindcss);
+      const set = this.getClassSet({
+        removeUniversalSelector
+      });
+      if (filename) {
+        await import_fs_extra5.default.ensureDir(import_pathe7.default.dirname(filename));
+        const classList = [...set];
+        await import_fs_extra5.default.outputJSON(filename, classList, {
+          spaces: loose ? 2 : void 0
+        });
+        return filename;
+      }
+    }
+  }
+};
+
+// src/cli.ts
+function init() {
+  const cwd = import_node_process4.default.cwd();
+  return (0, config_exports.initConfig)(cwd);
+}
+var cli = (0, import_cac.default)();
+cli.command("install", "patch install").action(() => {
+  const twPatcher = new TailwindcssPatcher({
+    patch: getPatchOptions()
+  });
+  twPatcher.patch();
+});
+cli.command("init").action(async () => {
+  await init();
+  logger_default.success(`\u2728 ${config_exports.configName}.config.ts initialized!`);
+});
+cli.command("extract").action(async () => {
+  const { config } = await (0, config_exports.getConfig)();
+  if (config) {
+    const twPatcher = new TailwindcssPatcher();
+    const p = await twPatcher.extract(config.patch);
+    logger_default.success(`\u2728 tailwindcss-patch extract success! file path: ${p}`);
+  }
+});
+cli.help();
+cli.parse();