weapp-tailwindcss 4.11.2 → 4.12.0-alpha.2

package/dist/cli.js

@@ -23,8 +23,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/cli.ts
-var import_node_process18 = __toESM(require("process"));
-var import_semver = __toESM(require("semver"));
+var import_node_process19 = __toESM(require("process"));
+var import_semver2 = __toESM(require("semver"));
 var import_tailwindcss_patch3 = require("tailwindcss-patch");
 
 // src/cli/context.ts
@@ -208,7 +208,7 @@ var import_logger2 = require("@weapp-tailwindcss/logger");
 // package.json
 var package_default = {
   name: "weapp-tailwindcss",
-  version: "4.11.2",
+  version: "4.12.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",
@@ -358,13 +358,14 @@ var package_default = {
     "dist",
     "index.css",
     "preflight.css",
+    "scripts/postinstall.mjs",
     "theme.css",
     "uni-app-x.css",
     "utilities.css",
     "with-layer.css"
   ],
   engines: {
-    node: "^18.17.0 || >=20.5.0"
+    node: "^20.19.0 || >=22.12.0"
   },
   scripts: {
     dev: "tsup --watch --sourcemap",
@@ -373,7 +374,7 @@ var package_default = {
     "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: "pnpm run cli:patch && vitest run",
     "test:dev": "vitest",
     "test:ui": "vitest --ui",
     bench: "vitest bench --config ./vitest.config.ts",
@@ -390,7 +391,7 @@ var package_default = {
     release: "tsx scripts/release.ts",
     lint: "eslint .",
     "lint:fix": "eslint ./src --fix",
-    postinstall: "node bin/weapp-tailwindcss.js patch",
+    postinstall: "node scripts/postinstall.mjs",
     "bench:vite-dev-hmr": "tsx scripts/vite-dev-hmr-bench.ts",
     "test:watch-hmr": "node --import tsx scripts/watch-hmr-regression/index.ts"
   },
@@ -410,6 +411,7 @@ var package_default = {
     "@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",
@@ -424,11 +426,14 @@ var package_default = {
     "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_REQUIRED_NODE_VERSION_RANGE = "^20.19.0 || >=22.12.0";
 var WEAPP_TW_VERSION = package_default.version;
 
 // src/tailwindcss/targets/record-io.ts
@@ -583,102 +588,1894 @@ function createPatchTargetRecorder(baseDir, patcher, options) {
     packageJsonPath: location.packageJsonPath
   });
   return {
-    recordPath: location.recordPath,
-    message,
-    reason,
-    onPatched
+    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" : "Weapp-tailwindcss";
+  if (!packageInfo?.rootPath) {
+    import_logger3.logger.warn(
+      "%s \u672A\u627E\u5230 Tailwind CSS \u4F9D\u8D56\uFF0C\u8BF7\u68C0\u67E5\u5728 %s \u662F\u5426\u5DF2\u5B89\u88C5 tailwindcss",
+      label,
+      baseDir ?? import_node_process6.default.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;
+  }
+  import_logger3.logger.info("%s \u7ED1\u5B9A Tailwind CSS -> %s%s", label, displayPath, version);
+}
+
+// src/tailwindcss/v4/config.ts
+var import_logger4 = require("@weapp-tailwindcss/logger");
+
+// src/tailwindcss/v4/patcher.ts
+var import_logger6 = require("@weapp-tailwindcss/logger");
+
+// src/tailwindcss/patcher.ts
+var import_node_path7 = __toESM(require("path"));
+var import_node_process8 = __toESM(require("process"));
+var import_logger5 = require("@weapp-tailwindcss/logger");
+var import_shared2 = require("@weapp-tailwindcss/shared");
+var import_tailwindcss_patch = require("tailwindcss-patch");
+
+// src/tailwindcss/patcher-resolve.ts
+var import_node_fs5 = require("fs");
+var import_node_module = require("module");
+var import_node_path6 = __toESM(require("path"));
+var import_node_process7 = __toESM(require("process"));
+var import_node_url = require("url");
+
+// src/tailwindcss/v4/css-entries.ts
+var import_node_path8 = __toESM(require("path"));
+
+// src/context/compiler-context-cache.ts
+var import_node_buffer = require("buffer");
+var import_node_path9 = __toESM(require("path"));
+var import_node_process9 = __toESM(require("process"));
+var import_logger7 = require("@weapp-tailwindcss/logger");
+var globalCacheHolder = globalThis;
+var compilerContextCache = globalCacheHolder.__WEAPP_TW_COMPILER_CONTEXT_CACHE__ ?? (globalCacheHolder.__WEAPP_TW_COMPILER_CONTEXT_CACHE__ = /* @__PURE__ */ new Map());
+
+// src/context/handlers.ts
+var import_postcss = require("@weapp-tailwindcss/postcss");
+
+// src/js/index.ts
+var import_lru_cache3 = require("lru-cache");
+
+// src/babel/index.ts
+var import_traverse = __toESM(require("@babel/traverse"));
+var import_parser = require("@babel/parser");
+function _interopDefaultCompat(e) {
+  return e && typeof e === "object" && "default" in e ? e.default : e;
+}
+var traverse = _interopDefaultCompat(import_traverse.default);
+
+// src/utils/nameMatcher.ts
+var import_regex = require("@weapp-core/regex");
+var NEVER_MATCH_NAME = () => false;
+var GLOBAL_FLAG_REGEXP = /g/g;
+function buildFuzzyMatcher(fuzzyStrings) {
+  if (fuzzyStrings.length === 0) {
+    return void 0;
+  }
+  if (fuzzyStrings.length === 1) {
+    const [needle] = fuzzyStrings;
+    return (value) => value.includes(needle);
+  }
+  const unique = [...new Set(fuzzyStrings)];
+  const pattern = new RegExp(unique.map(import_regex.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;
+  }
+  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));
+  };
+}
+
+// src/js/babel/parse.ts
+var import_lru_cache2 = require("lru-cache");
+var parseCache = new import_lru_cache2.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 = (0, import_parser.parse)(code, parseOptions);
+    if (cache) {
+      parseCache.set(cacheKeyString, result);
+    }
+  }
+  return result;
+}
+
+// src/js/babel/process.ts
+var import_magic_string = __toESM(require("magic-string"));
+
+// src/js/handlers.ts
+var import_escape3 = require("@ast-core/escape");
+var import_extractors = require("@weapp-tailwindcss/shared/extractors");
+
+// src/wxml/shared.ts
+var import_escape2 = require("@weapp-core/escape");
+var NEWLINE_RE = /[\n\r]+/g;
+function replaceWxml(original, options = {
+  keepEOL: false,
+  escapeMap: import_escape2.MappingChars2String
+}) {
+  const { keepEOL, escapeMap, ignoreHead } = options;
+  let res = original;
+  if (!keepEOL) {
+    res = res.replaceAll(NEWLINE_RE, "");
+  }
+  res = (0, import_escape2.escape)(res, {
+    map: escapeMap,
+    ignoreHead
+  });
+  return res;
+}
+
+// src/shared/classname-transform.ts
+var escapedCandidateCacheByEscapeMap = /* @__PURE__ */ new WeakMap();
+var defaultEscapedCandidateCache = /* @__PURE__ */ new Map();
+var lastEscapedCandidateEscapeMap;
+var 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;
+  }
+  const normalized = candidate.trim();
+  if (isUrlLikeCandidate(normalized)) {
+    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
+  );
+}
+var SKIP_RESULT = { decision: "skip" };
+var DIRECT_RESULT = { decision: "direct" };
+var 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;
+}
+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;
+}
+
+// src/utils/decode.ts
+var unicodeEscapeRE = /\\u([\dA-Fa-f]{4})/g;
+var 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);
+  }
+}
+
+// src/js/class-context.ts
+var CLASS_LIKE_KEYWORDS = /* @__PURE__ */ new Set([
+  "class",
+  "classname",
+  "hoverclass",
+  "virtualhostclass",
+  "rootclass"
+]);
+var CLASS_HELPER_IDENTIFIERS = /* @__PURE__ */ new Set([
+  "cn",
+  "clsx",
+  "classnames",
+  "twmerge",
+  "cva",
+  "tv",
+  "cx",
+  "r"
+]);
+var DASH_CODE = 45;
+var COLON_CODE = 58;
+var UPPERCASE_A_CODE = 65;
+var UPPERCASE_Z_CODE = 90;
+var UNDERSCORE_CODE = 95;
+var ASCII_MAX_CODE = 127;
+var 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(path22) {
+  if (path22.isIdentifier()) {
+    return path22.node.name;
+  }
+  if (path22.isStringLiteral()) {
+    return path22.node.value;
+  }
+  if (path22.isTemplateLiteral() && path22.node.expressions.length === 0) {
+    return path22.node.quasis[0]?.value.cooked ?? path22.node.quasis[0]?.value.raw;
+  }
+  return void 0;
+}
+function isClassLikeObjectProperty(path22, valuePath) {
+  if (!path22.isObjectProperty()) {
+    return false;
+  }
+  if (path22.get("value") !== valuePath) {
+    return false;
+  }
+  const keyName = readObjectKeyName(path22.get("key"));
+  if (!keyName) {
+    return false;
+  }
+  return CLASS_LIKE_KEYWORDS.has(normalizeKeyword(keyName));
+}
+function isClassLikeJsxAttribute(path22) {
+  if (!path22.isJSXAttribute()) {
+    return false;
+  }
+  const namePath = path22.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;
+    }
+  }
+  return void 0;
+}
+function isClassLikeCallExpression(path22, valuePath) {
+  if (!path22.isCallExpression()) {
+    return false;
+  }
+  const helperName = readCallHelperName(path22.get("callee"));
+  if (!helperName || !CLASS_HELPER_IDENTIFIERS.has(normalizeKeyword(helperName))) {
+    return false;
+  }
+  return path22.get("arguments").includes(valuePath);
+}
+function isClassContextLiteralPath(path22) {
+  let current = path22;
+  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;
+}
+
+// src/js/handlers.ts
+var debug2 = createDebug("[js:handlers] ");
+var replacementCacheByEscapeMap = /* @__PURE__ */ new WeakMap();
+var defaultReplacementCache = /* @__PURE__ */ new Map();
+var WEAPP_TW_IGNORE_MARKER = "weapp-tw";
+var 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(path22, { unescapeUnicode, arbitraryValues }) {
+  const allowDoubleQuotes = arbitraryValues?.allowDoubleQuotes;
+  const { node } = path22;
+  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(path22, options) {
+  const { needEscaped = false } = options;
+  const { classNameSet, alwaysEscape } = options;
+  const fallbackEnabled = shouldEnableArbitraryValueFallback(options);
+  if (!alwaysEscape && !fallbackEnabled && (!classNameSet || classNameSet.size === 0)) {
+    return void 0;
+  }
+  if (hasIgnoreComment(path22.node)) {
+    return void 0;
+  }
+  const { literal, original, allowDoubleQuotes, offset } = extractLiteralValue(path22, options);
+  const candidates = (0, import_extractors.splitCode)(literal, allowDoubleQuotes);
+  if (candidates.length === 0) {
+    return void 0;
+  }
+  const debugEnabled = debug2.enabled;
+  const classContext = options.wrapExpression || isClassContextLiteralPath(path22);
+  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 = path22.node;
+  if (!mutated || typeof node.start !== "number" || typeof node.end !== "number") {
+    return void 0;
+  }
+  if (debugEnabled) {
+    debug2(
+      "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 void 0;
+  }
+  const value = needEscaped ? (0, import_escape3.jsStringEscape)(transformed) : transformed;
+  return {
+    start,
+    end,
+    value,
+    path: path22
+  };
+}
+
+// src/js/sourceAnalysis.ts
+function hasReplacementEntries(replacements) {
+  for (const key in replacements) {
+    if (Object.hasOwn(replacements, key)) {
+      return true;
+    }
+  }
+  return false;
+}
+function createModuleSpecifierReplacementToken(path22, replacement) {
+  const node = path22.node;
+  if (node.value === replacement) {
+    return void 0;
+  }
+  if (typeof node.start !== "number" || typeof node.end !== "number") {
+    return void 0;
+  }
+  const start = node.start + 1;
+  const end = node.end - 1;
+  if (start >= end) {
+    return void 0;
+  }
+  return {
+    start,
+    end,
+    value: replacement,
+    path: path22
+  };
+}
+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 = (path22) => {
+    const replacement = replacements[path22.node.value];
+    if (!replacement) {
+      return;
+    }
+    const token = createModuleSpecifierReplacementToken(path22, 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;
+}
+
+// src/js/babel/process.ts
+var 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 import_magic_string.default(rawSource);
+  }
+  const replacementTokens = [];
+  for (const path22 of targetPaths) {
+    if (ignoredPaths.has(path22)) {
+      continue;
+    }
+    const token = replaceHandleValue(
+      path22,
+      path22.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 import_magic_string.default(rawSource);
+  }
+  const ms = new import_magic_string.default(rawSource);
+  jsTokenUpdater.push(...replacementTokens).filter((token) => !ignoredPaths.has(token.path)).updateMagicString(ms);
+  return ms;
+}
+
+// src/js/evalTransforms.ts
+var import_escape4 = require("@ast-core/escape");
+var evalHandlerOptionsCache = /* @__PURE__ */ new WeakMap();
+var EVAL_SCOPE_ERROR_REGEXP = /pass a scope and parentPath|traversing a Program\/File/i;
+function isEvalPath(path22) {
+  if (path22.isCallExpression()) {
+    const calleePath = path22.get("callee");
+    return calleePath.isIdentifier({ name: "eval" });
+  }
+  return false;
+}
+function createEvalReplacementToken(path22, updated) {
+  const node = path22.node;
+  let offset = 0;
+  let original;
+  if (path22.isStringLiteral()) {
+    offset = 1;
+    original = path22.node.value;
+  } else if (path22.isTemplateElement()) {
+    original = path22.node.value.raw;
+  } else {
+    original = "";
+  }
+  if (typeof node.start !== "number" || typeof node.end !== "number") {
+    return void 0;
+  }
+  const start = node.start + offset;
+  const end = node.end - offset;
+  if (start >= end) {
+    return void 0;
+  }
+  if (original === updated) {
+    return void 0;
+  }
+  const value = path22.isStringLiteral() ? (0, import_escape4.jsStringEscape)(updated) : updated;
+  return {
+    start,
+    end,
+    value,
+    path: path22
+  };
+}
+function handleEvalStringLiteral(path22, handlerOptions, updater, handler) {
+  const { code } = handler(path22.node.value, handlerOptions);
+  if (!code) {
+    return;
+  }
+  const token = createEvalReplacementToken(path22, code);
+  if (token) {
+    updater.addToken(token);
+  }
+}
+function handleEvalTemplateElement(path22, handlerOptions, updater, handler) {
+  const { code } = handler(path22.node.value.raw, handlerOptions);
+  if (!code) {
+    return;
+  }
+  const token = createEvalReplacementToken(path22, 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(path22, options, updater, handler) {
+  const stringHandlerOptions = getEvalStringHandlerOptions(options);
+  const templateHandlerOptions = getEvalTemplateHandlerOptions(options);
+  const maybeTraverse = path22?.traverse;
+  if (typeof maybeTraverse === "function") {
+    try {
+      return maybeTraverse.call(path22, {
+        StringLiteral(innerPath) {
+          handleEvalStringLiteral(innerPath, stringHandlerOptions, updater, handler);
+        },
+        TemplateElement(innerPath) {
+          handleEvalTemplateElement(innerPath, templateHandlerOptions, updater, handler);
+        }
+      });
+    } catch (error) {
+      const msg = error?.message ?? "";
+      const scopeError = EVAL_SCOPE_ERROR_REGEXP.test(msg);
+      if (!scopeError) {
+        throw error;
+      }
+    }
+  }
+  const getArgs = path22?.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 = path22?.node?.arguments;
+  if (Array.isArray(nodeArgs)) {
+    for (const n of nodeArgs) {
+      if (n?.type === "StringLiteral") {
+        const stub = {
+          node: n,
+          isStringLiteral: () => true
+        };
+        handleEvalStringLiteral(stub, stringHandlerOptions, updater, handler);
+      } else if (n?.type === "TemplateLiteral" && Array.isArray(n.quasis)) {
+        for (const q of n.quasis) {
+          const stub = {
+            node: q,
+            isTemplateElement: () => true
+          };
+          handleEvalTemplateElement(stub, templateHandlerOptions, updater, handler);
+        }
+      }
+    }
+  }
+}
+
+// src/js/JsTokenUpdater.ts
+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;
+  }
+};
+
+// 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);
+    }
+  }
+};
+
+// 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 ms = processUpdatedSource(state.source, childOptions, state.analysis);
+      const code = ms.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 {
+          const ast = babelParse(source, {
+            ...this.parserOptions,
+            sourceFilename: resolved
+          });
+          analysis = analyzeSource(ast, {
+            ...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 });
+      }
+    }
+  }
+};
+
+// src/js/node-path-walker/export-handlers.ts
+function walkExportDeclaration(ctx, path22) {
+  if (path22.isExportDeclaration()) {
+    if (path22.isExportNamedDeclaration()) {
+      walkExportNamedDeclaration(ctx, path22);
+    } else if (path22.isExportDefaultDeclaration()) {
+      walkExportDefaultDeclaration(ctx, path22);
+    } else if (path22.isExportAllDeclaration()) {
+      walkExportAllDeclaration(ctx, path22);
+    }
+  }
+}
+function walkExportNamedDeclaration(ctx, path22) {
+  const declaration = path22.get("declaration");
+  if (declaration.isVariableDeclaration()) {
+    for (const decl of declaration.get("declarations")) {
+      ctx.walkNode(decl);
+    }
+  }
+  const specifiers = path22.get("specifiers");
+  for (const spec of specifiers) {
+    if (spec.isExportSpecifier()) {
+      const local = spec.get("local");
+      if (local.isIdentifier()) {
+        ctx.walkNode(local);
+      }
+    }
+  }
+}
+function walkExportDefaultDeclaration(ctx, path22) {
+  const decl = path22.get("declaration");
+  if (decl.isIdentifier()) {
+    ctx.walkNode(decl);
+  } else {
+    ctx.walkNode(decl);
+  }
+}
+function walkExportAllDeclaration(ctx, path22) {
+  const source = path22.get("source");
+  if (source.isStringLiteral()) {
+    ctx.addImportToken(
+      {
+        declaration: path22,
+        source: source.node.value,
+        type: "ExportAllDeclaration"
+      }
+    );
+  }
+}
+
+// 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;
+}
+
+// src/js/NodePathWalker.ts
+var EMPTY_IGNORE_CALL_EXPRESSION_IDENTIFIERS = [];
+var EMPTY_IMPORT_TOKENS = /* @__PURE__ */ new Set();
+function NOOP_STRING_PATH_CALLBACK() {
+}
+var NEVER_MATCH_NAME2 = () => 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_NAME2;
+  }
+  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(path22) {
+    const init = path22.get("init");
+    this.walkNode(init);
+  }
+  walkTemplateLiteral(path22) {
+    for (const exp of path22.get("expressions")) {
+      this.walkNode(exp);
+    }
+    for (const quasis of path22.get("quasis")) {
+      this.callback(quasis);
+    }
+  }
+  walkStringLiteral(path22) {
+    this.callback(path22);
+  }
+  walkBinaryExpression(path22) {
+    const left = path22.get("left");
+    this.walkNode(left);
+    const right = path22.get("right");
+    this.walkNode(right);
+  }
+  walkLogicalExpression(path22) {
+    const left = path22.get("left");
+    this.walkNode(left);
+    const right = path22.get("right");
+    this.walkNode(right);
+  }
+  walkObjectExpression(path22) {
+    const props = path22.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(path22) {
+    const elements = path22.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(path22) {
+    if (!this.hasIgnoredCallIdentifiers) {
+      return;
+    }
+    const calleePath = path22.get("callee");
+    if (calleePath.isIdentifier() && this.isIgnoredCallIdentifier(calleePath.node.name)) {
+      for (const arg of path22.get("arguments")) {
+        this.walkNode(arg);
+      }
+    }
+  }
+  walkExportDeclaration(path22) {
+    walkExportDeclaration(this, path22);
+  }
+  walkExportNamedDeclaration(path22) {
+    walkExportNamedDeclaration(this, path22);
+  }
+  walkExportDefaultDeclaration(path22) {
+    walkExportDefaultDeclaration(this, path22);
+  }
+  walkExportAllDeclaration(path22) {
+    walkExportAllDeclaration(this, path22);
+  }
+};
+
+// 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 = /* @__PURE__ */ 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 = (path22, seen) => {
+    const propertyPath = path22.get("property");
+    if (propertyMatches(propertyPath)) {
+      return true;
+    }
+    const objectPath = path22.get("object");
+    if (objectPath.isIdentifier()) {
+      const scope = objectPath?.scope;
+      const binding = 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 expressions = current.get("expressions");
+        const last = expressions.at(-1);
+        if (last) {
+          current = last;
+          continue;
+        }
+      }
+      if (current.isCallExpression?.() || current.node.type === "CallExpression") {
+        const callee = current.get("callee");
+        current = callee;
+        continue;
+      }
+      break;
+    }
+    return current;
+  };
+  const evaluateTagPath = (tagPath, seen) => {
+    if (tagPath.isCallExpression?.() || tagPath.node.type === "CallExpression") {
+      const calleePath = tagPath.get("callee");
+      return evaluateTagPath(calleePath, 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
   };
 }
 
-// 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) {
-    import_logger3.logger.warn(
-      "%s \u672A\u627E\u5230 Tailwind CSS \u4F9D\u8D56\uFF0C\u8BF7\u68C0\u67E5\u5728 %s \u662F\u5426\u5DF2\u5B89\u88C5 tailwindcss",
-      label,
-      baseDir ?? import_node_process6.default.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;
+// src/js/babel.ts
+var EXPRESSION_WRAPPER_PREFIX = "(\n";
+var EXPRESSION_WRAPPER_SUFFIX = "\n)";
+var EMPTY_IGNORED_PATHS = /* @__PURE__ */ new WeakSet();
+var EMPTY_IMPORT_DECLARATIONS = /* @__PURE__ */ new Set();
+var EMPTY_EXPORT_DECLARATIONS = /* @__PURE__ */ new Set();
+var EMPTY_REQUIRE_CALL_PATHS = [];
+var ignoredTaggedTemplateMatcherCache = /* @__PURE__ */ new WeakMap();
+var 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.");
   }
-  import_logger3.logger.info("%s \u7ED1\u5B9A Tailwind CSS -> %s%s", label, displayPath, version);
+  return defaultEvalHandler;
 }
