weapp-tailwindcss 4.11.0-alpha.1 → 4.11.0-alpha.2

package/dist/cli.js

@@ -1,40 +1,899 @@
-"use strict"; function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+"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 __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
+));
 
+// src/cli.ts
+var import_node_process17 = __toESM(require("process"));
+var import_semver = __toESM(require("semver"));
+var import_tailwindcss_patch3 = require("tailwindcss-patch");
 
+// src/cli/context.ts
+var import_node_path12 = __toESM(require("path"));
+var import_node_process11 = __toESM(require("process"));
 
+// src/context/index.ts
+var import_promises2 = require("fs/promises");
+var import_logger10 = require("@weapp-tailwindcss/logger");
 
-var _chunkG5NLM3ALjs = require('./chunk-G5NLM3AL.js');
+// src/cache/index.ts
+var import_lru_cache = require("lru-cache");
 
+// src/cache/md5.ts
+var import_node = require("@weapp-tailwindcss/shared/node");
 
+// src/defaults.ts
+var import_escape = require("@weapp-core/escape");
 
-var _chunk4LPOQMFSjs = require('./chunk-4LPOQMFS.js');
-require('./chunk-ACTJYB33.js');
-require('./chunk-DYLQ6UOI.js');
-require('./chunk-OV7FX6XR.js');
+// src/utils/index.ts
+var import_shared = require("@weapp-tailwindcss/shared");
 
-// src/cli.ts
-var _process = require('process'); var _process2 = _interopRequireDefault(_process);
-var _semver = require('semver'); var _semver2 = _interopRequireDefault(_semver);
-var _tailwindcsspatch = require('tailwindcss-patch');
+// src/utils/hbuilderx.ts
+var import_node_path = __toESM(require("path"));
+var import_node_process = __toESM(require("process"));
 
