weapp-tailwindcss 4.12.0-next.0 → 5.0.0-next.1

package/dist/cli.mjs

@@ -1,1621 +1,2590 @@
-// src/cli.ts
-import process18 from "process";
+import { createRequire } from "node:module";
+import process from "node:process";
 import semver from "semver";
-import { createTailwindcssPatchCli } from "tailwindcss-patch";
-
-// src/cli/context.ts
-import path12 from "path";
-import process12 from "process";
-
-// src/context/index.ts
-import { rm } from "fs/promises";
-import { logger as logger11 } from "@weapp-tailwindcss/logger";
-
-// src/cache/index.ts
+import { TailwindcssPatcher, createTailwindcssPatchCli, normalizeOptions } from "tailwindcss-patch";
+import path from "node:path";
+import { access, mkdir, rm, writeFile } from "node:fs/promises";
+import { logger, logger as logger$1 } from "@weapp-tailwindcss/logger";
 import { LRUCache } from "lru-cache";
-
-// src/cache/md5.ts
-import { md5 } from "@weapp-tailwindcss/shared/node";
-
-// src/defaults.ts
-import { isAllowedClassName, MappingChars2String } from "@weapp-core/escape";
-
-// src/utils/index.ts
-import { defu, defuOverrideArray, groupBy, isMap, isRegexp, noop, regExpTest, removeExt } from "@weapp-tailwindcss/shared";
-
-// src/utils/hbuilderx.ts
-import path from "path";
-import process from "process";
-
-// src/utils/uni-platform.ts
-import process2 from "process";
-
-// src/debug/index.ts
+import { md5 as md5Hash } from "@weapp-tailwindcss/shared/node";
+import { MappingChars2String, escape } from "@weapp-core/escape";
+import "@weapp-tailwindcss/shared";
 import _createDebug from "debug";