-
-// src/tailwindcss/v4/config.ts
-var import_logger4 = require("@weapp-tailwindcss/logger");
-
-// src/tailwindcss/v4/patcher.ts
-var import_logger6 = require("@weapp-tailwindcss/logger");
-
-// src/tailwindcss/patcher.ts
-var import_node_path7 = __toESM(require("path"));
-var import_node_process8 = __toESM(require("process"));
-var import_logger5 = require("@weapp-tailwindcss/logger");
-var import_shared2 = require("@weapp-tailwindcss/shared");
-var import_tailwindcss_patch = require("tailwindcss-patch");
-
-// src/tailwindcss/patcher-resolve.ts
-var import_node_fs5 = require("fs");
-var import_node_module = require("module");
-var import_node_path6 = __toESM(require("path"));
-var import_node_process7 = __toESM(require("process"));
-var import_node_url = require("url");
-
-// src/tailwindcss/v4/css-entries.ts
-var import_node_path8 = __toESM(require("path"));
-
-// src/context/compiler-context-cache.ts
-var import_node_buffer = require("buffer");
-var import_node_path9 = __toESM(require("path"));
-var import_node_process9 = __toESM(require("process"));
-var import_logger7 = require("@weapp-tailwindcss/logger");
-var globalCacheHolder = globalThis;
-var compilerContextCache = globalCacheHolder.__WEAPP_TW_COMPILER_CONTEXT_CACHE__ ?? (globalCacheHolder.__WEAPP_TW_COMPILER_CONTEXT_CACHE__ = /* @__PURE__ */ new Map());
-
-// src/context/handlers.ts
-var import_postcss = require("@weapp-tailwindcss/postcss");
-
-// src/babel/index.ts
-var import_traverse = __toESM(require("@babel/traverse"));
-var import_parser = require("@babel/parser");
-function _interopDefaultCompat(e) {
-  return e && typeof e === "object" && "default" in e ? e.default : e;
+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(path22) {
+      ignoredPaths.add(path22);
+    }
+  }) : 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();
+  const templateElementEnter = 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);
+  };
+  const callExpressionEnter = !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);
+    }
+  };
+  const traverseOptions = {
+    StringLiteral: {
+      enter(p) {
+        if (isEvalPath(p.parentPath)) {
+          return;
+        }
+        targetPaths.push(p);
+      }
+    },
+    TemplateElement: {
+      enter: templateElementEnter
+    },
+    CallExpression: {
+      enter: callExpressionEnter
+    },
+    ...collectModuleMetadata ? {
+      ImportDeclaration: {
+        enter(p) {
+          importDeclarations.add(p);
+        }
+      },
+      ExportDeclaration: {
+        enter(p) {
+          exportDeclarations.add(p);
+        }
+      }
+    } : {}
+  };
+  traverse(ast, { ...traverseOptions, noScope: !needScope });
+  return {
+    walker,
+    jsTokenUpdater,
+    ast,
+    targetPaths,
+    importDeclarations,
+    exportDeclarations,
+    requireCallPaths,
+    ignoredPaths
+  };
 }