-// src/cli/context.ts
-var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+// src/utils/uni-platform.ts
+var import_node_process2 = __toESM(require("process"));
+
+// src/debug/index.ts
+var import_debug = __toESM(require("debug"));
+var _debug = (0, import_debug.default)("weapp-tw");
+function createDebug(prefix) {
+  const debug3 = ((formatter, ...args) => {
+    return _debug((prefix ?? "") + formatter, ...args);
+  });
+  Object.defineProperty(debug3, "enabled", {
+    enumerable: false,
+    configurable: false,
+    get() {
+      return _debug.enabled;
+    }
+  });
+  return debug3;
+}
+
+// src/tailwindcss/runtime/cache.ts
+var import_node_fs = require("fs");
+
+// src/tailwindcss/runtime.ts
+var debug = createDebug("[tailwindcss:runtime] ");
+
+// src/tailwindcss/targets.ts
+var import_node_process5 = __toESM(require("process"));
+var import_logger2 = require("@weapp-tailwindcss/logger");
+
+// src/tailwindcss/targets/paths.ts
+var import_node_fs3 = require("fs");
+var import_node_path3 = __toESM(require("path"));
+
+// src/context/workspace.ts
+var import_node_fs2 = require("fs");
+var import_node_path2 = __toESM(require("path"));
+function findWorkspaceRoot(startDir) {
+  if (!startDir) {
+    return void 0;
+  }
+  let current = import_node_path2.default.resolve(startDir);
+  while (true) {
+    const workspaceFile = import_node_path2.default.join(current, "pnpm-workspace.yaml");
+    if ((0, import_node_fs2.existsSync)(workspaceFile)) {
+      return current;
+    }
+    const parent = import_node_path2.default.dirname(current);
+    if (parent === current) {
+      return void 0;
+    }
+    current = parent;
+  }
+}
+function findNearestPackageRoot(startDir) {
+  if (!startDir) {
+    return void 0;
+  }
+  let current = import_node_path2.default.resolve(startDir);
+  while (true) {
+    const pkgPath = import_node_path2.default.join(current, "package.json");
+    if ((0, import_node_fs2.existsSync)(pkgPath)) {
+      return current;
+    }
+    const parent = import_node_path2.default.dirname(current);
+    if (parent === current) {
+      return void 0;
+    }
+    current = parent;
+  }
+}
+
+// src/tailwindcss/targets/paths.ts
+var PATCH_INFO_FILENAME = "tailwindcss-target.json";
+var PATCH_INFO_CACHE_RELATIVE_PATH = import_node_path3.default.join("node_modules", ".cache", "weapp-tailwindcss", PATCH_INFO_FILENAME);
+var PATCH_INFO_LEGACY_RELATIVE_PATH = import_node_path3.default.join(".tw-patch", PATCH_INFO_FILENAME);
+function formatRelativeToBase(targetPath, baseDir) {
+  if (!baseDir) {
+    return import_node_path3.default.normalize(targetPath);
+  }
+  const relative = import_node_path3.default.relative(baseDir, targetPath);
+  if (!relative || relative === ".") {
+    return ".";
+  }
+  if (relative.startsWith("..")) {
+    return import_node_path3.default.normalize(targetPath);
+  }
+  return import_node_path3.default.join(".", relative);
+}
+function resolveRecordLocation(baseDir) {
+  const normalizedBase = import_node_path3.default.normalize(baseDir);
+  const packageRoot = findNearestPackageRoot(normalizedBase) ?? normalizedBase;
+  const packageJsonPath = import_node_path3.default.join(packageRoot, "package.json");
+  const hasPackageJson = (0, import_node_fs3.existsSync)(packageJsonPath);
+  const recordKeySource = hasPackageJson ? packageJsonPath : normalizedBase;
+  const recordKey = (0, import_node.md5)(import_node_path3.default.normalize(recordKeySource));
+  const recordDir = import_node_path3.default.join(packageRoot, "node_modules", ".cache", "weapp-tailwindcss", recordKey);
+  const recordPath = import_node_path3.default.join(recordDir, PATCH_INFO_FILENAME);
+  return {
+    normalizedBase,
+    packageRoot,
+    recordDir,
+    recordKey,
+    recordPath,
+    packageJsonPath: hasPackageJson ? packageJsonPath : void 0
+  };
+}
+function getRecordFileCandidates(baseDir) {
+  const { normalizedBase, packageRoot, recordPath } = resolveRecordLocation(baseDir);
+  const candidates = /* @__PURE__ */ new Set([
+    recordPath,
+    import_node_path3.default.join(packageRoot, PATCH_INFO_CACHE_RELATIVE_PATH),
+    import_node_path3.default.join(normalizedBase, PATCH_INFO_CACHE_RELATIVE_PATH),
+    import_node_path3.default.join(normalizedBase, PATCH_INFO_LEGACY_RELATIVE_PATH)
+  ]);
+  return [...candidates];
+}
+
+// src/tailwindcss/targets/record-io.ts
+var import_node_fs4 = require("fs");
+var import_promises = require("fs/promises");
+var import_node_path4 = __toESM(require("path"));
+var import_node_process3 = __toESM(require("process"));
+var import_logger = require("@weapp-tailwindcss/logger");
+
+// package.json
+var package_default = {
+  name: "weapp-tailwindcss",
+  version: "4.11.0-alpha.2",
+  description: "\u628A tailwindcss \u539F\u5B50\u5316\u6837\u5F0F\u601D\u60F3\uFF0C\u5E26\u7ED9\u5C0F\u7A0B\u5E8F\u5F00\u53D1\u8005\u4EEC! bring tailwindcss to miniprogram developers!",
+  author: "ice breaker <1324318532@qq.com>",
+  license: "MIT",
+  homepage: "https://tw.icebreaker.top",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/sonofmagic/weapp-tailwindcss.git",
+    directory: "packages/weapp-tailwindcss"
+  },
+  bugs: {
+    url: "https://github.com/sonofmagic/weapp-tailwindcss/issues"
+  },
+  keywords: [
+    "tailwindcss",
+    "weapp",
+    "wechat",
+    "mini",
+    "miniprogram",
+    "mini app",
+    "weapp-tw",
+    "weapp-tailwindcss",
+    "taro",
+    "uni-app",
+    "remax",
+    "rax",
+    "mpx",
+    "jit",
+    "mp",
+    "android",
+    "ios",
+    "\u5C0F\u7A0B\u5E8F",
+    "vite",
+    "postcss",
+    "webpack",
+    "webpack-plugin",
+    "gulp",
+    "gulp-plugin"
+  ],
+  exports: {
+    ".": {
+      style: "./index.css",
+      types: "./dist/index.d.ts",
+      import: "./dist/index.mjs",
+      require: "./dist/index.js"
+    },
+    "./escape": {
+      types: "./dist/escape.d.ts",
+      import: "./dist/escape.mjs",
+      require: "./dist/escape.js"
+    },
+    "./vite": {
+      types: "./dist/vite.d.ts",
+      import: "./dist/vite.mjs",
+      require: "./dist/vite.js"
+    },
+    "./webpack": {
+      types: "./dist/webpack.d.ts",
+      import: "./dist/webpack.mjs",
+      require: "./dist/webpack.js"
+    },
+    "./webpack4": {
+      types: "./dist/webpack4.d.ts",
+      import: "./dist/webpack4.mjs",
+      require: "./dist/webpack4.js"
+    },
+    "./core": {
+      types: "./dist/core.d.ts",
+      import: "./dist/core.mjs",
+      require: "./dist/core.js"
+    },
+    "./gulp": {
+      types: "./dist/gulp.d.ts",
+      import: "./dist/gulp.mjs",
+      require: "./dist/gulp.js"
+    },
+    "./defaults": {
+      types: "./dist/defaults.d.ts",
+      import: "./dist/defaults.mjs",
+      require: "./dist/defaults.js"
+    },
+    "./presets": {
+      types: "./dist/presets.d.ts",
+      import: "./dist/presets.mjs",
+      require: "./dist/presets.js"
+    },
+    "./reset": {
+      types: "./dist/reset.d.ts",
+      import: "./dist/reset.mjs",
+      require: "./dist/reset.js"
+    },
+    "./css-macro/postcss": {
+      types: "./dist/css-macro/postcss.d.ts",
+      import: "./dist/css-macro/postcss.mjs",
+      require: "./dist/css-macro/postcss.js"
+    },
+    "./css-macro": {
+      types: "./dist/css-macro.d.ts",
+      import: "./dist/css-macro.mjs",
+      require: "./dist/css-macro.js"
+    },
+    "./types": {
+      types: "./dist/types.d.ts",
+      import: "./dist/types.mjs",
+      require: "./dist/types.js"
+    },
+    "./postcss-html-transform": {
+      types: "./dist/postcss-html-transform.d.ts",
+      import: "./dist/postcss-html-transform.mjs",
+      require: "./dist/postcss-html-transform.js"
+    },
+    "./package.json": "./package.json",
+    "./index.css": "./index.css",
+    "./index": "./index.css",
+    "./preflight.css": "./preflight.css",
+    "./preflight": "./preflight.css",
+    "./theme.css": "./theme.css",
+    "./theme": "./theme.css",
+    "./utilities.css": "./utilities.css",
+    "./utilities": "./utilities.css",
+    "./with-layer.css": "./with-layer.css",
+    "./with-layer": "./with-layer.css",
+    "./uni-app-x": "./uni-app-x.css",
+    "./uni-app-x.css": "./uni-app-x.css",
+    "./css": "./css/index.css",
+    "./*": "./*"
+  },
+  main: "./dist/index.js",
+  module: "./dist/index.mjs",
+  types: "./dist/index.d.ts",
+  style: "index.css",
+  typesVersions: {
+    "*": {
+      "*": [
+        "./dist/*",
+        "./dist/index.d.ts"
+      ]
+    }
+  },
+  bin: {
+    "weapp-tailwindcss-webpack-plugin": "bin/weapp-tailwindcss.js",
+    "weapp-tailwindcss": "bin/weapp-tailwindcss.js",
+    "weapp-tw": "bin/weapp-tailwindcss.js"
+  },
+  files: [
+    "bin",
+    "css",
+    "dist",
+    "index.css",
+    "preflight.css",
+    "theme.css",
+    "uni-app-x.css",
+    "utilities.css",
+    "with-layer.css"
+  ],
+  engines: {
+    node: "^18.17.0 || >=20.5.0"
+  },
+  scripts: {
+    dev: "tsup --watch --sourcemap",
+    build: "tsup && node scripts/ensure-escape-dts.mjs",
+    "build:tsc": "cross-env NODE_ENV=development tsc --build tsconfig.json",
+    "build:cli": "cd plugins/cli && pnpm run build",
+    "build:css": "tsx scripts/build-css.ts",
+    "build:weapp-theme": "tsx scripts/build-weapp-theme.ts",
+    test: "npm run postinstall && vitest run",
+    "test:dev": "vitest",
+    "test:ui": "vitest --ui",
+    bench: "vitest bench --config ./vitest.config.ts",
+    "bench:vite-perf": "tsx scripts/vite-perf-bench.ts",
+    "bench:vite-perf:summary": "tsx scripts/vite-perf-summary.ts",
+    "bench:js-handlers": "tsx scripts/js-bench.ts",
+    "bench:js-diff": "tsx scripts/js-bench-diff.ts",
+    tsd: "tsd",
+    clean: "tsx scripts/clean.ts",
+    "get-decl": "tsx scripts/get-decl.ts",
+    "ls:pack": "npm pack --dry-run",
+    "cli:patch": "node bin/weapp-tailwindcss.js patch",
+    colors: "tsx scripts/colors.ts",
+    release: "tsx scripts/release.ts",
+    lint: "eslint .",
+    "lint:fix": "eslint ./src --fix",
+    postinstall: "node bin/weapp-tailwindcss.js patch",
+    "bench:vite-dev-hmr": "tsx scripts/vite-dev-hmr-bench.ts",
+    "test:watch-hmr": "node --import tsx scripts/watch-hmr-regression/index.ts"
+  },
+  publishConfig: {
+    access: "public",
+    registry: "https://registry.npmjs.org"
+  },
+  dependencies: {
+    "@ast-core/escape": "~1.0.1",
+    "@babel/parser": "~7.29.2",
+    "@babel/traverse": "~7.29.0",
+    "@babel/types": "~7.29.0",
+    "@tailwindcss-mangle/config": "^6.1.3",
+    "@vue/compiler-dom": "catalog:vue3",
+    "@vue/compiler-sfc": "catalog:vue3",
+    "@weapp-core/escape": "~7.0.0",
+    "@weapp-core/regex": "~1.0.1",
+    "@weapp-tailwindcss/logger": "workspace:*",
+    "@weapp-tailwindcss/postcss": "workspace:*",
+    "@weapp-tailwindcss/shared": "workspace:*",
+    cac: "6.7.14",
+    debug: "~4.4.3",
+    "fast-glob": "^3.3.3",
+    htmlparser2: "10.1.0",
+    "loader-utils": "2.0.4",
+    "local-pkg": "^1.1.2",
+    "lru-cache": "10.4.3",
+    "magic-string": "0.30.21",
+    semver: "~7.7.4",
+    "tailwindcss-patch": "catalog:tailwindcssPatch",
+    "webpack-sources": "3.3.4",
+    yaml: "^2.8.3"
+  }
+};
+
+// src/constants.ts
+var WEAPP_TW_REQUIRED_NODE_VERSION = "18.17.0";
+var WEAPP_TW_VERSION = package_default.version;
+
+// src/tailwindcss/targets/record-io.ts
+var loggedInvalidPatchRecords = /* @__PURE__ */ new Set();
+function warnInvalidPatchTargetRecord(baseDir, recordPath, reason) {
+  const normalizedPath = import_node_path4.default.normalize(recordPath);
+  if (loggedInvalidPatchRecords.has(normalizedPath)) {
+    return;
+  }
+  loggedInvalidPatchRecords.add(normalizedPath);
+  const fileDisplay = formatRelativeToBase(normalizedPath, baseDir);
+  const baseDisplay = formatRelativeToBase(import_node_path4.default.normalize(baseDir), import_node_process3.default.cwd());
+  const reasonMessage = reason ? `\uFF1A${reason}` : "";
+  import_logger.logger.warn(
+    `\u68C0\u6D4B\u5230\u635F\u574F\u7684 Tailwind CSS \u76EE\u6807\u8BB0\u5F55 ${fileDisplay}${reasonMessage}\u3002\u8BF7\u5728 ${baseDisplay} \u91CD\u65B0\u6267\u884C "weapp-tw patch --record-target" \u6216\u5220\u9664\u8BE5\u6587\u4EF6\u540E\u518D\u8FD0\u884C\u3002`
+  );
+}
+function readPatchTargetRecord(baseDir) {
+  if (!baseDir) {
+    return void 0;
+  }
+  const normalizedBase = import_node_path4.default.normalize(baseDir);
+  for (const recordPath of getRecordFileCandidates(normalizedBase)) {
+    if (!(0, import_node_fs4.existsSync)(recordPath)) {
+      continue;
+    }
+    try {
+      const content = (0, import_node_fs4.readFileSync)(recordPath, "utf8");
+      const parsed = JSON.parse(content);
+      if (!parsed || typeof parsed.tailwindPackagePath !== "string") {
+        warnInvalidPatchTargetRecord(normalizedBase, recordPath, "\u7F3A\u5C11 tailwindPackagePath \u5B57\u6BB5");
+        continue;
+      }
+      return {
+        baseDir: normalizedBase,
+        path: recordPath,
+        record: parsed
+      };
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      warnInvalidPatchTargetRecord(normalizedBase, recordPath, reason);
+      continue;
+    }
+  }
+  return void 0;
+}
+async function saveCliPatchTargetRecord(baseDir, patcher, options) {
+  if (!baseDir || !patcher?.packageInfo?.rootPath) {
+    return void 0;
+  }
+  const normalizedBase = import_node_path4.default.normalize(baseDir);
+  const location = resolveRecordLocation(normalizedBase);
+  const recordPath = options?.recordPath ? import_node_path4.default.normalize(options.recordPath) : location.recordPath;
+  const record = {
+    tailwindPackagePath: import_node_path4.default.normalize(patcher.packageInfo.rootPath),
+    packageVersion: patcher.packageInfo.version,
+    recordedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    source: options?.source ?? "cli",
+    tailwindcssBasedir: normalizedBase,
+    cwd: options?.cwd ? import_node_path4.default.normalize(options.cwd) : normalizedBase,
+    patchVersion: WEAPP_TW_VERSION,
+    packageJsonPath: options?.packageJsonPath ?? location.packageJsonPath,
+    recordKey: options?.recordKey ?? location.recordKey
+  };
+  try {
+    await (0, import_promises.mkdir)(import_node_path4.default.dirname(recordPath), { recursive: true });
+    await (0, import_promises.writeFile)(recordPath, `${JSON.stringify(record, null, 2)}
+`, "utf8");
+    return recordPath;
+  } catch (error) {
+    const baseDisplay = formatRelativeToBase(normalizedBase, import_node_process3.default.cwd());
+    import_logger.logger.warn(
+      '\u81EA\u52A8\u66F4\u65B0 Tailwind CSS \u8865\u4E01\u8BB0\u5F55\u5931\u8D25\uFF0C\u8BF7\u5728 %s \u8FD0\u884C "weapp-tw patch --cwd %s"\u3002',
+      baseDisplay,
+      normalizedBase
+    );
+    import_logger.logger.debug("failed to persist patch target record %s: %O", recordPath, error);
+    return void 0;
+  }
+}
+
+// src/tailwindcss/targets/recorder.ts
+var import_node_path5 = __toESM(require("path"));
+var import_node_process4 = __toESM(require("process"));
+function findPatchTargetRecord(baseDir) {
+  const visited = /* @__PURE__ */ new Set();
+  const fallback = baseDir ?? import_node_process4.default.cwd();
+  let current = import_node_path5.default.resolve(fallback);
+  while (!visited.has(current)) {
+    const record = readPatchTargetRecord(current);
+    if (record) {
+      return record;
+    }
+    const parent = import_node_path5.default.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    visited.add(current);
+    current = parent;
+  }
+  return void 0;
+}
+function createPatchTargetRecorder(baseDir, patcher, options) {
+  if (!baseDir || !patcher?.packageInfo?.rootPath || options?.recordTarget === false) {
+    return void 0;
+  }
+  const normalizedBase = import_node_path5.default.normalize(baseDir);
+  const recorded = findPatchTargetRecord(normalizedBase);
+  const location = resolveRecordLocation(normalizedBase);
+  const expectedPath = import_node_path5.default.normalize(patcher.packageInfo.rootPath);
+  let reason;
+  if (!recorded) {
+    reason = "missing";
+  } else {
+    const normalizedRecorded = import_node_path5.default.normalize(recorded.record.tailwindPackagePath);
+    if (normalizedRecorded !== expectedPath) {
+      reason = "mismatch";
+    } else if (import_node_path5.default.normalize(recorded.path) !== import_node_path5.default.normalize(location.recordPath) || !recorded.record.recordKey || recorded.record.recordKey !== location.recordKey) {
+      reason = "migrate";
+    } else if (!recorded.record.patchVersion || recorded.record.patchVersion !== WEAPP_TW_VERSION) {
+      reason = "stale";
+    } else if (options?.cwd && recorded.record.cwd && import_node_path5.default.normalize(recorded.record.cwd) !== import_node_path5.default.normalize(options.cwd)) {
+      reason = "metadata";
+    } else if (!recorded.record.cwd && options?.cwd) {
+      reason = "metadata";
+    }
+  }
+  const shouldPersist = options?.alwaysRecord || !recorded || Boolean(reason);
+  if (!shouldPersist) {
+    return void 0;
+  }
+  let message;
+  switch (reason) {
+    case "mismatch":
+      message = "\u68C0\u6D4B\u5230 Tailwind CSS \u76EE\u6807\u8BB0\u5F55\u4E0E\u5F53\u524D\u89E3\u6790\u7ED3\u679C\u4E0D\u4E00\u81F4\uFF0C\u6B63\u5728\u81EA\u52A8\u91CD\u65B0 patch \u5E76\u5237\u65B0\u7F13\u5B58\u3002";
+      break;
+    case "migrate":
+    case "stale":
+      message = "\u6B63\u5728\u5237\u65B0\u5F53\u524D\u5B50\u5305\u7684 Tailwind CSS \u8865\u4E01\u8BB0\u5F55\uFF0C\u786E\u4FDD\u7F13\u5B58\u9694\u79BB\u3002";
+      break;
+    case "missing":
+      message = "\u672A\u627E\u5230\u5F53\u524D\u5B50\u5305\u7684 Tailwind CSS \u76EE\u6807\u8BB0\u5F55\uFF0C\u6B63\u5728\u751F\u6210\u3002";
+      break;
+    default:
+      break;
+  }
+  const onPatched = async () => saveCliPatchTargetRecord(normalizedBase, patcher, {
+    cwd: options?.cwd ?? normalizedBase,
+    source: options?.source ?? "cli",
+    recordPath: location.recordPath,
+    recordKey: location.recordKey,
+    packageJsonPath: location.packageJsonPath
+  });
+  return {
+    recordPath: location.recordPath,
+    message,
+    reason,
+    onPatched
+  };
+}
+
+// src/tailwindcss/targets.ts
+function logTailwindcssTarget(kind, patcher, baseDir) {
+  const packageInfo = patcher?.packageInfo;
+  const label = kind === "cli" ? "weapp-tw patch" : "tailwindcss-patcher";
+  if (!packageInfo?.rootPath) {
+    import_logger2.logger.warn(
+      "%s \u672A\u627E\u5230 Tailwind CSS \u4F9D\u8D56\uFF0C\u8BF7\u68C0\u67E5\u5728 %s \u662F\u5426\u5DF2\u5B89\u88C5 tailwindcss",
+      label,
+      baseDir ?? import_node_process5.default.cwd()
+    );
+    return;
+  }
+  const displayPath = formatRelativeToBase(packageInfo.rootPath, baseDir);
+  const version = packageInfo.version ? ` (v${packageInfo.version})` : "";
+  import_logger2.logger.info("%s \u7ED1\u5B9A Tailwind CSS -> %s%s", label, displayPath, version);
+}
+
+// src/tailwindcss/v4/config.ts
+var import_logger3 = require("@weapp-tailwindcss/logger");
+
+// src/tailwindcss/v4/patcher.ts
+var import_logger5 = require("@weapp-tailwindcss/logger");
+
+// src/tailwindcss/patcher.ts
+var import_node_path7 = __toESM(require("path"));
+var import_node_process7 = __toESM(require("process"));
+var import_logger4 = require("@weapp-tailwindcss/logger");
+var import_shared2 = require("@weapp-tailwindcss/shared");
+var import_tailwindcss_patch = require("tailwindcss-patch");
+
+// src/tailwindcss/patcher-resolve.ts
+var import_node_fs5 = require("fs");
+var import_node_module = require("module");
+var import_node_path6 = __toESM(require("path"));
+var import_node_process6 = __toESM(require("process"));
+var import_node_url = require("url");
+
+// src/tailwindcss/v4/css-entries.ts
+var import_node_path8 = __toESM(require("path"));
+
+// src/context/compiler-context-cache.ts
+var import_node_buffer = require("buffer");
+var import_node_path9 = __toESM(require("path"));
+var import_node_process8 = __toESM(require("process"));
+var import_logger6 = require("@weapp-tailwindcss/logger");
+var globalCacheHolder = globalThis;
+var compilerContextCache = globalCacheHolder.__WEAPP_TW_COMPILER_CONTEXT_CACHE__ ?? (globalCacheHolder.__WEAPP_TW_COMPILER_CONTEXT_CACHE__ = /* @__PURE__ */ new Map());
+
+// src/context/handlers.ts
+var import_postcss = require("@weapp-tailwindcss/postcss");
+
+// src/babel/index.ts
+var import_traverse = __toESM(require("@babel/traverse"));
+var import_parser = require("@babel/parser");
+function _interopDefaultCompat(e) {
+  return e && typeof e === "object" && "default" in e ? e.default : e;
+}
+var traverse = _interopDefaultCompat(import_traverse.default);
+
+// src/utils/nameMatcher.ts
+var import_regex = require("@weapp-core/regex");
+
+// src/js/babel/parse.ts
+var import_lru_cache2 = require("lru-cache");
+var parseCache = new import_lru_cache2.LRUCache(
+  {
+    max: 1024
+  }
+);
+
+// src/js/babel/process.ts
+var import_magic_string = __toESM(require("magic-string"));
+
+// src/js/handlers.ts
+var import_escape3 = require("@ast-core/escape");
+var import_extractors = require("@weapp-tailwindcss/shared/extractors");
+
+// src/wxml/shared.ts
+var import_escape2 = require("@weapp-core/escape");
+
+// src/js/handlers.ts
+var debug2 = createDebug("[js:handlers] ");
+
+// src/js/evalTransforms.ts
+var import_escape4 = require("@ast-core/escape");
+
+// src/wxml/utils/codegen/legacy-rewriter.ts
+var import_magic_string2 = __toESM(require("magic-string"));
+
+// src/wxml/utils/codegen/legacy-visitor.ts
+var t = __toESM(require("@babel/types"));
+
+// src/wxml/utils/codegen.ts
+var WRAP_EXPRESSION_HANDLER_OPTIONS = Object.freeze({
+  wrapExpression: true
+});
+
+// src/wxml/utils/custom-template.ts
+var import_htmlparser2 = require("htmlparser2");
+var import_magic_string4 = __toESM(require("magic-string"));
+
+// src/wxml/utils/template-fragments.ts
+var import_magic_string3 = __toESM(require("magic-string"));
+
+// src/wxml/whitespace.ts
+var WHITESPACE_CODES = /* @__PURE__ */ new Set([
+  9,
+  // 制表符 \t
+  10,
+  // 换行符 \n
+  11,
+  // 垂直制表符 \v
+  12,
+  // 换页符 \f
+  13,
+  // 回车符 \r
+  32,
+  // 空格
+  160,
+  // 不间断空格 \u00A0
+  65279
+  // 零宽无断行空格 \uFEFF
+]);
+function isWhitespace(char) {
+  if (char.length === 0) {
+    return false;
+  }
+  return WHITESPACE_CODES.has(char.charCodeAt(0));
+}
 