-var _debug = _createDebug("weapp-tw");
+import { constants, existsSync, readFileSync } from "node:fs";
+import "@weapp-tailwindcss/postcss";
+import _babelTraverse from "@babel/traverse";
+import { parse as parse$1 } from "@babel/parser";
+import { escapeStringRegexp } from "@weapp-core/regex";
+import MagicString from "magic-string";
+import { jsStringEscape } from "@ast-core/escape";
+import { splitCode } from "@weapp-tailwindcss/shared/extractors";
+import "@babel/types";
+import "htmlparser2";
+import { getPackageInfoSync } from "local-pkg";
+import fg from "fast-glob";
+import { parse } from "yaml";
+//#region src/debug/index.ts
+const _debug = _createDebug("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
-import { statSync } from "fs";
-
-// src/tailwindcss/runtime.ts
-var debug = createDebug("[tailwindcss:runtime] ");
-
-// src/tailwindcss/runtime-logs.ts
-import process3 from "process";
-import { logger, pc } from "@weapp-tailwindcss/logger";
-var runtimeLogDedupeHolder = globalThis;
-var runtimeLogDedupe = runtimeLogDedupeHolder.__WEAPP_TW_RUNTIME_LOG_DEDUPE__ ?? (runtimeLogDedupeHolder.__WEAPP_TW_RUNTIME_LOG_DEDUPE__ = /* @__PURE__ */ new Set());
+	const debug = ((formatter, ...args) => {
+		return _debug((prefix ?? "") + formatter, ...args);
+	});
+	Object.defineProperty(debug, "enabled", {
+		enumerable: false,
+		configurable: false,
+		get() {
+			return _debug.enabled;
+		}
+	});
+	return debug;
+}
+createDebug("[tailwindcss:runtime] ");
+//#endregion
+//#region src/tailwindcss/runtime-logs.ts
+const runtimeLogDedupeHolder = globalThis;
+const runtimeLogDedupe = runtimeLogDedupeHolder.__WEAPP_TW_RUNTIME_LOG_DEDUPE__ ?? (runtimeLogDedupeHolder.__WEAPP_TW_RUNTIME_LOG_DEDUPE__ = /* @__PURE__ */ new Set());
 function createRuntimeLogKey(category, baseDir, rootPath, version) {
-  return JSON.stringify([
-    category,
-    baseDir ?? process3.cwd(),
-    rootPath ?? "",
-    version ?? ""
-  ]);
+	return JSON.stringify([
+		category,
+		baseDir ?? process.cwd(),
+		rootPath ?? "",
+		version ?? ""
+	]);
 }
 function markRuntimeLog(category, baseDir, rootPath, version) {
-  const key = createRuntimeLogKey(category, baseDir, rootPath, version);
-  if (runtimeLogDedupe.has(key)) {
-    return false;
-  }
-  runtimeLogDedupe.add(key);
-  return true;
+	const key = createRuntimeLogKey(category, baseDir, rootPath, version);
+	if (runtimeLogDedupe.has(key)) return false;
+	runtimeLogDedupe.add(key);
+	return true;
 }
 function logRuntimeTailwindcssTarget(baseDir, rootPath, version) {
-  if (!markRuntimeLog("target", baseDir, rootPath, version)) {
-    return;
-  }
-  const versionText = version ? ` (v${version})` : "";
-  logger.info("%s \u4F7F\u7528 Tailwind CSS%s", "Weapp-tailwindcss", versionText);
-}
-
-// src/tailwindcss/targets.ts
-import process6 from "process";
-import { logger as logger3 } from "@weapp-tailwindcss/logger";
-
-// src/tailwindcss/targets/paths.ts
-import { existsSync as existsSync2 } from "fs";
-import path3 from "path";
-
-// src/context/workspace.ts
-import { existsSync, readdirSync, readFileSync } from "fs";
-import path2 from "path";
+	if (!markRuntimeLog("target", baseDir, rootPath, version)) return;
+	const versionText = version ? ` (v${version})` : "";
+	logger.info("%s 使用 Tailwind CSS%s", "Weapp-tailwindcss", versionText);
+}
+//#endregion
+//#region src/context/workspace.ts
 function findWorkspaceRoot(startDir) {
-  if (!startDir) {
-    return void 0;
-  }
-  let current = path2.resolve(startDir);
-  while (true) {
-    const workspaceFile = path2.join(current, "pnpm-workspace.yaml");
-    if (existsSync(workspaceFile)) {
-      return current;
-    }
-    const parent = path2.dirname(current);
-    if (parent === current) {
-      return void 0;
-    }
-    current = parent;
-  }
+	if (!startDir) return;
+	let current = path.resolve(startDir);
+	while (true) {
+		if (existsSync(path.join(current, "pnpm-workspace.yaml"))) return current;
+		const parent = path.dirname(current);
+		if (parent === current) return;
+		current = parent;
+	}
 }
 function findNearestPackageRoot(startDir) {
-  if (!startDir) {
-    return void 0;
-  }
-  let current = path2.resolve(startDir);
-  while (true) {
-    const pkgPath = path2.join(current, "package.json");
-    if (existsSync(pkgPath)) {
-      return current;
-    }
-    const parent = path2.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 = path3.join("node_modules", ".cache", "weapp-tailwindcss", PATCH_INFO_FILENAME);
-var PATCH_INFO_LEGACY_RELATIVE_PATH = path3.join(".tw-patch", PATCH_INFO_FILENAME);
+	if (!startDir) return;
+	let current = path.resolve(startDir);
+	while (true) {
+		if (existsSync(path.join(current, "package.json"))) return current;
+		const parent = path.dirname(current);
+		if (parent === current) return;
+		current = parent;
+	}
+}
+//#endregion
+//#region src/tailwindcss/targets/paths.ts
+const PATCH_INFO_FILENAME = "tailwindcss-target.json";
+const PATCH_INFO_CACHE_RELATIVE_PATH = path.join("node_modules", ".cache", "weapp-tailwindcss", PATCH_INFO_FILENAME);
+const PATCH_INFO_LEGACY_RELATIVE_PATH = path.join(".tw-patch", PATCH_INFO_FILENAME);
+function toDisplayPath(value) {
+	return path.normalize(value).replace(/\\/g, "/");
+}
 function formatRelativeToBase(targetPath, baseDir) {
-  if (!baseDir) {
-    return path3.normalize(targetPath);
-  }
-  const relative = path3.relative(baseDir, targetPath);
-  if (!relative || relative === ".") {
-    return ".";
-  }
-  if (relative.startsWith("..")) {
-    return path3.normalize(targetPath);
-  }
-  return path3.join(".", relative);
+	if (!baseDir) return toDisplayPath(targetPath);
+	const relative = path.relative(baseDir, targetPath);
+	if (!relative || relative === ".") return ".";
+	if (relative.startsWith("..")) return toDisplayPath(targetPath);
+	return toDisplayPath(path.join(".", relative));
 }
 function resolveRecordLocation(baseDir) {
-  const normalizedBase = path3.normalize(baseDir);
-  const packageRoot = findNearestPackageRoot(normalizedBase) ?? normalizedBase;
-  const packageJsonPath = path3.join(packageRoot, "package.json");
-  const hasPackageJson = existsSync2(packageJsonPath);
-  const recordKeySource = hasPackageJson ? packageJsonPath : normalizedBase;
-  const recordKey = md5(path3.normalize(recordKeySource));
-  const recordDir = path3.join(packageRoot, "node_modules", ".cache", "weapp-tailwindcss", recordKey);
-  const recordPath = path3.join(recordDir, PATCH_INFO_FILENAME);
-  return {
-    normalizedBase,
-    packageRoot,
-    recordDir,
-    recordKey,
-    recordPath,
-    packageJsonPath: hasPackageJson ? packageJsonPath : void 0
-  };
+	const normalizedBase = path.normalize(baseDir);
+	const packageRoot = findNearestPackageRoot(normalizedBase) ?? normalizedBase;
+	const packageJsonPath = path.join(packageRoot, "package.json");
+	const hasPackageJson = existsSync(packageJsonPath);
+	const recordKeySource = hasPackageJson ? packageJsonPath : normalizedBase;
+	const recordKey = md5Hash(path.normalize(recordKeySource));
+	const recordDir = path.join(packageRoot, "node_modules", ".cache", "weapp-tailwindcss", recordKey);
+	return {
+		normalizedBase,
+		packageRoot,
+		recordDir,
+		recordKey,
+		recordPath: path.join(recordDir, PATCH_INFO_FILENAME),
+		packageJsonPath: hasPackageJson ? packageJsonPath : void 0
+	};
 }
 function getRecordFileCandidates(baseDir) {
-  const { normalizedBase, packageRoot, recordPath } = resolveRecordLocation(baseDir);
-  const candidates = /* @__PURE__ */ new Set([
-    recordPath,
-    path3.join(packageRoot, PATCH_INFO_CACHE_RELATIVE_PATH),
-    path3.join(normalizedBase, PATCH_INFO_CACHE_RELATIVE_PATH),
-    path3.join(normalizedBase, PATCH_INFO_LEGACY_RELATIVE_PATH)
-  ]);
-  return [...candidates];
-}
-
-// src/tailwindcss/targets/record-io.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
-import { mkdir, writeFile } from "fs/promises";
-import path4 from "path";
-import process4 from "process";
-import { logger as logger2 } from "@weapp-tailwindcss/logger";
-
-// package.json
-var package_default = {
-  name: "weapp-tailwindcss",
-  version: "4.12.0-next.0",
-  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": "^7.0.0",
-    "@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/reset": "workspace:*",
-    "@weapp-tailwindcss/shared": "workspace:*",
-    cac: "6.7.14",
-    "comment-json": "^4.6.2",
-    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"
-  },
-  devDependencies: {
-    "fast-check": "^4.7.0"
-  }
-};
-
-// 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();
+	const { normalizedBase, packageRoot, recordPath } = resolveRecordLocation(baseDir);
+	return [...new Set([
+		recordPath,
+		path.join(packageRoot, PATCH_INFO_CACHE_RELATIVE_PATH),
+		path.join(normalizedBase, PATCH_INFO_CACHE_RELATIVE_PATH),
+		path.join(normalizedBase, PATCH_INFO_LEGACY_RELATIVE_PATH)
+	])];
+}
+//#endregion
+//#region package.json
+var version = "5.0.0-next.1";
+//#endregion
+//#region src/constants.ts
+const WEAPP_TW_REQUIRED_NODE_VERSION_RANGE = "^20.19.0 || >=22.12.0";
+const WEAPP_TW_VERSION = version;
+//#endregion
+//#region src/tailwindcss/targets/record-io.ts
+const loggedInvalidPatchRecords = /* @__PURE__ */ new Set();
 function warnInvalidPatchTargetRecord(baseDir, recordPath, reason) {
-  const normalizedPath = path4.normalize(recordPath);
-  if (loggedInvalidPatchRecords.has(normalizedPath)) {
-    return;
-  }
-  loggedInvalidPatchRecords.add(normalizedPath);
-  const fileDisplay = formatRelativeToBase(normalizedPath, baseDir);
-  const baseDisplay = formatRelativeToBase(path4.normalize(baseDir), process4.cwd());
-  const reasonMessage = reason ? `\uFF1A${reason}` : "";
-  logger2.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`
-  );
+	const normalizedPath = path.normalize(recordPath);
+	if (loggedInvalidPatchRecords.has(normalizedPath)) return;
+	loggedInvalidPatchRecords.add(normalizedPath);
+	const fileDisplay = formatRelativeToBase(normalizedPath, baseDir);
+	const baseDisplay = formatRelativeToBase(path.normalize(baseDir), process.cwd());
+	const reasonMessage = reason ? `：${reason}` : "";
+	logger.warn(`检测到损坏的 Tailwind CSS 目标记录 ${fileDisplay}${reasonMessage}。请在 ${baseDisplay} 重新执行 "weapp-tw patch --record-target" 或删除该文件后再运行。`);
 }
 function readPatchTargetRecord(baseDir) {
-  if (!baseDir) {
-    return void 0;
-  }
-  const normalizedBase = path4.normalize(baseDir);
-  for (const recordPath of getRecordFileCandidates(normalizedBase)) {
-    if (!existsSync3(recordPath)) {
-      continue;
-    }
-    try {
-      const content = readFileSync2(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;
+	if (!baseDir) return;
+	const normalizedBase = path.normalize(baseDir);
+	for (const recordPath of getRecordFileCandidates(normalizedBase)) {
+		if (!existsSync(recordPath)) continue;
+		try {
+			const content = readFileSync(recordPath, "utf8");
+			const parsed = JSON.parse(content);
+			if (!parsed || typeof parsed.tailwindPackagePath !== "string") {
+				warnInvalidPatchTargetRecord(normalizedBase, recordPath, "缺少 tailwindPackagePath 字段");
+				continue;
+			}
+			return {
+				baseDir: normalizedBase,
+				path: recordPath,
+				record: parsed
+			};
+		} catch (error) {
+			warnInvalidPatchTargetRecord(normalizedBase, recordPath, error instanceof Error ? error.message : String(error));
+			continue;
+		}
+	}
 }
 async function saveCliPatchTargetRecord(baseDir, patcher, options) {
-  if (!baseDir || !patcher?.packageInfo?.rootPath) {
-    return void 0;
-  }
-  const normalizedBase = path4.normalize(baseDir);
-  const location = resolveRecordLocation(normalizedBase);
-  const recordPath = options?.recordPath ? path4.normalize(options.recordPath) : location.recordPath;
-  const record = {
-    tailwindPackagePath: path4.normalize(patcher.packageInfo.rootPath),
-    packageVersion: patcher.packageInfo.version,
-    recordedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    source: options?.source ?? "cli",
-    tailwindcssBasedir: normalizedBase,
-    cwd: options?.cwd ? path4.normalize(options.cwd) : normalizedBase,
-    patchVersion: WEAPP_TW_VERSION,
-    packageJsonPath: options?.packageJsonPath ?? location.packageJsonPath,
-    recordKey: options?.recordKey ?? location.recordKey
-  };
-  try {
-    await mkdir(path4.dirname(recordPath), { recursive: true });
-    await writeFile(recordPath, `${JSON.stringify(record, null, 2)}
-`, "utf8");
-    return recordPath;
-  } catch (error) {
-    const baseDisplay = formatRelativeToBase(normalizedBase, process4.cwd());
-    logger2.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
-    );
-    logger2.debug("failed to persist patch target record %s: %O", recordPath, error);
-    return void 0;
-  }
-}
-
-// src/tailwindcss/targets/recorder.ts
-import path5 from "path";
-import process5 from "process";
+	if (!baseDir || !patcher?.packageInfo?.rootPath) return;
+	const normalizedBase = path.normalize(baseDir);
+	const location = resolveRecordLocation(normalizedBase);
+	const recordPath = options?.recordPath ? path.normalize(options.recordPath) : location.recordPath;
+	const record = {
+		tailwindPackagePath: path.normalize(patcher.packageInfo.rootPath),
+		packageVersion: patcher.packageInfo.version,
+		recordedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		source: options?.source ?? "cli",
+		tailwindcssBasedir: normalizedBase,
+		cwd: options?.cwd ? path.normalize(options.cwd) : normalizedBase,
+		patchVersion: WEAPP_TW_VERSION,
+		packageJsonPath: options?.packageJsonPath ?? location.packageJsonPath,
+		recordKey: options?.recordKey ?? location.recordKey
+	};
+	try {
+		await mkdir(path.dirname(recordPath), { recursive: true });
+		await writeFile(recordPath, `${JSON.stringify(record, null, 2)}\n`, "utf8");
+		return recordPath;
+	} catch (error) {
+		const baseDisplay = formatRelativeToBase(normalizedBase, process.cwd());
+		logger.warn("自动更新 Tailwind CSS 补丁记录失败，请在 %s 运行 \"weapp-tw patch --cwd %s\"。", baseDisplay, normalizedBase);
+		logger.debug("failed to persist patch target record %s: %O", recordPath, error);
+		return;
+	}
+}
+//#endregion
+//#region src/tailwindcss/targets/recorder.ts
 function findPatchTargetRecord(baseDir) {
-  const visited = /* @__PURE__ */ new Set();
-  const fallback = baseDir ?? process5.cwd();
-  let current = path5.resolve(fallback);
-  while (!visited.has(current)) {
-    const record = readPatchTargetRecord(current);
-    if (record) {
-      return record;
-    }
-    const parent = path5.dirname(current);
-    if (parent === current) {
-      break;
-    }
-    visited.add(current);
-    current = parent;
-  }
-  return void 0;
+	const visited = /* @__PURE__ */ new Set();
+	const fallback = baseDir ?? process.cwd();
+	let current = path.resolve(fallback);
+	while (!visited.has(current)) {
+		const record = readPatchTargetRecord(current);
+		if (record) return record;
+		const parent = path.dirname(current);
+		if (parent === current) break;
+		visited.add(current);
+		current = parent;
+	}
 }
 function createPatchTargetRecorder(baseDir, patcher, options) {
-  if (!baseDir || !patcher?.packageInfo?.rootPath || options?.recordTarget === false) {
-    return void 0;
-  }
-  const normalizedBase = path5.normalize(baseDir);
-  const recorded = findPatchTargetRecord(normalizedBase);
-  const location = resolveRecordLocation(normalizedBase);
-  const expectedPath = path5.normalize(patcher.packageInfo.rootPath);
-  let reason;
-  if (!recorded) {
-    reason = "missing";
-  } else {
-    const normalizedRecorded = path5.normalize(recorded.record.tailwindPackagePath);
-    if (normalizedRecorded !== expectedPath) {
-      reason = "mismatch";
-    } else if (path5.normalize(recorded.path) !== path5.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 && path5.normalize(recorded.record.cwd) !== path5.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
+	if (!baseDir || !patcher?.packageInfo?.rootPath || options?.recordTarget === false) return;
+	const normalizedBase = path.normalize(baseDir);
+	const recorded = findPatchTargetRecord(normalizedBase);
+	const location = resolveRecordLocation(normalizedBase);
+	const expectedPath = path.normalize(patcher.packageInfo.rootPath);
+	let reason;
+	if (!recorded) reason = "missing";
+	else if (path.normalize(recorded.record.tailwindPackagePath) !== expectedPath) reason = "mismatch";
+	else if (path.normalize(recorded.path) !== path.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 && path.normalize(recorded.record.cwd) !== path.normalize(options.cwd)) reason = "metadata";
+	else if (!recorded.record.cwd && options?.cwd) reason = "metadata";
+	if (!(options?.alwaysRecord || !recorded || Boolean(reason))) return;
+	let message;
+	switch (reason) {
+		case "mismatch":
+			message = "检测到 Tailwind CSS 目标记录与当前解析结果不一致，正在自动重新 patch 并刷新缓存。";
+			break;
+		case "migrate":
+		case "stale":
+			message = "正在刷新当前子包的 Tailwind CSS 补丁记录，确保缓存隔离。";
+			break;
+		case "missing":
+			message = "未找到当前子包的 Tailwind CSS 目标记录，正在生成。";
+			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
+	};
+}
+//#endregion
+//#region src/tailwindcss/targets.ts
 function logTailwindcssTarget(kind, patcher, baseDir) {
-  const packageInfo = patcher?.packageInfo;
-  const label = kind === "cli" ? "weapp-tw patch" : "Weapp-tailwindcss";
-  if (!packageInfo?.rootPath) {
-    logger3.warn(
-      "%s \u672A\u627E\u5230 Tailwind CSS \u4F9D\u8D56\uFF0C\u8BF7\u68C0\u67E5\u5728 %s \u662F\u5426\u5DF2\u5B89\u88C5 tailwindcss",
-      label,
-      baseDir ?? process6.cwd()
-    );
-    return;
-  }
-  const displayPath = formatRelativeToBase(packageInfo.rootPath, baseDir);
-  const version = packageInfo.version ? ` (v${packageInfo.version})` : "";
-  if (kind === "runtime") {
-    logRuntimeTailwindcssTarget(baseDir, packageInfo.rootPath, packageInfo.version);
-    return;
-  }
-  logger3.info("%s \u7ED1\u5B9A Tailwind CSS -> %s%s", label, displayPath, version);
-}
-
-// src/tailwindcss/v4/config.ts
-import { logger as logger4 } from "@weapp-tailwindcss/logger";
-
-// src/tailwindcss/v4/patcher.ts
-import { logger as logger6 } from "@weapp-tailwindcss/logger";
-
-// src/tailwindcss/patcher.ts
-import path7 from "path";
-import process8 from "process";
-import { logger as logger5 } from "@weapp-tailwindcss/logger";
-import { defuOverrideArray as defuOverrideArray2 } from "@weapp-tailwindcss/shared";
-import { TailwindcssPatcher } from "tailwindcss-patch";
-
-// src/tailwindcss/patcher-resolve.ts
-import { existsSync as existsSync4 } from "fs";
-import { createRequire } from "module";
-import path6 from "path";
-import process7 from "process";
-import { fileURLToPath } from "url";
-
-// src/tailwindcss/v4/css-entries.ts
-import path8 from "path";
-
-// src/context/compiler-context-cache.ts
-import { Buffer } from "buffer";
-import path9 from "path";
-import process9 from "process";
-import { logger as logger7 } from "@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
-import { createStyleHandler } from "@weapp-tailwindcss/postcss";
-
-// src/js/index.ts
-import { LRUCache as LRUCache3 } from "lru-cache";
-
-// src/babel/index.ts
-import _babelTraverse from "@babel/traverse";
-import { parse, parseExpression } from "@babel/parser";
+	const packageInfo = patcher?.packageInfo;
+	const label = kind === "cli" ? "weapp-tw patch" : "Weapp-tailwindcss";
+	if (!packageInfo?.rootPath) {
+		logger.warn("%s 未找到 Tailwind CSS 依赖，请检查在 %s 是否已安装 tailwindcss", label, baseDir ?? process.cwd());
+		return;
+	}
+	const displayPath = formatRelativeToBase(packageInfo.rootPath, baseDir);
+	const version = packageInfo.version ? ` (v${packageInfo.version})` : "";
+	if (kind === "runtime") {
+		logRuntimeTailwindcssTarget(baseDir, packageInfo.rootPath, packageInfo.version);
+		return;
+	}
+	logger.info("%s 绑定 Tailwind CSS -> %s%s", label, displayPath, version);
+}
+//#endregion
+//#region src/context/compiler-context-cache.ts
+const globalCacheHolder = globalThis;
+globalCacheHolder.__WEAPP_TW_COMPILER_CONTEXT_CACHE__ ?? (globalCacheHolder.__WEAPP_TW_COMPILER_CONTEXT_CACHE__ = /* @__PURE__ */ new Map());
+//#endregion
+//#region src/babel/index.ts
 function _interopDefaultCompat(e) {
-  return e && typeof e === "object" && "default" in e ? e.default : e;
+	return e && typeof e === "object" && "default" in e ? e.default : e;
 }
-var traverse = _interopDefaultCompat(_babelTraverse);
-
-// src/utils/nameMatcher.ts
-import { escapeStringRegexp } from "@weapp-core/regex";
-
-// src/js/babel/parse.ts
-import { LRUCache as LRUCache2 } from "lru-cache";
-var parseCache = new LRUCache2(
-  {
-    max: 1024
-  }
-);
-
-// src/js/babel/process.ts
-import MagicString from "magic-string";
-
-// src/js/handlers.ts
-import { jsStringEscape } from "@ast-core/escape";
-import { splitCode } from "@weapp-tailwindcss/shared/extractors";
-
-// src/wxml/shared.ts
-import { escape, MappingChars2String as MappingChars2String2 } from "@weapp-core/escape";
-
-// src/js/handlers.ts
-var debug2 = createDebug("[js:handlers] ");
-
-// src/js/evalTransforms.ts
-import { jsStringEscape as jsStringEscape2 } from "@ast-core/escape";
-
-// src/wxml/utils/codegen/legacy-rewriter.ts
-import MagicString2 from "magic-string";
-
-// src/wxml/utils/codegen/legacy-visitor.ts
-import * as t from "@babel/types";
-
-// src/wxml/utils/codegen.ts
-var WRAP_EXPRESSION_HANDLER_OPTIONS = Object.freeze({
-  wrapExpression: true
-});
-
-// src/wxml/utils/custom-template.ts
-import { Parser } from "htmlparser2";
-import MagicString4 from "magic-string";
-
-// src/wxml/utils/template-fragments.ts
-import MagicString3 from "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
+const traverse = _interopDefaultCompat(_babelTraverse);
+//#endregion
+//#region src/utils/nameMatcher.ts
+const NEVER_MATCH_NAME$1 = () => false;
+const GLOBAL_FLAG_REGEXP = /g/g;
+function buildFuzzyMatcher(fuzzyStrings) {
+	if (fuzzyStrings.length === 0) return;
+	if (fuzzyStrings.length === 1) {
+		const [needle] = fuzzyStrings;
+		return (value) => value.includes(needle);
+	}
+	const unique = [...new Set(fuzzyStrings)];
+	const pattern = new RegExp(unique.map(escapeStringRegexp).join("|"));
+	return (value) => pattern.test(value);
+}
+function normaliseRegex(regex) {
+	const { source, flags } = regex;
+	if (!flags.includes("g")) return regex;
+	return new RegExp(source, flags.replace(GLOBAL_FLAG_REGEXP, ""));
+}
+function createNameMatcher(list, { exact = false } = {}) {
+	if (!list || list.length === 0) return NEVER_MATCH_NAME$1;
+	const exactStrings = exact ? /* @__PURE__ */ new Set() : void 0;
+	const fuzzyStrings = [];
+	const regexList = [];
+	for (const item of list) if (typeof item === "string") if (exact) exactStrings.add(item);
+	else fuzzyStrings.push(item);
+	else regexList.push(normaliseRegex(item));
+	if (exact) {
+		const exactStringCount = exactStrings?.size ?? 0;
+		if (exactStringCount === 1 && regexList.length === 0) {
+			const [needle] = exactStrings;
+			return (value) => value === needle;
+		}
+		if (regexList.length === 0) return (value) => exactStrings.has(value);
+		if (exactStringCount === 0 && regexList.length === 1) {
+			const [regex] = regexList;
+			return (value) => regex.test(value);
+		}
+		return (value) => {
+			if (exactStrings?.has(value)) return true;
+			return regexList.some((regex) => regex.test(value));
+		};
+	}
+	const fuzzyMatcher = exact ? void 0 : buildFuzzyMatcher(fuzzyStrings);
+	const hasRegex = regexList.length > 0;
+	if (fuzzyMatcher && !hasRegex) return fuzzyMatcher;
+	if (!fuzzyMatcher && regexList.length === 1) {
+		const [regex] = regexList;
+		return (value) => regex.test(value);
+	}
+	return (value) => {
+		if (fuzzyMatcher?.(value)) return true;
+		if (!hasRegex) return false;
+		return regexList.some((regex) => regex.test(value));
+	};
+}
+//#endregion
+//#region src/js/babel/parse.ts
+const parseCache = new LRUCache({ max: 1024 });
+function genCacheKey(source, options) {
+	if (typeof options === "string") return source + options;
+	return source + JSON.stringify(options, (_, val) => typeof val === "function" ? val.toString() : val);
+}
+function babelParse(code, opts = {}) {
+	const { cache, cacheKey, ...rest } = opts;
+	const cacheKeyString = genCacheKey(code, cacheKey ?? rest);
+	let result;
+	if (cache) result = parseCache.get(cacheKeyString);
+	if (!result) {
+		const { cache: _cache, cacheKey: _cacheKey, ...parseOptions } = opts;
+		result = parse$1(code, parseOptions);
+		if (cache) parseCache.set(cacheKeyString, result);
+	}
+	return result;
+}
+//#endregion
+//#region src/wxml/shared.ts
+const NEWLINE_RE = /[\n\r]+/g;
+function replaceWxml(original, options = {
+	keepEOL: false,
+	escapeMap: MappingChars2String
+}) {
+	const { keepEOL, escapeMap, ignoreHead } = options;
+	let res = original;
+	if (!keepEOL) res = res.replaceAll(NEWLINE_RE, "");
+	res = escape(res, {
+		map: escapeMap,
+		ignoreHead
+	});
+	return res;
+}
+//#endregion
+//#region src/shared/classname-transform.ts
+const escapedCandidateCacheByEscapeMap = /* @__PURE__ */ new WeakMap();
+const defaultEscapedCandidateCache = /* @__PURE__ */ new Map();
+let lastEscapedCandidateEscapeMap;
+let lastEscapedCandidateCacheStore;
+function isUrlLikeCandidate(candidate) {
+	return candidate.startsWith("//") || candidate.startsWith("http://") || candidate.startsWith("https://");
+}
+function isArbitraryValueCandidate(candidate) {
+	let hasOpenBracket = false;
+	let hasCloseBracket = false;
+	for (let i = 0; i < candidate.length; i++) {
+		const char = candidate[i];
+		if (char === "[") hasOpenBracket = true;
+		else if (char === "]") hasCloseBracket = true;
+		if (hasOpenBracket && hasCloseBracket) break;
+	}
+	if (!hasOpenBracket || !hasCloseBracket) return false;
+	if (isUrlLikeCandidate(candidate.trim())) return false;
+	return true;
+}
+function shouldEnableArbitraryValueFallbackByInputs(classNameSet, jsArbitraryValueFallback, tailwindcssMajorVersion) {
+	if (jsArbitraryValueFallback === true) return true;
+	if (jsArbitraryValueFallback === false) return false;
+	return tailwindcssMajorVersion === 4 && (!classNameSet || classNameSet.size === 0);
+}
+function shouldEnableArbitraryValueFallback({ classNameSet, jsArbitraryValueFallback, tailwindcssMajorVersion }) {
+	return shouldEnableArbitraryValueFallbackByInputs(classNameSet, jsArbitraryValueFallback, tailwindcssMajorVersion);
+}
+const SKIP_RESULT = { decision: "skip" };
+const DIRECT_RESULT = { decision: "direct" };
+const FALLBACK_RESULT = { decision: "fallback" };
+function getEscapedCandidateCacheStore(escapeMap) {
+	if (!escapeMap) return defaultEscapedCandidateCache;
+	if (escapeMap === lastEscapedCandidateEscapeMap && lastEscapedCandidateCacheStore) return lastEscapedCandidateCacheStore;
+	let store = escapedCandidateCacheByEscapeMap.get(escapeMap);
+	if (!store) {
+		store = /* @__PURE__ */ new Map();
+		escapedCandidateCacheByEscapeMap.set(escapeMap, store);
+	}
+	lastEscapedCandidateEscapeMap = escapeMap;
+	lastEscapedCandidateCacheStore = store;
+	return store;
+}
+function getEscapedCandidate(candidate, escapeMap, store = getEscapedCandidateCacheStore(escapeMap)) {
+	let cached = store.get(candidate);
+	if (cached === void 0) {
+		cached = replaceWxml(candidate, { escapeMap });
+		store.set(candidate, cached);
+	}
+	return cached;
+}
+/**
+* JS 转译严格遵循 runtime class set：
+* 1. 直接命中 classNameSet 原始值；
+* 2. 兼容命中 classNameSet 中已转义值；
+* 3. 仅在受控条件下允许 class 语义兜底。
+*
+* 返回结构化结果，附带已计算的 escapedValue 以避免下游重复 escape。
+*/
+function resolveClassNameTransformWithResult(candidate, { alwaysEscape, classNameSet, escapeMap, jsArbitraryValueFallback, jsPreserveClass, tailwindcssMajorVersion, classContext }) {
+	if (alwaysEscape) return DIRECT_RESULT;
+	if (jsPreserveClass?.(candidate)) return SKIP_RESULT;
+	if (classNameSet?.has(candidate)) return DIRECT_RESULT;
+	if (classNameSet && classNameSet.size > 0) {
+		const escapedCandidate = getEscapedCandidate(candidate, escapeMap);
+		if (escapedCandidate !== candidate && classNameSet.has(escapedCandidate)) return {
+			decision: "escaped",
+			escapedValue: escapedCandidate
+		};
+	}
+	if (classContext && shouldEnableArbitraryValueFallbackByInputs(classNameSet, jsArbitraryValueFallback, tailwindcssMajorVersion) && isArbitraryValueCandidate(candidate)) return FALLBACK_RESULT;
+	return SKIP_RESULT;
+}
+//#endregion
+//#region src/utils/decode.ts
+const unicodeEscapeRE = /\\u([\dA-Fa-f]{4})/g;
+const unicodeEscapeTestRE = /\\u[\dA-Fa-f]{4}/;
+function decodeUnicode(value) {
+	if (!unicodeEscapeTestRE.test(value)) return value;
+	return value.replace(unicodeEscapeRE, (_match, hex) => {
+		const codePoint = Number.parseInt(hex, 16);
+		return Number.isNaN(codePoint) ? _match : String.fromCharCode(codePoint);
+	});
+}
+function decodeUnicode2(input) {
+	if (!unicodeEscapeTestRE.test(input)) return input;
+	try {
+		return JSON.parse(`"${input}"`);
+	} catch (_error) {
+		return decodeUnicode(input);
+	}
+}
+//#endregion
+//#region src/js/class-context.ts
+const CLASS_LIKE_KEYWORDS = new Set([
+	"class",
+	"classname",
+	"hoverclass",
+	"virtualhostclass",
+	"rootclass"
+]);
+const CLASS_HELPER_IDENTIFIERS = new Set([
+	"cn",
+	"clsx",
+	"classnames",
+	"twmerge",
+	"cva",
+	"tv",
+	"cx",
+	"r"
+]);
+const DASH_CODE = 45;
+const COLON_CODE = 58;
+const UPPERCASE_A_CODE = 65;
+const UPPERCASE_Z_CODE = 90;
+const UNDERSCORE_CODE = 95;
+const ASCII_MAX_CODE = 127;
+const NORMALIZE_KEYWORD_REGEXP = /[-_:]/g;
+function normalizeKeyword(name) {
+	const length = name.length;
+	let firstNormalizedIndex = -1;
+	for (let i = 0; i < length; i++) {
+		const code = name.charCodeAt(i);
+		if (code === DASH_CODE || code === UNDERSCORE_CODE || code === COLON_CODE || code >= UPPERCASE_A_CODE && code <= UPPERCASE_Z_CODE) {
+			firstNormalizedIndex = i;
+			break;
+		}
+		if (code > ASCII_MAX_CODE) return name.replace(NORMALIZE_KEYWORD_REGEXP, "").toLowerCase();
+	}
+	if (firstNormalizedIndex === -1) return name;
+	let normalized = name.slice(0, firstNormalizedIndex);
+	for (let i = firstNormalizedIndex; i < length; i++) {
+		const code = name.charCodeAt(i);
+		if (code === DASH_CODE || code === UNDERSCORE_CODE || code === COLON_CODE) continue;
+		if (code >= UPPERCASE_A_CODE && code <= UPPERCASE_Z_CODE) {
+			normalized += String.fromCharCode(code + 32);
+			continue;
+		}
+		if (code > ASCII_MAX_CODE) return name.replace(NORMALIZE_KEYWORD_REGEXP, "").toLowerCase();
+		normalized += name[i];
+	}
+	return normalized;
+}
+function readObjectKeyName(path) {
+	if (path.isIdentifier()) return path.node.name;
+	if (path.isStringLiteral()) return path.node.value;
+	if (path.isTemplateLiteral() && path.node.expressions.length === 0) return path.node.quasis[0]?.value.cooked ?? path.node.quasis[0]?.value.raw;
+}
+function isClassLikeObjectProperty(path, valuePath) {
+	if (!path.isObjectProperty()) return false;
+	if (path.get("value") !== valuePath) return false;
+	const keyName = readObjectKeyName(path.get("key"));
+	if (!keyName) return false;
+	return CLASS_LIKE_KEYWORDS.has(normalizeKeyword(keyName));
+}
+function isClassLikeJsxAttribute(path) {
+	if (!path.isJSXAttribute()) return false;
+	const namePath = path.get("name");
+	if (!namePath.isJSXIdentifier()) return false;
+	return CLASS_LIKE_KEYWORDS.has(normalizeKeyword(namePath.node.name));
+}
+function readCallHelperName(calleePath) {
+	if (calleePath.isIdentifier()) return calleePath.node.name;
+	if (calleePath.isMemberExpression()) {
+		const propertyPath = calleePath.get("property");
+		if (propertyPath.isIdentifier()) return propertyPath.node.name;
+		if (propertyPath.isStringLiteral()) return propertyPath.node.value;
+	}
+}
+function isClassLikeCallExpression(path, valuePath) {
+	if (!path.isCallExpression()) return false;
+	const helperName = readCallHelperName(path.get("callee"));
+	if (!helperName || !CLASS_HELPER_IDENTIFIERS.has(normalizeKeyword(helperName))) return false;
+	return path.get("arguments").some((argumentPath) => argumentPath.node === valuePath.node);
+}
+/**
+* 判断字符串字面量是否处于 class 语义上下文。
+* 仅用于受控兜底场景，避免将普通业务文本误判为 class。
+*/
+function isClassContextLiteralPath(path) {
+	let current = path;
+	while (current.parentPath) {
+		const parent = current.parentPath;
+		if (isClassLikeObjectProperty(parent, current)) return true;
+		if (isClassLikeJsxAttribute(parent)) return true;
+		if (isClassLikeCallExpression(parent, current)) return true;
+		current = parent;
+	}
+	return false;
+}
+//#endregion
+//#region src/js/handlers.ts
+const debug = createDebug("[js:handlers] ");
+const replacementCacheByEscapeMap = /* @__PURE__ */ new WeakMap();
+const defaultReplacementCache = /* @__PURE__ */ new Map();
+const WEAPP_TW_IGNORE_MARKER = "weapp-tw";
+const IGNORE_MARKER = "ignore";
+function getReplacementCacheStore(escapeMap) {
+	if (!escapeMap) return defaultReplacementCache;
+	let store = replacementCacheByEscapeMap.get(escapeMap);
+	if (!store) {
+		store = /* @__PURE__ */ new Map();
+		replacementCacheByEscapeMap.set(escapeMap, store);
+	}
+	return store;
+}
+function getReplacement(candidate, escapeMap, store = getReplacementCacheStore(escapeMap)) {
+	let cached = store.get(candidate);
+	if (cached === void 0) {
+		cached = replaceWxml(candidate, { escapeMap });
+		store.set(candidate, cached);
+	}
+	return cached;
+}
+function hasIgnoreComment(node) {
+	const { leadingComments } = node;
+	if (!Array.isArray(leadingComments) || leadingComments.length === 0) return false;
+	for (const comment of leadingComments) {
+		const { value } = comment;
+		if (value.includes(WEAPP_TW_IGNORE_MARKER) && value.includes(IGNORE_MARKER)) return true;
+	}
+	return false;
+}
+function extractLiteralValue(path, { unescapeUnicode, arbitraryValues }) {
+	const allowDoubleQuotes = arbitraryValues?.allowDoubleQuotes;
+	const { node } = path;
+	let offset = 0;
+	let original;
+	if (node.type === "StringLiteral") {
+		offset = 1;
+		original = node.value;
+	} else if (node.type === "TemplateElement") original = node.value.raw;
+	else original = "";
+	let literal = original;
+	if (unescapeUnicode && original.includes("\\u")) literal = decodeUnicode2(original);
+	return {
+		allowDoubleQuotes,
+		literal,
+		offset,
+		original
+	};
+}
+function createCandidatePlanResolver(options, classContext) {
+	const { escapeMap } = options;
+	const replacementCache = getReplacementCacheStore(escapeMap);
+	const transformOptions = classContext ? {
+		...options,
+		classContext
+	} : options;
+	let firstCandidate = "";
+	let firstPlan;
+	let cache;
+	const buildCandidatePlan = (candidate) => {
+		const result = resolveClassNameTransformWithResult(candidate, transformOptions);
+		if (result.decision === "skip") return { result };
+		let replacement;
+		if (result.decision === "escaped" && result.escapedValue) {
+			replacement = result.escapedValue;
+			replacementCache.set(candidate, replacement);
+		} else replacement = getReplacement(candidate, escapeMap, replacementCache);
+		return {
+			result,
+			replacement
+		};
+	};
+	return (candidate) => {
+		if (cache) {
+			const cached = cache.get(candidate);
+			if (cached) return cached;
+		} else if (firstPlan && candidate === firstCandidate) return firstPlan;
+		const plan = buildCandidatePlan(candidate);
+		if (!firstPlan) {
+			firstCandidate = candidate;
+			firstPlan = plan;
+			return plan;
+		}
+		if (!cache) {
+			cache = /* @__PURE__ */ new Map();
+			cache.set(firstCandidate, firstPlan);
+		}
+		cache.set(candidate, plan);
+		return plan;
+	};
+}
+function replaceHandleValue(path, options) {
+	const { needEscaped = false } = options;
+	const { classNameSet, alwaysEscape } = options;
+	const fallbackEnabled = shouldEnableArbitraryValueFallback(options);
+	if (!alwaysEscape && !fallbackEnabled && (!classNameSet || classNameSet.size === 0)) return;
+	if (hasIgnoreComment(path.node)) return;
+	const { literal, original, allowDoubleQuotes, offset } = extractLiteralValue(path, options);
+	const candidates = splitCode(literal, allowDoubleQuotes);
+	if (candidates.length === 0) return;
+	const debugEnabled = debug.enabled;
+	const classContext = options.wrapExpression || isClassContextLiteralPath(path);
+	let transformed = literal;
+	let mutated = false;
+	let matchedCandidateCount = 0;
+	let escapedDecisionCount = 0;
+	let fallbackDecisionCount = 0;
+	let escapedSamples;
+	let skippedSamples;
+	const resolveCandidatePlan = createCandidatePlanResolver(options, classContext);
+	for (const candidate of candidates) {
+		const plan = resolveCandidatePlan(candidate);
+		if (plan.result.decision === "skip") {
+			if (debugEnabled) {
+				if (!skippedSamples) skippedSamples = [];
+				if (skippedSamples.length < 6) skippedSamples.push(candidate);
+			}
+			continue;
+		}
+		if (debugEnabled) {
+			matchedCandidateCount += 1;
+			if (plan.result.decision === "escaped") {
+				escapedDecisionCount += 1;
+				if (!escapedSamples) escapedSamples = [];
+				if (escapedSamples.length < 6) escapedSamples.push(candidate);
+			}
+			if (plan.result.decision === "fallback") fallbackDecisionCount += 1;
+		}
+		const replaced = transformed.replace(candidate, plan.replacement);
+		if (replaced !== transformed) {
+			transformed = replaced;
+			mutated = true;
+		}
+	}
+	const node = path.node;
+	if (!mutated || typeof node.start !== "number" || typeof node.end !== "number") return;
+	if (debugEnabled) debug("runtimeSet size=%d fallbackTriggered=%s candidates=%d matched=%d escapedHits=%d skipped=%d file=%s escapedSamples=%s skippedSamples=%s", classNameSet?.size ?? 0, fallbackDecisionCount > 0, candidates.length, matchedCandidateCount, escapedDecisionCount, skippedSamples?.length ?? 0, options.filename ?? "unknown", escapedSamples?.join(",") || "-", skippedSamples?.join(",") || "-");
+	const start = node.start + offset;
+	const end = node.end - offset;
+	if (start >= end || transformed === original) return;
+	return {
+		start,
+		end,
+		value: needEscaped ? jsStringEscape(transformed) : transformed,
+		path
+	};
+}
+//#endregion
+//#region src/js/sourceAnalysis.ts
+function hasReplacementEntries(replacements) {
+	for (const key in replacements) if (Object.hasOwn(replacements, key)) return true;
+	return false;
+}
+function createModuleSpecifierReplacementToken(path, replacement) {
+	const node = path.node;
+	if (node.value === replacement) return;
+	if (typeof node.start !== "number" || typeof node.end !== "number") return;
+	const start = node.start + 1;
+	const end = node.end - 1;
+	if (start >= end) return;
+	return {
+		start,
+		end,
+		value: replacement,
+		path
+	};
+}
+function collectModuleSpecifierReplacementTokens(analysis, replacements) {
+	if (!hasReplacementEntries(replacements)) return [];
+	if (analysis.importDeclarations.size === 0 && analysis.exportDeclarations.size === 0 && analysis.requireCallPaths.length === 0 && analysis.walker.imports.size === 0) return [];
+	const tokens = [];
+	const applyReplacement = (path) => {
+		const replacement = replacements[path.node.value];
+		if (!replacement) return;
+		const token = createModuleSpecifierReplacementToken(path, replacement);
+		if (token) tokens.push(token);
+	};
+	for (const importPath of analysis.importDeclarations) {
+		const source = importPath.get("source");
+		if (source.isStringLiteral()) applyReplacement(source);
+	}
+	for (const exportPath of analysis.exportDeclarations) if (exportPath.isExportNamedDeclaration() || exportPath.isExportAllDeclaration()) {
+		const source = exportPath.get("source");
+		if (source && !Array.isArray(source) && source.isStringLiteral()) applyReplacement(source);
+	}
+	for (const literalPath of analysis.requireCallPaths) applyReplacement(literalPath);
+	for (const token of analysis.walker.imports) {
+		const replacement = replacements[token.source];
+		if (replacement) token.source = replacement;
+	}
+	return tokens;
+}
+//#endregion
+//#region src/js/babel/process.ts
+const optionVariantsCache = /* @__PURE__ */ new WeakMap();
+function getNeedEscapedOptions(options, needEscaped) {
+	if (options.needEscaped === needEscaped) return options;
+	let cached = optionVariantsCache.get(options);
+	if (!cached) {
+		cached = {};
+		optionVariantsCache.set(options, cached);
+	}
+	if (needEscaped) {
+		if (!cached.stringLiteralOptions) cached.stringLiteralOptions = {
+			...options,
+			needEscaped: true
+		};
+		return cached.stringLiteralOptions;
+	}
+	if (!cached.templateLiteralOptions) cached.templateLiteralOptions = {
+		...options,
+		needEscaped: false
+	};
+	return cached.templateLiteralOptions;
+}
+function processUpdatedSource(rawSource, options, analysis) {
+	const { targetPaths, jsTokenUpdater, ignoredPaths } = analysis;
+	if (targetPaths.length === 0 && !options.moduleSpecifierReplacements && jsTokenUpdater.length === 0) return new MagicString(rawSource);
+	const replacementTokens = [];
+	for (const path of targetPaths) {
+		if (ignoredPaths.has(path)) continue;
+		const token = replaceHandleValue(path, path.isStringLiteral() ? getNeedEscapedOptions(options, true) : getNeedEscapedOptions(options, false));
+		if (token) replacementTokens.push(token);
+	}
+	if (options.moduleSpecifierReplacements) replacementTokens.push(...collectModuleSpecifierReplacementTokens(analysis, options.moduleSpecifierReplacements));
+	if (jsTokenUpdater.length + replacementTokens.length === 0) return new MagicString(rawSource);
+	const ms = new MagicString(rawSource);
+	jsTokenUpdater.push(...replacementTokens).filter((token) => !ignoredPaths.has(token.path)).updateMagicString(ms);
+	return ms;
+}
+//#endregion
+//#region src/js/evalTransforms.ts
+const evalHandlerOptionsCache = /* @__PURE__ */ new WeakMap();
+const EVAL_SCOPE_ERROR_REGEXP = /pass a scope and parentPath|traversing a Program\/File/i;
+function isEvalPath(path) {
+	if (path.isCallExpression()) return path.get("callee").isIdentifier({ name: "eval" });
+	return false;
+}
+function createEvalReplacementToken(path, updated) {
+	const node = path.node;
+	let offset = 0;
+	let original;
+	if (path.isStringLiteral()) {
+		offset = 1;
+		original = path.node.value;
+	} else if (path.isTemplateElement()) original = path.node.value.raw;
+	else original = "";
+	if (typeof node.start !== "number" || typeof node.end !== "number") return;
+	const start = node.start + offset;
+	const end = node.end - offset;
+	if (start >= end) return;
+	if (original === updated) return;
+	return {
+		start,
+		end,
+		value: path.isStringLiteral() ? jsStringEscape(updated) : updated,
+		path
+	};
+}
+function handleEvalStringLiteral(path, handlerOptions, updater, handler) {
+	const { code } = handler(path.node.value, handlerOptions);
+	if (!code) return;
+	const token = createEvalReplacementToken(path, code);
+	if (token) updater.addToken(token);
+}
+function handleEvalTemplateElement(path, handlerOptions, updater, handler) {
+	const { code } = handler(path.node.value.raw, handlerOptions);
+	if (!code) return;
+	const token = createEvalReplacementToken(path, code);
+	if (token) updater.addToken(token);
+}
+function getEvalStringHandlerOptions(options) {
+	if (options.needEscaped === false && options.generateMap === false) return options;
+	let cached = evalHandlerOptionsCache.get(options);
+	if (!cached) {
+		cached = {};
+		evalHandlerOptionsCache.set(options, cached);
+	}
+	if (!cached.stringLiteralOptions) cached.stringLiteralOptions = {
+		...options,
+		needEscaped: false,
+		generateMap: false
+	};
+	return cached.stringLiteralOptions;
+}
+function getEvalTemplateHandlerOptions(options) {
+	if (options.generateMap === false) return options;
+	let cached = evalHandlerOptionsCache.get(options);
+	if (!cached) {
+		cached = {};
+		evalHandlerOptionsCache.set(options, cached);
+	}
+	if (!cached.templateLiteralOptions) cached.templateLiteralOptions = {
+		...options,
+		generateMap: false
+	};
+	return cached.templateLiteralOptions;
+}
+function walkEvalExpression(path, options, updater, handler) {
+	const stringHandlerOptions = getEvalStringHandlerOptions(options);
+	const templateHandlerOptions = getEvalTemplateHandlerOptions(options);
+	const maybeTraverse = path?.traverse;
+	if (typeof maybeTraverse === "function") try {
+		return maybeTraverse.call(path, {
+			StringLiteral(innerPath) {
+				handleEvalStringLiteral(innerPath, stringHandlerOptions, updater, handler);
+			},
+			TemplateElement(innerPath) {
+				handleEvalTemplateElement(innerPath, templateHandlerOptions, updater, handler);
+			}
+		});
+	} catch (error) {
+		const msg = error?.message ?? "";
+		if (!EVAL_SCOPE_ERROR_REGEXP.test(msg)) throw error;
+	}
+	const getArgs = path?.get?.("arguments");
+	if (Array.isArray(getArgs)) {
+		for (const arg of getArgs) {
+			if (arg?.isStringLiteral?.()) {
+				handleEvalStringLiteral(arg, stringHandlerOptions, updater, handler);
+				continue;
+			}
+			if (arg?.isTemplateLiteral?.()) for (const quasi of arg.get("quasis")) handleEvalTemplateElement(quasi, templateHandlerOptions, updater, handler);
+		}
+		return;
+	}
+	const nodeArgs = path?.node?.arguments;
+	if (Array.isArray(nodeArgs)) {
+		for (const n of nodeArgs) if (n?.type === "StringLiteral") handleEvalStringLiteral({
+			node: n,
+			isStringLiteral: () => true
+		}, stringHandlerOptions, updater, handler);
+		else if (n?.type === "TemplateLiteral" && Array.isArray(n.quasis)) for (const q of n.quasis) handleEvalTemplateElement({
+			node: q,
+			isStringLiteral: () => false,
+			isTemplateElement: () => true
+		}, templateHandlerOptions, updater, handler);
+	}
+}
+//#endregion
+//#region src/js/JsTokenUpdater.ts
+/**
+* Lightweight helper that batches updates to {@link MagicString}.
+* It keeps the transformation logic out of the traversal code and makes
+* it easier to reason about the order in which tokens are written back.
+*/
+var JsTokenUpdater = class {
+	constructor({ value } = {}) {
+		this.tokens = value ? [...value] : [];
+	}
+	addToken(token) {
+		if (token) this.tokens.push(token);
+	}
+	push(...args) {
+		this.tokens.push(...args);
+		return this;
+	}
+	/**
+	* 待写入的 token 数量。
+	*/
+	get length() {
+		return this.tokens.length;
+	}
+	map(callbackfn) {
+		this.tokens = this.tokens.map(callbackfn);
+		return this;
+	}
+	filter(callbackfn) {
+		this.tokens = this.tokens.filter(callbackfn);
+		return this;
+	}
+	updateMagicString(ms) {
+		for (const { start, end, value } of this.tokens) ms.update(start, end, value);
+		return ms;
+	}
+};
+//#endregion
+//#region src/js/module-graph/ignored-exports.ts
+var IgnoredExportsTracker = class {
+	constructor(options) {
+		this.options = options;
+		this.ignoredExportNames = /* @__PURE__ */ new Map();
+	}
+	addIgnoredExport(filename, exportName) {
+		if (!exportName) return;
+		let pending = this.ignoredExportNames.get(filename);
+		if (!pending) {
+			pending = /* @__PURE__ */ new Set();
+			this.ignoredExportNames.set(filename, pending);
+		}
+		if (pending.has(exportName)) return;
+		pending.add(exportName);
+		const existing = this.options.modules.get(filename);
+		if (existing) this.applyIgnoredExportsToAnalysis(filename, existing.analysis);
+	}
+	registerIgnoredExportsFromTokens(resolved, tokens) {
+		for (const token of tokens) if (token.type === "ImportSpecifier") this.addIgnoredExport(resolved, token.imported);
+		else if (token.type === "ImportDefaultSpecifier") this.addIgnoredExport(resolved, "default");
+	}
+	applyIgnoredExportsToAnalysis(filename, analysis) {
+		const pending = this.ignoredExportNames.get(filename);
+		if (!pending || pending.size === 0) return;
+		const names = new Set(pending);
+		pending.clear();
+		const propagate = [];
+		for (const exportPath of analysis.exportDeclarations) {
+			if (names.size === 0) break;
+			if (exportPath.isExportDefaultDeclaration()) {
+				if (names.has("default")) {
+					analysis.walker.walkExportDefaultDeclaration(exportPath);
+					names.delete("default");
+				}
+				continue;
+			}
+			if (exportPath.isExportNamedDeclaration()) {
+				const source = exportPath.node.source?.value;
+				if (typeof source === "string") {
+					for (const spec of exportPath.get("specifiers")) {
+						if (!spec.isExportSpecifier()) continue;
+						const exported = spec.get("exported");
+						let exportedName;
+						if (exported.isIdentifier()) exportedName = exported.node.name;
+						else if (exported.isStringLiteral()) exportedName = exported.node.value;
+						if (!exportedName || !names.has(exportedName)) continue;
+						const local = spec.get("local");
+						if (local.isIdentifier()) {
+							propagate.push({
+								specifier: source,
+								exportName: local.node.name
+							});
+							names.delete(exportedName);
+						} else if (local.isStringLiteral()) {
+							propagate.push({
+								specifier: source,
+								exportName: local.node.value
+							});
+							names.delete(exportedName);
+						}
+					}
+					continue;
+				}
+				const declaration = exportPath.get("declaration");
+				if (declaration.isVariableDeclaration()) for (const decl of declaration.get("declarations")) {
+					const id = decl.get("id");
+					if (id.isIdentifier()) {
+						const exportName = id.node.name;
+						if (names.has(exportName)) {
+							analysis.walker.walkVariableDeclarator(decl);
+							names.delete(exportName);
+						}
+					}
+				}
+				for (const spec of exportPath.get("specifiers")) {
+					if (!spec.isExportSpecifier()) continue;
+					const exported = spec.get("exported");
+					let exportedName;
+					if (exported.isIdentifier()) exportedName = exported.node.name;
+					else if (exported.isStringLiteral()) exportedName = exported.node.value;
+					if (!exportedName || !names.has(exportedName)) continue;
+					const local = spec.get("local");
+					analysis.walker.walkNode(local);
+					names.delete(exportedName);
+				}
+				continue;
+			}
+			if (exportPath.isExportAllDeclaration()) {
+				const source = exportPath.node.source?.value;
+				if (typeof source === "string") {
+					for (const exportName of names) propagate.push({
+						specifier: source,
+						exportName
+					});
+					names.clear();
+				}
+			}
+		}
+		for (const { specifier, exportName } of propagate) {
+			let resolved;
+			try {
+				resolved = this.options.resolve(specifier, filename);
+			} catch {
+				resolved = void 0;
+			}
+			if (!resolved) {
+				pending.add(exportName);
+				continue;
+			}
+			if (this.options.filter && !this.options.filter(resolved, specifier, filename)) {
+				pending.add(exportName);
+				continue;
+			}
+			this.addIgnoredExport(resolved, exportName);
+		}
+		for (const name of names) pending.add(name);
+	}
+};
+//#endregion
+//#region src/js/ModuleGraph.ts
+var JsModuleGraph = class {
+	constructor(entry, graphOptions) {
+		this.modules = /* @__PURE__ */ new Map();
+		this.queue = [];
+		this.resolve = graphOptions.resolve;
+		this.load = graphOptions.load;
+		this.filter = graphOptions.filter;
+		this.maxDepth = graphOptions.maxDepth ?? Number.POSITIVE_INFINITY;
+		const { moduleGraph: _moduleGraph, filename: _ignoredFilename, ...rest } = entry.handlerOptions;
+		this.baseOptions = {
+			...rest,
+			filename: entry.filename
+		};
+		this.parserOptions = entry.handlerOptions.babelParserOptions;
+		this.rootFilename = entry.filename;
+		this.ignoredExports = new IgnoredExportsTracker({
+			resolve: this.resolve,
+			filter: this.filter,
+			modules: this.modules
+		});
+		this.modules.set(entry.filename, {
+			filename: entry.filename,
+			source: entry.source,
+			analysis: entry.analysis
+		});
+		this.queue.push({
+			filename: entry.filename,
+			depth: 0
+		});
+	}
+	build() {
+		this.collectDependencies();
+		let linked;
+		for (const [filename, state] of this.modules) {
+			if (filename === this.rootFilename) continue;
+			const childOptions = {
+				...this.baseOptions,
+				filename
+			};
+			const code = processUpdatedSource(state.source, childOptions, state.analysis).toString();
+			if (code !== state.source) {
+				if (!linked) linked = {};
+				linked[filename] = { code };
+			}
+		}
+		return linked;
+	}
+	collectDependencies() {
+		while (this.queue.length > 0) {
+			const { filename, depth } = this.queue.shift();
+			if (depth >= this.maxDepth) continue;
+			const state = this.modules.get(filename);
+			if (!state) continue;
+			const dependencySpecifiers = /* @__PURE__ */ new Map();
+			for (const token of state.analysis.walker.imports) {
+				if (!dependencySpecifiers.has(token.source)) dependencySpecifiers.set(token.source, []);
+				dependencySpecifiers.get(token.source).push(token);
+			}
+			for (const exportPath of state.analysis.exportDeclarations) if (exportPath.isExportAllDeclaration() || exportPath.isExportNamedDeclaration()) {
+				const source = exportPath.node.source?.value;
+				if (typeof source === "string" && !dependencySpecifiers.has(source)) dependencySpecifiers.set(source, []);
+			}
+			for (const [specifier, tokens] of dependencySpecifiers) {
+				let resolved;
+				try {
+					resolved = this.resolve(specifier, filename);
+				} catch {
+					continue;
+				}
+				if (!resolved) continue;
+				if (this.filter && !this.filter(resolved, specifier, filename)) continue;
+				if (tokens.length > 0) this.ignoredExports.registerIgnoredExportsFromTokens(resolved, tokens);
+				if (this.modules.has(resolved)) continue;
+				let source;
+				try {
+					source = this.load(resolved);
+				} catch {
+					continue;
+				}
+				if (typeof source !== "string") continue;
+				let analysis;
+				try {
+					analysis = analyzeSource(babelParse(source, {
+						...this.parserOptions,
+						sourceFilename: resolved
+					}), {
+						...this.baseOptions,
+						filename: resolved
+					});
+					this.ignoredExports.applyIgnoredExportsToAnalysis(resolved, analysis);
+				} catch {
+					continue;
+				}
+				this.modules.set(resolved, {
+					filename: resolved,
+					source,
+					analysis
+				});
+				this.queue.push({
+					filename: resolved,
+					depth: depth + 1
+				});
+			}
+		}
+	}
+};
+//#endregion
+//#region src/js/node-path-walker/export-handlers.ts
+function walkExportDeclaration(ctx, path) {
+	if (path.isExportDeclaration()) {
+		if (path.isExportNamedDeclaration()) walkExportNamedDeclaration(ctx, path);
+		else if (path.isExportDefaultDeclaration()) walkExportDefaultDeclaration(ctx, path);
+		else if (path.isExportAllDeclaration()) walkExportAllDeclaration(ctx, path);
+	}
+}
+function walkExportNamedDeclaration(ctx, path) {
+	const declaration = path.get("declaration");
+	if (declaration.isVariableDeclaration()) for (const decl of declaration.get("declarations")) ctx.walkNode(decl);
+	const specifiers = path.get("specifiers");
+	for (const spec of specifiers) if (spec.isExportSpecifier()) {
+		const local = spec.get("local");
+		if (local.isIdentifier()) ctx.walkNode(local);
+	}
+}
+function walkExportDefaultDeclaration(ctx, path) {
+	const decl = path.get("declaration");
+	if (decl.isIdentifier()) ctx.walkNode(decl);
+	else ctx.walkNode(decl);
+}
+function walkExportAllDeclaration(ctx, path) {
+	const source = path.get("source");
+	if (source.isStringLiteral()) ctx.addImportToken({
+		declaration: path,
+		source: source.node.value,
+		type: "ExportAllDeclaration"
+	});
+}
+//#endregion
+//#region src/js/node-path-walker/import-tokens.ts
+function maybeAddImportToken(imports, arg) {
+	if (!(arg.isImportSpecifier() && arg.node.importKind !== "type" || arg.isImportDefaultSpecifier())) return false;
+	const importDeclaration = arg.parentPath;
+	if (!importDeclaration.isImportDeclaration() || importDeclaration.node.importKind === "type") return false;
+	if (arg.isImportSpecifier()) {
+		const imported = arg.get("imported");
+		if (imported.isIdentifier()) imports.add({
+			declaration: importDeclaration,
+			specifier: arg,
+			imported: imported.node.name,
+			local: arg.node.local.name,
+			source: importDeclaration.node.source.value,
+			type: "ImportSpecifier"
+		});
+		return true;
+	}
+	imports.add({
+		declaration: importDeclaration,
+		specifier: arg,
+		local: arg.node.local.name,
+		source: importDeclaration.node.source.value,
+		type: "ImportDefaultSpecifier"
+	});
+	return true;
+}
+//#endregion
+//#region src/js/NodePathWalker.ts
+const EMPTY_IGNORE_CALL_EXPRESSION_IDENTIFIERS = [];
+const EMPTY_IMPORT_TOKENS = /* @__PURE__ */ new Set();
+function NOOP_STRING_PATH_CALLBACK() {}
+const NEVER_MATCH_NAME = () => false;
+/**
+* 遍历我们关注的调用表达式所关联的绑定，收集后续需要转换的字符串节点。
+*/
+var NodePathWalker = class {
+	constructor({ ignoreCallExpressionIdentifiers, callback } = {}) {
+		this.hasIgnoredCallIdentifiers = Boolean(ignoreCallExpressionIdentifiers && ignoreCallExpressionIdentifiers.length > 0);
+		this.ignoreCallExpressionIdentifiers = ignoreCallExpressionIdentifiers ?? EMPTY_IGNORE_CALL_EXPRESSION_IDENTIFIERS;
+		this.callback = callback ?? NOOP_STRING_PATH_CALLBACK;
+		this.isIgnoredCallIdentifier = this.hasIgnoredCallIdentifiers ? createNameMatcher(this.ignoreCallExpressionIdentifiers, { exact: true }) : NEVER_MATCH_NAME;
+	}
+	get imports() {
+		return this.importsStore ?? EMPTY_IMPORT_TOKENS;
+	}
+	getWritableImports() {
+		if (!this.importsStore) this.importsStore = /* @__PURE__ */ new Set();
+		return this.importsStore;
+	}
+	addImportToken(token) {
+		this.getWritableImports().add(token);
+	}
+	getVisited() {
+		if (!this.visitedStore) this.visitedStore = /* @__PURE__ */ new WeakSet();
+		return this.visitedStore;
+	}
+	walkVariableDeclarator(path) {
+		const init = path.get("init");
+		this.walkNode(init);
+	}
+	walkTemplateLiteral(path) {
+		for (const exp of path.get("expressions")) this.walkNode(exp);
+		for (const quasis of path.get("quasis")) this.callback(quasis);
+	}
+	walkStringLiteral(path) {
+		this.callback(path);
+	}
+	walkBinaryExpression(path) {
+		const left = path.get("left");
+		this.walkNode(left);
+		const right = path.get("right");
+		this.walkNode(right);
+	}
+	walkLogicalExpression(path) {
+		const left = path.get("left");
+		this.walkNode(left);
+		const right = path.get("right");
+		this.walkNode(right);
+	}
+	walkObjectExpression(path) {
+		const props = path.get("properties");
+		for (const prop of props) if (prop.isObjectProperty()) {
+			const key = prop.get("key");
+			this.walkNode(key);
+			const value = prop.get("value");
+			this.walkNode(value);
+		}
+	}
+	walkArrayExpression(path) {
+		const elements = path.get("elements");
+		for (const element of elements) this.walkNode(element);
+	}
+	walkNode(arg) {
+		const visited = this.getVisited();
+		if (visited.has(arg)) return;
+		visited.add(arg);
+		if (arg.isIdentifier()) {
+			const binding = arg?.scope?.getBinding?.(arg.node.name);
+			if (binding) this.walkNode(binding.path);
+		} else if (arg.isMemberExpression()) {
+			const objectPath = arg.get("object");
+			if (objectPath.isIdentifier()) {
+				const binding = arg?.scope?.getBinding?.(objectPath.node.name);
+				if (binding) {
+					if (binding.path.isVariableDeclarator()) this.walkVariableDeclarator(binding.path);
+				}
+			}
+		} else if (arg.isTemplateLiteral()) this.walkTemplateLiteral(arg);
+		else if (arg.isStringLiteral()) this.walkStringLiteral(arg);
+		else if (arg.isBinaryExpression()) this.walkBinaryExpression(arg);
+		else if (arg.isLogicalExpression()) this.walkLogicalExpression(arg);
+		else if (arg.isObjectExpression()) this.walkObjectExpression(arg);
+		else if (arg.isArrayExpression()) this.walkArrayExpression(arg);
+		else if (arg.isVariableDeclarator()) this.walkVariableDeclarator(arg);
+		else if (maybeAddImportToken(this.getWritableImports(), arg)) {}
+	}
+	/**
+	* Walk the arguments of a desired call expression so their bindings can be analysed.
+	*/
+	walkCallExpression(path) {
+		if (!this.hasIgnoredCallIdentifiers) return;
+		const calleePath = path.get("callee");
+		if (calleePath.isIdentifier() && this.isIgnoredCallIdentifier(calleePath.node.name)) for (const arg of path.get("arguments")) this.walkNode(arg);
+	}
+	walkExportDeclaration(path) {
+		walkExportDeclaration(this, path);
+	}
+	walkExportNamedDeclaration(path) {
+		walkExportNamedDeclaration(this, path);
+	}
+	walkExportDefaultDeclaration(path) {
+		walkExportDefaultDeclaration(this, path);
+	}
+	walkExportAllDeclaration(path) {
+		walkExportAllDeclaration(this, path);
+	}
+};
+//#endregion
+//#region src/js/taggedTemplateIgnore.ts
+function createTaggedTemplateIgnore({ matcher, names }) {
+	const bindingIgnoreCache = /* @__PURE__ */ new Map();
+	const taggedTemplateIgnoreCache = /* @__PURE__ */ new WeakMap();
+	const seenBindings = /* @__PURE__ */ new Set();
+	let singleCanonicalIgnoreName;
+	let canonicalIgnoreNames;
+	for (const item of names ?? []) {
+		if (typeof item !== "string") continue;
+		if (singleCanonicalIgnoreName === void 0) {
+			singleCanonicalIgnoreName = item;
+			continue;
+		}
+		if (item === singleCanonicalIgnoreName) continue;
+		if (!canonicalIgnoreNames) {
+			canonicalIgnoreNames = new Set([singleCanonicalIgnoreName, item]);
+			continue;
+		}
+		canonicalIgnoreNames.add(item);
+	}
+	const hasCanonicalIgnoreNames = singleCanonicalIgnoreName !== void 0;
+	const matchesIgnoreName = (value) => {
+		if (hasCanonicalIgnoreNames) {
+			if (canonicalIgnoreNames) {
+				if (canonicalIgnoreNames.has(value)) return true;
+			} else if (value === singleCanonicalIgnoreName) return true;
+		}
+		return matcher(value);
+	};
+	const propertyMatches = (propertyPath) => {
+		if (!propertyPath) return false;
+		if (propertyPath.isIdentifier()) return matchesIgnoreName(propertyPath.node.name);
+		if (propertyPath.isStringLiteral()) return matchesIgnoreName(propertyPath.node.value);
+		return false;
+	};
+	const resolvesMemberExpressionToIgnore = (path, seen) => {
+		if (propertyMatches(path.get("property"))) return true;
+		const objectPath = path.get("object");
+		if (objectPath.isIdentifier()) {
+			const binding = (objectPath?.scope)?.getBinding?.(objectPath.node.name);
+			if (binding) return resolvesToWeappTwIgnore(binding, seen);
+		}
+		return false;
+	};
+	const resolvesToWeappTwIgnore = (binding, seen) => {
+		const cached = bindingIgnoreCache.get(binding);
+		if (cached !== void 0) return cached;
+		if (seen.has(binding)) return false;
+		seen.add(binding);
+		let result = false;
+		const bindingPath = binding.path;
+		if (bindingPath.isImportSpecifier()) {
+			const imported = bindingPath.node.imported;
+			if (imported.type === "Identifier" && matchesIgnoreName(imported.name)) result = true;
+			else if (imported.type === "StringLiteral" && matchesIgnoreName(imported.value)) result = true;
+		} else if (bindingPath.isVariableDeclarator()) {
+			const init = bindingPath.get("init");
+			if (init && init.node) {
+				if (init.isIdentifier()) {
+					const target = binding?.scope?.getBinding?.(init.node.name);
+					if (target) result = resolvesToWeappTwIgnore(target, seen);
+				} else if (init.isMemberExpression()) result = resolvesMemberExpressionToIgnore(init, seen);
+			}
+		}
+		bindingIgnoreCache.set(binding, result);
+		seen.delete(binding);
+		return result;
+	};
+	const getEffectiveTagPath = (tagPath) => {
+		let current = tagPath;
+		while (true) {
+			if (current.isParenthesizedExpression?.() || current.node.type === "ParenthesizedExpression") {
+				current = current.get("expression");
+				continue;
+			}
+			if (current.isTSAsExpression() || current.isTSTypeAssertion()) {
+				current = current.get("expression");
+				continue;
+			}
+			if (current.isTSNonNullExpression()) {
+				current = current.get("expression");
+				continue;
+			}
+			if (current.isTypeCastExpression?.()) {
+				current = current.get("expression");
+				continue;
+			}
+			if (current.isSequenceExpression()) {
+				const last = current.get("expressions").at(-1);
+				if (last) {
+					current = last;
+					continue;
+				}
+			}
+			if (current.isCallExpression?.() || current.node.type === "CallExpression") {
+				current = current.get("callee");
+				continue;
+			}
+			break;
+		}
+		return current;
+	};
+	const evaluateTagPath = (tagPath, seen) => {
+		if (tagPath.isCallExpression?.() || tagPath.node.type === "CallExpression") return evaluateTagPath(tagPath.get("callee"), seen);
+		if (tagPath.isIdentifier()) {
+			if (matchesIgnoreName(tagPath.node.name)) return true;
+			const binding = tagPath?.scope?.getBinding?.(tagPath.node.name);
+			if (binding) return resolvesToWeappTwIgnore(binding, seen);
+			return false;
+		}
+		if (tagPath.isMemberExpression()) return resolvesMemberExpressionToIgnore(tagPath, seen);
+		return false;
+	};
+	const computeIgnore = (tagPath) => {
+		const cached = taggedTemplateIgnoreCache.get(tagPath.node);
+		if (cached !== void 0) return cached;
+		const effectiveTagPath = getEffectiveTagPath(tagPath);
+		const effectiveCached = taggedTemplateIgnoreCache.get(effectiveTagPath.node);
+		if (effectiveCached !== void 0) {
+			taggedTemplateIgnoreCache.set(tagPath.node, effectiveCached);
+			return effectiveCached;
+		}
+		seenBindings.clear();
+		const result = evaluateTagPath(effectiveTagPath, seenBindings);
+		taggedTemplateIgnoreCache.set(effectiveTagPath.node, result);
+		taggedTemplateIgnoreCache.set(tagPath.node, result);
+		return result;
+	};
+	return {
+		shouldIgnore(tagPath) {
+			return computeIgnore(tagPath);
+		},
+		getEffectiveTagPath
+	};
+}
+//#endregion
+//#region src/js/babel.ts
+const EXPRESSION_WRAPPER_PREFIX = "(\n";
+const EXPRESSION_WRAPPER_SUFFIX = "\n)";
+const EMPTY_IGNORED_PATHS = /* @__PURE__ */ new WeakSet();
+const EMPTY_IMPORT_DECLARATIONS = /* @__PURE__ */ new Set();
+const EMPTY_EXPORT_DECLARATIONS = /* @__PURE__ */ new Set();
+const EMPTY_REQUIRE_CALL_PATHS = [];
+const ignoredTaggedTemplateMatcherCache = /* @__PURE__ */ new WeakMap();
+let defaultEvalHandler;
+function getIgnoredTaggedTemplateMatcher(options) {
+	const cached = ignoredTaggedTemplateMatcherCache.get(options);
+	if (cached) return cached;
+	const created = createNameMatcher(options.ignoreTaggedTemplateExpressionIdentifiers, { exact: true });
+	ignoredTaggedTemplateMatcherCache.set(options, created);
+	return created;
+}
+function getDefaultEvalHandler() {
+	if (!defaultEvalHandler) throw new Error("Default JS eval handler is not initialized.");
+	return defaultEvalHandler;
+}
+function analyzeSource(ast, options, handler, collectModuleMetadata = true) {
+	const jsTokenUpdater = new JsTokenUpdater();
+	const needScope = Boolean(options.ignoreCallExpressionIdentifiers && options.ignoreCallExpressionIdentifiers.length > 0);
+	const ignoredPaths = needScope ? /* @__PURE__ */ new WeakSet() : EMPTY_IGNORED_PATHS;
+	const walker = needScope ? new NodePathWalker({
+		ignoreCallExpressionIdentifiers: options.ignoreCallExpressionIdentifiers,
+		callback(path) {
+			ignoredPaths.add(path);
+		}
+	}) : new NodePathWalker();
+	let taggedTemplateIgnore;
+	const hasTaggedTemplateIgnoreIdentifiers = Boolean(options.ignoreTaggedTemplateExpressionIdentifiers && options.ignoreTaggedTemplateExpressionIdentifiers.length > 0);
+	function getTaggedTemplateIgnore() {
+		if (!taggedTemplateIgnore) taggedTemplateIgnore = createTaggedTemplateIgnore({
+			matcher: getIgnoredTaggedTemplateMatcher(options),
+			names: options.ignoreTaggedTemplateExpressionIdentifiers
+		});
+		return taggedTemplateIgnore;
+	}
+	const targetPaths = [];
+	const importDeclarations = collectModuleMetadata ? /* @__PURE__ */ new Set() : EMPTY_IMPORT_DECLARATIONS;
+	const exportDeclarations = collectModuleMetadata ? /* @__PURE__ */ new Set() : EMPTY_EXPORT_DECLARATIONS;
+	const requireCallPaths = collectModuleMetadata ? [] : EMPTY_REQUIRE_CALL_PATHS;
+	const evalHandler = handler ?? getDefaultEvalHandler();
+	traverse(ast, {
+		StringLiteral: { enter(p) {
+			if (isEvalPath(p.parentPath)) return;
+			targetPaths.push(p);
+		} },
+		TemplateElement: { enter: hasTaggedTemplateIgnoreIdentifiers ? (p) => {
+			const pp = p.parentPath;
+			if (pp.isTemplateLiteral()) {
+				const ppp = pp.parentPath;
+				if (isEvalPath(ppp)) return;
+				if (ppp.isTaggedTemplateExpression()) {
+					const tagPath = ppp.get("tag");
+					if (getTaggedTemplateIgnore().shouldIgnore(tagPath)) return;
+				}
+			}
+			targetPaths.push(p);
+		} : (p) => {
+			const pp = p.parentPath;
+			if (pp.isTemplateLiteral()) {
+				const ppp = pp.parentPath;
+				if (isEvalPath(ppp)) return;
+			}
+			targetPaths.push(p);
+		} },
+		CallExpression: { enter: !collectModuleMetadata && !needScope ? (p) => {
+			if (isEvalPath(p)) walkEvalExpression(p, options, jsTokenUpdater, evalHandler);
+		} : (p) => {
+			if (isEvalPath(p)) {
+				walkEvalExpression(p, options, jsTokenUpdater, evalHandler);
+				return;
+			}
+			const calleePath = p.get("callee");
+			if (collectModuleMetadata && calleePath.isIdentifier({ name: "require" }) && !p?.scope?.hasBinding?.("require")) {
+				const args = p.get("arguments");
+				if (Array.isArray(args) && args.length > 0) {
+					const first = args[0];
+					if (first?.isStringLiteral()) requireCallPaths.push(first);
+				}
+			}
+			if (needScope) walker.walkCallExpression(p);
+		} },
+		...collectModuleMetadata ? {
+			ImportDeclaration: { enter(p) {
+				importDeclarations.add(p);
+			} },
+			ExportDeclaration: { enter(p) {
+				exportDeclarations.add(p);
+			} }
+		} : {},
+		noScope: !needScope
+	});
+	return {
+		walker,
+		jsTokenUpdater,
+		ast,
+		targetPaths,
+		importDeclarations,
+		exportDeclarations,
+		requireCallPaths,
+		ignoredPaths
+	};
+}
+function jsHandler(rawSource, options) {
+	const shouldWrapExpression = Boolean(options.wrapExpression);
+	const source = shouldWrapExpression ? `${EXPRESSION_WRAPPER_PREFIX}${rawSource}${EXPRESSION_WRAPPER_SUFFIX}` : rawSource;
+	let ast;
+	try {
+		ast = babelParse(source, options.babelParserOptions);
+	} catch (error) {
+		return {
+			code: rawSource,
+			error
+		};
+	}
+	const needsModuleMetadata = Boolean(options.moduleSpecifierReplacements || options.moduleGraph && options.filename);
+	const analysis = analyzeSource(ast, options, jsHandler, needsModuleMetadata);
+	const ms = processUpdatedSource(source, options, analysis);
+	if (shouldWrapExpression) {
+		const start = 0;
+		const end = source.length;
+		const prefixLength = 2;
+		const suffixLength = 2;
+		ms.remove(start, start + prefixLength);
+		ms.remove(end - suffixLength, end);
+	}
+	const result = { code: ms.toString() };
+	if (options.generateMap) Object.defineProperty(result, "map", {
+		configurable: true,
+		enumerable: true,
+		get() {
+			return ms.generateMap();
+		}
+	});
+	if (options.moduleGraph && options.filename) {
+		const linked = new JsModuleGraph({
+			filename: options.filename,
+			source: rawSource,
+			analysis,
+			handlerOptions: options
+		}, options.moduleGraph).build();
+		if (linked) result.linked = linked;
+	}
+	return result;
+}
+defaultEvalHandler = jsHandler;
+Object.freeze({ wrapExpression: true });
+//#endregion
+//#region src/wxml/whitespace.ts
+const WHITESPACE_CODES = new Set([
+	9,
+	10,
+	11,
+	12,
+	13,
+	32,
+	160,
+	65279
 ]);
 function isWhitespace(char) {
-  if (char.length === 0) {
-    return false;
-  }
-  return WHITESPACE_CODES.has(char.charCodeAt(0));
+	if (char.length === 0) return false;
+	return WHITESPACE_CODES.has(char.charCodeAt(0));
 }
-
-// src/wxml/Tokenizer.ts
+//#endregion
+//#region 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 = [];
-  }
+	constructor() {
+		this.reset();
+	}
+	processChar(char, index) {
+		switch (this.state) {
+			case 0:
+				if (isWhitespace(char)) {} else if (char === "{") {
+					this.state = 2;
+					this.bufferStartIndex = index;
+					this.buffer += char;
+					this.expressionBuffer = char;
+					this.expressionStartIndex = index;
+				} else {
+					this.state = 1;
+					this.bufferStartIndex = index;
+					this.buffer += char;
+				}
+				break;
+			case 1:
+				if (isWhitespace(char)) {
+					this.tokens.push({
+						start: this.bufferStartIndex,
+						end: index,
+						value: this.buffer,
+						expressions: this.expressions
+					});
+					this.buffer = "";
+					this.expressions = [];
+					this.state = 0;
+				} else if (char === "{") {
+					this.buffer += char;
+					this.expressionBuffer = char;
+					this.expressionStartIndex = index;
+					this.state = 2;
+				} else this.buffer += char;
+				break;
+			case 2:
+				if (char === "}") {
+					this.buffer += char;
+					this.expressionBuffer += char;
+					this.state = 3;
+				} else {
+					this.buffer += char;
+					this.expressionBuffer += char;
+				}
+				break;
+			case 3:
+				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;
+				} else {
+					this.buffer += char;
+					this.expressionBuffer += char;
+					this.state = 2;
+				}
+				break;
+			case 4:
+				if (isWhitespace(char)) {
+					this.tokens.push({
+						start: this.bufferStartIndex,
+						end: index,
+						value: this.buffer,
+						expressions: this.expressions
+					});
+					this.buffer = "";
+					this.expressions = [];
+					this.state = 0;
+				} else if (char === "{") {
+					this.expressionStartIndex = index;
+					this.expressionBuffer = char;
+					this.buffer += char;
+					this.state = 2;
+				} else {
+					this.buffer += char;
+					this.state = 1;
+				}
+				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;
+		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
-import { logger as logger8 } from "@weapp-tailwindcss/logger";
-
-// src/context/tailwindcss.ts
-import { logger as logger10 } from "@weapp-tailwindcss/logger";
-
-// src/context/tailwindcss/basedir.ts
-import { createRequire as createRequire2 } from "module";
-import path10 from "path";
-import process10 from "process";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import { logger as logger9 } from "@weapp-tailwindcss/logger";
-
-// src/context/tailwindcss/rax.ts
-import { existsSync as existsSync5, readFileSync as readFileSync3 } from "fs";
-import path11 from "path";
-import process11 from "process";
-
-// src/context/index.ts
+new Tokenizer();
+//#endregion
+//#region 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) {
-      logger11.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 rm(cachePath, { force: true, recursive });
-    } catch (error) {
-      const err = error;
-      if (err?.code === "ENOENT") {
-        continue;
-      }
-      logger11.debug("failed to clear tailwindcss patcher cache: %s %O", cachePath, err);
-    }
-  }
-}
-
-// src/cli/context.ts
+	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) {
+		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 rm(cachePath, {
+			force: true,
+			recursive
+		});
+	} catch (error) {
+		const err = error;
+		if (err?.code === "ENOENT") continue;
+		logger.debug("failed to clear tailwindcss patcher cache: %s %O", cachePath, err);
+	}
+}
+//#endregion
+//#region src/cli/context.ts
 function formatOutputPath(target, baseDir) {
-  const root = baseDir ?? process12.cwd();
-  const relative = path12.relative(root, target);
-  if (!relative) {
-    return ".";
-  }
-  if (relative.startsWith("..")) {
-    return path12.normalize(target);
-  }
-  return relative.startsWith(".") ? relative : `.${path12.sep}${relative}`;
-}
-
-// src/cli/helpers.ts
-import { mkdir as mkdir2 } from "fs/promises";
-import process15 from "process";
-
-// src/logger/index.ts
-import { logger as logger12 } from "@weapp-tailwindcss/logger";
-
-// src/cli/helpers/options/parse.ts
+	const root = baseDir ?? process.cwd();
+	const relative = path.relative(root, target);
+	if (!relative) return ".";
+	if (relative.startsWith("..")) return path.normalize(target);
+	return relative.startsWith(".") ? relative : `.${path.sep}${relative}`;
+}
+//#endregion
+//#region src/cli/doctor/constants.ts
+const CONFIG_FILES = {
+	tailwind: [
+		"tailwind.config.js",
+		"tailwind.config.cjs",
+		"tailwind.config.mjs",
+		"tailwind.config.ts"
+	],
+	postcss: [
+		"postcss.config.js",
+		"postcss.config.cjs",
+		"postcss.config.mjs",
+		"postcss.config.ts"
+	],
+	vite: [
+		"vite.config.js",
+		"vite.config.mjs",
+		"vite.config.ts"
+	],
+	webpack: [
+		"webpack.config.js",
+		"webpack.config.cjs",
+		"webpack.config.ts"
+	]
+};
+const FRAMEWORK_DEPS = [
+	["@tarojs/taro", "Taro"],
+	["@dcloudio/uni-app", "uni-app"],
+	["@mpxjs/core", "MPX"],
+	["remax", "Remax"],
+	["rax", "Rax"]
+];
+//#endregion
+//#region src/cli/doctor.ts
+function tryReadJson$1(file) {
+	try {
+		return JSON.parse(readFileSync(file, "utf8"));
+	} catch {
+		return;
+	}
+}
+function findFirstExisting(cwd, files) {
+	return files.find((file) => existsSync(path.join(cwd, file)));
+}
+function readProjectPackageJson(cwd) {
+	return tryReadJson$1(path.join(cwd, "package.json"));
+}
+function readDependencyVersion(cwd, packageName) {
+	try {
+		return tryReadJson$1(createRequire(path.join(cwd, "package.json")).resolve(`${packageName}/package.json`))?.version;
+	} catch {
+		return;
+	}
+}
+function collectDependencySpecs(pkg) {
+	return {
+		...pkg?.dependencies ?? {},
+		...pkg?.devDependencies ?? {},
+		...pkg?.optionalDependencies ?? {},
+		...pkg?.peerDependencies ?? {}
+	};
+}
+function detectPackageManager(cwd, pkg) {
+	if (pkg?.packageManager) return pkg.packageManager;
+	if (existsSync(path.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+	if (existsSync(path.join(cwd, "package-lock.json"))) return "npm";
+	if (existsSync(path.join(cwd, "yarn.lock"))) return "yarn";
+}
+function detectFrameworks(deps) {
+	return FRAMEWORK_DEPS.filter(([dependency]) => dependency in deps).map(([, label]) => label);
+}
+function addCheck(checks, check) {
+	checks.push(check);
+}
+function summarizeChecks(checks) {
+	return checks.reduce((summary, check) => {
+		summary[check.status] += 1;
+		return summary;
+	}, {
+		ok: 0,
+		warn: 0,
+		error: 0,
+		info: 0
+	});
+}
+function hasDependency(deps, packageName) {
+	return packageName in deps;
+}
+function getMajorVersion(version) {
+	if (!version) return;
+	return semver.parse(version)?.major;
+}
+function getDependencyMajor(deps, packageName) {
+	const spec = deps[packageName];
+	return spec ? semver.minVersion(spec)?.major : void 0;
+}
+function createDoctorReport(options = {}) {
+	const cwd = path.resolve(options.cwd ?? process.cwd());
+	const nodeVersion = options.nodeVersion ?? process.versions.node;
+	const pkg = readProjectPackageJson(cwd);
+	const deps = collectDependencySpecs(pkg);
+	const checks = [];
+	const packageManager = detectPackageManager(cwd, pkg);
+	const frameworks = detectFrameworks(deps);
+	const tailwindcssVersion = readDependencyVersion(cwd, "tailwindcss");
+	const weappTailwindcssVersion = readDependencyVersion(cwd, "weapp-tailwindcss");
+	const tailwindMajor = getMajorVersion(tailwindcssVersion) ?? getDependencyMajor(deps, "tailwindcss");
+	const tailwindConfig = findFirstExisting(cwd, CONFIG_FILES.tailwind);
+	const postcssConfig = findFirstExisting(cwd, CONFIG_FILES.postcss);
+	const viteConfig = findFirstExisting(cwd, CONFIG_FILES.vite);
+	const webpackConfig = findFirstExisting(cwd, CONFIG_FILES.webpack);
+	addCheck(checks, pkg ? {
+		id: "package-json",
+		title: "package.json",
+		status: "ok",
+		message: "已找到项目 package.json。"
+	} : {
+		id: "package-json",
+		title: "package.json",
+		status: "error",
+		message: "当前目录没有 package.json。",
+		suggestion: "请在项目根目录运行 doctor，或通过 --cwd 指向项目根目录。"
+	});
+	addCheck(checks, semver.satisfies(nodeVersion, "^20.19.0 || >=22.12.0") ? {
+		id: "node-version",
+		title: "Node.js",
+		status: "ok",
+		message: `当前 Node.js ${nodeVersion} 满足版本要求 ${WEAPP_TW_REQUIRED_NODE_VERSION_RANGE}。`
+	} : {
+		id: "node-version",
+		title: "Node.js",
+		status: "error",
+		message: `当前 Node.js ${nodeVersion} 不满足版本要求 ${WEAPP_TW_REQUIRED_NODE_VERSION_RANGE}。`,
+		suggestion: "请升级 Node.js 后再安装或构建 weapp-tailwindcss 项目。"
+	});
+	addCheck(checks, packageManager ? {
+		id: "package-manager",
+		title: "包管理器",
+		status: packageManager.startsWith("pnpm") ? "ok" : "info",
+		message: `检测到 ${packageManager}。`
+	} : {
+		id: "package-manager",
+		title: "包管理器",
+		status: "info",
+		message: "未检测到 lockfile 或 packageManager 字段。"
+	});
+	addCheck(checks, hasDependency(deps, "weapp-tailwindcss") || Boolean(weappTailwindcssVersion) ? {
+		id: "weapp-tailwindcss",
+		title: "weapp-tailwindcss",
+		status: "ok",
+		message: `检测到 weapp-tailwindcss${weappTailwindcssVersion ? `@${weappTailwindcssVersion}` : ""}。`
+	} : {
+		id: "weapp-tailwindcss",
+		title: "weapp-tailwindcss",
+		status: "warn",
+		message: "未在当前项目依赖中检测到 weapp-tailwindcss。",
+		suggestion: "如果这是业务项目，请安装 weapp-tailwindcss 并确认命令运行在项目根目录。"
+	});
+	addCheck(checks, hasDependency(deps, "tailwindcss") || Boolean(tailwindcssVersion) ? {
+		id: "tailwindcss",
+		title: "Tailwind CSS",
+		status: "ok",
+		message: `检测到 tailwindcss${tailwindcssVersion ? `@${tailwindcssVersion}` : ""}。`
+	} : {
+		id: "tailwindcss",
+		title: "Tailwind CSS",
+		status: "error",
+		message: "未检测到 tailwindcss。",
+		suggestion: "请安装 tailwindcss，并确认依赖可以从当前项目解析。"
+	});
+	addCheck(checks, tailwindConfig ? {
+		id: "tailwind-config",
+		title: "Tailwind 配置",
+		status: "ok",
+		message: `检测到 ${tailwindConfig}。`
+	} : {
+		id: "tailwind-config",
+		title: "Tailwind 配置",
+		status: tailwindMajor === 4 ? "info" : "warn",
+		message: "未检测到 tailwind.config.*。",
+		suggestion: tailwindMajor === 4 ? "Tailwind CSS v4 可以采用 CSS-first 配置；如果使用 v3 或复杂 content/source，请补充配置文件。" : "请确认 Tailwind content/source 配置能够覆盖小程序页面、组件和脚本文件。"
+	});
+	addCheck(checks, postcssConfig ? {
+		id: "postcss-config",
+		title: "PostCSS 配置",
+		status: "ok",
+		message: `检测到 ${postcssConfig}。`
+	} : {
+		id: "postcss-config",
+		title: "PostCSS 配置",
+		status: viteConfig ? "info" : "warn",
+		message: "未检测到 postcss.config.*。",
+		suggestion: "如果通过 PostCSS 接入，请补充 postcss.config.*；如果通过 Vite/Taro 插件接入，可忽略此项。"
+	});
+	if (tailwindMajor === 4 && postcssConfig && !hasDependency(deps, "@tailwindcss/postcss")) addCheck(checks, {
+		id: "tailwindcss-v4-postcss",
+		title: "Tailwind v4 PostCSS",
+		status: "warn",
+		message: "Tailwind CSS v4 项目存在 PostCSS 配置，但未检测到 @tailwindcss/postcss。",
+		suggestion: "如果 PostCSS 配置中仍直接使用 tailwindcss，请迁移到 @tailwindcss/postcss。"
+	});
+	addCheck(checks, frameworks.length > 0 ? {
+		id: "framework",
+		title: "框架识别",
+		status: "ok",
+		message: `检测到 ${frameworks.join(", ")}。`
+	} : {
+		id: "framework",
+		title: "框架识别",
+		status: "info",
+		message: "未从依赖中识别出 Taro、uni-app、MPX、Remax 或 Rax。"
+	});
+	addCheck(checks, viteConfig || webpackConfig ? {
+		id: "bundler-config",
+		title: "构建器配置",
+		status: "ok",
+		message: `检测到 ${[viteConfig, webpackConfig].filter(Boolean).join(", ")}。`
+	} : {
+		id: "bundler-config",
+		title: "构建器配置",
+		status: "info",
+		message: "未检测到 vite.config.* 或 webpack.config.*。"
+	});
+	return {
+		cwd,
+		nodeVersion,
+		detected: {
+			packageManager,
+			frameworks,
+			tailwindcssVersion,
+			weappTailwindcssVersion
+		},
+		summary: summarizeChecks(checks),
+		checks
+	};
+}
+function hasDoctorFailure(report, strict = false) {
+	return report.summary.error > 0 || strict && report.summary.warn > 0;
+}
+function formatDoctorReport(report) {
+	const lines = [
+		`weapp-tailwindcss doctor`,
+		`cwd: ${report.cwd}`,
+		`summary: ${report.summary.error} error, ${report.summary.warn} warn, ${report.summary.ok} ok, ${report.summary.info} info`,
+		""
+	];
+	for (const check of report.checks) {
+		lines.push(`[${check.status}] ${check.title}: ${check.message}`);
+		if (check.suggestion) lines.push(`  -> ${check.suggestion}`);
+	}
+	return lines.join("\n");
+}
+//#endregion
+//#region src/cli/helpers/options/parse.ts
 function readStringOption(flag, value) {
-  if (value == null) {
-    return void 0;
-  }
-  if (typeof value !== "string") {
-    throw new TypeError(`Option "--${flag}" expects a string value.`);
-  }
-  const trimmed = value.trim();
-  if (trimmed.length === 0) {
-    throw new TypeError(`Option "--${flag}" expects a non-empty value.`);
-  }
-  return trimmed;
+	if (value == null) return;
+	if (typeof value !== "string") throw new TypeError(`Option "--${flag}" expects a string value.`);
+	const trimmed = value.trim();
+	if (trimmed.length === 0) throw new TypeError(`Option "--${flag}" expects a non-empty value.`);
+	return trimmed;
 }
 function readStringArrayOption(flag, value) {
-  if (value == null) {
-    return void 0;
-  }
-  if (Array.isArray(value)) {
-    const normalized2 = value.filter((entry) => entry != null).map((entry) => {
-      if (typeof entry !== "string") {
-        throw new TypeError(`Option "--${flag}" expects string values.`);
-      }
-      const trimmed = entry.trim();
-      if (!trimmed) {
-        throw new TypeError(`Option "--${flag}" expects non-empty values.`);
-      }
-      return trimmed;
-    });
-    return normalized2.length > 0 ? normalized2 : void 0;
-  }
-  const normalized = readStringOption(flag, value);
-  return normalized ? [normalized] : void 0;
+	if (value == null) return;
+	if (Array.isArray(value)) {
+		const normalized = value.filter((entry) => entry != null).map((entry) => {
+			if (typeof entry !== "string") throw new TypeError(`Option "--${flag}" expects string values.`);
+			const trimmed = entry.trim();
+			if (!trimmed) throw new TypeError(`Option "--${flag}" expects non-empty values.`);
+			return trimmed;
+		});
+		return normalized.length > 0 ? normalized : void 0;
+	}
+	const normalized = readStringOption(flag, value);
+	return normalized ? [normalized] : void 0;
 }
 function toBoolean(value, fallback) {
-  if (typeof value === "boolean") {
-    return value;
-  }
-  if (typeof value === "string") {
-    if (value === "true") {
-      return true;
-    }
-    if (value === "false") {
-      return false;
-    }
-  }
-  if (value == null) {
-    return fallback;
-  }
-  return Boolean(value);
-}
-
-// src/cli/helpers/options/resolve.ts
-import path13 from "path";
-import process13 from "process";
+	if (typeof value === "boolean") return value;
+	if (typeof value === "string") {
+		if (value === "true") return true;
+		if (value === "false") return false;
+	}
+	if (value == null) return fallback;
+	return Boolean(value);
+}
+//#endregion
+//#region src/cli/helpers/options/resolve.ts
 function resolveCliCwd(value) {
-  const raw = readStringOption("cwd", value);
-  if (!raw) {
-    return void 0;
-  }
-  return path13.isAbsolute(raw) ? path13.normalize(raw) : path13.resolve(process13.cwd(), raw);
-}
-
-// src/cli/helpers/patch-cwd.ts
-import path14 from "path";
-import process14 from "process";
-
-// src/tailwindcss/index.ts
-import { getPackageInfoSync } from "local-pkg";
+	const raw = readStringOption("cwd", value);
+	if (!raw) return;
+	return path.isAbsolute(raw) ? path.normalize(raw) : path.resolve(process.cwd(), raw);
+}
+//#endregion
+//#region src/tailwindcss/index.ts
 function getTailwindcssPackageInfo(options) {
-  return getPackageInfoSync("tailwindcss", options);
+	return getPackageInfoSync("tailwindcss", options);
 }
-
-// src/cli/helpers/patch-cwd.ts
+//#endregion
+//#region src/cli/helpers/patch-cwd.ts
+/**
+* Resolve default working directory for `weapp-tw patch`.
+* Prefer explicit env overrides to avoid cross-package INIT_CWD pollution.
+*/
 function normalizeCandidatePath(baseDir, candidate) {
-  if (!candidate) {
-    return void 0;
-  }
-  return path14.isAbsolute(candidate) ? path14.normalize(candidate) : path14.resolve(baseDir, candidate);
+	if (!candidate) return;
+	return path.isAbsolute(candidate) ? path.normalize(candidate) : path.resolve(baseDir, candidate);
 }
 function detectTailwindWorkspace(paths) {
-  for (const candidate of paths) {
-    try {
-      const info = getTailwindcssPackageInfo({ paths: [candidate] });
-      if (info?.rootPath) {
-        return candidate;
-      }
-    } catch {
-    }
-  }
-  return void 0;
-}
-function resolvePatchDefaultCwd(currentCwd = process14.cwd()) {
-  const baseDir = path14.normalize(currentCwd);
-  const explicitCwd = normalizeCandidatePath(baseDir, process14.env.WEAPP_TW_PATCH_CWD);
-  if (explicitCwd) {
-    return explicitCwd;
-  }
-  const workspaceRoot = findWorkspaceRoot(baseDir);
-  const initCwd = normalizeCandidatePath(baseDir, process14.env.INIT_CWD);
-  const localPrefix = normalizeCandidatePath(baseDir, process14.env.npm_config_local_prefix);
-  const candidates = [
-    baseDir,
-    workspaceRoot,
-    initCwd,
-    localPrefix
-  ].filter(Boolean);
-  const detected = detectTailwindWorkspace([...new Set(candidates)]);
-  if (detected) {
-    return detected;
-  }
-  return initCwd ?? localPrefix ?? workspaceRoot ?? baseDir;
-}
-
-// src/cli/helpers.ts
+	for (const candidate of paths) try {
+		if (getTailwindcssPackageInfo({ paths: [candidate] })?.rootPath) return candidate;
+	} catch {}
+}
+function resolvePatchDefaultCwd(currentCwd = process.cwd()) {
+	const baseDir = path.normalize(currentCwd);
+	const explicitCwd = normalizeCandidatePath(baseDir, process.env.WEAPP_TW_PATCH_CWD);
+	if (explicitCwd) return explicitCwd;
+	const workspaceRoot = findWorkspaceRoot(baseDir);
+	const initCwd = normalizeCandidatePath(baseDir, process.env.INIT_CWD);
+	const localPrefix = normalizeCandidatePath(baseDir, process.env.npm_config_local_prefix);
+	const candidates = [
+		baseDir,
+		workspaceRoot,
+		initCwd,
+		localPrefix
+	].filter(Boolean);
+	const detected = detectTailwindWorkspace([...new Set(candidates)]);
+	if (detected) return detected;
+	return initCwd ?? localPrefix ?? workspaceRoot ?? baseDir;
+}
+//#endregion
+//#region src/cli/helpers.ts
 async function ensureDir(dir) {
-  await mkdir2(dir, { recursive: true });
+	await mkdir(dir, { recursive: true });
 }
-function handleCliError(error) {
-  if (error instanceof Error) {
-    logger12.error(error.message);
-    if (error.stack && process15.env.WEAPP_TW_DEBUG === "1") {
-      logger12.error(error.stack);
-    }
-  } else {
-    logger12.error(String(error));
-  }
+function handleCliError$1(error) {
+	if (error instanceof Error) {
+		logger$1.error(error.message);
+		if (error.stack && process.env.WEAPP_TW_DEBUG === "1") logger$1.error(error.stack);
+	} else logger$1.error(String(error));
 }
 function commandAction(handler) {
-  return async (...args) => {
-    try {
-      await handler(...args);
-    } catch (error) {
-      handleCliError(error);
-      process15.exitCode = 1;
-    }
-  };
-}
-
-// src/cli/mount-options.ts
-import process17 from "process";
-
-// src/cli/mount-options/patch-status.ts
+	return async (...args) => {
+		try {
+			await handler(...args);
+		} catch (error) {
+			handleCliError$1(error);
+			process.exitCode = 1;
+		}
+	};
+}
+//#endregion
+//#region src/cli/mount-options/patch-status.ts
 function formatStatusFilesHint(files) {
-  if (!files?.length) {
-    return "";
-  }
-  return ` (${files.join(", ")})`;
+	if (!files?.length) return "";
+	return ` (${files.join(", ")})`;
 }
 function logPatchStatusReport(report) {
-  const applied = report.entries.filter((entry) => entry.status === "applied");
-  const pending = report.entries.filter((entry) => entry.status === "not-applied");
-  const skipped = report.entries.filter(
-    (entry) => entry.status === "skipped" || entry.status === "unsupported"
-  );
-  const packageLabel = `${report.package.name ?? "tailwindcss"}@${report.package.version ?? "unknown"}`;
-  logger12.info(`Patch status for ${packageLabel} (v${report.majorVersion})`);
-  if (applied.length) {
-    logger12.success("Applied:");
-    applied.forEach((entry) => {
-      logger12.success(`  - ${entry.name}${formatStatusFilesHint(entry.files)}`);
-    });
-  }
-  if (pending.length) {
-    logger12.warn("Needs attention:");
-    pending.forEach((entry) => {
-      const details = entry.reason ? ` - ${entry.reason}` : "";
-      logger12.warn(`  - ${entry.name}${formatStatusFilesHint(entry.files)}${details}`);
-    });
-  } else {
-    logger12.success("All applicable patches are applied.");
-  }
-  if (skipped.length) {
-    logger12.info("Skipped:");
-    skipped.forEach((entry) => {
-      const details = entry.reason ? ` - ${entry.reason}` : "";
-      logger12.info(`  - ${entry.name}${details}`);
-    });
-  }
-}
-
-// src/cli/patch-options.ts
-var DEFAULT_EXTEND_LENGTH_UNITS_FEATURE = {
-  enabled: true,
-  units: ["rpx"],
-  overwrite: true
+	const applied = report.entries.filter((entry) => entry.status === "applied");
+	const pending = report.entries.filter((entry) => entry.status === "not-applied");
+	const skipped = report.entries.filter((entry) => entry.status === "skipped" || entry.status === "unsupported");
+	const packageLabel = `${report.package.name ?? "tailwindcss"}@${report.package.version ?? "unknown"}`;
+	logger$1.info(`Patch status for ${packageLabel} (v${report.majorVersion})`);
+	if (applied.length) {
+		logger$1.success("Applied:");
+		applied.forEach((entry) => {
+			logger$1.success(`  - ${entry.name}${formatStatusFilesHint(entry.files)}`);
+		});
+	}
+	if (pending.length) {
+		logger$1.warn("Needs attention:");
+		pending.forEach((entry) => {
+			const details = entry.reason ? ` - ${entry.reason}` : "";
+			logger$1.warn(`  - ${entry.name}${formatStatusFilesHint(entry.files)}${details}`);
+		});
+	} else logger$1.success("All applicable patches are applied.");
+	if (skipped.length) {
+		logger$1.info("Skipped:");
+		skipped.forEach((entry) => {
+			const details = entry.reason ? ` - ${entry.reason}` : "";
+			logger$1.info(`  - ${entry.name}${details}`);
+		});
+	}
+}
+//#endregion
+//#region src/cli/patch-options.ts
+const DEFAULT_EXTEND_LENGTH_UNITS_FEATURE = {
+	enabled: true,
+	units: ["rpx"],
+	overwrite: true
 };
 function withDefaultExtendLengthUnits(options) {
-  const normalized = options ?? {};
-  const extendLengthUnits = normalized.apply?.extendLengthUnits;
-  if (extendLengthUnits == null) {
-    return {
-      ...normalized,
-      apply: {
-        ...normalized.apply ?? {},
-        extendLengthUnits: DEFAULT_EXTEND_LENGTH_UNITS_FEATURE
-      }
-    };
-  }
-  return normalized;
+	const normalized = options ?? {};
+	if (normalized.apply?.extendLengthUnits == null) return {
+		...normalized,
+		apply: {
+			...normalized.apply ?? {},
+			extendLengthUnits: DEFAULT_EXTEND_LENGTH_UNITS_FEATURE
+		}
+	};
+	return normalized;
 }
 function buildExtendLengthUnitsOverride(options) {
-  const extendLengthUnits = options?.apply?.extendLengthUnits;
-  if (extendLengthUnits == null) {
-    return {
-      apply: {
-        ...options?.apply ?? {},
-        extendLengthUnits: DEFAULT_EXTEND_LENGTH_UNITS_FEATURE
-      }
-    };
-  }
-  return void 0;
-}
-
-// src/cli/workspace.ts
-import path19 from "path";
-import process16 from "process";
-
-// src/cli/workspace/package-dirs.ts
-import { existsSync as existsSync8 } from "fs";
-import path17 from "path";
-import fg from "fast-glob";
-
-// src/cli/workspace/workspace-globs.ts
-import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
-import path15 from "path";
-import { parse as parseYaml } from "yaml";
-
-// src/cli/workspace/workspace-io.ts
-import { readFileSync as readFileSync4 } from "fs";
+	if (options?.apply?.extendLengthUnits == null) return { apply: {
+		...options?.apply ?? {},
+		extendLengthUnits: DEFAULT_EXTEND_LENGTH_UNITS_FEATURE
+	} };
+}
+//#endregion
+//#region src/cli/workspace/workspace-io.ts
 function tryReadJson(file) {
-  try {
-    const content = readFileSync4(file, "utf8");
-    return JSON.parse(content);
-  } catch {
-    return void 0;
-  }
-}
-
-// src/cli/workspace/workspace-globs.ts
+	try {
+		const content = readFileSync(file, "utf8");
+		return JSON.parse(content);
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/cli/workspace/workspace-globs.ts
 function parseWorkspaceGlobsFromPackageJson(workspaceRoot) {
-  const pkgJsonPath = path15.join(workspaceRoot, "package.json");
-  const pkg = tryReadJson(pkgJsonPath);
-  if (!pkg?.workspaces) {
-    return [];
-  }
-  if (Array.isArray(pkg.workspaces)) {
-    return pkg.workspaces.filter(Boolean);
-  }
-  if (Array.isArray(pkg.workspaces.packages)) {
-    return pkg.workspaces.packages.filter(Boolean);
-  }
-  return [];
+	const pkg = tryReadJson(path.join(workspaceRoot, "package.json"));
+	if (!pkg?.workspaces) return [];
+	if (Array.isArray(pkg.workspaces)) return pkg.workspaces.filter(Boolean);
+	if (Array.isArray(pkg.workspaces.packages)) return pkg.workspaces.packages.filter(Boolean);
+	return [];
 }
 function parseWorkspaceGlobsFromWorkspaceFile(workspaceRoot) {
-  const workspaceFile = path15.join(workspaceRoot, "pnpm-workspace.yaml");
-  if (!existsSync6(workspaceFile)) {
-    return [];
-  }
-  try {
-    const parsed = parseYaml(readFileSync5(workspaceFile, "utf8"));
-    return Array.isArray(parsed?.packages) ? parsed.packages.filter(Boolean) : [];
-  } catch {
-    return [];
-  }
-}
-
-// src/cli/workspace/workspace-lock.ts
-import { existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
-import path16 from "path";
-import { parse as parseYaml2 } from "yaml";
+	const workspaceFile = path.join(workspaceRoot, "pnpm-workspace.yaml");
+	if (!existsSync(workspaceFile)) return [];
+	try {
+		const parsed = parse(readFileSync(workspaceFile, "utf8"));
+		return Array.isArray(parsed?.packages) ? parsed.packages.filter(Boolean) : [];
+	} catch {
+		return [];
+	}
+}
+//#endregion
+//#region src/cli/workspace/workspace-lock.ts
 function parseImportersFromLock(workspaceRoot) {
-  const lockPath = path16.join(workspaceRoot, "pnpm-lock.yaml");
-  if (!existsSync7(lockPath)) {
-    return [];
-  }
-  try {
-    const parsed = parseYaml2(readFileSync6(lockPath, "utf8"));
-    const importers = parsed?.importers;
-    if (!importers) {
-      return [];
-    }
-    return Object.keys(importers).map((key) => {
-      if (!key || key === ".") {
-        return workspaceRoot;
-      }
-      return path16.join(workspaceRoot, key);
-    });
-  } catch {
-    return [];
-  }
-}
-
-// src/cli/workspace/package-dirs.ts
-var BACKSLASH_RE = /\\/g;
-var TRAILING_SLASH_RE = /\/+$/;
+	const lockPath = path.join(workspaceRoot, "pnpm-lock.yaml");
+	if (!existsSync(lockPath)) return [];
+	try {
+		const importers = parse(readFileSync(lockPath, "utf8"))?.importers;
+		if (!importers) return [];
+		return Object.keys(importers).map((key) => {
+			if (!key || key === ".") return workspaceRoot;
+			return path.join(workspaceRoot, key);
+		});
+	} catch {
+		return [];
+	}
+}
+//#endregion
+//#region src/cli/workspace/package-dirs.ts
+const BACKSLASH_RE$1 = /\\/g;
+const TRAILING_SLASH_RE = /\/+$/;
 async function resolveWorkspacePackageDirs(workspaceRoot) {
-  const dirs = /* @__PURE__ */ new Set();
-  for (const importerDir of parseImportersFromLock(workspaceRoot)) {
-    dirs.add(path17.normalize(importerDir));
-  }
-  if (!dirs.size) {
-    let globs = parseWorkspaceGlobsFromWorkspaceFile(workspaceRoot);
-    if (!globs.length) {
-      globs = parseWorkspaceGlobsFromPackageJson(workspaceRoot);
-    }
-    if (globs.length > 0) {
-      const patterns = globs.map((pattern) => {
-        const normalized = pattern.replace(BACKSLASH_RE, "/").replace(TRAILING_SLASH_RE, "");
-        return normalized.endsWith("package.json") ? normalized : `${normalized}/package.json`;
-      });
-      const packageJsonFiles = await fg(patterns, {
-        cwd: workspaceRoot,
-        absolute: true,
-        onlyFiles: true,
-        unique: true,
-        ignore: ["**/node_modules/**", "**/.git/**"]
-      });
-      for (const file of packageJsonFiles) {
-        dirs.add(path17.normalize(path17.dirname(file)));
-      }
-    }
-  }
-  const rootPkg = path17.join(workspaceRoot, "package.json");
-  if (existsSync8(rootPkg)) {
-    dirs.add(path17.normalize(workspaceRoot));
-  }
-  return [...dirs];
-}
-
-// src/cli/workspace/patch-package.ts
-import { normalizeOptions, TailwindcssPatcher as TailwindcssPatcher2 } from "tailwindcss-patch";
-
-// src/cli/workspace/patch-utils.ts
-import path18 from "path";
+	const dirs = /* @__PURE__ */ new Set();
+	for (const importerDir of parseImportersFromLock(workspaceRoot)) dirs.add(path.normalize(importerDir));
+	if (!dirs.size) {
+		let globs = parseWorkspaceGlobsFromWorkspaceFile(workspaceRoot);
+		if (!globs.length) globs = parseWorkspaceGlobsFromPackageJson(workspaceRoot);
+		if (globs.length > 0) {
+			const packageJsonFiles = await fg(globs.map((pattern) => {
+				const normalized = pattern.replace(BACKSLASH_RE$1, "/").replace(TRAILING_SLASH_RE, "");
+				return normalized.endsWith("package.json") ? normalized : `${normalized}/package.json`;
+			}), {
+				cwd: workspaceRoot,
+				absolute: true,
+				onlyFiles: true,
+				unique: true,
+				ignore: ["**/node_modules/**", "**/.git/**"]
+			});
+			for (const file of packageJsonFiles) dirs.add(path.normalize(path.dirname(file)));
+		}
+	}
+	if (existsSync(path.join(workspaceRoot, "package.json"))) dirs.add(path.normalize(workspaceRoot));
+	return [...dirs];
+}
+//#endregion
+//#region src/cli/workspace/patch-utils.ts
 function formatDisplayName(workspaceRoot, dir, name) {
-  const relative = path18.relative(workspaceRoot, dir) || ".";
-  return name ? `${name} (${relative})` : relative;
+	const relative = path.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;
-  logger12.info("[workspace] \u6C47\u603B\uFF1A\u5DF2\u8865\u4E01 %d\uFF0C\u8DF3\u8FC7 %d\uFF0C\u5931\u8D25 %d", patched, skipped, failed);
+	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;
+	logger$1.info("[workspace] 汇总：已补丁 %d，跳过 %d，失败 %d", patched, skipped, failed);
 }
-
-// src/cli/workspace/patch-package.ts
+//#endregion
+//#region src/cli/workspace/patch-package.ts
 function createWorkspacePatcher(cwd) {
-  const normalized = normalizeOptions(
-    withDefaultExtendLengthUnits({
-      projectRoot: cwd
-    })
-  );
-  return new TailwindcssPatcher2(normalized);
+	return new TailwindcssPatcher(normalizeOptions(withDefaultExtendLengthUnits({ projectRoot: cwd })));
 }
 async function patchWorkspacePackage(workspaceRoot, dir, pkgName, options) {
-  const displayName = formatDisplayName(workspaceRoot, dir, pkgName);
-  const tailwindInfo = getTailwindcssPackageInfo({ paths: [dir] });
-  if (!tailwindInfo?.rootPath) {
-    logger12.info("[workspace] \u8DF3\u8FC7 %s\uFF08tailwindcss \u672A\u5B89\u88C5\uFF09\u3002", displayName);
-    return {
-      dir,
-      name: pkgName,
-      status: "skipped",
-      message: "tailwindcss \u672A\u5B89\u88C5\uFF0C\u5DF2\u8DF3\u8FC7\u3002"
-    };
-  }
-  try {
-    const patcher = createWorkspacePatcher(dir);
-    if (options.clearCache) {
-      await clearTailwindcssPatcherCache(patcher, { removeDirectory: true });
-    }
-    const recorder = createPatchTargetRecorder(dir, patcher, {
-      source: "cli",
-      cwd: dir,
-      recordTarget: options.recordTarget !== false,
-      alwaysRecord: true
-    });
-    if (recorder?.message) {
-      logger12.info("[workspace] %s %s", displayName, recorder.message);
-    }
-    logTailwindcssTarget("cli", patcher, dir);
-    await patcher.patch();
-    if (recorder?.onPatched) {
-      await recorder.onPatched();
-    }
-    logger12.success("[workspace] \u5DF2\u8865\u4E01 %s", displayName);
-    return {
-      dir,
-      name: pkgName,
-      status: "patched",
-      message: "\u5DF2\u5B8C\u6210 patch\u3002"
-    };
-  } catch (error) {
-    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}`;
-    logger12.error("[workspace] \u8865\u4E01\u5931\u8D25 %s\uFF1A%s", displayName, message);
-    return {
-      dir,
-      name: pkgName,
-      status: "failed",
-      message
-    };
-  }
-}
-
-// src/cli/workspace.ts
+	const displayName = formatDisplayName(workspaceRoot, dir, pkgName);
+	if (!getTailwindcssPackageInfo({ paths: [dir] })?.rootPath) {
+		logger$1.info("[workspace] 跳过 %s（tailwindcss 未安装）。", displayName);
+		return {
+			dir,
+			name: pkgName,
+			status: "skipped",
+			message: "tailwindcss 未安装，已跳过。"
+		};
+	}
+	try {
+		const patcher = createWorkspacePatcher(dir);
+		if (options.clearCache) await clearTailwindcssPatcherCache(patcher, { removeDirectory: true });
+		const recorder = createPatchTargetRecorder(dir, patcher, {
+			source: "cli",
+			cwd: dir,
+			recordTarget: options.recordTarget !== false,
+			alwaysRecord: true
+		});
+		if (recorder?.message) logger$1.info("[workspace] %s %s", displayName, recorder.message);
+		logTailwindcssTarget("cli", patcher, dir);
+		await patcher.patch();
+		if (recorder?.onPatched) await recorder.onPatched();
+		logger$1.success("[workspace] 已补丁 %s", displayName);
+		return {
+			dir,
+			name: pkgName,
+			status: "patched",
+			message: "已完成 patch。"
+		};
+	} catch (error) {
+		const message = `${error instanceof Error ? error.message : String(error)}，${`请在 ${dir} 运行 "weapp-tw patch --cwd ${dir}".`}`;
+		logger$1.error("[workspace] 补丁失败 %s：%s", displayName, message);
+		return {
+			dir,
+			name: pkgName,
+			status: "failed",
+			message
+		};
+	}
+}
+//#endregion
+//#region src/cli/workspace.ts
 async function patchWorkspace(options) {
-  const cwd = options.cwd ?? process16.cwd();
-  const workspaceRoot = findWorkspaceRoot(cwd) ?? cwd;
-  const packageDirs = await resolveWorkspacePackageDirs(workspaceRoot);
-  if (packageDirs.length === 0) {
-    logger12.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 = path19.join(dir, "package.json");
-    const pkgJson = tryReadJson(pkgJsonPath);
-    results.push(await patchWorkspacePackage(workspaceRoot, dir, pkgJson?.name, options));
-  }
-  summarizeWorkspaceResults(results);
-}
-
-// src/cli/mount-options.ts
-function handleCliError2(error) {
-  if (error instanceof Error) {
-    logger12.error(error.message);
-    if (error.stack && process17.env.WEAPP_TW_DEBUG === "1") {
-      logger12.error(error.stack);
-    }
-  } else {
-    logger12.error(String(error));
-  }
+	const cwd = options.cwd ?? process.cwd();
+	const workspaceRoot = findWorkspaceRoot(cwd) ?? cwd;
+	const packageDirs = await resolveWorkspacePackageDirs(workspaceRoot);
+	if (packageDirs.length === 0) {
+		logger$1.warn("未在 %s 检测到 workspace 包，已跳过批量 patch。", workspaceRoot);
+		return;
+	}
+	const results = [];
+	for (const dir of packageDirs) {
+		const pkgJson = tryReadJson(path.join(dir, "package.json"));
+		results.push(await patchWorkspacePackage(workspaceRoot, dir, pkgJson?.name, options));
+	}
+	summarizeWorkspaceResults(results);
+}
+//#endregion
+//#region src/cli/mount-options.ts
+function handleCliError(error) {
+	if (error instanceof Error) {
+		logger$1.error(error.message);
+		if (error.stack && process.env.WEAPP_TW_DEBUG === "1") logger$1.error(error.stack);
+	} else logger$1.error(String(error));
 }
 function withCommandErrorHandling(handler) {
-  return (async (ctx, next) => {
-    try {
-      return await handler(ctx, next);
-    } catch (error) {
-      handleCliError2(error);
-      process17.exitCode = 1;
-      return void 0;
-    }
-  });
+	return (async (ctx, next) => {
+		try {
+			return await handler(ctx, next);
+		} catch (error) {
+			handleCliError(error);
+			process.exitCode = 1;
+			return;
+		}
+	});
 }
 async function createPatcherWithDefaultExtendLengthUnits(ctx) {
-  const patchOptions = await ctx.loadPatchOptions();
-  const extendLengthUnitsOverride = buildExtendLengthUnitsOverride(patchOptions);
-  if (extendLengthUnitsOverride) {
-    return ctx.createPatcher(extendLengthUnitsOverride);
-  }
-  return ctx.createPatcher();
-}
-var mountOptions = {
-  commandOptions: {
-    install: {
-      name: "patch",
-      aliases: ["install"],
-      appendDefaultOptions: false,
-      optionDefs: [
-        {
-          flags: "--cwd <dir>",
-          description: "Working directory",
-          config: { default: resolvePatchDefaultCwd() }
-        },
-        {
-          flags: "--record-target",
-          description: 'Write tailwindcss target metadata (node_modules/.cache/weapp-tailwindcss/tailwindcss-target.json). Pass "--record-target false" to skip.',
-          config: { default: true }
-        },
-        {
-          flags: "--clear-cache",
-          description: "Clear tailwindcss-patch cache before patch (opt-in)"
-        },
-        {
-          flags: "--workspace",
-          description: "Scan pnpm workspace packages and patch each Tailwind CSS dependency"
-        }
-      ]
-    },
-    status: {
-      appendDefaultOptions: false,
-      optionDefs: [
-        {
-          flags: "--cwd <dir>",
-          description: "Working directory",
-          config: { default: resolvePatchDefaultCwd() }
-        },
-        {
-          flags: "--json",
-          description: "Print a JSON report of patch status"
-        }
-      ]
-    }
-  },
-  commandHandlers: {
-    install: withCommandErrorHandling(async (ctx) => {
-      const shouldClearCache = toBoolean(ctx.args.clearCache, false);
-      const shouldRecordTarget = toBoolean(ctx.args.recordTarget, true);
-      const runWorkspace = toBoolean(ctx.args.workspace, false);
-      if (runWorkspace) {
-        await patchWorkspace({
-          cwd: ctx.cwd,
-          clearCache: shouldClearCache,
-          recordTarget: shouldRecordTarget
-        });
-        return;
-      }
-      const patcher = await createPatcherWithDefaultExtendLengthUnits(ctx);
-      if (shouldClearCache) {
-        await clearTailwindcssPatcherCache(patcher, { removeDirectory: true });
-      }
-      const recorder = createPatchTargetRecorder(ctx.cwd, patcher, {
-        source: "cli",
-        cwd: ctx.cwd,
-        recordTarget: shouldRecordTarget,
-        alwaysRecord: true
-      });
-      if (recorder?.message) {
-        logger12.info(recorder.message);
-      }
-      logTailwindcssTarget("cli", patcher, ctx.cwd);
-      await patcher.patch();
-      if (recorder?.onPatched) {
-        const recordPath = await recorder.onPatched();
-        if (recordPath) {
-          logger12.info(`\u8BB0\u5F55 weapp-tw patch \u76EE\u6807 -> ${formatOutputPath(recordPath, ctx.cwd)}`);
-        }
-      }
-      logger12.success("Tailwind CSS \u8FD0\u884C\u65F6\u8865\u4E01\u5DF2\u5B8C\u6210\u3002");
-    }),
-    extract: withCommandErrorHandling(async (_ctx, next) => next()),
-    tokens: withCommandErrorHandling(async (_ctx, next) => next()),
-    init: withCommandErrorHandling(async (_ctx, next) => next()),
-    status: withCommandErrorHandling(async (ctx) => {
-      const patcher = await createPatcherWithDefaultExtendLengthUnits(ctx);
-      const report = await patcher.getPatchStatus();
-      if (ctx.args.json) {
-        logger12.log(JSON.stringify(report, null, 2));
-        return report;
-      }
-      logPatchStatusReport(report);
-      return report;
-    })
-  }
+	const extendLengthUnitsOverride = buildExtendLengthUnitsOverride(await ctx.loadPatchOptions());
+	if (extendLengthUnitsOverride) return ctx.createPatcher(extendLengthUnitsOverride);
+	return ctx.createPatcher();
+}
+const mountOptions = {
+	commandOptions: {
+		install: {
+			name: "patch",
+			aliases: ["install"],
+			appendDefaultOptions: false,
+			optionDefs: [
+				{
+					flags: "--cwd <dir>",
+					description: "Working directory",
+					config: { default: resolvePatchDefaultCwd() }
+				},
+				{
+					flags: "--record-target",
+					description: "Write tailwindcss target metadata (node_modules/.cache/weapp-tailwindcss/tailwindcss-target.json). Pass \"--record-target false\" to skip.",
+					config: { default: true }
+				},
+				{
+					flags: "--clear-cache",
+					description: "Clear tailwindcss-patch cache before patch (opt-in)"
+				},
+				{
+					flags: "--workspace",
+					description: "Scan pnpm workspace packages and patch each Tailwind CSS dependency"
+				}
+			]
+		},
+		status: {
+			appendDefaultOptions: false,
+			optionDefs: [{
+				flags: "--cwd <dir>",
+				description: "Working directory",
+				config: { default: resolvePatchDefaultCwd() }
+			}, {
+				flags: "--json",
+				description: "Print a JSON report of patch status"
+			}]
+		}
+	},
+	commandHandlers: {
+		install: withCommandErrorHandling(async (ctx) => {
+			const shouldClearCache = toBoolean(ctx.args.clearCache, false);
+			const shouldRecordTarget = toBoolean(ctx.args.recordTarget, true);
+			if (toBoolean(ctx.args.workspace, false)) {
+				await patchWorkspace({
+					cwd: ctx.cwd,
+					clearCache: shouldClearCache,
+					recordTarget: shouldRecordTarget
+				});
+				return;
+			}
+			const patcher = await createPatcherWithDefaultExtendLengthUnits(ctx);
+			if (shouldClearCache) await clearTailwindcssPatcherCache(patcher, { removeDirectory: true });
+			const recorder = createPatchTargetRecorder(ctx.cwd, patcher, {
+				source: "cli",
+				cwd: ctx.cwd,
+				recordTarget: shouldRecordTarget,
+				alwaysRecord: true
+			});
+			if (recorder?.message) logger$1.info(recorder.message);
+			logTailwindcssTarget("cli", patcher, ctx.cwd);
+			await patcher.patch();
+			if (recorder?.onPatched) {
+				const recordPath = await recorder.onPatched();
+				if (recordPath) logger$1.info(`记录 weapp-tw patch 目标 -> ${formatOutputPath(recordPath, ctx.cwd)}`);
+			}
+			logger$1.success("Tailwind CSS 运行时补丁已完成。");
+		}),
+		extract: withCommandErrorHandling(async (_ctx, next) => next()),
+		tokens: withCommandErrorHandling(async (_ctx, next) => next()),
+		init: withCommandErrorHandling(async (_ctx, next) => next()),
+		status: withCommandErrorHandling(async (ctx) => {
+			const report = await (await createPatcherWithDefaultExtendLengthUnits(ctx)).getPatchStatus();
+			if (ctx.args.json) {
+				logger$1.log(JSON.stringify(report, null, 2));
+				return report;
+			}
+			logPatchStatusReport(report);
+			return report;
+		})
+	}
 };