-var traverse = _interopDefaultCompat(import_traverse.default);
-
-// src/utils/nameMatcher.ts
-var import_regex = require("@weapp-core/regex");
-
-// src/js/babel/parse.ts
-var import_lru_cache2 = require("lru-cache");
-var parseCache = new import_lru_cache2.LRUCache(
-  {
-    max: 1024
+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
+    };
   }
-);
-
-// src/js/babel/process.ts
-var import_magic_string = __toESM(require("magic-string"));
-
-// src/js/handlers.ts
-var import_escape3 = require("@ast-core/escape");
-var import_extractors = require("@weapp-tailwindcss/shared/extractors");
-
-// src/wxml/shared.ts
-var import_escape2 = require("@weapp-core/escape");
-
-// src/js/handlers.ts
-var debug2 = createDebug("[js:handlers] ");
-
-// src/js/evalTransforms.ts
-var import_escape4 = require("@ast-core/escape");
+  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 = EXPRESSION_WRAPPER_PREFIX.length;
+    const suffixLength = EXPRESSION_WRAPPER_SUFFIX.length;
+    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 graph = new JsModuleGraph(
+      {
+        filename: options.filename,
+        source: rawSource,
+        analysis,
+        handlerOptions: options
+      },
+      options.moduleGraph
+    );
+    const linked = graph.build();
+    if (linked) {
+      result.linked = linked;
+    }
+  }
+  return result;
+}
+defaultEvalHandler = jsHandler;
 
 // src/wxml/utils/codegen/legacy-rewriter.ts
 var import_magic_string2 = __toESM(require("magic-string"));