+// src/wxml/Tokenizer.ts
+var Tokenizer = class {
+  constructor() {
+    this.reset();
+  }
+  processChar(char, index) {
+    switch (this.state) {
+      case 0 /* START */:
+        if (isWhitespace(char)) {
+        } else if (char === "{") {
+          this.state = 2 /* OPEN_BRACE */;
+          this.bufferStartIndex = index;
+          this.buffer += char;
+          this.expressionBuffer = char;
+          this.expressionStartIndex = index;
+        } else {
+          this.state = 1 /* TEXT */;
+          this.bufferStartIndex = index;
+          this.buffer += char;
+        }
+        break;
+      case 1 /* TEXT */:
+        if (isWhitespace(char)) {
+          this.tokens.push({ start: this.bufferStartIndex, end: index, value: this.buffer, expressions: this.expressions });
+          this.buffer = "";
+          this.expressions = [];
+          this.state = 0 /* START */;
+        } else if (char === "{") {
+          this.buffer += char;
+          this.expressionBuffer = char;
+          this.expressionStartIndex = index;
+          this.state = 2 /* OPEN_BRACE */;
+        } else {
+          this.buffer += char;
+        }
+        break;
+      case 2 /* OPEN_BRACE */:
+        if (char === "}") {
+          this.buffer += char;
+          this.expressionBuffer += char;
+          this.state = 3 /* POTENTIAL_CLOSE */;
+        } else {
+          this.buffer += char;
+          this.expressionBuffer += char;
+        }
+        break;
+      case 3 /* POTENTIAL_CLOSE */:
+        if (char === "}") {
+          this.buffer += char;
+          this.expressionBuffer += char;
+          this.expressions.push({
+            start: this.expressionStartIndex,
+            end: index + 1,
+            value: this.expressionBuffer
+          });
+          this.expressionBuffer = "";
+          this.state = 4 /* BRACES_COMPLETE */;
+        } else {
+          this.buffer += char;
+          this.expressionBuffer += char;
+          this.state = 2 /* OPEN_BRACE */;
+        }
+        break;
+      case 4 /* BRACES_COMPLETE */:
+        if (isWhitespace(char)) {
+          this.tokens.push({
+            start: this.bufferStartIndex,
+            end: index,
+            value: this.buffer,
+            expressions: this.expressions
+          });
+          this.buffer = "";
+          this.expressions = [];
+          this.state = 0 /* START */;
+        } else if (char === "{") {
+          this.expressionStartIndex = index;
+          this.expressionBuffer = char;
+          this.buffer += char;
+          this.state = 2 /* OPEN_BRACE */;
+        } else {
+          this.buffer += char;
+          this.state = 1 /* TEXT */;
+        }
+        break;
+      default:
+        throw new Error("Unexpected state");
+    }
+  }
+  run(input) {
+    this.reset();
+    for (let i = 0; i < input.length; i++) {
+      const char = input[i];
+      this.processChar(char, i);
+    }
+    if (this.buffer.length > 0) {
+      this.tokens.push({
+        start: this.bufferStartIndex,
+        end: input.length,
+        value: this.buffer,
+        expressions: this.expressions
+      });
+    }
+    const tokens = this.tokens;
+    this.reset();
+    return tokens;
+  }
+  reset() {
+    this.state = 0 /* START */;
+    this.buffer = "";
+    this.tokens = [];
+    this.bufferStartIndex = 0;
+    this.expressionBuffer = "";
+    this.expressionStartIndex = 0;
+    this.expressions = [];
+  }
+};
+
+// src/wxml/utils/template-fragments.ts
+var sharedTokenizer = new Tokenizer();
+
+// src/context/logger.ts
+var import_logger7 = require("@weapp-tailwindcss/logger");
+
+// src/context/tailwindcss.ts
+var import_logger9 = require("@weapp-tailwindcss/logger");
+
+// src/context/tailwindcss/basedir.ts
+var import_node_module2 = require("module");
+var import_node_path10 = __toESM(require("path"));
+var import_node_process9 = __toESM(require("process"));
+var import_node_url2 = require("url");
+var import_logger8 = require("@weapp-tailwindcss/logger");
+
+// src/context/tailwindcss/rax.ts
+var import_node_fs6 = require("fs");
+var import_node_path11 = __toESM(require("path"));
+var import_node_process10 = __toESM(require("process"));
+
+// src/context/index.ts
+async function clearTailwindcssPatcherCache(patcher, options) {
+  if (!patcher) {
+    return;
+  }
+  const cacheOptions = patcher.options?.cache;
+  if (cacheOptions == null || typeof cacheOptions === "object" && cacheOptions.enabled === false) {
+    return;
+  }
+  if (typeof patcher.clearCache === "function") {
+    try {
+      await patcher.clearCache({ scope: "all" });
+    } catch (error) {
+      import_logger10.logger.debug("failed to clear tailwindcss patcher cache via clearCache(): %O", error);
+    }
+  }
+  if (!options?.removeDirectory) {
+    return;
+  }
+  const cachePaths = /* @__PURE__ */ new Map();
+  const normalizedCacheOptions = typeof cacheOptions === "object" ? cacheOptions : void 0;
+  if (normalizedCacheOptions?.path) {
+    cachePaths.set(normalizedCacheOptions.path, false);
+  }
+  const privateCachePath = patcher?.cacheStore?.options?.path;
+  if (privateCachePath) {
+    cachePaths.set(privateCachePath, false);
+  }
+  if (options?.removeDirectory && normalizedCacheOptions?.dir) {
+    cachePaths.set(normalizedCacheOptions.dir, true);
+  }
+  if (!cachePaths.size) {
+    return;
+  }
+  for (const [cachePath, recursive] of cachePaths.entries()) {
+    try {
+      await (0, import_promises2.rm)(cachePath, { force: true, recursive });
+    } catch (error) {
+      const err = error;
+      if (err?.code === "ENOENT") {
+        continue;
+      }
+      import_logger10.logger.debug("failed to clear tailwindcss patcher cache: %s %O", cachePath, err);
+    }
+  }
+}
+
+// src/cli/context.ts
 function formatOutputPath(target, baseDir) {
-  const root = _nullishCoalesce(baseDir, () => ( _process2.default.cwd()));
-  const relative = _path2.default.relative(root, target);
+  const root = baseDir ?? import_node_process11.default.cwd();
+  const relative = import_node_path12.default.relative(root, target);
   if (!relative) {
     return ".";
   }
   if (relative.startsWith("..")) {
-    return _path2.default.normalize(target);
+    return import_node_path12.default.normalize(target);
   }
-  return relative.startsWith(".") ? relative : `.${_path2.default.sep}${relative}`;
+  return relative.startsWith(".") ? relative : `.${import_node_path12.default.sep}${relative}`;
 }
 
 // src/cli/helpers.ts
