weapp-tailwindcss 4.10.3 → 4.11.0-alpha.1

package/dist/{chunk-E7775SFS.mjs → chunk-FZNYV7VH.mjs}

@@ -3,10 +3,10 @@ import {
   createTailwindcssPatcherFromContext,
   findNearestPackageRoot,
   warnMissingCssEntries
-} from "./chunk-QOTLDKI4.mjs";
+} from "./chunk-IEZ5RBMG.mjs";
 import {
   getDefaultOptions
-} from "./chunk-3WUHHFLF.mjs";
+} from "./chunk-35EI5JMK.mjs";
 import {
   defuOverrideArray,
   isMap
@@ -16,15 +16,24 @@ import {
 import _createDebug from "debug";
 var _debug = _createDebug("weapp-tw");
 function createDebug(prefix) {
-  function debug3(formatter, ...args) {
+  const debug3 = ((formatter, ...args) => {
     return _debug((prefix ?? "") + formatter, ...args);
-  }
+  });
+  Object.defineProperty(debug3, "enabled", {
+    enumerable: false,
+    configurable: false,
+    get() {
+      return _debug.enabled;
+    }
+  });
   return debug3;
 }
 
 // src/tailwindcss/runtime/cache.ts
 import { statSync } from "fs";
 var runtimeClassSetCache = /* @__PURE__ */ new WeakMap();
+var runtimeConfigSignatureCache = /* @__PURE__ */ new Map();
+var runtimeConfigSignatureCacheClearTimer;
 function getCacheEntry(twPatcher) {
   let entry = runtimeClassSetCache.get(twPatcher);
   if (!entry) {
@@ -33,17 +42,35 @@ function getCacheEntry(twPatcher) {
   }
   return entry;
 }
+function scheduleRuntimeConfigSignatureCacheClear() {
+  if (runtimeConfigSignatureCacheClearTimer) {
+    return;
+  }
+  runtimeConfigSignatureCacheClearTimer = setTimeout(() => {
+    runtimeConfigSignatureCache.clear();
+    runtimeConfigSignatureCacheClearTimer = void 0;
+  }, 0);
+  runtimeConfigSignatureCacheClearTimer.unref?.();
+}
 function getTailwindConfigSignature(twPatcher) {
   const configPath = twPatcher.options?.tailwind?.config;
   if (typeof configPath !== "string" || configPath.length === 0) {
     return void 0;
   }
+  const cached = runtimeConfigSignatureCache.get(configPath);
+  if (cached !== void 0) {
+    return cached;
+  }
+  let signature;
   try {
     const stats = statSync(configPath);
-    return `${configPath}:${stats.size}:${stats.mtimeMs}`;
+    signature = `${configPath}:${stats.size}:${stats.mtimeMs}`;
   } catch {
-    return `${configPath}:missing`;
+    signature = `${configPath}:missing`;
   }
+  runtimeConfigSignatureCache.set(configPath, signature);
+  scheduleRuntimeConfigSignatureCacheClear();
+  return signature;
 }
 function getPatchTargetSignature(twPatcher) {
   const packageInfo = twPatcher.packageInfo;
@@ -53,6 +80,10 @@ function invalidateRuntimeClassSet(twPatcher) {
   if (!twPatcher) {
     return;
   }
+  const configPath = twPatcher.options?.tailwind?.config;
+  if (typeof configPath === "string" && configPath.length > 0) {
+    runtimeConfigSignatureCache.delete(configPath);
+  }
   runtimeClassSetCache.delete(twPatcher);
 }
 function getRuntimeClassSetCacheEntry(twPatcher) {
@@ -285,7 +316,7 @@ async function collectRuntimeClassSet(twPatcher, options = {}) {
 // package.json
 var package_default = {
   name: "weapp-tailwindcss",
-  version: "4.10.3",
+  version: "4.11.0-alpha.1",
   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",
@@ -469,7 +500,7 @@ var package_default = {
     "lint:fix": "eslint ./src --fix",
     postinstall: "node bin/weapp-tailwindcss.js patch",
     "bench:vite-dev-hmr": "tsx scripts/vite-dev-hmr-bench.ts",
-    "test:watch-hmr": "tsx scripts/watch-hmr-regression/index.ts"
+    "test:watch-hmr": "node --import tsx scripts/watch-hmr-regression/index.ts"
   },
   publishConfig: {
     access: "public",
@@ -859,13 +890,13 @@ import { Buffer } from "buffer";
 import path4 from "path";
 import process4 from "process";
 import { logger as logger3 } from "@weapp-tailwindcss/logger";
+var PAREN_CONTENT_RE = /\(([^)]+)\)/u;
+var AT_LOCATION_RE = /at\s+(\S.*)$/u;
+var TRAILING_LINE_COL_RE = /:\d+(?::\d+)?$/u;
 var globalCacheHolder = globalThis;
 var compilerContextCache = globalCacheHolder.__WEAPP_TW_COMPILER_CONTEXT_CACHE__ ?? (globalCacheHolder.__WEAPP_TW_COMPILER_CONTEXT_CACHE__ = /* @__PURE__ */ new Map());
-function compareNormalizedValues(a, b) {
-  const aStr = JSON.stringify(a);
-  const bStr = JSON.stringify(b);
-  return aStr.localeCompare(bStr);
-}
+var compilerContextKeyCacheByOptions = /* @__PURE__ */ new WeakMap();
+var compilerContextKeyCacheWithoutOptions = /* @__PURE__ */ new Map();
 function withCircularGuard(value, stack, factory) {
   if (stack.has(value)) {
     throw new TypeError("Cannot serialize circular structure in compiler context options");
@@ -884,6 +915,15 @@ function encodeTaggedValue(type, value) {
   }
   return record;
 }
+function hasExplicitOptionBasedir(opts) {
+  return typeof opts?.tailwindcssBasedir === "string" && opts.tailwindcssBasedir.length > 0;
+}
+function shouldProbeCallerLocation(opts) {
+  if (hasExplicitOptionBasedir(opts)) {
+    return false;
+  }
+  return !(process4.env.WEAPP_TAILWINDCSS_BASEDIR || process4.env.WEAPP_TAILWINDCSS_BASE_DIR || process4.env.TAILWINDCSS_BASEDIR || process4.env.TAILWINDCSS_BASE_DIR);
+}
 function detectCallerLocation() {
   const stack = new Error("compiler-context-cache stack probe").stack;
   if (!stack) {
@@ -891,12 +931,12 @@ function detectCallerLocation() {
   }
   const lines = stack.split("\n");
   for (const line of lines) {
-    const match = line.match(/\(([^)]+)\)/u) ?? line.match(/at\s+(\S.*)$/u);
+    const match = line.match(PAREN_CONTENT_RE) ?? line.match(AT_LOCATION_RE);
     const location = match?.[1];
     if (!location) {
       continue;
     }
-    const candidatePath = location.replace(/:\d+(?::\d+)?$/u, "");
+    const candidatePath = location.replace(TRAILING_LINE_COL_RE, "");
     if (!candidatePath || !path4.isAbsolute(candidatePath)) {
       continue;
     }
@@ -907,23 +947,62 @@ function detectCallerLocation() {
   }
   return void 0;
 }
-function getRuntimeCacheScope() {
-  return {
+function getRuntimeCacheScope(opts) {
+  if (hasExplicitOptionBasedir(opts)) {
+    return {
+      caller: void 0
+    };
+  }
+  const runtimeScope = {
+    caller: void 0,
     cwd: process4.cwd(),
-    npm_package_json: process4.env.npm_package_json,
+    init_cwd: process4.env.INIT_CWD,
     npm_config_local_prefix: process4.env.npm_config_local_prefix,
+    npm_package_json: process4.env.npm_package_json,
     pnpm_package_name: process4.env.PNPM_PACKAGE_NAME,
-    init_cwd: process4.env.INIT_CWD,
     pwd: process4.env.PWD,
-    weapp_tailwindcss_basedir: process4.env.WEAPP_TAILWINDCSS_BASEDIR,
-    weapp_tailwindcss_base_dir: process4.env.WEAPP_TAILWINDCSS_BASE_DIR,
-    tailwindcss_basedir: process4.env.TAILWINDCSS_BASEDIR,
     tailwindcss_base_dir: process4.env.TAILWINDCSS_BASE_DIR,
+    tailwindcss_basedir: process4.env.TAILWINDCSS_BASEDIR,
+    uni_app_input_dir: process4.env.UNI_APP_INPUT_DIR,
+    uni_cli_root: process4.env.UNI_CLI_ROOT,
     uni_input_dir: process4.env.UNI_INPUT_DIR,
     uni_input_root: process4.env.UNI_INPUT_ROOT,
-    uni_cli_root: process4.env.UNI_CLI_ROOT,
-    uni_app_input_dir: process4.env.UNI_APP_INPUT_DIR,
-    caller: detectCallerLocation()
+    weapp_tailwindcss_base_dir: process4.env.WEAPP_TAILWINDCSS_BASE_DIR,
+    weapp_tailwindcss_basedir: process4.env.WEAPP_TAILWINDCSS_BASEDIR
+  };
+  if (shouldProbeCallerLocation(opts)) {
+    runtimeScope.caller = detectCallerLocation();
+  }
+  return runtimeScope;
+}
+function serializeNormalizedValue(value) {
+  return JSON.stringify(value);
+}
+function createRuntimeCacheScopeKey(opts) {
+  return serializeNormalizedValue(normalizeOptionsValue(getRuntimeCacheScope(opts)));
+}
+function getCompilerContextKeyCacheStore(opts) {
+  if (!opts) {
+    return compilerContextKeyCacheWithoutOptions;
+  }
+  let store = compilerContextKeyCacheByOptions.get(opts);
+  if (!store) {
+    store = /* @__PURE__ */ new Map();
+    compilerContextKeyCacheByOptions.set(opts, store);
+  }
+  return store;
+}
+function createComparableNormalizedValue(rawValue, stack) {
+  const normalized = normalizeOptionsValue(rawValue, stack);
+  return {
+    normalized,
+    sortKey: serializeNormalizedValue(normalized)
+  };
+}
+function getRuntimeCacheScopeValue(opts) {
+  return {
+    options: opts ?? {},
+    runtime: getRuntimeCacheScope(opts)
   };
 }
 function normalizeOptionsValue(rawValue, stack = /* @__PURE__ */ new WeakSet()) {
@@ -989,21 +1068,25 @@ function normalizeOptionsValue(rawValue, stack = /* @__PURE__ */ new WeakSet())
   }
   if (rawValue instanceof Set) {
     return withCircularGuard(rawValue, stack, () => {
-      const normalizedEntries = Array.from(rawValue, (element) => normalizeOptionsValue(element, stack));
-      normalizedEntries.sort(compareNormalizedValues);
+      const normalizedEntries = Array.from(rawValue, (element) => createComparableNormalizedValue(element, stack));
+      normalizedEntries.sort((a, b) => a.sortKey.localeCompare(b.sortKey));
       return {
         __type: "Set",
-        value: normalizedEntries
+        value: normalizedEntries.map((entry) => entry.normalized)
       };
     });
   }
   if (rawValue instanceof Map) {
     return withCircularGuard(rawValue, stack, () => {
-      const normalizedEntries = Array.from(rawValue.entries()).map(([key, entryValue]) => ({
-        key: normalizeOptionsValue(key, stack),
-        value: normalizeOptionsValue(entryValue, stack)
-      }));
-      normalizedEntries.sort((a, b) => compareNormalizedValues(a.key, b.key));
+      const normalizedEntries = Array.from(rawValue.entries(), ([key, entryValue]) => {
+        const normalizedKey = createComparableNormalizedValue(key, stack);
+        return {
+          key: normalizedKey.normalized,
+          sortKey: normalizedKey.sortKey,
+          value: normalizeOptionsValue(entryValue, stack)
+        };
+      });
+      normalizedEntries.sort((a, b) => a.sortKey.localeCompare(b.sortKey));
       return {
         __type: "Map",
         value: normalizedEntries.map((entry) => [entry.key, entry.value])
@@ -1046,12 +1129,16 @@ function normalizeOptionsValue(rawValue, stack = /* @__PURE__ */ new WeakSet())
 }
 function createCompilerContextCacheKey(opts) {
   try {
-    const normalized = normalizeOptionsValue({
-      options: opts ?? {},
-      runtime: getRuntimeCacheScope()
-    });
-    const serialized = JSON.stringify(normalized);
-    return md5(serialized);
+    const runtimeCacheScopeKey = createRuntimeCacheScopeKey(opts);
+    const keyStore = getCompilerContextKeyCacheStore(opts);
+    const cached = keyStore.get(runtimeCacheScopeKey);
+    if (cached !== void 0) {
+      return cached;
+    }
+    const normalized = normalizeOptionsValue(getRuntimeCacheScopeValue(opts));
+    const cacheKey = md5(serializeNormalizedValue(normalized));
+    keyStore.set(runtimeCacheScopeKey, cacheKey);
+    return cacheKey;
   } catch (error) {
     logger3.debug("skip compiler context cache: %O", error);
     return void 0;
@@ -1098,6 +1185,8 @@ var traverse = _interopDefaultCompat(_babelTraverse);
 
 // src/utils/nameMatcher.ts
 import { escapeStringRegexp } from "@weapp-core/regex";
+var NEVER_MATCH_NAME = () => false;
+var GLOBAL_FLAG_REGEXP = /g/g;
 function buildFuzzyMatcher(fuzzyStrings) {
   if (fuzzyStrings.length === 0) {
     return void 0;
@@ -1115,11 +1204,11 @@ function normaliseRegex(regex) {
   if (!flags.includes("g")) {
     return regex;
   }
-  return new RegExp(source, flags.replace(/g/g, ""));
+  return new RegExp(source, flags.replace(GLOBAL_FLAG_REGEXP, ""));
 }
 function createNameMatcher(list, { exact = false } = {}) {
   if (!list || list.length === 0) {
-    return () => false;
+    return NEVER_MATCH_NAME;
   }
   const exactStrings = exact ? /* @__PURE__ */ new Set() : void 0;
   const fuzzyStrings = [];
@@ -1135,12 +1224,36 @@ function createNameMatcher(list, { exact = false } = {}) {
       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 (exact && exactStrings?.has(value)) {
-      return true;
-    }
     if (fuzzyMatcher?.(value)) {
       return true;
     }
@@ -1186,11 +1299,11 @@ import MagicString from "magic-string";
 
 // src/js/handlers.ts
 import { jsStringEscape } from "@ast-core/escape";
-import { escapeStringRegexp as escapeStringRegexp2 } from "@weapp-core/regex";
 import { splitCode } from "@weapp-tailwindcss/shared/extractors";
 
 // src/wxml/shared.ts
 import { escape, MappingChars2String } from "@weapp-core/escape";
+var NEWLINE_RE = /[\n\r]+/g;
 function replaceWxml(original, options = {
   keepEOL: false,
   escapeMap: MappingChars2String
@@ -1198,7 +1311,7 @@ function replaceWxml(original, options = {
   const { keepEOL, escapeMap, ignoreHead } = options;
   let res = original;
   if (!keepEOL) {
-    res = res.replaceAll(/[\n\r]+/g, "");
+    res = res.replaceAll(NEWLINE_RE, "");
   }
   res = escape(res, {
     map: escapeMap,
@@ -1208,21 +1321,37 @@ function replaceWxml(original, options = {
 }
 
 // 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) {
-  const normalized = candidate.trim();
-  if (!normalized.includes("[") || !normalized.includes("]")) {
+  let hasOpenBracket = false;
+  let hasCloseBracket = false;
+  for (let i = 0; i < candidate.length; i++) {
+    const char = candidate[i];
+    if (char === "[") {
+      hasOpenBracket = true;
+    } else if (char === "]") {
+      hasCloseBracket = true;
+    }
+    if (hasOpenBracket && hasCloseBracket) {
+      break;
+    }
+  }
+  if (!hasOpenBracket || !hasCloseBracket) {
     return false;
   }
-  if (/^(?:https?:)?\/\//.test(normalized)) {
+  const normalized = candidate.trim();
+  if (isUrlLikeCandidate(normalized)) {
     return false;
   }
   return true;
 }
-function shouldEnableArbitraryValueFallback({
-  classNameSet,
-  jsArbitraryValueFallback,
-  tailwindcssMajorVersion
-}) {
+function shouldEnableArbitraryValueFallbackByInputs(classNameSet, jsArbitraryValueFallback, tailwindcssMajorVersion) {
   if (jsArbitraryValueFallback === true) {
     return true;
   }
@@ -1231,7 +1360,45 @@ function shouldEnableArbitraryValueFallback({
   }
   return tailwindcssMajorVersion === 4 && (!classNameSet || classNameSet.size === 0);
 }
-function resolveClassNameTransformDecision(candidate, {
+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,
@@ -1241,28 +1408,24 @@ function resolveClassNameTransformDecision(candidate, {
   classContext
 }) {
   if (alwaysEscape) {
-    return "direct";
+    return DIRECT_RESULT;
   }
   if (jsPreserveClass?.(candidate)) {
-    return "skip";
+    return SKIP_RESULT;
   }
   if (classNameSet?.has(candidate)) {
-    return "direct";
+    return DIRECT_RESULT;
   }
   if (classNameSet && classNameSet.size > 0) {
-    const escapedCandidate = replaceWxml(candidate, { escapeMap });
+    const escapedCandidate = getEscapedCandidate(candidate, escapeMap);
     if (escapedCandidate !== candidate && classNameSet.has(escapedCandidate)) {
-      return "escaped";
+      return { decision: "escaped", escapedValue: escapedCandidate };
     }
   }
-  if (classContext && isArbitraryValueCandidate(candidate) && shouldEnableArbitraryValueFallback({
-    classNameSet,
-    jsArbitraryValueFallback,
-    tailwindcssMajorVersion
-  })) {
-    return "fallback";
+  if (classContext && shouldEnableArbitraryValueFallbackByInputs(classNameSet, jsArbitraryValueFallback, tailwindcssMajorVersion) && isArbitraryValueCandidate(candidate)) {
+    return FALLBACK_RESULT;
   }
-  return "skip";
+  return SKIP_RESULT;
 }
 
 // src/utils/decode.ts
@@ -1306,8 +1469,45 @@ var CLASS_HELPER_IDENTIFIERS = /* @__PURE__ */ new Set([
   "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) {
-  return name.replace(/[-_:]/g, "").toLowerCase();
+  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(path5) {
   if (path5.isIdentifier()) {
@@ -1344,28 +1544,30 @@ function isClassLikeJsxAttribute(path5) {
   }
   return CLASS_LIKE_KEYWORDS.has(normalizeKeyword(namePath.node.name));
 }
-function isClassLikeCallExpression(path5, valuePath) {
-  if (!path5.isCallExpression()) {
-    return false;
-  }
-  const args = path5.get("arguments");
-  if (!args.includes(valuePath)) {
-    return false;
-  }
-  const calleePath = path5.get("callee");
+function readCallHelperName(calleePath) {
   if (calleePath.isIdentifier()) {
-    return CLASS_HELPER_IDENTIFIERS.has(normalizeKeyword(calleePath.node.name));
+    return calleePath.node.name;
   }
   if (calleePath.isMemberExpression()) {
     const propertyPath = calleePath.get("property");
     if (propertyPath.isIdentifier()) {
-      return CLASS_HELPER_IDENTIFIERS.has(normalizeKeyword(propertyPath.node.name));
+      return propertyPath.node.name;
     }
     if (propertyPath.isStringLiteral()) {
-      return CLASS_HELPER_IDENTIFIERS.has(normalizeKeyword(propertyPath.node.value));
+      return propertyPath.node.value;
     }
   }
-  return false;
+  return void 0;
+}
+function isClassLikeCallExpression(path5, valuePath) {
+  if (!path5.isCallExpression()) {
+    return false;
+  }
+  const helperName = readCallHelperName(path5.get("callee"));
+  if (!helperName || !CLASS_HELPER_IDENTIFIERS.has(normalizeKeyword(helperName))) {
+    return false;
+  }
+  return path5.get("arguments").includes(valuePath);
 }
 function isClassContextLiteralPath(path5) {
   let current = path5;
@@ -1387,31 +1589,22 @@ function isClassContextLiteralPath(path5) {
 
 // src/js/handlers.ts
 var debug2 = createDebug("[js:handlers] ");
-var patternCache = /* @__PURE__ */ new Map();
 var replacementCacheByEscapeMap = /* @__PURE__ */ new WeakMap();
 var defaultReplacementCache = /* @__PURE__ */ new Map();
-function getPattern(candidate) {
-  let cached = patternCache.get(candidate);
-  if (!cached) {
-    cached = new RegExp(escapeStringRegexp2(candidate));
-    patternCache.set(candidate, cached);
-  }
-  return cached;
-}
-function getReplacement(candidate, escapeMap) {
+var WEAPP_TW_IGNORE_MARKER = "weapp-tw";
+var IGNORE_MARKER = "ignore";
+function getReplacementCacheStore(escapeMap) {
   if (!escapeMap) {
-    let cached2 = defaultReplacementCache.get(candidate);
-    if (cached2 === void 0) {
-      cached2 = replaceWxml(candidate, { escapeMap });
-      defaultReplacementCache.set(candidate, cached2);
-    }
-    return cached2;
+    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 });
@@ -1420,17 +1613,28 @@ function getReplacement(candidate, escapeMap) {
   return cached;
 }
 function hasIgnoreComment(node) {
-  return Array.isArray(node.leadingComments) && node.leadingComments.some((comment) => comment.value.includes("weapp-tw") && comment.value.includes("ignore"));
+  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(path5, { unescapeUnicode, arbitraryValues }) {
   const allowDoubleQuotes = arbitraryValues?.allowDoubleQuotes;
+  const { node } = path5;
   let offset = 0;
   let original;
-  if (path5.isStringLiteral()) {
+  if (node.type === "StringLiteral") {
     offset = 1;
-    original = path5.node.value;
-  } else if (path5.isTemplateElement()) {
-    original = path5.node.value.raw;
+    original = node.value;
+  } else if (node.type === "TemplateElement") {
+    original = node.value.raw;
   } else {
     original = "";
   }
@@ -1445,59 +1649,110 @@ function extractLiteralValue(path5, { unescapeUnicode, arbitraryValues }) {
     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(path5, options) {
-  const {
-    escapeMap,
-    needEscaped = false
-  } = options;
+  const { needEscaped = false } = options;
   const { classNameSet, alwaysEscape } = options;
   const fallbackEnabled = shouldEnableArbitraryValueFallback(options);
-  const classContext = options.wrapExpression || isClassContextLiteralPath(path5);
   if (!alwaysEscape && !fallbackEnabled && (!classNameSet || classNameSet.size === 0)) {
     return void 0;
   }
-  const { literal, original, allowDoubleQuotes, offset } = extractLiteralValue(path5, options);
   if (hasIgnoreComment(path5.node)) {
     return void 0;
   }
+  const { literal, original, allowDoubleQuotes, offset } = extractLiteralValue(path5, options);
   const candidates = splitCode(literal, allowDoubleQuotes);
   if (candidates.length === 0) {
     return void 0;
   }
+  const debugEnabled = debug2.enabled;
+  const classContext = options.wrapExpression || isClassContextLiteralPath(path5);
   let transformed = literal;
   let mutated = false;
   let matchedCandidateCount = 0;
   let escapedDecisionCount = 0;
   let fallbackDecisionCount = 0;
-  const escapedSamples = [];
-  const skippedSamples = [];
+  let escapedSamples;
+  let skippedSamples;
+  const resolveCandidatePlan = createCandidatePlanResolver(options, classContext);
   for (const candidate of candidates) {
-    const decision = resolveClassNameTransformDecision(candidate, {
-      ...options,
-      classContext
-    });
-    if (decision === "skip") {
-      if (skippedSamples.length < 6) {
-        skippedSamples.push(candidate);
+    const plan = resolveCandidatePlan(candidate);
+    if (plan.result.decision === "skip") {
+      if (debugEnabled) {
+        if (!skippedSamples) {
+          skippedSamples = [];
+        }
+        if (skippedSamples.length < 6) {
+          skippedSamples.push(candidate);
+        }
       }
       continue;
     }
-    matchedCandidateCount += 1;
-    if (decision === "escaped") {
-      escapedDecisionCount += 1;
-      if (escapedSamples.length < 6) {
-        escapedSamples.push(candidate);
+    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;
       }
     }
-    if (decision === "fallback") {
-      fallbackDecisionCount += 1;
-    }
-    if (!transformed.includes(candidate)) {
-      continue;
-    }
-    const pattern = getPattern(candidate);
-    const replacement = getReplacement(candidate, escapeMap);
-    const replaced = transformed.replace(pattern, replacement);
+    const replaced = transformed.replace(candidate, plan.replacement);
     if (replaced !== transformed) {
       transformed = replaced;
       mutated = true;
@@ -1507,18 +1762,20 @@ function replaceHandleValue(path5, options) {
   if (!mutated || typeof node.start !== "number" || typeof node.end !== "number") {
     return void 0;
   }
-  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,
-    options.filename ?? "unknown",
-    escapedSamples.join(",") || "-",
-    skippedSamples.join(",") || "-"
-  );
+  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) {
@@ -1534,6 +1791,14 @@ function replaceHandleValue(path5, options) {
 }
 
 // src/js/sourceAnalysis.ts
+function hasReplacementEntries(replacements) {
+  for (const key in replacements) {
+    if (Object.hasOwn(replacements, key)) {
+      return true;
+    }
+  }
+  return false;
+}
 function createModuleSpecifierReplacementToken(path5, replacement) {
   const node = path5.node;
   if (node.value === replacement) {
@@ -1555,6 +1820,12 @@ function createModuleSpecifierReplacementToken(path5, replacement) {
   };
 }
 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 = (path5) => {
     const replacement = replacements[path5.node.value];
@@ -1593,8 +1864,38 @@ function collectModuleSpecifierReplacementTokens(analysis, replacements) {
 }
 
 // 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 MagicString(rawSource);
+  }
   const replacementTokens = [];
   for (const path5 of targetPaths) {
     if (ignoredPaths.has(path5)) {
@@ -1602,10 +1903,7 @@ function processUpdatedSource(rawSource, options, analysis) {
     }
     const token = replaceHandleValue(
       path5,
-      {
-        ...options,
-        needEscaped: path5.isStringLiteral() ? options.needEscaped ?? true : false
-      }
+      path5.isStringLiteral() ? getNeedEscapedOptions(options, true) : getNeedEscapedOptions(options, false)
     );
     if (token) {
       replacementTokens.push(token);
@@ -1626,6 +1924,8 @@ function processUpdatedSource(rawSource, options, analysis) {
 
 // src/js/evalTransforms.ts
 import { jsStringEscape as jsStringEscape2 } from "@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(path5) {
   if (path5.isCallExpression()) {
     const calleePath = path5.get("callee");
@@ -1664,12 +1964,8 @@ function createEvalReplacementToken(path5, updated) {
     path: path5
   };
 }
-function handleEvalStringLiteral(path5, options, updater, handler) {
-  const { code } = handler(path5.node.value, {
-    ...options,
-    needEscaped: false,
-    generateMap: false
-  });
+function handleEvalStringLiteral(path5, handlerOptions, updater, handler) {
+  const { code } = handler(path5.node.value, handlerOptions);
   if (!code) {
     return;
   }
@@ -1678,11 +1974,8 @@ function handleEvalStringLiteral(path5, options, updater, handler) {
     updater.addToken(token);
   }
 }
-function handleEvalTemplateElement(path5, options, updater, handler) {
-  const { code } = handler(path5.node.value.raw, {
-    ...options,
-    generateMap: false
-  });
+function handleEvalTemplateElement(path5, handlerOptions, updater, handler) {
+  const { code } = handler(path5.node.value.raw, handlerOptions);
   if (!code) {
     return;
   }
@@ -1691,21 +1984,58 @@ function handleEvalTemplateElement(path5, options, updater, handler) {
     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(path5, options, updater, handler) {
+  const stringHandlerOptions = getEvalStringHandlerOptions(options);
+  const templateHandlerOptions = getEvalTemplateHandlerOptions(options);
   const maybeTraverse = path5?.traverse;
   if (typeof maybeTraverse === "function") {
     try {
       return maybeTraverse.call(path5, {
         StringLiteral(innerPath) {
-          handleEvalStringLiteral(innerPath, options, updater, handler);
+          handleEvalStringLiteral(innerPath, stringHandlerOptions, updater, handler);
         },
         TemplateElement(innerPath) {
-          handleEvalTemplateElement(innerPath, options, updater, handler);
+          handleEvalTemplateElement(innerPath, templateHandlerOptions, updater, handler);
         }
       });
     } catch (error) {
       const msg = error?.message ?? "";
-      const scopeError = /pass a scope and parentPath|traversing a Program\/File/i.test(msg);
+      const scopeError = EVAL_SCOPE_ERROR_REGEXP.test(msg);
       if (!scopeError) {
         throw error;
       }
@@ -1715,12 +2045,12 @@ function walkEvalExpression(path5, options, updater, handler) {
   if (Array.isArray(getArgs)) {
     for (const arg of getArgs) {
       if (arg?.isStringLiteral?.()) {
-        handleEvalStringLiteral(arg, options, updater, handler);
+        handleEvalStringLiteral(arg, stringHandlerOptions, updater, handler);
         continue;
       }
       if (arg?.isTemplateLiteral?.()) {
         for (const quasi of arg.get("quasis")) {
-          handleEvalTemplateElement(quasi, options, updater, handler);
+          handleEvalTemplateElement(quasi, templateHandlerOptions, updater, handler);
         }
       }
     }
@@ -1734,14 +2064,14 @@ function walkEvalExpression(path5, options, updater, handler) {
           node: n,
           isStringLiteral: () => true
         };
-        handleEvalStringLiteral(stub, options, updater, handler);
+        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, options, updater, handler);
+          handleEvalTemplateElement(stub, templateHandlerOptions, updater, handler);
         }
       }
     }
@@ -1969,7 +2299,7 @@ var JsModuleGraph = class {
   }
   build() {
     this.collectDependencies();
-    const linked = {};
+    let linked;
     for (const [filename, state] of this.modules) {
       if (filename === this.rootFilename) {
         continue;
@@ -1981,6 +2311,9 @@ var JsModuleGraph = class {
       const ms = processUpdatedSource(state.source, childOptions, state.analysis);
       const code = ms.toString();
       if (code !== state.source) {
+        if (!linked) {
+          linked = {};
+        }
         linked[filename] = { code };
       }
     }
@@ -2104,7 +2437,7 @@ function walkExportDefaultDeclaration(ctx, path5) {
 function walkExportAllDeclaration(ctx, path5) {
   const source = path5.get("source");
   if (source.isStringLiteral()) {
-    ctx.imports.add(
+    ctx.addImportToken(
       {
         declaration: path5,
         source: source.node.value,
@@ -2152,14 +2485,35 @@ function maybeAddImportToken(imports, arg) {
 }
 
 // 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.ignoreCallExpressionIdentifiers = ignoreCallExpressionIdentifiers ?? [];
-    this.callback = callback ?? (() => {
-    });
-    this.imports = /* @__PURE__ */ new Set();
-    this.visited = /* @__PURE__ */ new WeakSet();
-    this.isIgnoredCallIdentifier = createNameMatcher(this.ignoreCallExpressionIdentifiers, { exact: true });
+    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(path5) {
     const init = path5.get("init");
@@ -2206,10 +2560,11 @@ var NodePathWalker = class {
     }
   }
   walkNode(arg) {
-    if (this.visited.has(arg)) {
+    const visited = this.getVisited();
+    if (visited.has(arg)) {
       return;
     }
-    this.visited.add(arg);
+    visited.add(arg);
     if (arg.isIdentifier()) {
       const binding = arg?.scope?.getBinding?.(arg.node.name);
       if (binding) {
@@ -2239,13 +2594,16 @@ var NodePathWalker = class {
       this.walkArrayExpression(arg);
     } else if (arg.isVariableDeclarator()) {
       this.walkVariableDeclarator(arg);
-    } else if (maybeAddImportToken(this.imports, arg)) {
+    } else if (maybeAddImportToken(this.getWritableImports(), arg)) {
     }
   }
   /**
    * Walk the arguments of a desired call expression so their bindings can be analysed.
    */
   walkCallExpression(path5) {
+    if (!this.hasIgnoredCallIdentifiers) {
+      return;
+    }
     const calleePath = path5.get("callee");
     if (calleePath.isIdentifier() && this.isIgnoredCallIdentifier(calleePath.node.name)) {
       for (const arg of path5.get("arguments")) {
@@ -2271,20 +2629,48 @@ var NodePathWalker = class {
 function createTaggedTemplateIgnore({ matcher, names }) {
   const bindingIgnoreCache = /* @__PURE__ */ new Map();
   const taggedTemplateIgnoreCache = /* @__PURE__ */ new WeakMap();
-  const canonicalIgnoreNames = new Set(
-    (names ?? []).filter((item) => typeof item === "string")
-  );
+  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()) {
-      const { name } = propertyPath.node;
-      return canonicalIgnoreNames.has(name) || matcher(name);
+      return matchesIgnoreName(propertyPath.node.name);
     }
     if (propertyPath.isStringLiteral()) {
-      const { value } = propertyPath.node;
-      return canonicalIgnoreNames.has(value) || matcher(value);
+      return matchesIgnoreName(propertyPath.node.value);
     }
     return false;
   };
@@ -2316,9 +2702,9 @@ function createTaggedTemplateIgnore({ matcher, names }) {
     const bindingPath = binding.path;
     if (bindingPath.isImportSpecifier()) {
       const imported = bindingPath.node.imported;
-      if (imported.type === "Identifier" && (canonicalIgnoreNames.has(imported.name) || matcher(imported.name))) {
+      if (imported.type === "Identifier" && matchesIgnoreName(imported.name)) {
         result = true;
-      } else if (imported.type === "StringLiteral" && (canonicalIgnoreNames.has(imported.value) || matcher(imported.value))) {
+      } else if (imported.type === "StringLiteral" && matchesIgnoreName(imported.value)) {
         result = true;
       }
     } else if (bindingPath.isVariableDeclarator()) {
@@ -2359,7 +2745,7 @@ function createTaggedTemplateIgnore({ matcher, names }) {
       }
       if (current.isSequenceExpression()) {
         const expressions = current.get("expressions");
-        const last = expressions[expressions.length - 1];
+        const last = expressions.at(-1);
         if (last) {
           current = last;
           continue;
@@ -2374,23 +2760,23 @@ function createTaggedTemplateIgnore({ matcher, names }) {
     }
     return current;
   };
-  const evaluateTagPath = (tagPath) => {
+  const evaluateTagPath = (tagPath, seen) => {
     if (tagPath.isCallExpression?.() || tagPath.node.type === "CallExpression") {
       const calleePath = tagPath.get("callee");
-      return evaluateTagPath(calleePath);
+      return evaluateTagPath(calleePath, seen);
     }
     if (tagPath.isIdentifier()) {
-      if (matcher(tagPath.node.name)) {
+      if (matchesIgnoreName(tagPath.node.name)) {
         return true;
       }
       const binding = tagPath?.scope?.getBinding?.(tagPath.node.name);
       if (binding) {
-        return resolvesToWeappTwIgnore(binding, /* @__PURE__ */ new Set());
+        return resolvesToWeappTwIgnore(binding, seen);
       }
       return false;
     }
     if (tagPath.isMemberExpression()) {
-      return resolvesMemberExpressionToIgnore(tagPath, /* @__PURE__ */ new Set());
+      return resolvesMemberExpressionToIgnore(tagPath, seen);
     }
     return false;
   };
@@ -2405,7 +2791,8 @@ function createTaggedTemplateIgnore({ matcher, names }) {
       taggedTemplateIgnoreCache.set(tagPath.node, effectiveCached);
       return effectiveCached;
     }
-    const result = evaluateTagPath(effectiveTagPath);
+    seenBindings.clear();
+    const result = evaluateTagPath(effectiveTagPath, seenBindings);
     taggedTemplateIgnoreCache.set(effectiveTagPath.node, result);
     taggedTemplateIgnoreCache.set(tagPath.node, result);
     return result;
@@ -2421,30 +2808,96 @@ function createTaggedTemplateIgnore({ matcher, names }) {
 // src/js/babel.ts
 var EXPRESSION_WRAPPER_PREFIX = "(\n";
 var EXPRESSION_WRAPPER_SUFFIX = "\n)";
-function analyzeSource(ast, options, handler) {
+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();
+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 analyzeSource(ast, options, handler, collectModuleMetadata = true) {
   const jsTokenUpdater = new JsTokenUpdater();
-  const ignoredPaths = /* @__PURE__ */ new WeakSet();
-  const walker = new NodePathWalker(
-    {
-      ignoreCallExpressionIdentifiers: options.ignoreCallExpressionIdentifiers,
-      callback(path5) {
-        if (path5.isStringLiteral() || path5.isTemplateElement()) {
-          ignoredPaths.add(path5);
-        }
-      }
-    }
-  );
-  const isIgnoredTaggedTemplate = createNameMatcher(options.ignoreTaggedTemplateExpressionIdentifiers, { exact: true });
-  const taggedTemplateIgnore = createTaggedTemplateIgnore({
-    matcher: isIgnoredTaggedTemplate,
-    names: options.ignoreTaggedTemplateExpressionIdentifiers
-  });
   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(path5) {
+      ignoredPaths.add(path5);
+    }
+  }) : 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 = /* @__PURE__ */ new Set();
-  const exportDeclarations = /* @__PURE__ */ new Set();
-  const requireCallPaths = [];
+  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 ?? jsHandler;
+  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) {
@@ -2455,54 +2908,23 @@ function analyzeSource(ast, options, handler) {
       }
     },
     TemplateElement: {
-      enter(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 (taggedTemplateIgnore.shouldIgnore(tagPath)) {
-              return;
-            }
-          }
-        }
-        targetPaths.push(p);
-      }
+      enter: templateElementEnter
     },
     CallExpression: {
-      enter(p) {
-        if (isEvalPath(p)) {
-          walkEvalExpression(p, options, jsTokenUpdater, evalHandler);
-          return;
-        }
-        const calleePath = p.get("callee");
-        if (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);
-            }
-          }
+      enter: callExpressionEnter
+    },
+    ...collectModuleMetadata ? {
+      ImportDeclaration: {
+        enter(p) {
+          importDeclarations.add(p);
         }
-        if (needScope) {
-          walker.walkCallExpression(p);
+      },
+      ExportDeclaration: {
+        enter(p) {
+          exportDeclarations.add(p);
         }
       }
-    },
-    ImportDeclaration: {
-      enter(p) {
-        importDeclarations.add(p);
-      }
-    },
-    ExportDeclaration: {
-      enter(p) {
-        exportDeclarations.add(p);
-      }
-    }
+    } : {}
   };
   traverse(ast, { ...traverseOptions, noScope: !needScope });
   return {
@@ -2528,7 +2950,8 @@ function jsHandler(rawSource, options) {
       error
     };
   }
-  const analysis = analyzeSource(ast, options, jsHandler);
+  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;
@@ -2539,11 +2962,17 @@ function jsHandler(rawSource, options) {
     ms.remove(end - suffixLength, end);
   }
   const result = {
-    code: ms.toString(),
-    get map() {
-      return ms.generateMap();
-    }
+    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(
       {
@@ -2555,7 +2984,7 @@ function jsHandler(rawSource, options) {
       options.moduleGraph
     );
     const linked = graph.build();
-    if (Object.keys(linked).length > 0) {
+    if (linked) {
       result.linked = linked;
     }
   }
@@ -2563,51 +2992,142 @@ function jsHandler(rawSource, options) {
 }
 
 // src/js/index.ts
+function hasDefinedOverrides(options) {
+  if (!options) {
+    return false;
+  }
+  for (const key in options) {
+    if (options[key] !== void 0) {
+      return true;
+    }
+  }
+  return false;
+}
+var CACHEABLE_SOURCE_MAX_LENGTH = 512;
+var RESULT_CACHE_LIMIT = 256;
+function shouldCacheJsResult(rawSource, options) {
+  if (rawSource.length === 0 || rawSource.length > CACHEABLE_SOURCE_MAX_LENGTH) {
+    return false;
+  }
+  if (options.moduleGraph || options.filename) {
+    return false;
+  }
+  return true;
+}
 function createJsHandler(options) {
-  const {
-    arbitraryValues,
-    escapeMap,
-    staleClassNameFallback,
-    jsArbitraryValueFallback,
-    tailwindcssMajorVersion,
-    jsPreserveClass,
-    generateMap,
-    needEscaped,
-    alwaysEscape,
-    unescapeUnicode,
-    babelParserOptions,
-    ignoreCallExpressionIdentifiers,
-    ignoreTaggedTemplateExpressionIdentifiers,
-    uniAppX,
-    moduleSpecifierReplacements
-  } = options;
-  function handler(rawSource, classNameSet, options2) {
-    const overrideOptions = options2 ?? {};
-    const resolvedOptions = defuOverrideArray(
+  const defaults = {
+    escapeMap: options.escapeMap,
+    staleClassNameFallback: options.staleClassNameFallback,
+    jsArbitraryValueFallback: options.jsArbitraryValueFallback,
+    tailwindcssMajorVersion: options.tailwindcssMajorVersion,
+    arbitraryValues: options.arbitraryValues,
+    jsPreserveClass: options.jsPreserveClass,
+    generateMap: options.generateMap,
+    needEscaped: options.needEscaped,
+    alwaysEscape: options.alwaysEscape,
+    unescapeUnicode: options.unescapeUnicode,
+    babelParserOptions: options.babelParserOptions,
+    ignoreCallExpressionIdentifiers: options.ignoreCallExpressionIdentifiers,
+    ignoreTaggedTemplateExpressionIdentifiers: options.ignoreTaggedTemplateExpressionIdentifiers,
+    uniAppX: options.uniAppX,
+    moduleSpecifierReplacements: options.moduleSpecifierReplacements
+  };
+  const resolvedOptionsByClassNameSet = /* @__PURE__ */ new WeakMap();
+  let resolvedOptionsWithoutClassNameSet;
+  const resolvedOverrideOptions = /* @__PURE__ */ new WeakMap();
+  const resolvedOverrideOptionsByClassNameSet = /* @__PURE__ */ new WeakMap();
+  const resultCache = /* @__PURE__ */ new WeakMap();
+  function resolveDefaultOptions(classNameSet) {
+    if (!classNameSet) {
+      if (!resolvedOptionsWithoutClassNameSet) {
+        resolvedOptionsWithoutClassNameSet = {
+          ...defaults,
+          classNameSet
+        };
+      }
+      return resolvedOptionsWithoutClassNameSet;
+    }
+    const cached = resolvedOptionsByClassNameSet.get(classNameSet);
+    if (cached) {
+      return cached;
+    }
+    const created = {
+      ...defaults,
+      classNameSet
+    };
+    resolvedOptionsByClassNameSet.set(classNameSet, created);
+    return created;
+  }
+  function getCachedJsResult(rawSource, resolvedOptions) {
+    if (!shouldCacheJsResult(rawSource, resolvedOptions)) {
+      return void 0;
+    }
+    const cache = resultCache.get(resolvedOptions);
+    return cache?.get(rawSource);
+  }
+  function setCachedJsResult(rawSource, resolvedOptions, result) {
+    if (!shouldCacheJsResult(rawSource, resolvedOptions) || result.error || result.linked) {
+      return result;
+    }
+    let cache = resultCache.get(resolvedOptions);
+    if (!cache) {
+      cache = /* @__PURE__ */ new Map();
+      resultCache.set(resolvedOptions, cache);
+    }
+    cache.set(rawSource, result);
+    if (cache.size > RESULT_CACHE_LIMIT) {
+      const firstKey = cache.keys().next().value;
+      if (typeof firstKey === "string") {
+        cache.delete(firstKey);
+      }
+    }
+    return result;
+  }
+  function resolveOptions(classNameSet, overrideOptions) {
+    if (!hasDefinedOverrides(overrideOptions)) {
+      return resolveDefaultOptions(classNameSet);
+    }
+    if (!classNameSet) {
+      const cached2 = resolvedOverrideOptions.get(overrideOptions);
+      if (cached2) {
+        return cached2;
+      }
+      const created2 = defuOverrideArray(
+        {
+          ...overrideOptions,
+          classNameSet
+        },
+        defaults
+      );
+      resolvedOverrideOptions.set(overrideOptions, created2);
+      return created2;
+    }
+    let cache = resolvedOverrideOptionsByClassNameSet.get(overrideOptions);
+    if (!cache) {
+      cache = /* @__PURE__ */ new WeakMap();
+      resolvedOverrideOptionsByClassNameSet.set(overrideOptions, cache);
+    }
+    const cached = cache.get(classNameSet);
+    if (cached) {
+      return cached;
+    }
+    const created = defuOverrideArray(
       {
         ...overrideOptions,
         classNameSet
       },
-      {
-        classNameSet,
-        escapeMap,
-        staleClassNameFallback,
-        jsArbitraryValueFallback,
-        tailwindcssMajorVersion,
-        arbitraryValues,
-        jsPreserveClass,
-        generateMap,
-        needEscaped,
-        alwaysEscape,
-        unescapeUnicode,
-        babelParserOptions,
-        ignoreCallExpressionIdentifiers,
-        ignoreTaggedTemplateExpressionIdentifiers,
-        uniAppX,
-        moduleSpecifierReplacements
-      }
+      defaults
     );
-    return jsHandler(rawSource, resolvedOptions);
+    cache.set(classNameSet, created);
+    return created;
+  }
+  function handler(rawSource, classNameSet, options2) {
+    const resolvedOptions = resolveOptions(classNameSet, options2);
+    const cached = getCachedJsResult(rawSource, resolvedOptions);
+    if (cached) {
+      return cached;
+    }
+    return setCachedJsResult(rawSource, resolvedOptions, jsHandler(rawSource, resolvedOptions));
   }
   return handler;
 }
@@ -2695,6 +3215,12 @@ function shouldSkipLegacyStringLiteral(path5) {
   );
 }
 function createLegacyTraverseOptions(options, jsTokenUpdater) {
+  const legacyReplaceOptions = {
+    escapeMap: options.escapeMap,
+    classNameSet: options.runtimeSet,
+    needEscaped: true,
+    alwaysEscape: true
+  };
   return {
     StringLiteral(path5) {
       if (shouldSkipLegacyStringLiteral(path5)) {
@@ -2703,12 +3229,7 @@ function createLegacyTraverseOptions(options, jsTokenUpdater) {
       jsTokenUpdater.addToken(
         replaceHandleValue(
           path5,
-          {
-            escapeMap: options.escapeMap,
-            classNameSet: options.runtimeSet,
-            needEscaped: true,
-            alwaysEscape: true
-          }
+          legacyReplaceOptions
         )
       );
     },
@@ -2718,25 +3239,34 @@ function createLegacyTraverseOptions(options, jsTokenUpdater) {
 
 // src/wxml/utils/codegen/legacy-rewriter.ts
 function rewriteLegacyExpression(match, options) {
-  const ms = new MagicString2(match);
   const ast = parseExpression(match);
   const jsTokenUpdater = new JsTokenUpdater();
   traverse(ast, createLegacyTraverseOptions(options, jsTokenUpdater));
+  if (jsTokenUpdater.length === 0) {
+    return match;
+  }
+  const ms = new MagicString2(match);
   jsTokenUpdater.updateMagicString(ms);
   return ms.toString();
 }
 
 // src/wxml/utils/codegen.ts
+var WRAP_EXPRESSION_HANDLER_OPTIONS = Object.freeze({
+  wrapExpression: true
+});
 function generateCode(match, options = {}) {
   try {
-    const { jsHandler: jsHandler2, runtimeSet } = options;
+    const { jsHandler: jsHandler2, runtimeSet, wrapExpression } = options;
     if (jsHandler2 && runtimeSet) {
-      const runHandler = (wrap) => jsHandler2(match, runtimeSet, wrap ? { wrapExpression: true } : void 0);
-      const initial = runHandler(options.wrapExpression);
-      if (!initial.error || options.wrapExpression) {
+      const initial = jsHandler2(
+        match,
+        runtimeSet,
+        wrapExpression ? WRAP_EXPRESSION_HANDLER_OPTIONS : void 0
+      );
+      if (!initial.error || wrapExpression) {
         return initial.code;
       }
-      const fallback = runHandler(true);
+      const fallback = jsHandler2(match, runtimeSet, WRAP_EXPRESSION_HANDLER_OPTIONS);
       return fallback.code;
     } else {
       return rewriteLegacyExpression(match, options);
@@ -2952,7 +3482,7 @@ function handleEachClassFragment(ms, tokens, options = {}) {
     previousEnd = token.end;
   }
   if (tokens.length > 0) {
-    const lastToken = tokens[tokens.length - 1];
+    const lastToken = tokens.at(-1);
     if (lastToken.end < ms.original.length) {
       updateWhitespaceGap(ms, lastToken.end, ms.original.length, options);
     }
@@ -2960,16 +3490,17 @@ function handleEachClassFragment(ms, tokens, options = {}) {
 }
 
 // src/wxml/utils/template-fragments.ts
-function templateReplacer(original, options = {}) {
+var sharedTokenizer = new Tokenizer();
+function templateReplacer(original, options = {}, tokenizer) {
   const ms = new MagicString3(original);
-  const tokenizer = new Tokenizer();
-  const tokens = tokenizer.run(ms.original);
+  const tok = tokenizer ?? sharedTokenizer;
+  const tokens = tok.run(ms.original);
   handleEachClassFragment(ms, tokens, options);
   return ms.toString();
 }
 
 // src/wxml/utils/custom-template.ts
-async function customTemplateHandler(rawSource, options) {
+async function customTemplateHandler(rawSource, options, cachedMatcher) {
   const {
     customAttributesEntities = [],
     disabledDefaultTemplateHandler,
@@ -2977,10 +3508,41 @@ async function customTemplateHandler(rawSource, options) {
     runtimeSet,
     jsHandler: jsHandler2
   } = options ?? {};
-  const matchCustomAttribute = createAttributeMatcher(customAttributesEntities);
-  const s = new MagicString4(rawSource);
+  const matchCustomAttribute = cachedMatcher ?? createAttributeMatcher(customAttributesEntities);
+  const defaultTemplateHandlerEnabled = !disabledDefaultTemplateHandler;
+  let replaceOptions;
+  let cachedQuote;
+  let s;
   let tag = "";
-  const wxsArray = [];
+  let wxsArray;
+  function getMagicString() {
+    if (!s) {
+      s = new MagicString4(rawSource);
+    }
+    return s;
+  }
+  function getReplaceOptions(quote) {
+    if (!replaceOptions) {
+      replaceOptions = {
+        ...options,
+        quote
+      };
+      cachedQuote = quote;
+      return replaceOptions;
+    }
+    if (cachedQuote !== quote) {
+      replaceOptions.quote = quote;
+      cachedQuote = quote;
+    }
+    return replaceOptions;
+  }
+  function isDefaultTemplateAttribute(name) {
+    if (name === "class" || name === "hover-class" || name === "virtualhostclass") {
+      return true;
+    }
+    const lowerName = name.toLowerCase();
+    return lowerName === "class" || lowerName === "hover-class" || lowerName === "virtualhostclass";
+  }
   const parser = new Parser(
     {
       onopentagname(name) {
@@ -2990,28 +3552,25 @@ async function customTemplateHandler(rawSource, options) {
         if (!value) {
           return;
         }
-        const lowerName = name.toLowerCase();
-        const shouldHandleDefault = !disabledDefaultTemplateHandler && (lowerName === "class" || lowerName === "hover-class" || lowerName === "virtualhostclass");
+        const shouldHandleDefault = defaultTemplateHandlerEnabled && isDefaultTemplateAttribute(name);
         const shouldHandleCustom = matchCustomAttribute?.(tag, name) ?? false;
         if (!shouldHandleDefault && !shouldHandleCustom) {
           return;
         }
-        s.update(
+        getMagicString().update(
           parser.startIndex + name.length + 2,
           // !important
           // htmlparser2 9.0.0: parser.endIndex
           // htmlparser2 9.1.0: parser.endIndex - 1
           // https://github.com/sonofmagic/weapp-tailwindcss/issues/269
           parser.endIndex - 1,
-          templateReplacer(value, {
-            ...options,
-            quote
-          })
+          templateReplacer(value, getReplaceOptions(quote))
         );
       },
       ontext(data) {
         if (inlineWxs && tag === "wxs") {
-          wxsArray.push({
+          ;
+          (wxsArray ?? (wxsArray = [])).push({
             data,
             endIndex: parser.endIndex + 1,
             startIndex: parser.startIndex
@@ -3026,19 +3585,38 @@ async function customTemplateHandler(rawSource, options) {
       xmlMode: true
     }
   );
-  parser.write(s.original);
+  parser.write(rawSource);
   parser.end();
-  for (const { data, endIndex, startIndex } of wxsArray) {
+  for (const { data, endIndex, startIndex } of wxsArray ?? []) {
     const { code } = await jsHandler2(data, runtimeSet);
-    s.update(startIndex, endIndex, code);
+    if (code !== data) {
+      getMagicString().update(startIndex, endIndex, code);
+    }
   }
-  return s.toString();
+  return s?.toString() ?? rawSource;
 }
 
 // src/wxml/utils.ts
 function createTemplateHandler(options = {}) {
-  return (rawSource, opt = {}) => {
-    return customTemplateHandler(rawSource, defuOverrideArray(opt, options));
+  const cachedMatcher = createAttributeMatcher(
+    options.customAttributesEntities
+  );
+  const defaultOptions = options;
+  let cachedRuntimeSet;
+  let cachedOptionsWithRuntimeSet;
+  return (rawSource, opt) => {
+    const runtimeSet = opt?.runtimeSet;
+    if (runtimeSet === void 0) {
+      return customTemplateHandler(rawSource, defaultOptions, cachedMatcher);
+    }
+    if (cachedRuntimeSet !== runtimeSet || !cachedOptionsWithRuntimeSet) {
+      cachedRuntimeSet = runtimeSet;
+      cachedOptionsWithRuntimeSet = {
+        ...defaultOptions,
+        runtimeSet
+      };
+    }
+    return customTemplateHandler(rawSource, cachedOptionsWithRuntimeSet, cachedMatcher);
   };
 }
 
@@ -3253,6 +3831,8 @@ export {
   createPatchTargetRecorder,
   logTailwindcssTarget,
   toCustomAttributesEntities,
+  traverse,
+  babelParse,
   replaceWxml,
   createAttributeMatcher,
   generateCode,