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

package/dist/cli.mjs

@@ -1,40 +1,875 @@
-import {
-  WEAPP_TW_REQUIRED_NODE_VERSION,
-  clearTailwindcssPatcherCache,
-  createPatchTargetRecorder,
-  logTailwindcssTarget
-} from "./chunk-FZNYV7VH.mjs";
-import {
-  findWorkspaceRoot,
-  logger
-} from "./chunk-IEZ5RBMG.mjs";
-import "./chunk-35EI5JMK.mjs";
-import "./chunk-OOHJLO5M.mjs";
-import "./chunk-DOH7FULQ.mjs";
-
 // src/cli.ts
-import process7 from "process";
+import process17 from "process";
 import semver from "semver";
 import { createTailwindcssPatchCli } from "tailwindcss-patch";
 
 // src/cli/context.ts
+import path12 from "path";
+import process11 from "process";
+
+// src/context/index.ts
+import { rm } from "fs/promises";
+import { logger as logger10, pc } from "@weapp-tailwindcss/logger";
+
+// src/cache/index.ts
+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 _createDebug from "debug";
+var _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/targets.ts
+import process5 from "process";
+import { logger as logger2 } 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";
+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;
+  }
+}
+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);
+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);
+}
+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
+  };
+}
+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 process3 from "process";
+import { logger } from "@weapp-tailwindcss/logger";
+
+// package.json
+var package_default = {
+  name: "weapp-tailwindcss",
+  version: "4.11.0-alpha.2",
+  description: "\u628A tailwindcss \u539F\u5B50\u5316\u6837\u5F0F\u601D\u60F3\uFF0C\u5E26\u7ED9\u5C0F\u7A0B\u5E8F\u5F00\u53D1\u8005\u4EEC! bring tailwindcss to miniprogram developers!",
+  author: "ice breaker <1324318532@qq.com>",
+  license: "MIT",
+  homepage: "https://tw.icebreaker.top",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/sonofmagic/weapp-tailwindcss.git",
+    directory: "packages/weapp-tailwindcss"
+  },
+  bugs: {
+    url: "https://github.com/sonofmagic/weapp-tailwindcss/issues"
+  },
+  keywords: [
+    "tailwindcss",
+    "weapp",
+    "wechat",
+    "mini",
+    "miniprogram",
+    "mini app",
+    "weapp-tw",
+    "weapp-tailwindcss",
+    "taro",
+    "uni-app",
+    "remax",
+    "rax",
+    "mpx",
+    "jit",
+    "mp",
+    "android",
+    "ios",
+    "\u5C0F\u7A0B\u5E8F",
+    "vite",
+    "postcss",
+    "webpack",
+    "webpack-plugin",
+    "gulp",
+    "gulp-plugin"
+  ],
+  exports: {
+    ".": {
+      style: "./index.css",
+      types: "./dist/index.d.ts",
+      import: "./dist/index.mjs",
+      require: "./dist/index.js"
+    },
+    "./escape": {
+      types: "./dist/escape.d.ts",
+      import: "./dist/escape.mjs",
+      require: "./dist/escape.js"
+    },
+    "./vite": {
+      types: "./dist/vite.d.ts",
+      import: "./dist/vite.mjs",
+      require: "./dist/vite.js"
+    },
+    "./webpack": {
+      types: "./dist/webpack.d.ts",
+      import: "./dist/webpack.mjs",
+      require: "./dist/webpack.js"
+    },
+    "./webpack4": {
+      types: "./dist/webpack4.d.ts",
+      import: "./dist/webpack4.mjs",
+      require: "./dist/webpack4.js"
+    },
+    "./core": {
+      types: "./dist/core.d.ts",
+      import: "./dist/core.mjs",
+      require: "./dist/core.js"
+    },
+    "./gulp": {
+      types: "./dist/gulp.d.ts",
+      import: "./dist/gulp.mjs",
+      require: "./dist/gulp.js"
+    },
+    "./defaults": {
+      types: "./dist/defaults.d.ts",
+      import: "./dist/defaults.mjs",
+      require: "./dist/defaults.js"
+    },
+    "./presets": {
+      types: "./dist/presets.d.ts",
+      import: "./dist/presets.mjs",
+      require: "./dist/presets.js"
+    },
+    "./reset": {
+      types: "./dist/reset.d.ts",
+      import: "./dist/reset.mjs",
+      require: "./dist/reset.js"
+    },
+    "./css-macro/postcss": {
+      types: "./dist/css-macro/postcss.d.ts",
+      import: "./dist/css-macro/postcss.mjs",
+      require: "./dist/css-macro/postcss.js"
+    },
+    "./css-macro": {
+      types: "./dist/css-macro.d.ts",
+      import: "./dist/css-macro.mjs",
+      require: "./dist/css-macro.js"
+    },
+    "./types": {
+      types: "./dist/types.d.ts",
+      import: "./dist/types.mjs",
+      require: "./dist/types.js"
+    },
+    "./postcss-html-transform": {
+      types: "./dist/postcss-html-transform.d.ts",
+      import: "./dist/postcss-html-transform.mjs",
+      require: "./dist/postcss-html-transform.js"
+    },
+    "./package.json": "./package.json",
+    "./index.css": "./index.css",
+    "./index": "./index.css",
+    "./preflight.css": "./preflight.css",
+    "./preflight": "./preflight.css",
+    "./theme.css": "./theme.css",
+    "./theme": "./theme.css",
+    "./utilities.css": "./utilities.css",
+    "./utilities": "./utilities.css",
+    "./with-layer.css": "./with-layer.css",
+    "./with-layer": "./with-layer.css",
+    "./uni-app-x": "./uni-app-x.css",
+    "./uni-app-x.css": "./uni-app-x.css",
+    "./css": "./css/index.css",
+    "./*": "./*"
+  },
+  main: "./dist/index.js",
+  module: "./dist/index.mjs",
+  types: "./dist/index.d.ts",
+  style: "index.css",
+  typesVersions: {
+    "*": {
+      "*": [
+        "./dist/*",
+        "./dist/index.d.ts"
+      ]
+    }
+  },
+  bin: {
+    "weapp-tailwindcss-webpack-plugin": "bin/weapp-tailwindcss.js",
+    "weapp-tailwindcss": "bin/weapp-tailwindcss.js",
+    "weapp-tw": "bin/weapp-tailwindcss.js"
+  },
+  files: [
+    "bin",
+    "css",
+    "dist",
+    "index.css",
+    "preflight.css",
+    "theme.css",
+    "uni-app-x.css",
+    "utilities.css",
+    "with-layer.css"
+  ],
+  engines: {
+    node: "^18.17.0 || >=20.5.0"
+  },
+  scripts: {
+    dev: "tsup --watch --sourcemap",
+    build: "tsup && node scripts/ensure-escape-dts.mjs",
+    "build:tsc": "cross-env NODE_ENV=development tsc --build tsconfig.json",
+    "build:cli": "cd plugins/cli && pnpm run build",
+    "build:css": "tsx scripts/build-css.ts",
+    "build:weapp-theme": "tsx scripts/build-weapp-theme.ts",
+    test: "npm run postinstall && vitest run",
+    "test:dev": "vitest",
+    "test:ui": "vitest --ui",
+    bench: "vitest bench --config ./vitest.config.ts",
+    "bench:vite-perf": "tsx scripts/vite-perf-bench.ts",
+    "bench:vite-perf:summary": "tsx scripts/vite-perf-summary.ts",
+    "bench:js-handlers": "tsx scripts/js-bench.ts",
+    "bench:js-diff": "tsx scripts/js-bench-diff.ts",
+    tsd: "tsd",
+    clean: "tsx scripts/clean.ts",
+    "get-decl": "tsx scripts/get-decl.ts",
+    "ls:pack": "npm pack --dry-run",
+    "cli:patch": "node bin/weapp-tailwindcss.js patch",
+    colors: "tsx scripts/colors.ts",
+    release: "tsx scripts/release.ts",
+    lint: "eslint .",
+    "lint:fix": "eslint ./src --fix",
+    postinstall: "node bin/weapp-tailwindcss.js patch",
+    "bench:vite-dev-hmr": "tsx scripts/vite-dev-hmr-bench.ts",
+    "test:watch-hmr": "node --import tsx scripts/watch-hmr-regression/index.ts"
+  },
+  publishConfig: {
+    access: "public",
+    registry: "https://registry.npmjs.org"
+  },
+  dependencies: {
+    "@ast-core/escape": "~1.0.1",
+    "@babel/parser": "~7.29.2",
+    "@babel/traverse": "~7.29.0",
+    "@babel/types": "~7.29.0",
+    "@tailwindcss-mangle/config": "^6.1.3",
+    "@vue/compiler-dom": "catalog:vue3",
+    "@vue/compiler-sfc": "catalog:vue3",
+    "@weapp-core/escape": "~7.0.0",
+    "@weapp-core/regex": "~1.0.1",
+    "@weapp-tailwindcss/logger": "workspace:*",
+    "@weapp-tailwindcss/postcss": "workspace:*",
+    "@weapp-tailwindcss/shared": "workspace:*",
+    cac: "6.7.14",
+    debug: "~4.4.3",
+    "fast-glob": "^3.3.3",
+    htmlparser2: "10.1.0",
+    "loader-utils": "2.0.4",
+    "local-pkg": "^1.1.2",
+    "lru-cache": "10.4.3",
+    "magic-string": "0.30.21",
+    semver: "~7.7.4",
+    "tailwindcss-patch": "catalog:tailwindcssPatch",
+    "webpack-sources": "3.3.4",
+    yaml: "^2.8.3"
+  }
+};
+
+// src/constants.ts
+var WEAPP_TW_REQUIRED_NODE_VERSION = "18.17.0";
+var WEAPP_TW_VERSION = package_default.version;
+
+// src/tailwindcss/targets/record-io.ts
+var loggedInvalidPatchRecords = /* @__PURE__ */ new Set();
+function warnInvalidPatchTargetRecord(baseDir, recordPath, reason) {
+  const normalizedPath = path4.normalize(recordPath);
+  if (loggedInvalidPatchRecords.has(normalizedPath)) {
+    return;
+  }
+  loggedInvalidPatchRecords.add(normalizedPath);
+  const fileDisplay = formatRelativeToBase(normalizedPath, baseDir);
+  const baseDisplay = formatRelativeToBase(path4.normalize(baseDir), process3.cwd());
+  const reasonMessage = reason ? `\uFF1A${reason}` : "";
+  logger.warn(
+    `\u68C0\u6D4B\u5230\u635F\u574F\u7684 Tailwind CSS \u76EE\u6807\u8BB0\u5F55 ${fileDisplay}${reasonMessage}\u3002\u8BF7\u5728 ${baseDisplay} \u91CD\u65B0\u6267\u884C "weapp-tw patch --record-target" \u6216\u5220\u9664\u8BE5\u6587\u4EF6\u540E\u518D\u8FD0\u884C\u3002`
+  );
+}
+function readPatchTargetRecord(baseDir) {
+  if (!baseDir) {
+    return void 0;
+  }
+  const normalizedBase = 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;
+}
+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, process3.cwd());
+    logger.warn(
+      '\u81EA\u52A8\u66F4\u65B0 Tailwind CSS \u8865\u4E01\u8BB0\u5F55\u5931\u8D25\uFF0C\u8BF7\u5728 %s \u8FD0\u884C "weapp-tw patch --cwd %s"\u3002',
+      baseDisplay,
+      normalizedBase
+    );
+    logger.debug("failed to persist patch target record %s: %O", recordPath, error);
+    return void 0;
+  }
+}
+
+// src/tailwindcss/targets/recorder.ts
+import path5 from "path";
+import process4 from "process";
+function findPatchTargetRecord(baseDir) {
+  const visited = /* @__PURE__ */ new Set();
+  const fallback = baseDir ?? process4.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;
+}
+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
+function logTailwindcssTarget(kind, patcher, baseDir) {
+  const packageInfo = patcher?.packageInfo;
+  const label = kind === "cli" ? "weapp-tw patch" : "tailwindcss-patcher";
+  if (!packageInfo?.rootPath) {
+    logger2.warn(
+      "%s \u672A\u627E\u5230 Tailwind CSS \u4F9D\u8D56\uFF0C\u8BF7\u68C0\u67E5\u5728 %s \u662F\u5426\u5DF2\u5B89\u88C5 tailwindcss",
+      label,
+      baseDir ?? process5.cwd()
+    );
+    return;
+  }
+  const displayPath = formatRelativeToBase(packageInfo.rootPath, baseDir);
+  const version = packageInfo.version ? ` (v${packageInfo.version})` : "";
+  logger2.info("%s \u7ED1\u5B9A Tailwind CSS -> %s%s", label, displayPath, version);
+}
+
+// src/tailwindcss/v4/config.ts
+import { logger as logger3 } from "@weapp-tailwindcss/logger";
+
+// src/tailwindcss/v4/patcher.ts
+import { logger as logger5 } from "@weapp-tailwindcss/logger";
+
+// src/tailwindcss/patcher.ts
+import path7 from "path";
+import process7 from "process";
+import { logger as logger4 } 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 process6 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 process8 from "process";
+import { logger as logger6 } 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/babel/index.ts
+import _babelTraverse from "@babel/traverse";
+import { parse, parseExpression } from "@babel/parser";
+function _interopDefaultCompat(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
+]);
+function isWhitespace(char) {
+  if (char.length === 0) {
+    return false;
+  }
+  return WHITESPACE_CODES.has(char.charCodeAt(0));
+}
+
+// src/wxml/Tokenizer.ts
+var Tokenizer = class {
+  constructor() {
+    this.reset();
+  }
+  processChar(char, index) {
+    switch (this.state) {
+      case 0 /* START */:
+        if (isWhitespace(char)) {
+        } else if (char === "{") {
+          this.state = 2 /* OPEN_BRACE */;
+          this.bufferStartIndex = index;
+          this.buffer += char;
+          this.expressionBuffer = char;
+          this.expressionStartIndex = index;
+        } else {
+          this.state = 1 /* TEXT */;
+          this.bufferStartIndex = index;
+          this.buffer += char;
+        }
+        break;
+      case 1 /* TEXT */:
+        if (isWhitespace(char)) {
+          this.tokens.push({ start: this.bufferStartIndex, end: index, value: this.buffer, expressions: this.expressions });
+          this.buffer = "";
+          this.expressions = [];
+          this.state = 0 /* START */;
+        } else if (char === "{") {
+          this.buffer += char;
+          this.expressionBuffer = char;
+          this.expressionStartIndex = index;
+          this.state = 2 /* OPEN_BRACE */;
+        } else {
+          this.buffer += char;
+        }
+        break;
+      case 2 /* OPEN_BRACE */:
+        if (char === "}") {
+          this.buffer += char;
+          this.expressionBuffer += char;
+          this.state = 3 /* POTENTIAL_CLOSE */;
+        } else {
+          this.buffer += char;
+          this.expressionBuffer += char;
+        }
+        break;
+      case 3 /* POTENTIAL_CLOSE */:
+        if (char === "}") {
+          this.buffer += char;
+          this.expressionBuffer += char;
+          this.expressions.push({
+            start: this.expressionStartIndex,
+            end: index + 1,
+            value: this.expressionBuffer
+          });
+          this.expressionBuffer = "";
+          this.state = 4 /* BRACES_COMPLETE */;
+        } else {
+          this.buffer += char;
+          this.expressionBuffer += char;
+          this.state = 2 /* OPEN_BRACE */;
+        }
+        break;
+      case 4 /* BRACES_COMPLETE */:
+        if (isWhitespace(char)) {
+          this.tokens.push({
+            start: this.bufferStartIndex,
+            end: index,
+            value: this.buffer,
+            expressions: this.expressions
+          });
+          this.buffer = "";
+          this.expressions = [];
+          this.state = 0 /* START */;
+        } else if (char === "{") {
+          this.expressionStartIndex = index;
+          this.expressionBuffer = char;
+          this.buffer += char;
+          this.state = 2 /* OPEN_BRACE */;
+        } else {
+          this.buffer += char;
+          this.state = 1 /* TEXT */;
+        }
+        break;
+      default:
+        throw new Error("Unexpected state");
+    }
+  }
+  run(input) {
+    this.reset();
+    for (let i = 0; i < input.length; i++) {
+      const char = input[i];
+      this.processChar(char, i);
+    }
+    if (this.buffer.length > 0) {
+      this.tokens.push({
+        start: this.bufferStartIndex,
+        end: input.length,
+        value: this.buffer,
+        expressions: this.expressions
+      });
+    }
+    const tokens = this.tokens;
+    this.reset();
+    return tokens;
+  }
+  reset() {
+    this.state = 0 /* START */;
+    this.buffer = "";
+    this.tokens = [];
+    this.bufferStartIndex = 0;
+    this.expressionBuffer = "";
+    this.expressionStartIndex = 0;
+    this.expressions = [];
+  }
+};
+
+// src/wxml/utils/template-fragments.ts
+var sharedTokenizer = new Tokenizer();
+
+// src/context/logger.ts
+import { logger as logger7 } from "@weapp-tailwindcss/logger";
+
+// src/context/tailwindcss.ts
+import { logger as logger9 } from "@weapp-tailwindcss/logger";
+
+// src/context/tailwindcss/basedir.ts
+import { createRequire as createRequire2 } from "module";
+import path10 from "path";
+import process9 from "process";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { logger as logger8 } from "@weapp-tailwindcss/logger";
+
+// src/context/tailwindcss/rax.ts
+import { existsSync as existsSync5, readFileSync as readFileSync3 } from "fs";
+import path11 from "path";
+import process10 from "process";
+
+// src/context/index.ts
+async function clearTailwindcssPatcherCache(patcher, options) {
+  if (!patcher) {
+    return;
+  }
+  const cacheOptions = patcher.options?.cache;
+  if (cacheOptions == null || typeof cacheOptions === "object" && cacheOptions.enabled === false) {
+    return;
+  }
+  if (typeof patcher.clearCache === "function") {
+    try {
+      await patcher.clearCache({ scope: "all" });
+    } catch (error) {
+      logger10.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;
+      }
+      logger10.debug("failed to clear tailwindcss patcher cache: %s %O", cachePath, err);
+    }
+  }
+}
+
+// src/cli/context.ts
 function formatOutputPath(target, baseDir) {
-  const root = baseDir ?? process.cwd();
-  const relative = path.relative(root, target);
+  const root = baseDir ?? process11.cwd();
+  const relative = path12.relative(root, target);
   if (!relative) {
     return ".";
   }
   if (relative.startsWith("..")) {
-    return path.normalize(target);
+    return path12.normalize(target);
   }
-  return relative.startsWith(".") ? relative : `.${path.sep}${relative}`;
+  return relative.startsWith(".") ? relative : `.${path12.sep}${relative}`;
 }
 
 // src/cli/helpers.ts