@@ -922,9 +2719,273 @@ function formatOutputPath(target, baseDir) {
   return relative.startsWith(".") ? relative : `.${import_node_path12.default.sep}${relative}`;
 }
 
+// src/cli/doctor.ts
+var import_node_fs7 = require("fs");
+var import_node_module3 = require("module");
+var import_node_path13 = __toESM(require("path"));
+var import_node_process13 = __toESM(require("process"));
+var import_semver = __toESM(require("semver"));
+
+// src/cli/doctor/constants.ts
+var 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"]
+};
+var FRAMEWORK_DEPS = [
+  ["@tarojs/taro", "Taro"],
+  ["@dcloudio/uni-app", "uni-app"],
+  ["@mpxjs/core", "MPX"],
+  ["remax", "Remax"],
+  ["rax", "Rax"]
+];
+
+// src/cli/doctor.ts
+function tryReadJson(file) {
+  try {
+    return JSON.parse((0, import_node_fs7.readFileSync)(file, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function findFirstExisting(cwd, files) {
+  return files.find((file) => (0, import_node_fs7.existsSync)(import_node_path13.default.join(cwd, file)));
+}
+function readProjectPackageJson(cwd) {
+  return tryReadJson(import_node_path13.default.join(cwd, "package.json"));
+}
+function readDependencyVersion(cwd, packageName) {
+  try {
+    const requireFromCwd = (0, import_node_module3.createRequire)(import_node_path13.default.join(cwd, "package.json"));
+    const packageJsonPath = requireFromCwd.resolve(`${packageName}/package.json`);
+    return tryReadJson(packageJsonPath)?.version;
+  } catch {
+    return void 0;
+  }
+}
+function collectDependencySpecs(pkg) {
+  return {
+    ...pkg?.dependencies ?? {},
+    ...pkg?.devDependencies ?? {},
+    ...pkg?.optionalDependencies ?? {},
+    ...pkg?.peerDependencies ?? {}
+  };
+}
+function detectPackageManager(cwd, pkg) {
+  if (pkg?.packageManager) {
+    return pkg.packageManager;
+  }
+  if ((0, import_node_fs7.existsSync)(import_node_path13.default.join(cwd, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if ((0, import_node_fs7.existsSync)(import_node_path13.default.join(cwd, "package-lock.json"))) {
+    return "npm";
+  }
+  if ((0, import_node_fs7.existsSync)(import_node_path13.default.join(cwd, "yarn.lock"))) {
+    return "yarn";
+  }
+  return void 0;
+}
+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 void 0;
+  }
+  return import_semver.default.parse(version)?.major;
+}
+function getDependencyMajor(deps, packageName) {
+  const spec = deps[packageName];
+  return spec ? import_semver.default.minVersion(spec)?.major : void 0;
+}
+function createDoctorReport(options = {}) {
+  const cwd = import_node_path13.default.resolve(options.cwd ?? import_node_process13.default.cwd());
+  const nodeVersion = options.nodeVersion ?? import_node_process13.default.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: "\u5DF2\u627E\u5230\u9879\u76EE package.json\u3002"
+  } : {
+    id: "package-json",
+    title: "package.json",
+    status: "error",
+    message: "\u5F53\u524D\u76EE\u5F55\u6CA1\u6709 package.json\u3002",
+    suggestion: "\u8BF7\u5728\u9879\u76EE\u6839\u76EE\u5F55\u8FD0\u884C doctor\uFF0C\u6216\u901A\u8FC7 --cwd \u6307\u5411\u9879\u76EE\u6839\u76EE\u5F55\u3002"
+  });
+  addCheck(checks, import_semver.default.satisfies(nodeVersion, WEAPP_TW_REQUIRED_NODE_VERSION_RANGE) ? {
+    id: "node-version",
+    title: "Node.js",
+    status: "ok",
+    message: `\u5F53\u524D Node.js ${nodeVersion} \u6EE1\u8DB3\u7248\u672C\u8981\u6C42 ${WEAPP_TW_REQUIRED_NODE_VERSION_RANGE}\u3002`
+  } : {
+    id: "node-version",
+    title: "Node.js",
+    status: "error",
+    message: `\u5F53\u524D Node.js ${nodeVersion} \u4E0D\u6EE1\u8DB3\u7248\u672C\u8981\u6C42 ${WEAPP_TW_REQUIRED_NODE_VERSION_RANGE}\u3002`,
+    suggestion: "\u8BF7\u5347\u7EA7 Node.js \u540E\u518D\u5B89\u88C5\u6216\u6784\u5EFA weapp-tailwindcss \u9879\u76EE\u3002"
+  });
+  addCheck(checks, packageManager ? {
+    id: "package-manager",
+    title: "\u5305\u7BA1\u7406\u5668",
+    status: packageManager.startsWith("pnpm") ? "ok" : "info",
+    message: `\u68C0\u6D4B\u5230 ${packageManager}\u3002`
+  } : {
+    id: "package-manager",
+    title: "\u5305\u7BA1\u7406\u5668",
+    status: "info",
+    message: "\u672A\u68C0\u6D4B\u5230 lockfile \u6216 packageManager \u5B57\u6BB5\u3002"
+  });
+  addCheck(checks, hasDependency(deps, "weapp-tailwindcss") || Boolean(weappTailwindcssVersion) ? {
+    id: "weapp-tailwindcss",
+    title: "weapp-tailwindcss",
+    status: "ok",
+    message: `\u68C0\u6D4B\u5230 weapp-tailwindcss${weappTailwindcssVersion ? `@${weappTailwindcssVersion}` : ""}\u3002`
+  } : {
+    id: "weapp-tailwindcss",
+    title: "weapp-tailwindcss",
+    status: "warn",
+    message: "\u672A\u5728\u5F53\u524D\u9879\u76EE\u4F9D\u8D56\u4E2D\u68C0\u6D4B\u5230 weapp-tailwindcss\u3002",
+    suggestion: "\u5982\u679C\u8FD9\u662F\u4E1A\u52A1\u9879\u76EE\uFF0C\u8BF7\u5B89\u88C5 weapp-tailwindcss \u5E76\u786E\u8BA4\u547D\u4EE4\u8FD0\u884C\u5728\u9879\u76EE\u6839\u76EE\u5F55\u3002"
+  });
+  addCheck(checks, hasDependency(deps, "tailwindcss") || Boolean(tailwindcssVersion) ? {
+    id: "tailwindcss",
+    title: "Tailwind CSS",
+    status: "ok",
+    message: `\u68C0\u6D4B\u5230 tailwindcss${tailwindcssVersion ? `@${tailwindcssVersion}` : ""}\u3002`
+  } : {
+    id: "tailwindcss",
+    title: "Tailwind CSS",
+    status: "error",
+    message: "\u672A\u68C0\u6D4B\u5230 tailwindcss\u3002",
+    suggestion: "\u8BF7\u5B89\u88C5 tailwindcss\uFF0C\u5E76\u786E\u8BA4\u4F9D\u8D56\u53EF\u4EE5\u4ECE\u5F53\u524D\u9879\u76EE\u89E3\u6790\u3002"
+  });
+  addCheck(checks, tailwindConfig ? {
+    id: "tailwind-config",
+    title: "Tailwind \u914D\u7F6E",
+    status: "ok",
+    message: `\u68C0\u6D4B\u5230 ${tailwindConfig}\u3002`
+  } : {
+    id: "tailwind-config",
+    title: "Tailwind \u914D\u7F6E",
+    status: tailwindMajor === 4 ? "info" : "warn",
+    message: "\u672A\u68C0\u6D4B\u5230 tailwind.config.*\u3002",
+    suggestion: tailwindMajor === 4 ? "Tailwind CSS v4 \u53EF\u4EE5\u91C7\u7528 CSS-first \u914D\u7F6E\uFF1B\u5982\u679C\u4F7F\u7528 v3 \u6216\u590D\u6742 content/source\uFF0C\u8BF7\u8865\u5145\u914D\u7F6E\u6587\u4EF6\u3002" : "\u8BF7\u786E\u8BA4 Tailwind content/source \u914D\u7F6E\u80FD\u591F\u8986\u76D6\u5C0F\u7A0B\u5E8F\u9875\u9762\u3001\u7EC4\u4EF6\u548C\u811A\u672C\u6587\u4EF6\u3002"
+  });
+  addCheck(checks, postcssConfig ? {
+    id: "postcss-config",
+    title: "PostCSS \u914D\u7F6E",
+    status: "ok",
+    message: `\u68C0\u6D4B\u5230 ${postcssConfig}\u3002`
+  } : {
+    id: "postcss-config",
+    title: "PostCSS \u914D\u7F6E",
+    status: viteConfig ? "info" : "warn",
+    message: "\u672A\u68C0\u6D4B\u5230 postcss.config.*\u3002",
+    suggestion: "\u5982\u679C\u901A\u8FC7 PostCSS \u63A5\u5165\uFF0C\u8BF7\u8865\u5145 postcss.config.*\uFF1B\u5982\u679C\u901A\u8FC7 Vite/Taro \u63D2\u4EF6\u63A5\u5165\uFF0C\u53EF\u5FFD\u7565\u6B64\u9879\u3002"
+  });
+  if (tailwindMajor === 4 && postcssConfig && !hasDependency(deps, "@tailwindcss/postcss")) {
+    addCheck(checks, {
+      id: "tailwindcss-v4-postcss",
+      title: "Tailwind v4 PostCSS",
+      status: "warn",
+      message: "Tailwind CSS v4 \u9879\u76EE\u5B58\u5728 PostCSS \u914D\u7F6E\uFF0C\u4F46\u672A\u68C0\u6D4B\u5230 @tailwindcss/postcss\u3002",
+      suggestion: "\u5982\u679C PostCSS \u914D\u7F6E\u4E2D\u4ECD\u76F4\u63A5\u4F7F\u7528 tailwindcss\uFF0C\u8BF7\u8FC1\u79FB\u5230 @tailwindcss/postcss\u3002"
+    });
+  }
+  addCheck(checks, frameworks.length > 0 ? {
+    id: "framework",
+    title: "\u6846\u67B6\u8BC6\u522B",
+    status: "ok",
+    message: `\u68C0\u6D4B\u5230 ${frameworks.join(", ")}\u3002`
+  } : {
+    id: "framework",
+    title: "\u6846\u67B6\u8BC6\u522B",
+    status: "info",
+    message: "\u672A\u4ECE\u4F9D\u8D56\u4E2D\u8BC6\u522B\u51FA Taro\u3001uni-app\u3001MPX\u3001Remax \u6216 Rax\u3002"
+  });
+  addCheck(checks, viteConfig || webpackConfig ? {
+    id: "bundler-config",
+    title: "\u6784\u5EFA\u5668\u914D\u7F6E",
+    status: "ok",
+    message: `\u68C0\u6D4B\u5230 ${[viteConfig, webpackConfig].filter(Boolean).join(", ")}\u3002`
+  } : {
+    id: "bundler-config",
+    title: "\u6784\u5EFA\u5668\u914D\u7F6E",
+    status: "info",
+    message: "\u672A\u68C0\u6D4B\u5230 vite.config.* \u6216 webpack.config.*\u3002"
+  });
+  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");
+}
+
 // src/cli/helpers.ts
 var import_promises3 = require("fs/promises");
-var import_node_process15 = __toESM(require("process"));
+var import_node_process16 = __toESM(require("process"));
 
 // src/logger/index.ts
 var import_logger13 = require("@weapp-tailwindcss/logger");
@@ -982,19 +3043,19 @@ function toBoolean(value, fallback) {
 }
 
 // src/cli/helpers/options/resolve.ts
-var import_node_path13 = __toESM(require("path"));
-var import_node_process13 = __toESM(require("process"));
+var import_node_path14 = __toESM(require("path"));
+var import_node_process14 = __toESM(require("process"));
 function resolveCliCwd(value) {
   const raw = readStringOption("cwd", value);
   if (!raw) {
     return void 0;
   }
-  return import_node_path13.default.isAbsolute(raw) ? import_node_path13.default.normalize(raw) : import_node_path13.default.resolve(import_node_process13.default.cwd(), raw);
+  return import_node_path14.default.isAbsolute(raw) ? import_node_path14.default.normalize(raw) : import_node_path14.default.resolve(import_node_process14.default.cwd(), raw);
 }
 
 // src/cli/helpers/patch-cwd.ts
-var import_node_path14 = __toESM(require("path"));
-var import_node_process14 = __toESM(require("process"));
+var import_node_path15 = __toESM(require("path"));
+var import_node_process15 = __toESM(require("process"));
 
 // src/tailwindcss/index.ts
 var import_local_pkg = require("local-pkg");
@@ -1007,7 +3068,7 @@ function normalizeCandidatePath(baseDir, candidate) {
   if (!candidate) {
     return void 0;
   }
-  return import_node_path14.default.isAbsolute(candidate) ? import_node_path14.default.normalize(candidate) : import_node_path14.default.resolve(baseDir, candidate);
+  return import_node_path15.default.isAbsolute(candidate) ? import_node_path15.default.normalize(candidate) : import_node_path15.default.resolve(baseDir, candidate);
 }
 function detectTailwindWorkspace(paths) {
   for (const candidate of paths) {
@@ -1021,15 +3082,15 @@ function detectTailwindWorkspace(paths) {
   }
   return void 0;
 }
-function resolvePatchDefaultCwd(currentCwd = import_node_process14.default.cwd()) {
-  const baseDir = import_node_path14.default.normalize(currentCwd);
-  const explicitCwd = normalizeCandidatePath(baseDir, import_node_process14.default.env.WEAPP_TW_PATCH_CWD);
+function resolvePatchDefaultCwd(currentCwd = import_node_process15.default.cwd()) {
+  const baseDir = import_node_path15.default.normalize(currentCwd);
+  const explicitCwd = normalizeCandidatePath(baseDir, import_node_process15.default.env.WEAPP_TW_PATCH_CWD);
   if (explicitCwd) {
     return explicitCwd;
   }
   const workspaceRoot = findWorkspaceRoot(baseDir);
-  const initCwd = normalizeCandidatePath(baseDir, import_node_process14.default.env.INIT_CWD);
-  const localPrefix = normalizeCandidatePath(baseDir, import_node_process14.default.env.npm_config_local_prefix);
+  const initCwd = normalizeCandidatePath(baseDir, import_node_process15.default.env.INIT_CWD);
+  const localPrefix = normalizeCandidatePath(baseDir, import_node_process15.default.env.npm_config_local_prefix);
   const candidates = [
     baseDir,
     workspaceRoot,
@@ -1050,7 +3111,7 @@ async function ensureDir(dir) {
 function handleCliError(error) {
   if (error instanceof Error) {
     import_logger13.logger.error(error.message);
-    if (error.stack && import_node_process15.default.env.WEAPP_TW_DEBUG === "1") {
+    if (error.stack && import_node_process16.default.env.WEAPP_TW_DEBUG === "1") {
       import_logger13.logger.error(error.stack);
     }
   } else {
@@ -1063,13 +3124,13 @@ function commandAction(handler) {
       await handler(...args);
     } catch (error) {
       handleCliError(error);
-      import_node_process15.default.exitCode = 1;
+      import_node_process16.default.exitCode = 1;
     }
   };
 }
 
 // src/cli/mount-options.ts
-var import_node_process17 = __toESM(require("process"));
+var import_node_process18 = __toESM(require("process"));
 
 // src/cli/mount-options/patch-status.ts
 function formatStatusFilesHint(files) {
@@ -1144,24 +3205,24 @@ function buildExtendLengthUnitsOverride(options) {
 }
 
 // src/cli/workspace.ts
-var import_node_path19 = __toESM(require("path"));
-var import_node_process16 = __toESM(require("process"));
+var import_node_path20 = __toESM(require("path"));
+var import_node_process17 = __toESM(require("process"));
 
 // src/cli/workspace/package-dirs.ts
-var import_node_fs10 = require("fs");
-var import_node_path17 = __toESM(require("path"));
+var import_node_fs11 = require("fs");
+var import_node_path18 = __toESM(require("path"));
 var import_fast_glob = __toESM(require("fast-glob"));
 
 // src/cli/workspace/workspace-globs.ts
-var import_node_fs8 = require("fs");
-var import_node_path15 = __toESM(require("path"));
+var import_node_fs9 = require("fs");
+var import_node_path16 = __toESM(require("path"));
 var import_yaml = require("yaml");
 
 // src/cli/workspace/workspace-io.ts
-var import_node_fs7 = require("fs");
-function tryReadJson(file) {
+var import_node_fs8 = require("fs");
+function tryReadJson2(file) {
   try {
-    const content = (0, import_node_fs7.readFileSync)(file, "utf8");
+    const content = (0, import_node_fs8.readFileSync)(file, "utf8");
     return JSON.parse(content);
   } catch {
     return void 0;
@@ -1170,8 +3231,8 @@ function tryReadJson(file) {
 
 // src/cli/workspace/workspace-globs.ts
 function parseWorkspaceGlobsFromPackageJson(workspaceRoot) {
-  const pkgJsonPath = import_node_path15.default.join(workspaceRoot, "package.json");
-  const pkg = tryReadJson(pkgJsonPath);
+  const pkgJsonPath = import_node_path16.default.join(workspaceRoot, "package.json");
+  const pkg = tryReadJson2(pkgJsonPath);
   if (!pkg?.workspaces) {
     return [];
   }
@@ -1184,12 +3245,12 @@ function parseWorkspaceGlobsFromPackageJson(workspaceRoot) {
   return [];
 }
 function parseWorkspaceGlobsFromWorkspaceFile(workspaceRoot) {
-  const workspaceFile = import_node_path15.default.join(workspaceRoot, "pnpm-workspace.yaml");
-  if (!(0, import_node_fs8.existsSync)(workspaceFile)) {
+  const workspaceFile = import_node_path16.default.join(workspaceRoot, "pnpm-workspace.yaml");
+  if (!(0, import_node_fs9.existsSync)(workspaceFile)) {
     return [];
   }
   try {
-    const parsed = (0, import_yaml.parse)((0, import_node_fs8.readFileSync)(workspaceFile, "utf8"));
+    const parsed = (0, import_yaml.parse)((0, import_node_fs9.readFileSync)(workspaceFile, "utf8"));
     return Array.isArray(parsed?.packages) ? parsed.packages.filter(Boolean) : [];
   } catch {
     return [];
@@ -1197,16 +3258,16 @@ function parseWorkspaceGlobsFromWorkspaceFile(workspaceRoot) {
 }
 
 // src/cli/workspace/workspace-lock.ts
-var import_node_fs9 = require("fs");
-var import_node_path16 = __toESM(require("path"));
+var import_node_fs10 = require("fs");
+var import_node_path17 = __toESM(require("path"));
 var import_yaml2 = require("yaml");
 function parseImportersFromLock(workspaceRoot) {
-  const lockPath = import_node_path16.default.join(workspaceRoot, "pnpm-lock.yaml");
-  if (!(0, import_node_fs9.existsSync)(lockPath)) {
+  const lockPath = import_node_path17.default.join(workspaceRoot, "pnpm-lock.yaml");
+  if (!(0, import_node_fs10.existsSync)(lockPath)) {
     return [];
   }
   try {
-    const parsed = (0, import_yaml2.parse)((0, import_node_fs9.readFileSync)(lockPath, "utf8"));
+    const parsed = (0, import_yaml2.parse)((0, import_node_fs10.readFileSync)(lockPath, "utf8"));
     const importers = parsed?.importers;
     if (!importers) {
       return [];
@@ -1215,7 +3276,7 @@ function parseImportersFromLock(workspaceRoot) {
       if (!key || key === ".") {
         return workspaceRoot;
       }
-      return import_node_path16.default.join(workspaceRoot, key);
+      return import_node_path17.default.join(workspaceRoot, key);
     });
   } catch {
     return [];
@@ -1228,7 +3289,7 @@ var TRAILING_SLASH_RE = /\/+$/;
 async function resolveWorkspacePackageDirs(workspaceRoot) {
   const dirs = /* @__PURE__ */ new Set();
   for (const importerDir of parseImportersFromLock(workspaceRoot)) {
-    dirs.add(import_node_path17.default.normalize(importerDir));
+    dirs.add(import_node_path18.default.normalize(importerDir));
   }
   if (!dirs.size) {
     let globs = parseWorkspaceGlobsFromWorkspaceFile(workspaceRoot);
@@ -1248,13 +3309,13 @@ async function resolveWorkspacePackageDirs(workspaceRoot) {
         ignore: ["**/node_modules/**", "**/.git/**"]
       });
       for (const file of packageJsonFiles) {
-        dirs.add(import_node_path17.default.normalize(import_node_path17.default.dirname(file)));
+        dirs.add(import_node_path18.default.normalize(import_node_path18.default.dirname(file)));
       }
     }
   }
-  const rootPkg = import_node_path17.default.join(workspaceRoot, "package.json");
-  if ((0, import_node_fs10.existsSync)(rootPkg)) {
-    dirs.add(import_node_path17.default.normalize(workspaceRoot));
+  const rootPkg = import_node_path18.default.join(workspaceRoot, "package.json");
+  if ((0, import_node_fs11.existsSync)(rootPkg)) {
+    dirs.add(import_node_path18.default.normalize(workspaceRoot));
   }
   return [...dirs];
 }
@@ -1263,9 +3324,9 @@ async function resolveWorkspacePackageDirs(workspaceRoot) {
 var import_tailwindcss_patch2 = require("tailwindcss-patch");
 
 // src/cli/workspace/patch-utils.ts
-var import_node_path18 = __toESM(require("path"));
+var import_node_path19 = __toESM(require("path"));
 function formatDisplayName(workspaceRoot, dir, name) {
-  const relative = import_node_path18.default.relative(workspaceRoot, dir) || ".";
+  const relative = import_node_path19.default.relative(workspaceRoot, dir) || ".";
   return name ? `${name} (${relative})` : relative;
 }
 function summarizeWorkspaceResults(results) {
@@ -1338,7 +3399,7 @@ async function patchWorkspacePackage(workspaceRoot, dir, pkgName, options) {
 
 // src/cli/workspace.ts
 async function patchWorkspace(options) {
-  const cwd = options.cwd ?? import_node_process16.default.cwd();
+  const cwd = options.cwd ?? import_node_process17.default.cwd();
   const workspaceRoot = findWorkspaceRoot(cwd) ?? cwd;
   const packageDirs = await resolveWorkspacePackageDirs(workspaceRoot);
   if (packageDirs.length === 0) {
@@ -1347,8 +3408,8 @@ async function patchWorkspace(options) {
   }
   const results = [];
   for (const dir of packageDirs) {
-    const pkgJsonPath = import_node_path19.default.join(dir, "package.json");
-    const pkgJson = tryReadJson(pkgJsonPath);
+    const pkgJsonPath = import_node_path20.default.join(dir, "package.json");
+    const pkgJson = tryReadJson2(pkgJsonPath);
     results.push(await patchWorkspacePackage(workspaceRoot, dir, pkgJson?.name, options));
   }
   summarizeWorkspaceResults(results);
@@ -1358,7 +3419,7 @@ async function patchWorkspace(options) {
 function handleCliError2(error) {
   if (error instanceof Error) {
     import_logger13.logger.error(error.message);
-    if (error.stack && import_node_process17.default.env.WEAPP_TW_DEBUG === "1") {
+    if (error.stack && import_node_process18.default.env.WEAPP_TW_DEBUG === "1") {
       import_logger13.logger.error(error.stack);
     }
   } else {
@@ -1371,7 +3432,7 @@ function withCommandErrorHandling(handler) {
       return await handler(ctx, next);
     } catch (error) {
       handleCliError2(error);
-      import_node_process17.default.exitCode = 1;
+      import_node_process18.default.exitCode = 1;
       return void 0;
     }
   });
@@ -1479,9 +3540,9 @@ var mountOptions = {
 };
 
 // src/cli/vscode-entry.ts
-var import_node_fs11 = require("fs");
+var import_node_fs12 = require("fs");
 var import_promises4 = require("fs/promises");
-var import_node_path20 = __toESM(require("path"));
+var import_node_path21 = __toESM(require("path"));
 var DEFAULT_VSCODE_ENTRY_OUTPUT = ".vscode/weapp-tailwindcss.intellisense.css";
 var DEFAULT_VSCODE_SOURCES = [
   'not "./dist"',
@@ -1498,7 +3559,7 @@ function toPosixPath(filepath) {
 }
 async function assertFileExists(filepath) {
   try {
-    await (0, import_promises4.access)(filepath, import_node_fs11.constants.F_OK);
+    await (0, import_promises4.access)(filepath, import_node_fs12.constants.F_OK);
   } catch (error) {
     const err = error;
     if (err?.code === "ENOENT") {
@@ -1509,7 +3570,7 @@ async function assertFileExists(filepath) {
 }
 async function assertCanWrite(filepath, force) {
   try {
-    await (0, import_promises4.access)(filepath, import_node_fs11.constants.F_OK);
+    await (0, import_promises4.access)(filepath, import_node_fs12.constants.F_OK);
     if (!force) {
       throw new Error(
         `VS Code helper already exists at ${filepath}. Re-run with --force to overwrite it.`
@@ -1554,16 +3615,16 @@ function formatSource(pattern) {
 }
 function resolveOutputPath(baseDir, output) {
   const target = output ?? DEFAULT_VSCODE_ENTRY_OUTPUT;
-  return import_node_path20.default.isAbsolute(target) ? import_node_path20.default.normalize(target) : import_node_path20.default.resolve(baseDir, target);
+  return import_node_path21.default.isAbsolute(target) ? import_node_path21.default.normalize(target) : import_node_path21.default.resolve(baseDir, target);
 }
 function resolveCssEntry(baseDir, entry) {
-  return import_node_path20.default.isAbsolute(entry) ? import_node_path20.default.normalize(entry) : import_node_path20.default.resolve(baseDir, entry);
+  return import_node_path21.default.isAbsolute(entry) ? import_node_path21.default.normalize(entry) : import_node_path21.default.resolve(baseDir, entry);
 }
 function toRelativeImport(fromFile, targetFile) {
-  const fromDir = import_node_path20.default.dirname(fromFile);
-  let relative = import_node_path20.default.relative(fromDir, targetFile);
+  const fromDir = import_node_path21.default.dirname(fromFile);
+  let relative = import_node_path21.default.relative(fromDir, targetFile);
   if (!relative) {
-    relative = import_node_path20.default.basename(targetFile);
+    relative = import_node_path21.default.basename(targetFile);
   }
   if (!relative.startsWith(".")) {
     relative = `./${relative}`;
@@ -1575,7 +3636,7 @@ async function generateVscodeIntellisenseEntry(options) {
   const cssEntryPath = resolveCssEntry(baseDir, options.cssEntry);
   await assertFileExists(cssEntryPath);
   const outputPath = resolveOutputPath(baseDir, options.output);
-  await ensureDir(import_node_path20.default.dirname(outputPath));
+  await ensureDir(import_node_path21.default.dirname(outputPath));
   await assertCanWrite(outputPath, options.force);
   const sources = options.sources && options.sources.length > 0 ? options.sources : DEFAULT_VSCODE_SOURCES;
   const formattedSources = sources.map(formatSource).filter((statement) => Boolean(statement));
@@ -1600,10 +3661,10 @@ async function generateVscodeIntellisenseEntry(options) {
 }
 
 // src/cli.ts
-import_node_process18.default.title = "node (weapp-tailwindcss)";
-if (import_semver.default.lt(import_node_process18.default.versions.node, WEAPP_TW_REQUIRED_NODE_VERSION)) {
+import_node_process19.default.title = "node (weapp-tailwindcss)";
+if (!import_semver2.default.satisfies(import_node_process19.default.versions.node, WEAPP_TW_REQUIRED_NODE_VERSION_RANGE)) {
   import_logger13.logger.warn(
-    `You are using Node.js ${import_node_process18.default.versions.node}. For weapp-tailwindcss, Node.js version >= v${WEAPP_TW_REQUIRED_NODE_VERSION} is required.`
+    `You are using Node.js ${import_node_process19.default.versions.node}. For weapp-tailwindcss, Node.js version ${WEAPP_TW_REQUIRED_NODE_VERSION_RANGE} is required.`
   );
 }
 var cli = (0, import_tailwindcss_patch3.createTailwindcssPatchCli)({
@@ -1613,7 +3674,7 @@ var cli = (0, import_tailwindcss_patch3.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 ?? import_node_process18.default.cwd();
+    const baseDir = resolvedCwd ?? import_node_process19.default.cwd();
     const cssEntry = readStringOption("css", options.css);
     if (!cssEntry) {
       throw new Error('Option "--css" is required.');
@@ -1633,6 +3694,20 @@ cli.command("vscode-entry", "Generate a VS Code helper CSS for Tailwind IntelliS
     );
   })
 );
+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 resolvedCwd = resolveCliCwd(options.cwd);
+    const report = createDoctorReport({ cwd: resolvedCwd });
+    if (toBoolean(options.json, false)) {
+      import_logger13.logger.log(JSON.stringify(report, null, 2));
+    } else {
+      import_logger13.logger.log(formatDoctorReport(report));
+    }
+    if (hasDoctorFailure(report, toBoolean(options.strict, false))) {
+      import_node_process19.default.exitCode = 1;
+    }
+  })
+);
 cli.help();
-cli.version(import_node_process18.default.env.npm_package_version ?? "0.0.0");
+cli.version(import_node_process19.default.env.npm_package_version ?? "0.0.0");
 cli.parse();