-var _promises = require('fs/promises');
+var import_promises3 = require("fs/promises");
+var import_node_process14 = __toESM(require("process"));
 
+// src/logger/index.ts
+var import_logger12 = require("@weapp-tailwindcss/logger");
 
 // src/cli/helpers/options/parse.ts
 function readStringOption(flag, value) {
@@ -89,24 +948,24 @@ function toBoolean(value, fallback) {
 }
 
 // src/cli/helpers/options/resolve.ts
-
-
+var import_node_path13 = __toESM(require("path"));
+var import_node_process12 = __toESM(require("process"));
 function resolveCliCwd(value) {
   const raw = readStringOption("cwd", value);
   if (!raw) {
     return void 0;
   }
-  return _path2.default.isAbsolute(raw) ? _path2.default.normalize(raw) : _path2.default.resolve(_process2.default.cwd(), raw);
+  return import_node_path13.default.isAbsolute(raw) ? import_node_path13.default.normalize(raw) : import_node_path13.default.resolve(import_node_process12.default.cwd(), raw);
 }
 
 // src/cli/helpers/patch-cwd.ts
-
-
+var import_node_path14 = __toESM(require("path"));
+var import_node_process13 = __toESM(require("process"));
 
 // src/tailwindcss/index.ts
-var _localpkg = require('local-pkg');
+var import_local_pkg = require("local-pkg");
 function getTailwindcssPackageInfo(options) {
-  return _localpkg.getPackageInfoSync.call(void 0, "tailwindcss", options);
+  return (0, import_local_pkg.getPackageInfoSync)("tailwindcss", options);
 }
 
 // src/cli/helpers/patch-cwd.ts
@@ -114,29 +973,29 @@ function normalizeCandidatePath(baseDir, candidate) {
   if (!candidate) {
     return void 0;
   }
-  return _path2.default.isAbsolute(candidate) ? _path2.default.normalize(candidate) : _path2.default.resolve(baseDir, candidate);
+  return import_node_path14.default.isAbsolute(candidate) ? import_node_path14.default.normalize(candidate) : import_node_path14.default.resolve(baseDir, candidate);
 }
 function detectTailwindWorkspace(paths) {
   for (const candidate of paths) {
     try {
       const info = getTailwindcssPackageInfo({ paths: [candidate] });
-      if (_optionalChain([info, 'optionalAccess', _ => _.rootPath])) {
+      if (info?.rootPath) {
         return candidate;
       }
-    } catch (e) {
+    } catch {
     }
   }
   return void 0;
 }
-function resolvePatchDefaultCwd(currentCwd = _process2.default.cwd()) {
-  const baseDir = _path2.default.normalize(currentCwd);
-  const explicitCwd = normalizeCandidatePath(baseDir, _process2.default.env.WEAPP_TW_PATCH_CWD);
+function resolvePatchDefaultCwd(currentCwd = import_node_process13.default.cwd()) {
+  const baseDir = import_node_path14.default.normalize(currentCwd);
+  const explicitCwd = normalizeCandidatePath(baseDir, import_node_process13.default.env.WEAPP_TW_PATCH_CWD);
   if (explicitCwd) {
     return explicitCwd;
   }
-  const workspaceRoot = _chunk4LPOQMFSjs.findWorkspaceRoot.call(void 0, baseDir);
-  const initCwd = normalizeCandidatePath(baseDir, _process2.default.env.INIT_CWD);
-  const localPrefix = normalizeCandidatePath(baseDir, _process2.default.env.npm_config_local_prefix);
+  const workspaceRoot = findWorkspaceRoot(baseDir);
+  const initCwd = normalizeCandidatePath(baseDir, import_node_process13.default.env.INIT_CWD);
+  const localPrefix = normalizeCandidatePath(baseDir, import_node_process13.default.env.npm_config_local_prefix);
   const candidates = [
     baseDir,
     workspaceRoot,
@@ -147,21 +1006,21 @@ function resolvePatchDefaultCwd(currentCwd = _process2.default.cwd()) {
   if (detected) {
     return detected;
   }
-  return _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(initCwd, () => ( localPrefix)), () => ( workspaceRoot)), () => ( baseDir));
+  return initCwd ?? localPrefix ?? workspaceRoot ?? baseDir;
 }
 
 // src/cli/helpers.ts
 async function ensureDir(dir) {
-  await _promises.mkdir.call(void 0, dir, { recursive: true });
+  await (0, import_promises3.mkdir)(dir, { recursive: true });
 }
 function handleCliError(error) {
   if (error instanceof Error) {
-    _chunk4LPOQMFSjs.logger.error(error.message);
-    if (error.stack && _process2.default.env.WEAPP_TW_DEBUG === "1") {
-      _chunk4LPOQMFSjs.logger.error(error.stack);
+    import_logger12.logger.error(error.message);
+    if (error.stack && import_node_process14.default.env.WEAPP_TW_DEBUG === "1") {
+      import_logger12.logger.error(error.stack);
     }
   } else {
-    _chunk4LPOQMFSjs.logger.error(String(error));
+    import_logger12.logger.error(String(error));
   }
 }
 function commandAction(handler) {
@@ -170,17 +1029,17 @@ function commandAction(handler) {
       await handler(...args);
     } catch (error) {
       handleCliError(error);
-      _process2.default.exitCode = 1;
+      import_node_process14.default.exitCode = 1;
     }
   };
 }
 
 // src/cli/mount-options.ts
-
+var import_node_process16 = __toESM(require("process"));
 
 // src/cli/mount-options/patch-status.ts
 function formatStatusFilesHint(files) {
-  if (!_optionalChain([files, 'optionalAccess', _2 => _2.length])) {
+  if (!files?.length) {
     return "";
   }
   return ` (${files.join(", ")})`;
@@ -191,28 +1050,28 @@ function logPatchStatusReport(report) {
   const skipped = report.entries.filter(
     (entry) => entry.status === "skipped" || entry.status === "unsupported"
   );
-  const packageLabel = `${_nullishCoalesce(report.package.name, () => ( "tailwindcss"))}@${_nullishCoalesce(report.package.version, () => ( "unknown"))}`;
-  _chunk4LPOQMFSjs.logger.info(`Patch status for ${packageLabel} (v${report.majorVersion})`);
+  const packageLabel = `${report.package.name ?? "tailwindcss"}@${report.package.version ?? "unknown"}`;
+  import_logger12.logger.info(`Patch status for ${packageLabel} (v${report.majorVersion})`);
   if (applied.length) {
-    _chunk4LPOQMFSjs.logger.success("Applied:");
+    import_logger12.logger.success("Applied:");
     applied.forEach((entry) => {
-      _chunk4LPOQMFSjs.logger.success(`  - ${entry.name}${formatStatusFilesHint(entry.files)}`);
+      import_logger12.logger.success(`  - ${entry.name}${formatStatusFilesHint(entry.files)}`);
     });
   }
   if (pending.length) {
-    _chunk4LPOQMFSjs.logger.warn("Needs attention:");
+    import_logger12.logger.warn("Needs attention:");
     pending.forEach((entry) => {
       const details = entry.reason ? ` - ${entry.reason}` : "";
-      _chunk4LPOQMFSjs.logger.warn(`  - ${entry.name}${formatStatusFilesHint(entry.files)}${details}`);
+      import_logger12.logger.warn(`  - ${entry.name}${formatStatusFilesHint(entry.files)}${details}`);
     });
   } else {
-    _chunk4LPOQMFSjs.logger.success("All applicable patches are applied.");
+    import_logger12.logger.success("All applicable patches are applied.");
   }
   if (skipped.length) {
-    _chunk4LPOQMFSjs.logger.info("Skipped:");
+    import_logger12.logger.info("Skipped:");
     skipped.forEach((entry) => {
       const details = entry.reason ? ` - ${entry.reason}` : "";
-      _chunk4LPOQMFSjs.logger.info(`  - ${entry.name}${details}`);
+      import_logger12.logger.info(`  - ${entry.name}${details}`);
     });
   }
 }
@@ -224,13 +1083,13 @@ var DEFAULT_EXTEND_LENGTH_UNITS_FEATURE = {
   overwrite: true
 };
 function withDefaultExtendLengthUnits(options) {
-  const normalized = _nullishCoalesce(options, () => ( {}));
-  const extendLengthUnits = _optionalChain([normalized, 'access', _3 => _3.apply, 'optionalAccess', _4 => _4.extendLengthUnits]);
+  const normalized = options ?? {};
+  const extendLengthUnits = normalized.apply?.extendLengthUnits;
   if (extendLengthUnits == null) {
     return {
       ...normalized,
       apply: {
-        ..._nullishCoalesce(normalized.apply, () => ( {})),
+        ...normalized.apply ?? {},
         extendLengthUnits: DEFAULT_EXTEND_LENGTH_UNITS_FEATURE
       }
     };
@@ -238,11 +1097,11 @@ function withDefaultExtendLengthUnits(options) {
   return normalized;
 }
 function buildExtendLengthUnitsOverride(options) {
-  const extendLengthUnits = _optionalChain([options, 'optionalAccess', _5 => _5.apply, 'optionalAccess', _6 => _6.extendLengthUnits]);
+  const extendLengthUnits = options?.apply?.extendLengthUnits;
   if (extendLengthUnits == null) {
     return {
       apply: {
-        ..._nullishCoalesce(_optionalChain([options, 'optionalAccess', _7 => _7.apply]), () => ( {})),
+        ...options?.apply ?? {},
         extendLengthUnits: DEFAULT_EXTEND_LENGTH_UNITS_FEATURE
       }
     };
@@ -251,35 +1110,35 @@ function buildExtendLengthUnitsOverride(options) {
 }
 
 // src/cli/workspace.ts
-
-
+var import_node_path19 = __toESM(require("path"));
+var import_node_process15 = __toESM(require("process"));
 
 // src/cli/workspace/package-dirs.ts
-var _fs = require('fs');
-
-var _fastglob = require('fast-glob'); var _fastglob2 = _interopRequireDefault(_fastglob);
+var import_node_fs10 = require("fs");
+var import_node_path17 = __toESM(require("path"));
+var import_fast_glob = __toESM(require("fast-glob"));
 
 // src/cli/workspace/workspace-globs.ts
-
-
-var _yaml = require('yaml');
+var import_node_fs8 = require("fs");
+var import_node_path15 = __toESM(require("path"));
+var import_yaml = require("yaml");
 
 // src/cli/workspace/workspace-io.ts
-
+var import_node_fs7 = require("fs");
 function tryReadJson(file) {
   try {
-    const content = _fs.readFileSync.call(void 0, file, "utf8");
+    const content = (0, import_node_fs7.readFileSync)(file, "utf8");
     return JSON.parse(content);
-  } catch (e2) {
+  } catch {
     return void 0;
   }
 }
 
 // src/cli/workspace/workspace-globs.ts
 function parseWorkspaceGlobsFromPackageJson(workspaceRoot) {
-  const pkgJsonPath = _path2.default.join(workspaceRoot, "package.json");
+  const pkgJsonPath = import_node_path15.default.join(workspaceRoot, "package.json");
   const pkg = tryReadJson(pkgJsonPath);
-  if (!_optionalChain([pkg, 'optionalAccess', _8 => _8.workspaces])) {
+  if (!pkg?.workspaces) {
     return [];
   }
   if (Array.isArray(pkg.workspaces)) {
@@ -291,30 +1150,30 @@ function parseWorkspaceGlobsFromPackageJson(workspaceRoot) {
   return [];
 }
 function parseWorkspaceGlobsFromWorkspaceFile(workspaceRoot) {
-  const workspaceFile = _path2.default.join(workspaceRoot, "pnpm-workspace.yaml");
-  if (!_fs.existsSync.call(void 0, workspaceFile)) {
+  const workspaceFile = import_node_path15.default.join(workspaceRoot, "pnpm-workspace.yaml");
+  if (!(0, import_node_fs8.existsSync)(workspaceFile)) {
     return [];
   }
   try {
-    const parsed = _yaml.parse.call(void 0, _fs.readFileSync.call(void 0, workspaceFile, "utf8"));
-    return Array.isArray(_optionalChain([parsed, 'optionalAccess', _9 => _9.packages])) ? parsed.packages.filter(Boolean) : [];
-  } catch (e3) {
+    const parsed = (0, import_yaml.parse)((0, import_node_fs8.readFileSync)(workspaceFile, "utf8"));
+    return Array.isArray(parsed?.packages) ? parsed.packages.filter(Boolean) : [];
+  } catch {
     return [];
   }
 }
 
 // src/cli/workspace/workspace-lock.ts
-
-
-
+var import_node_fs9 = require("fs");
+var import_node_path16 = __toESM(require("path"));
+var import_yaml2 = require("yaml");
 function parseImportersFromLock(workspaceRoot) {
-  const lockPath = _path2.default.join(workspaceRoot, "pnpm-lock.yaml");
-  if (!_fs.existsSync.call(void 0, lockPath)) {
+  const lockPath = import_node_path16.default.join(workspaceRoot, "pnpm-lock.yaml");
+  if (!(0, import_node_fs9.existsSync)(lockPath)) {
     return [];
   }
   try {
-    const parsed = _yaml.parse.call(void 0, _fs.readFileSync.call(void 0, lockPath, "utf8"));
-    const importers = _optionalChain([parsed, 'optionalAccess', _10 => _10.importers]);
+    const parsed = (0, import_yaml2.parse)((0, import_node_fs9.readFileSync)(lockPath, "utf8"));
+    const importers = parsed?.importers;
     if (!importers) {
       return [];
     }
@@ -322,9 +1181,9 @@ function parseImportersFromLock(workspaceRoot) {
       if (!key || key === ".") {
         return workspaceRoot;
       }
-      return _path2.default.join(workspaceRoot, key);
+      return import_node_path16.default.join(workspaceRoot, key);
     });
-  } catch (e4) {
+  } catch {
     return [];
   }
 }
@@ -335,7 +1194,7 @@ var TRAILING_SLASH_RE = /\/+$/;
 async function resolveWorkspacePackageDirs(workspaceRoot) {
   const dirs = /* @__PURE__ */ new Set();
   for (const importerDir of parseImportersFromLock(workspaceRoot)) {
-    dirs.add(_path2.default.normalize(importerDir));
+    dirs.add(import_node_path17.default.normalize(importerDir));
   }
   if (!dirs.size) {
     let globs = parseWorkspaceGlobsFromWorkspaceFile(workspaceRoot);
@@ -347,7 +1206,7 @@ async function resolveWorkspacePackageDirs(workspaceRoot) {
         const normalized = pattern.replace(BACKSLASH_RE, "/").replace(TRAILING_SLASH_RE, "");
         return normalized.endsWith("package.json") ? normalized : `${normalized}/package.json`;
       });
-      const packageJsonFiles = await _fastglob2.default.call(void 0, patterns, {
+      const packageJsonFiles = await (0, import_fast_glob.default)(patterns, {
         cwd: workspaceRoot,
         absolute: true,
         onlyFiles: true,
@@ -355,47 +1214,47 @@ async function resolveWorkspacePackageDirs(workspaceRoot) {
         ignore: ["**/node_modules/**", "**/.git/**"]
       });
       for (const file of packageJsonFiles) {
-        dirs.add(_path2.default.normalize(_path2.default.dirname(file)));
+        dirs.add(import_node_path17.default.normalize(import_node_path17.default.dirname(file)));
       }
     }
   }
-  const rootPkg = _path2.default.join(workspaceRoot, "package.json");
-  if (_fs.existsSync.call(void 0, rootPkg)) {
-    dirs.add(_path2.default.normalize(workspaceRoot));
+  const rootPkg = import_node_path17.default.join(workspaceRoot, "package.json");
+  if ((0, import_node_fs10.existsSync)(rootPkg)) {
+    dirs.add(import_node_path17.default.normalize(workspaceRoot));
   }
   return [...dirs];
 }
 
 // src/cli/workspace/patch-package.ts
-
+var import_tailwindcss_patch2 = require("tailwindcss-patch");
 
 // src/cli/workspace/patch-utils.ts
-
+var import_node_path18 = __toESM(require("path"));
 function formatDisplayName(workspaceRoot, dir, name) {
-  const relative = _path2.default.relative(workspaceRoot, dir) || ".";
+  const relative = import_node_path18.default.relative(workspaceRoot, dir) || ".";
   return name ? `${name} (${relative})` : relative;
 }
 function summarizeWorkspaceResults(results) {
   const patched = results.filter((result) => result.status === "patched").length;
   const skipped = results.filter((result) => result.status === "skipped").length;
   const failed = results.filter((result) => result.status === "failed").length;
-  _chunk4LPOQMFSjs.logger.info("[workspace] \u6C47\u603B\uFF1A\u5DF2\u8865\u4E01 %d\uFF0C\u8DF3\u8FC7 %d\uFF0C\u5931\u8D25 %d", patched, skipped, failed);
+  import_logger12.logger.info("[workspace] \u6C47\u603B\uFF1A\u5DF2\u8865\u4E01 %d\uFF0C\u8DF3\u8FC7 %d\uFF0C\u5931\u8D25 %d", patched, skipped, failed);
 }
 
 // src/cli/workspace/patch-package.ts
 function createWorkspacePatcher(cwd) {
-  const normalized = _tailwindcsspatch.normalizeOptions.call(void 0, 
+  const normalized = (0, import_tailwindcss_patch2.normalizeOptions)(
     withDefaultExtendLengthUnits({
       projectRoot: cwd
     })
   );
-  return new (0, _tailwindcsspatch.TailwindcssPatcher)(normalized);
+  return new import_tailwindcss_patch2.TailwindcssPatcher(normalized);
 }
 async function patchWorkspacePackage(workspaceRoot, dir, pkgName, options) {
   const displayName = formatDisplayName(workspaceRoot, dir, pkgName);
   const tailwindInfo = getTailwindcssPackageInfo({ paths: [dir] });
-  if (!_optionalChain([tailwindInfo, 'optionalAccess', _11 => _11.rootPath])) {
-    _chunk4LPOQMFSjs.logger.info("[workspace] \u8DF3\u8FC7 %s\uFF08tailwindcss \u672A\u5B89\u88C5\uFF09\u3002", displayName);
+  if (!tailwindInfo?.rootPath) {
+    import_logger12.logger.info("[workspace] \u8DF3\u8FC7 %s\uFF08tailwindcss \u672A\u5B89\u88C5\uFF09\u3002", displayName);
     return {
       dir,
       name: pkgName,
@@ -406,23 +1265,23 @@ async function patchWorkspacePackage(workspaceRoot, dir, pkgName, options) {
   try {
     const patcher = createWorkspacePatcher(dir);
     if (options.clearCache) {
-      await _chunkG5NLM3ALjs.clearTailwindcssPatcherCache.call(void 0, patcher, { removeDirectory: true });
+      await clearTailwindcssPatcherCache(patcher, { removeDirectory: true });
     }
-    const recorder = _chunkG5NLM3ALjs.createPatchTargetRecorder.call(void 0, dir, patcher, {
+    const recorder = createPatchTargetRecorder(dir, patcher, {
       source: "cli",
       cwd: dir,
       recordTarget: options.recordTarget !== false,
       alwaysRecord: true
     });
-    if (_optionalChain([recorder, 'optionalAccess', _12 => _12.message])) {
-      _chunk4LPOQMFSjs.logger.info("[workspace] %s %s", displayName, recorder.message);
+    if (recorder?.message) {
+      import_logger12.logger.info("[workspace] %s %s", displayName, recorder.message);
     }
-    _chunkG5NLM3ALjs.logTailwindcssTarget.call(void 0, "cli", patcher, dir);
+    logTailwindcssTarget("cli", patcher, dir);
     await patcher.patch();
-    if (_optionalChain([recorder, 'optionalAccess', _13 => _13.onPatched])) {
+    if (recorder?.onPatched) {
       await recorder.onPatched();
     }
-    _chunk4LPOQMFSjs.logger.success("[workspace] \u5DF2\u8865\u4E01 %s", displayName);
+    import_logger12.logger.success("[workspace] \u5DF2\u8865\u4E01 %s", displayName);
     return {
       dir,
       name: pkgName,
@@ -433,7 +1292,7 @@ async function patchWorkspacePackage(workspaceRoot, dir, pkgName, options) {
     const reason = error instanceof Error ? error.message : String(error);
     const suggestion = `\u8BF7\u5728 ${dir} \u8FD0\u884C "weapp-tw patch --cwd ${dir}".`;
     const message = `${reason}\uFF0C${suggestion}`;
-    _chunk4LPOQMFSjs.logger.error("[workspace] \u8865\u4E01\u5931\u8D25 %s\uFF1A%s", displayName, message);
+    import_logger12.logger.error("[workspace] \u8865\u4E01\u5931\u8D25 %s\uFF1A%s", displayName, message);
     return {
       dir,
       name: pkgName,
@@ -445,18 +1304,18 @@ async function patchWorkspacePackage(workspaceRoot, dir, pkgName, options) {
 
 // src/cli/workspace.ts
 async function patchWorkspace(options) {
-  const cwd = _nullishCoalesce(options.cwd, () => ( _process2.default.cwd()));
-  const workspaceRoot = _nullishCoalesce(_chunk4LPOQMFSjs.findWorkspaceRoot.call(void 0, cwd), () => ( cwd));
+  const cwd = options.cwd ?? import_node_process15.default.cwd();
+  const workspaceRoot = findWorkspaceRoot(cwd) ?? cwd;
   const packageDirs = await resolveWorkspacePackageDirs(workspaceRoot);
   if (packageDirs.length === 0) {
-    _chunk4LPOQMFSjs.logger.warn("\u672A\u5728 %s \u68C0\u6D4B\u5230 workspace \u5305\uFF0C\u5DF2\u8DF3\u8FC7\u6279\u91CF patch\u3002", workspaceRoot);
+    import_logger12.logger.warn("\u672A\u5728 %s \u68C0\u6D4B\u5230 workspace \u5305\uFF0C\u5DF2\u8DF3\u8FC7\u6279\u91CF patch\u3002", workspaceRoot);
     return;
   }
   const results = [];
   for (const dir of packageDirs) {
-    const pkgJsonPath = _path2.default.join(dir, "package.json");
+    const pkgJsonPath = import_node_path19.default.join(dir, "package.json");
     const pkgJson = tryReadJson(pkgJsonPath);
-    results.push(await patchWorkspacePackage(workspaceRoot, dir, _optionalChain([pkgJson, 'optionalAccess', _14 => _14.name]), options));
+    results.push(await patchWorkspacePackage(workspaceRoot, dir, pkgJson?.name, options));
   }
   summarizeWorkspaceResults(results);
 }
@@ -464,12 +1323,12 @@ async function patchWorkspace(options) {
 // src/cli/mount-options.ts
 function handleCliError2(error) {
   if (error instanceof Error) {
-    _chunk4LPOQMFSjs.logger.error(error.message);
-    if (error.stack && _process2.default.env.WEAPP_TW_DEBUG === "1") {
-      _chunk4LPOQMFSjs.logger.error(error.stack);
+    import_logger12.logger.error(error.message);
+    if (error.stack && import_node_process16.default.env.WEAPP_TW_DEBUG === "1") {
+      import_logger12.logger.error(error.stack);
     }
   } else {
-    _chunk4LPOQMFSjs.logger.error(String(error));
+    import_logger12.logger.error(String(error));
   }
 }
 function withCommandErrorHandling(handler) {
@@ -478,7 +1337,7 @@ function withCommandErrorHandling(handler) {
       return await handler(ctx, next);
     } catch (error) {
       handleCliError2(error);
-      _process2.default.exitCode = 1;
+      import_node_process16.default.exitCode = 1;
       return void 0;
     }
   });
@@ -548,26 +1407,26 @@ var mountOptions = {
       }
       const patcher = await createPatcherWithDefaultExtendLengthUnits(ctx);
       if (shouldClearCache) {
-        await _chunkG5NLM3ALjs.clearTailwindcssPatcherCache.call(void 0, patcher, { removeDirectory: true });
+        await clearTailwindcssPatcherCache(patcher, { removeDirectory: true });
       }
-      const recorder = _chunkG5NLM3ALjs.createPatchTargetRecorder.call(void 0, ctx.cwd, patcher, {
+      const recorder = createPatchTargetRecorder(ctx.cwd, patcher, {
         source: "cli",
         cwd: ctx.cwd,
         recordTarget: shouldRecordTarget,
         alwaysRecord: true
       });
-      if (_optionalChain([recorder, 'optionalAccess', _15 => _15.message])) {
-        _chunk4LPOQMFSjs.logger.info(recorder.message);
+      if (recorder?.message) {
+        import_logger12.logger.info(recorder.message);
       }
-      _chunkG5NLM3ALjs.logTailwindcssTarget.call(void 0, "cli", patcher, ctx.cwd);
+      logTailwindcssTarget("cli", patcher, ctx.cwd);
       await patcher.patch();
-      if (_optionalChain([recorder, 'optionalAccess', _16 => _16.onPatched])) {
+      if (recorder?.onPatched) {
         const recordPath = await recorder.onPatched();
         if (recordPath) {
-          _chunk4LPOQMFSjs.logger.info(`\u8BB0\u5F55 weapp-tw patch \u76EE\u6807 -> ${formatOutputPath(recordPath, ctx.cwd)}`);
+          import_logger12.logger.info(`\u8BB0\u5F55 weapp-tw patch \u76EE\u6807 -> ${formatOutputPath(recordPath, ctx.cwd)}`);
         }
       }
-      _chunk4LPOQMFSjs.logger.success("Tailwind CSS \u8FD0\u884C\u65F6\u8865\u4E01\u5DF2\u5B8C\u6210\u3002");
+      import_logger12.logger.success("Tailwind CSS \u8FD0\u884C\u65F6\u8865\u4E01\u5DF2\u5B8C\u6210\u3002");
     }),
     extract: withCommandErrorHandling(async (_ctx, next) => next()),
     tokens: withCommandErrorHandling(async (_ctx, next) => next()),
@@ -576,7 +1435,7 @@ var mountOptions = {
       const patcher = await createPatcherWithDefaultExtendLengthUnits(ctx);
       const report = await patcher.getPatchStatus();
       if (ctx.args.json) {
-        _chunk4LPOQMFSjs.logger.log(JSON.stringify(report, null, 2));
+        import_logger12.logger.log(JSON.stringify(report, null, 2));
         return report;
       }
       logPatchStatusReport(report);
@@ -586,9 +1445,9 @@ var mountOptions = {
 };
 
 // src/cli/vscode-entry.ts
-
-
-
+var import_node_fs11 = require("fs");
+var import_promises4 = require("fs/promises");
+var import_node_path20 = __toESM(require("path"));
 var DEFAULT_VSCODE_ENTRY_OUTPUT = ".vscode/weapp-tailwindcss.intellisense.css";
 var DEFAULT_VSCODE_SOURCES = [
   'not "./dist"',
@@ -605,10 +1464,10 @@ function toPosixPath(filepath) {
 }
 async function assertFileExists(filepath) {
   try {
-    await _promises.access.call(void 0, filepath, _fs.constants.F_OK);
+    await (0, import_promises4.access)(filepath, import_node_fs11.constants.F_OK);
   } catch (error) {
     const err = error;
-    if (_optionalChain([err, 'optionalAccess', _17 => _17.code]) === "ENOENT") {
+    if (err?.code === "ENOENT") {
       throw new Error(`CSS entry file not found: ${filepath}`);
     }
     throw err;
@@ -616,7 +1475,7 @@ async function assertFileExists(filepath) {
 }
 async function assertCanWrite(filepath, force) {
   try {
-    await _promises.access.call(void 0, filepath, _fs.constants.F_OK);
+    await (0, import_promises4.access)(filepath, import_node_fs11.constants.F_OK);
     if (!force) {
       throw new Error(
         `VS Code helper already exists at ${filepath}. Re-run with --force to overwrite it.`
@@ -624,7 +1483,7 @@ async function assertCanWrite(filepath, force) {
     }
   } catch (error) {
     const err = error;
-    if (_optionalChain([err, 'optionalAccess', _18 => _18.code]) === "ENOENT") {
+    if (err?.code === "ENOENT") {
       return;
     }
     throw err;
@@ -660,17 +1519,17 @@ function formatSource(pattern) {
   return `@source ${keyword}${body};`;
 }
 function resolveOutputPath(baseDir, output) {
-  const target = _nullishCoalesce(output, () => ( DEFAULT_VSCODE_ENTRY_OUTPUT));
-  return _path2.default.isAbsolute(target) ? _path2.default.normalize(target) : _path2.default.resolve(baseDir, target);
+  const target = output ?? DEFAULT_VSCODE_ENTRY_OUTPUT;
+  return import_node_path20.default.isAbsolute(target) ? import_node_path20.default.normalize(target) : import_node_path20.default.resolve(baseDir, target);
 }
 function resolveCssEntry(baseDir, entry) {
-  return _path2.default.isAbsolute(entry) ? _path2.default.normalize(entry) : _path2.default.resolve(baseDir, entry);
+  return import_node_path20.default.isAbsolute(entry) ? import_node_path20.default.normalize(entry) : import_node_path20.default.resolve(baseDir, entry);
 }
 function toRelativeImport(fromFile, targetFile) {
-  const fromDir = _path2.default.dirname(fromFile);
-  let relative = _path2.default.relative(fromDir, targetFile);
+  const fromDir = import_node_path20.default.dirname(fromFile);
+  let relative = import_node_path20.default.relative(fromDir, targetFile);
   if (!relative) {
-    relative = _path2.default.basename(targetFile);
+    relative = import_node_path20.default.basename(targetFile);
   }
   if (!relative.startsWith(".")) {
     relative = `./${relative}`;
@@ -682,7 +1541,7 @@ async function generateVscodeIntellisenseEntry(options) {
   const cssEntryPath = resolveCssEntry(baseDir, options.cssEntry);
   await assertFileExists(cssEntryPath);
   const outputPath = resolveOutputPath(baseDir, options.output);
-  await ensureDir(_path2.default.dirname(outputPath));
+  await ensureDir(import_node_path20.default.dirname(outputPath));
   await assertCanWrite(outputPath, options.force);
   const sources = options.sources && options.sources.length > 0 ? options.sources : DEFAULT_VSCODE_SOURCES;
   const formattedSources = sources.map(formatSource).filter((statement) => Boolean(statement));
@@ -701,26 +1560,26 @@ async function generateVscodeIntellisenseEntry(options) {
     `@import '${cssImport}';`,
     ""
   ].filter((line, idx, arr) => !(line === "" && arr[idx - 1] === "")).join("\n");
-  await _promises.writeFile.call(void 0, outputPath, `${content}
+  await (0, import_promises4.writeFile)(outputPath, `${content}
 `, "utf8");
   return { outputPath, cssEntryPath };
 }
 
 // src/cli.ts
-_process2.default.title = "node (weapp-tailwindcss)";
-if (_semver2.default.lt(_process2.default.versions.node, _chunkG5NLM3ALjs.WEAPP_TW_REQUIRED_NODE_VERSION)) {
-  _chunk4LPOQMFSjs.logger.warn(
-    `You are using Node.js ${_process2.default.versions.node}. For weapp-tailwindcss, Node.js version >= v${_chunkG5NLM3ALjs.WEAPP_TW_REQUIRED_NODE_VERSION} is required.`
+import_node_process17.default.title = "node (weapp-tailwindcss)";
+if (import_semver.default.lt(import_node_process17.default.versions.node, WEAPP_TW_REQUIRED_NODE_VERSION)) {
+  import_logger12.logger.warn(
+    `You are using Node.js ${import_node_process17.default.versions.node}. For weapp-tailwindcss, Node.js version >= v${WEAPP_TW_REQUIRED_NODE_VERSION} is required.`
   );
 }
-var cli = _tailwindcsspatch.createTailwindcssPatchCli.call(void 0, {
+var cli = (0, import_tailwindcss_patch3.createTailwindcssPatchCli)({
   name: "weapp-tailwindcss",
   mountOptions
 });
 cli.command("vscode-entry", "Generate a VS Code helper CSS for Tailwind IntelliSense").option("--cwd <dir>", "Working directory").option("--css <file>", "Path to the CSS file that imports weapp-tailwindcss (required)").option("--output <file>", `Helper output path. Defaults to ${DEFAULT_VSCODE_ENTRY_OUTPUT}`).option("--source <pattern>", "Additional @source glob (can be repeated)").option("--force", "Overwrite the helper file when it already exists").action(
   commandAction(async (options) => {
     const resolvedCwd = resolveCliCwd(options.cwd);
-    const baseDir = _nullishCoalesce(resolvedCwd, () => ( _process2.default.cwd()));
+    const baseDir = resolvedCwd ?? import_node_process17.default.cwd();
     const cssEntry = readStringOption("css", options.css);
     if (!cssEntry) {
       throw new Error('Option "--css" is required.');
@@ -735,11 +1594,11 @@ cli.command("vscode-entry", "Generate a VS Code helper CSS for Tailwind IntelliS
       sources,
       force
     });
-    _chunk4LPOQMFSjs.logger.success(
+    import_logger12.logger.success(
       `VS Code helper generated -> ${formatOutputPath(result.outputPath, resolvedCwd)}`
     );
   })
 );
 cli.help();
-cli.version(_nullishCoalesce(_process2.default.env.npm_package_version, () => ( "0.0.0")));
+cli.version(import_node_process17.default.env.npm_package_version ?? "0.0.0");
 cli.parse();