-
-// src/cli/vscode-entry.ts
-import { constants } from "fs";
-import { access, writeFile as writeFile2 } from "fs/promises";
-import path20 from "path";
-var DEFAULT_VSCODE_ENTRY_OUTPUT = ".vscode/weapp-tailwindcss.intellisense.css";
-var DEFAULT_VSCODE_SOURCES = [
-  'not "./dist"',
-  'not "./unpackage"',
-  "./src/**/*.{wxml,axml,swan,qml,ttml,ux,uts}",
-  "./src/**/*.{js,jsx,ts,tsx}",
-  "./src/**/*.{vue,svelte,html,md,mdx}"
+//#endregion
+//#region src/cli/vscode-entry.ts
+const DEFAULT_VSCODE_ENTRY_OUTPUT = ".vscode/weapp-tailwindcss.intellisense.css";
+const DEFAULT_VSCODE_SOURCES = [
+	"not \"./dist\"",
+	"not \"./unpackage\"",
+	"./src/**/*.{wxml,axml,swan,qml,ttml,ux,uts}",
+	"./src/**/*.{js,jsx,ts,tsx,mjs,cjs,wxs,sjs}",
+	"./src/**/*.{vue,svelte,mpx,html,md,mdx}"
 ];
-var SINGLE_QUOTE = "'";
-var DOUBLE_QUOTE = '"';
-var BACKSLASH_RE2 = /\\/g;
+const SINGLE_QUOTE = "'";
+const DOUBLE_QUOTE = "\"";
+const BACKSLASH_RE = /\\/g;
 function toPosixPath(filepath) {
-  return filepath.replace(BACKSLASH_RE2, "/");
+	return filepath.replace(BACKSLASH_RE, "/");
 }
 async function assertFileExists(filepath) {
-  try {
-    await access(filepath, constants.F_OK);
-  } catch (error) {
-    const err = error;
-    if (err?.code === "ENOENT") {
-      throw new Error(`CSS entry file not found: ${filepath}`);
-    }
-    throw err;
-  }
+	try {
+		await access(filepath, constants.F_OK);
+	} catch (error) {
+		const err = error;
+		if (err?.code === "ENOENT") throw new Error(`CSS entry file not found: ${filepath}`);
+		throw err;
+	}
 }
 async function assertCanWrite(filepath, force) {
-  try {
-    await access(filepath, constants.F_OK);
-    if (!force) {
-      throw new Error(
-        `VS Code helper already exists at ${filepath}. Re-run with --force to overwrite it.`
-      );
-    }
-  } catch (error) {
-    const err = error;
-    if (err?.code === "ENOENT") {
-      return;
-    }
-    throw err;
-  }
+	try {
+		await access(filepath, constants.F_OK);
+		if (!force) throw new Error(`VS Code helper already exists at ${filepath}. Re-run with --force to overwrite it.`);
+	} catch (error) {
+		const err = error;
+		if (err?.code === "ENOENT") return;
+		throw err;
+	}
 }
 function toCssLiteral(value) {
-  const normalized = toPosixPath(value);
-  return JSON.stringify(normalized);
+	const normalized = toPosixPath(value);
+	return JSON.stringify(normalized);
 }
 function formatSource(pattern) {
-  const trimmed = pattern.trim();
-  if (!trimmed) {
-    return null;
-  }
-  if (trimmed.startsWith("@source ")) {
-    return trimmed.endsWith(";") ? trimmed : `${trimmed};`;
-  }
-  let body = trimmed;
-  let keyword = "";
-  if (body.startsWith("not ")) {
-    keyword = "not ";
-    body = body.slice(4).trim();
-  } else if (body.startsWith("!")) {
-    keyword = "not ";
-    body = body.slice(1).trim();
-  }
-  if (!body) {
-    throw new Error("Invalid @source pattern: empty body.");
-  }
-  if (!body.startsWith(SINGLE_QUOTE) && !body.startsWith(DOUBLE_QUOTE)) {
-    body = toCssLiteral(body);
-  }
-  return `@source ${keyword}${body};`;
+	const trimmed = pattern.trim();
+	if (!trimmed) return null;
+	if (trimmed.startsWith("@source ")) return trimmed.endsWith(";") ? trimmed : `${trimmed};`;
+	let body = trimmed;
+	let keyword = "";
+	if (body.startsWith("not ")) {
+		keyword = "not ";
+		body = body.slice(4).trim();
+	} else if (body.startsWith("!")) {
+		keyword = "not ";
+		body = body.slice(1).trim();
+	}
+	if (!body) throw new Error("Invalid @source pattern: empty body.");
+	if (!body.startsWith(SINGLE_QUOTE) && !body.startsWith(DOUBLE_QUOTE)) body = toCssLiteral(body);
+	return `@source ${keyword}${body};`;
 }
 function resolveOutputPath(baseDir, output) {
-  const target = output ?? DEFAULT_VSCODE_ENTRY_OUTPUT;
-  return path20.isAbsolute(target) ? path20.normalize(target) : path20.resolve(baseDir, target);
+	const target = output ?? ".vscode/weapp-tailwindcss.intellisense.css";
+	return path.isAbsolute(target) ? path.normalize(target) : path.resolve(baseDir, target);
 }
 function resolveCssEntry(baseDir, entry) {
-  return path20.isAbsolute(entry) ? path20.normalize(entry) : path20.resolve(baseDir, entry);
+	return path.isAbsolute(entry) ? path.normalize(entry) : path.resolve(baseDir, entry);
 }
 function toRelativeImport(fromFile, targetFile) {
-  const fromDir = path20.dirname(fromFile);
-  let relative = path20.relative(fromDir, targetFile);
-  if (!relative) {
-    relative = path20.basename(targetFile);
-  }
-  if (!relative.startsWith(".")) {
-    relative = `./${relative}`;
-  }
-  return toPosixPath(relative);
+	const fromDir = path.dirname(fromFile);
+	let relative = path.relative(fromDir, targetFile);
+	if (!relative) relative = path.basename(targetFile);
+	if (!relative.startsWith(".")) relative = `./${relative}`;
+	return toPosixPath(relative);
 }
 async function generateVscodeIntellisenseEntry(options) {
-  const baseDir = options.baseDir;
-  const cssEntryPath = resolveCssEntry(baseDir, options.cssEntry);
-  await assertFileExists(cssEntryPath);
-  const outputPath = resolveOutputPath(baseDir, options.output);
-  await ensureDir(path20.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));
-  const cssImport = toRelativeImport(outputPath, cssEntryPath);
-  const separator = formattedSources.length > 0 ? [""] : [];
-  const content = [
-    "/*",
-    " * Auto-generated by weapp-tailwindcss.",
-    " * This file exists solely to activate Tailwind CSS IntelliSense in VS Code.",
-    " * Do not import it in your actual mini-program bundles.",
-    " */",
-    "@import 'tailwindcss';",
-    "",
-    ...formattedSources,
-    ...separator,
-    `@import '${cssImport}';`,
-    ""
-  ].filter((line, idx, arr) => !(line === "" && arr[idx - 1] === "")).join("\n");
-  await writeFile2(outputPath, `${content}
-`, "utf8");
-  return { outputPath, cssEntryPath };
-}
-
-// src/cli.ts
-process18.title = "node (weapp-tailwindcss)";
-if (semver.lt(process18.versions.node, WEAPP_TW_REQUIRED_NODE_VERSION)) {
-  logger12.warn(
-    `You are using Node.js ${process18.versions.node}. For weapp-tailwindcss, Node.js version >= v${WEAPP_TW_REQUIRED_NODE_VERSION} is required.`
-  );
-}
-var cli = createTailwindcssPatchCli({
-  name: "weapp-tailwindcss",
-  mountOptions
+	const baseDir = options.baseDir;
+	const cssEntryPath = resolveCssEntry(baseDir, options.cssEntry);
+	await assertFileExists(cssEntryPath);
+	const outputPath = resolveOutputPath(baseDir, options.output);
+	await ensureDir(path.dirname(outputPath));
+	await assertCanWrite(outputPath, options.force);
+	const formattedSources = (options.sources && options.sources.length > 0 ? options.sources : DEFAULT_VSCODE_SOURCES).map(formatSource).filter((statement) => Boolean(statement));
+	const cssImport = toRelativeImport(outputPath, cssEntryPath);
+	const separator = formattedSources.length > 0 ? [""] : [];
+	await writeFile(outputPath, `${[
+		"/*",
+		" * Auto-generated by weapp-tailwindcss.",
+		" * This file exists solely to activate Tailwind CSS IntelliSense in VS Code.",
+		" * Do not import it in your actual mini-program bundles.",
+		" */",
+		"@import 'tailwindcss';",
+		"",
+		...formattedSources,
+		...separator,
+		`@import '${cssImport}';`,
+		""
+	].filter((line, idx, arr) => !(line === "" && arr[idx - 1] === "")).join("\n")}\n`, "utf8");
+	return {
+		outputPath,
+		cssEntryPath
+	};
+}
+//#endregion
+//#region src/cli.ts
+process.title = "node (weapp-tailwindcss)";
+if (!semver.satisfies(process.versions.node, "^20.19.0 || >=22.12.0")) logger$1.warn(`You are using Node.js ${process.versions.node}. For weapp-tailwindcss, Node.js version ${WEAPP_TW_REQUIRED_NODE_VERSION_RANGE} is required.`);
+const cli = 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 = resolvedCwd ?? process18.cwd();
-    const cssEntry = readStringOption("css", options.css);
-    if (!cssEntry) {
-      throw new Error('Option "--css" is required.');
-    }
-    const output = readStringOption("output", options.output);
-    const sources = readStringArrayOption("source", options.source);
-    const force = toBoolean(options.force, false);
-    const result = await generateVscodeIntellisenseEntry({
-      baseDir,
-      cssEntry,
-      output,
-      sources,
-      force
-    });
-    logger12.success(
-      `VS Code helper generated -> ${formatOutputPath(result.outputPath, resolvedCwd)}`
-    );
-  })
-);
+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 = resolvedCwd ?? process.cwd();
+	const cssEntry = readStringOption("css", options.css);
+	if (!cssEntry) throw new Error("Option \"--css\" is required.");
+	const result = await generateVscodeIntellisenseEntry({
+		baseDir,
+		cssEntry,
+		output: readStringOption("output", options.output),
+		sources: readStringArrayOption("source", options.source),
+		force: toBoolean(options.force, false)
+	});
+	logger$1.success(`VS Code helper generated -> ${formatOutputPath(result.outputPath, resolvedCwd)}`);
+}));
+cli.command("doctor", "Check project setup for weapp-tailwindcss").option("--cwd <dir>", "Working directory").option("--json", "Print a JSON report").option("--strict", "Exit with code 1 when warnings are found").action(commandAction(async (options) => {
+	const report = createDoctorReport({ cwd: resolveCliCwd(options.cwd) });
+	if (toBoolean(options.json, false)) logger$1.log(JSON.stringify(report, null, 2));
+	else logger$1.log(formatDoctorReport(report));
+	if (hasDoctorFailure(report, toBoolean(options.strict, false))) process.exitCode = 1;
+}));
 cli.help();
-cli.version(process18.env.npm_package_version ?? "0.0.0");
+cli.version(process.env.npm_package_version ?? "0.0.0");
 cli.parse();
+//#endregion
+export {};