-import { mkdir } from "fs/promises";
-import process4 from "process";
+import { mkdir as mkdir2 } from "fs/promises";
+import process14 from "process";
+
+// src/logger/index.ts
+import { logger as logger11 } from "@weapp-tailwindcss/logger";
 
 // src/cli/helpers/options/parse.ts
 function readStringOption(flag, value) {
@@ -89,19 +924,19 @@ function toBoolean(value, fallback) {
 }
 
 // src/cli/helpers/options/resolve.ts
-import path2 from "path";
-import process2 from "process";
+import path13 from "path";
+import process12 from "process";
 function resolveCliCwd(value) {
   const raw = readStringOption("cwd", value);
   if (!raw) {
     return void 0;
   }
-  return path2.isAbsolute(raw) ? path2.normalize(raw) : path2.resolve(process2.cwd(), raw);
+  return path13.isAbsolute(raw) ? path13.normalize(raw) : path13.resolve(process12.cwd(), raw);
 }
 
 // src/cli/helpers/patch-cwd.ts
-import path3 from "path";
-import process3 from "process";
+import path14 from "path";
+import process13 from "process";
 
 // src/tailwindcss/index.ts
 import { getPackageInfoSync } from "local-pkg";
@@ -114,7 +949,7 @@ function normalizeCandidatePath(baseDir, candidate) {
   if (!candidate) {
     return void 0;
   }
-  return path3.isAbsolute(candidate) ? path3.normalize(candidate) : path3.resolve(baseDir, candidate);
+  return path14.isAbsolute(candidate) ? path14.normalize(candidate) : path14.resolve(baseDir, candidate);
 }
 function detectTailwindWorkspace(paths) {
   for (const candidate of paths) {
@@ -128,15 +963,15 @@ function detectTailwindWorkspace(paths) {
   }
   return void 0;
 }
-function resolvePatchDefaultCwd(currentCwd = process3.cwd()) {
-  const baseDir = path3.normalize(currentCwd);
-  const explicitCwd = normalizeCandidatePath(baseDir, process3.env.WEAPP_TW_PATCH_CWD);
+function resolvePatchDefaultCwd(currentCwd = process13.cwd()) {
+  const baseDir = path14.normalize(currentCwd);
+  const explicitCwd = normalizeCandidatePath(baseDir, process13.env.WEAPP_TW_PATCH_CWD);
   if (explicitCwd) {
     return explicitCwd;
   }
   const workspaceRoot = findWorkspaceRoot(baseDir);
-  const initCwd = normalizeCandidatePath(baseDir, process3.env.INIT_CWD);
-  const localPrefix = normalizeCandidatePath(baseDir, process3.env.npm_config_local_prefix);
+  const initCwd = normalizeCandidatePath(baseDir, process13.env.INIT_CWD);
+  const localPrefix = normalizeCandidatePath(baseDir, process13.env.npm_config_local_prefix);
   const candidates = [
     baseDir,
     workspaceRoot,
@@ -152,16 +987,16 @@ function resolvePatchDefaultCwd(currentCwd = process3.cwd()) {
 
 // src/cli/helpers.ts
 async function ensureDir(dir) {
-  await mkdir(dir, { recursive: true });
+  await mkdir2(dir, { recursive: true });
 }
 function handleCliError(error) {
   if (error instanceof Error) {
-    logger.error(error.message);
-    if (error.stack && process4.env.WEAPP_TW_DEBUG === "1") {
-      logger.error(error.stack);
+    logger11.error(error.message);
+    if (error.stack && process14.env.WEAPP_TW_DEBUG === "1") {
+      logger11.error(error.stack);
     }
   } else {
-    logger.error(String(error));
+    logger11.error(String(error));
   }
 }
 function commandAction(handler) {
@@ -170,13 +1005,13 @@ function commandAction(handler) {
       await handler(...args);
     } catch (error) {
       handleCliError(error);
-      process4.exitCode = 1;
+      process14.exitCode = 1;
     }
   };
 }
 
 // src/cli/mount-options.ts
-import process6 from "process";
+import process16 from "process";
 
 // src/cli/mount-options/patch-status.ts
 function formatStatusFilesHint(files) {
@@ -192,27 +1027,27 @@ function logPatchStatusReport(report) {
     (entry) => entry.status === "skipped" || entry.status === "unsupported"
   );
   const packageLabel = `${report.package.name ?? "tailwindcss"}@${report.package.version ?? "unknown"}`;
-  logger.info(`Patch status for ${packageLabel} (v${report.majorVersion})`);
+  logger11.info(`Patch status for ${packageLabel} (v${report.majorVersion})`);
   if (applied.length) {
-    logger.success("Applied:");
+    logger11.success("Applied:");
     applied.forEach((entry) => {
-      logger.success(`  - ${entry.name}${formatStatusFilesHint(entry.files)}`);
+      logger11.success(`  - ${entry.name}${formatStatusFilesHint(entry.files)}`);
     });
   }
   if (pending.length) {
-    logger.warn("Needs attention:");
+    logger11.warn("Needs attention:");
     pending.forEach((entry) => {
       const details = entry.reason ? ` - ${entry.reason}` : "";
-      logger.warn(`  - ${entry.name}${formatStatusFilesHint(entry.files)}${details}`);
+      logger11.warn(`  - ${entry.name}${formatStatusFilesHint(entry.files)}${details}`);
     });
   } else {
-    logger.success("All applicable patches are applied.");
+    logger11.success("All applicable patches are applied.");
   }
   if (skipped.length) {
-    logger.info("Skipped:");
+    logger11.info("Skipped:");
     skipped.forEach((entry) => {
       const details = entry.reason ? ` - ${entry.reason}` : "";
-      logger.info(`  - ${entry.name}${details}`);
+      logger11.info(`  - ${entry.name}${details}`);
     });
   }
 }
@@ -251,24 +1086,24 @@ function buildExtendLengthUnitsOverride(options) {
 }
 
 // src/cli/workspace.ts
-import path8 from "path";
-import process5 from "process";
+import path19 from "path";
+import process15 from "process";
 
 // src/cli/workspace/package-dirs.ts
-import { existsSync as existsSync3 } from "fs";
-import path6 from "path";
+import { existsSync as existsSync8 } from "fs";
+import path17 from "path";
 import fg from "fast-glob";
 
 // src/cli/workspace/workspace-globs.ts
-import { existsSync, readFileSync as readFileSync2 } from "fs";
-import path4 from "path";
+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 } from "fs";
+import { readFileSync as readFileSync4 } from "fs";
 function tryReadJson(file) {
   try {
-    const content = readFileSync(file, "utf8");
+    const content = readFileSync4(file, "utf8");
     return JSON.parse(content);
   } catch {
     return void 0;
@@ -277,7 +1112,7 @@ function tryReadJson(file) {
 
 // src/cli/workspace/workspace-globs.ts
 function parseWorkspaceGlobsFromPackageJson(workspaceRoot) {
-  const pkgJsonPath = path4.join(workspaceRoot, "package.json");
+  const pkgJsonPath = path15.join(workspaceRoot, "package.json");
   const pkg = tryReadJson(pkgJsonPath);
   if (!pkg?.workspaces) {
     return [];
@@ -291,12 +1126,12 @@ function parseWorkspaceGlobsFromPackageJson(workspaceRoot) {
   return [];
 }
 function parseWorkspaceGlobsFromWorkspaceFile(workspaceRoot) {
-  const workspaceFile = path4.join(workspaceRoot, "pnpm-workspace.yaml");
-  if (!existsSync(workspaceFile)) {
+  const workspaceFile = path15.join(workspaceRoot, "pnpm-workspace.yaml");
+  if (!existsSync6(workspaceFile)) {
     return [];
   }
   try {
-    const parsed = parseYaml(readFileSync2(workspaceFile, "utf8"));
+    const parsed = parseYaml(readFileSync5(workspaceFile, "utf8"));
     return Array.isArray(parsed?.packages) ? parsed.packages.filter(Boolean) : [];
   } catch {
     return [];
@@ -304,16 +1139,16 @@ function parseWorkspaceGlobsFromWorkspaceFile(workspaceRoot) {
 }
 
 // src/cli/workspace/workspace-lock.ts
-import { existsSync as existsSync2, readFileSync as readFileSync3 } from "fs";
-import path5 from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
+import path16 from "path";
 import { parse as parseYaml2 } from "yaml";
 function parseImportersFromLock(workspaceRoot) {
-  const lockPath = path5.join(workspaceRoot, "pnpm-lock.yaml");
-  if (!existsSync2(lockPath)) {
+  const lockPath = path16.join(workspaceRoot, "pnpm-lock.yaml");
+  if (!existsSync7(lockPath)) {
     return [];
   }
   try {
-    const parsed = parseYaml2(readFileSync3(lockPath, "utf8"));
+    const parsed = parseYaml2(readFileSync6(lockPath, "utf8"));
     const importers = parsed?.importers;
     if (!importers) {
       return [];
@@ -322,7 +1157,7 @@ function parseImportersFromLock(workspaceRoot) {
       if (!key || key === ".") {
         return workspaceRoot;
       }
-      return path5.join(workspaceRoot, key);
+      return path16.join(workspaceRoot, key);
     });
   } catch {
     return [];
@@ -335,7 +1170,7 @@ var TRAILING_SLASH_RE = /\/+$/;
 async function resolveWorkspacePackageDirs(workspaceRoot) {
   const dirs = /* @__PURE__ */ new Set();
   for (const importerDir of parseImportersFromLock(workspaceRoot)) {
-    dirs.add(path6.normalize(importerDir));
+    dirs.add(path17.normalize(importerDir));
   }
   if (!dirs.size) {
     let globs = parseWorkspaceGlobsFromWorkspaceFile(workspaceRoot);
@@ -355,31 +1190,31 @@ async function resolveWorkspacePackageDirs(workspaceRoot) {
         ignore: ["**/node_modules/**", "**/.git/**"]
       });
       for (const file of packageJsonFiles) {
-        dirs.add(path6.normalize(path6.dirname(file)));
+        dirs.add(path17.normalize(path17.dirname(file)));
       }
     }
   }
-  const rootPkg = path6.join(workspaceRoot, "package.json");
-  if (existsSync3(rootPkg)) {
-    dirs.add(path6.normalize(workspaceRoot));
+  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 } from "tailwindcss-patch";
+import { normalizeOptions, TailwindcssPatcher as TailwindcssPatcher2 } from "tailwindcss-patch";
 
 // src/cli/workspace/patch-utils.ts
-import path7 from "path";
+import path18 from "path";
 function formatDisplayName(workspaceRoot, dir, name) {
-  const relative = path7.relative(workspaceRoot, dir) || ".";
+  const relative = path18.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;
-  logger.info("[workspace] \u6C47\u603B\uFF1A\u5DF2\u8865\u4E01 %d\uFF0C\u8DF3\u8FC7 %d\uFF0C\u5931\u8D25 %d", patched, skipped, failed);
+  logger11.info("[workspace] \u6C47\u603B\uFF1A\u5DF2\u8865\u4E01 %d\uFF0C\u8DF3\u8FC7 %d\uFF0C\u5931\u8D25 %d", patched, skipped, failed);
 }
 
 // src/cli/workspace/patch-package.ts
@@ -389,13 +1224,13 @@ function createWorkspacePatcher(cwd) {
       projectRoot: cwd
     })
   );
-  return new TailwindcssPatcher(normalized);
+  return new TailwindcssPatcher2(normalized);
 }
 async function patchWorkspacePackage(workspaceRoot, dir, pkgName, options) {
   const displayName = formatDisplayName(workspaceRoot, dir, pkgName);
   const tailwindInfo = getTailwindcssPackageInfo({ paths: [dir] });
   if (!tailwindInfo?.rootPath) {
-    logger.info("[workspace] \u8DF3\u8FC7 %s\uFF08tailwindcss \u672A\u5B89\u88C5\uFF09\u3002", displayName);
+    logger11.info("[workspace] \u8DF3\u8FC7 %s\uFF08tailwindcss \u672A\u5B89\u88C5\uFF09\u3002", displayName);
     return {
       dir,
       name: pkgName,
@@ -415,14 +1250,14 @@ async function patchWorkspacePackage(workspaceRoot, dir, pkgName, options) {
       alwaysRecord: true
     });
     if (recorder?.message) {
-      logger.info("[workspace] %s %s", displayName, recorder.message);
+      logger11.info("[workspace] %s %s", displayName, recorder.message);
     }
     logTailwindcssTarget("cli", patcher, dir);
     await patcher.patch();
     if (recorder?.onPatched) {
       await recorder.onPatched();
     }
-    logger.success("[workspace] \u5DF2\u8865\u4E01 %s", displayName);
+    logger11.success("[workspace] \u5DF2\u8865\u4E01 %s", displayName);
     return {
       dir,
       name: pkgName,
@@ -433,7 +1268,7 @@ async function patchWorkspacePackage(workspaceRoot, dir, pkgName, options) {
     const reason = error instanceof Error ? error.message : String(error);
     const suggestion = `\u8BF7\u5728 ${dir} \u8FD0\u884C "weapp-tw patch --cwd ${dir}".`;
     const message = `${reason}\uFF0C${suggestion}`;
-    logger.error("[workspace] \u8865\u4E01\u5931\u8D25 %s\uFF1A%s", displayName, message);
+    logger11.error("[workspace] \u8865\u4E01\u5931\u8D25 %s\uFF1A%s", displayName, message);
     return {
       dir,
       name: pkgName,
@@ -445,16 +1280,16 @@ async function patchWorkspacePackage(workspaceRoot, dir, pkgName, options) {
 
 // src/cli/workspace.ts
 async function patchWorkspace(options) {
-  const cwd = options.cwd ?? process5.cwd();
+  const cwd = options.cwd ?? process15.cwd();
   const workspaceRoot = findWorkspaceRoot(cwd) ?? cwd;
   const packageDirs = await resolveWorkspacePackageDirs(workspaceRoot);
   if (packageDirs.length === 0) {
-    logger.warn("\u672A\u5728 %s \u68C0\u6D4B\u5230 workspace \u5305\uFF0C\u5DF2\u8DF3\u8FC7\u6279\u91CF patch\u3002", workspaceRoot);
+    logger11.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 = path8.join(dir, "package.json");
+    const pkgJsonPath = path19.join(dir, "package.json");
     const pkgJson = tryReadJson(pkgJsonPath);
     results.push(await patchWorkspacePackage(workspaceRoot, dir, pkgJson?.name, options));
   }
@@ -464,12 +1299,12 @@ async function patchWorkspace(options) {
 // src/cli/mount-options.ts
 function handleCliError2(error) {
   if (error instanceof Error) {
-    logger.error(error.message);
-    if (error.stack && process6.env.WEAPP_TW_DEBUG === "1") {
-      logger.error(error.stack);
+    logger11.error(error.message);
+    if (error.stack && process16.env.WEAPP_TW_DEBUG === "1") {
+      logger11.error(error.stack);
     }
   } else {
-    logger.error(String(error));
+    logger11.error(String(error));
   }
 }
 function withCommandErrorHandling(handler) {
@@ -478,7 +1313,7 @@ function withCommandErrorHandling(handler) {
       return await handler(ctx, next);
     } catch (error) {
       handleCliError2(error);
-      process6.exitCode = 1;
+      process16.exitCode = 1;
       return void 0;
     }
   });
@@ -557,17 +1392,17 @@ var mountOptions = {
         alwaysRecord: true
       });
       if (recorder?.message) {
-        logger.info(recorder.message);
+        logger11.info(recorder.message);
       }
       logTailwindcssTarget("cli", patcher, ctx.cwd);
       await patcher.patch();
       if (recorder?.onPatched) {
         const recordPath = await recorder.onPatched();
         if (recordPath) {
-          logger.info(`\u8BB0\u5F55 weapp-tw patch \u76EE\u6807 -> ${formatOutputPath(recordPath, ctx.cwd)}`);
+          logger11.info(`\u8BB0\u5F55 weapp-tw patch \u76EE\u6807 -> ${formatOutputPath(recordPath, ctx.cwd)}`);
         }
       }
-      logger.success("Tailwind CSS \u8FD0\u884C\u65F6\u8865\u4E01\u5DF2\u5B8C\u6210\u3002");
+      logger11.success("Tailwind CSS \u8FD0\u884C\u65F6\u8865\u4E01\u5DF2\u5B8C\u6210\u3002");
     }),
     extract: withCommandErrorHandling(async (_ctx, next) => next()),
     tokens: withCommandErrorHandling(async (_ctx, next) => next()),
@@ -576,7 +1411,7 @@ var mountOptions = {
       const patcher = await createPatcherWithDefaultExtendLengthUnits(ctx);
       const report = await patcher.getPatchStatus();
       if (ctx.args.json) {
-        logger.log(JSON.stringify(report, null, 2));
+        logger11.log(JSON.stringify(report, null, 2));
         return report;
       }
       logPatchStatusReport(report);
@@ -587,8 +1422,8 @@ var mountOptions = {
 
 // src/cli/vscode-entry.ts
 import { constants } from "fs";
-import { access, writeFile } from "fs/promises";
-import path9 from "path";
+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"',
@@ -661,16 +1496,16 @@ function formatSource(pattern) {
 }
 function resolveOutputPath(baseDir, output) {
   const target = output ?? DEFAULT_VSCODE_ENTRY_OUTPUT;
-  return path9.isAbsolute(target) ? path9.normalize(target) : path9.resolve(baseDir, target);
+  return path20.isAbsolute(target) ? path20.normalize(target) : path20.resolve(baseDir, target);
 }
 function resolveCssEntry(baseDir, entry) {
-  return path9.isAbsolute(entry) ? path9.normalize(entry) : path9.resolve(baseDir, entry);
+  return path20.isAbsolute(entry) ? path20.normalize(entry) : path20.resolve(baseDir, entry);
 }
 function toRelativeImport(fromFile, targetFile) {
-  const fromDir = path9.dirname(fromFile);
-  let relative = path9.relative(fromDir, targetFile);
+  const fromDir = path20.dirname(fromFile);
+  let relative = path20.relative(fromDir, targetFile);
   if (!relative) {
-    relative = path9.basename(targetFile);
+    relative = path20.basename(targetFile);
   }
   if (!relative.startsWith(".")) {
     relative = `./${relative}`;
@@ -682,7 +1517,7 @@ async function generateVscodeIntellisenseEntry(options) {
   const cssEntryPath = resolveCssEntry(baseDir, options.cssEntry);
   await assertFileExists(cssEntryPath);
   const outputPath = resolveOutputPath(baseDir, options.output);
-  await ensureDir(path9.dirname(outputPath));
+  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));
@@ -701,16 +1536,16 @@ async function generateVscodeIntellisenseEntry(options) {
     `@import '${cssImport}';`,
     ""
   ].filter((line, idx, arr) => !(line === "" && arr[idx - 1] === "")).join("\n");
-  await writeFile(outputPath, `${content}
+  await writeFile2(outputPath, `${content}
 `, "utf8");
   return { outputPath, cssEntryPath };
 }
 
 // src/cli.ts
-process7.title = "node (weapp-tailwindcss)";
-if (semver.lt(process7.versions.node, WEAPP_TW_REQUIRED_NODE_VERSION)) {
-  logger.warn(
-    `You are using Node.js ${process7.versions.node}. For weapp-tailwindcss, Node.js version >= v${WEAPP_TW_REQUIRED_NODE_VERSION} is required.`
+process17.title = "node (weapp-tailwindcss)";
+if (semver.lt(process17.versions.node, WEAPP_TW_REQUIRED_NODE_VERSION)) {
+  logger11.warn(
+    `You are using Node.js ${process17.versions.node}. For weapp-tailwindcss, Node.js version >= v${WEAPP_TW_REQUIRED_NODE_VERSION} is required.`
   );
 }
 var cli = createTailwindcssPatchCli({
@@ -720,7 +1555,7 @@ var cli = createTailwindcssPatchCli({
 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 ?? process7.cwd();
+    const baseDir = resolvedCwd ?? process17.cwd();
     const cssEntry = readStringOption("css", options.css);
     if (!cssEntry) {
       throw new Error('Option "--css" is required.');
@@ -735,11 +1570,11 @@ cli.command("vscode-entry", "Generate a VS Code helper CSS for Tailwind IntelliS
       sources,
       force
     });
-    logger.success(
+    logger11.success(
       `VS Code helper generated -> ${formatOutputPath(result.outputPath, resolvedCwd)}`
     );
   })
 );
 cli.help();
-cli.version(process7.env.npm_package_version ?? "0.0.0");
+cli.version(process17.env.npm_package_version ?? "0.0.0");
 cli.parse();