weapp-tailwindcss 4.10.3 → 4.11.0-alpha.1

package/dist/{chunk-DEIJXHGJ.js → chunk-G5NLM3AL.js}

@@ -3,10 +3,10 @@
 
 
 
-var _chunkRYC23C3Kjs = require('./chunk-RYC23C3K.js');
+var _chunk4LPOQMFSjs = require('./chunk-4LPOQMFS.js');
 
 
-var _chunk5U24PLVVjs = require('./chunk-5U24PLVV.js');
+var _chunkACTJYB33js = require('./chunk-ACTJYB33.js');
 
 
 
@@ -16,15 +16,24 @@ var _chunkDYLQ6UOIjs = require('./chunk-DYLQ6UOI.js');
 var _debug2 = require('debug'); var _debug3 = _interopRequireDefault(_debug2);
 var _debug = _debug3.default.call(void 0, "weapp-tw");
 function createDebug(prefix) {
-  function debug3(formatter, ...args) {
+  const debug3 = ((formatter, ...args) => {
     return _debug((_nullishCoalesce(prefix, () => ( ""))) + formatter, ...args);
-  }
+  });
+  Object.defineProperty(debug3, "enabled", {
+    enumerable: false,
+    configurable: false,
+    get() {
+      return _debug.enabled;
+    }
+  });
   return debug3;
 }
 
 // src/tailwindcss/runtime/cache.ts
 var _fs = require('fs');
 var runtimeClassSetCache = /* @__PURE__ */ new WeakMap();
+var runtimeConfigSignatureCache = /* @__PURE__ */ new Map();
+var runtimeConfigSignatureCacheClearTimer;
 function getCacheEntry(twPatcher) {
   let entry = runtimeClassSetCache.get(twPatcher);
   if (!entry) {
@@ -33,26 +42,48 @@ function getCacheEntry(twPatcher) {
   }
   return entry;
 }
+function scheduleRuntimeConfigSignatureCacheClear() {
+  if (runtimeConfigSignatureCacheClearTimer) {
+    return;
+  }
+  runtimeConfigSignatureCacheClearTimer = setTimeout(() => {
+    runtimeConfigSignatureCache.clear();
+    runtimeConfigSignatureCacheClearTimer = void 0;
+  }, 0);
+  _optionalChain([runtimeConfigSignatureCacheClearTimer, 'access', _2 => _2.unref, 'optionalCall', _3 => _3()]);
+}
 function getTailwindConfigSignature(twPatcher) {
-  const configPath = _optionalChain([twPatcher, 'access', _2 => _2.options, 'optionalAccess', _3 => _3.tailwind, 'optionalAccess', _4 => _4.config]);
+  const configPath = _optionalChain([twPatcher, 'access', _4 => _4.options, 'optionalAccess', _5 => _5.tailwind, 'optionalAccess', _6 => _6.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 = _fs.statSync.call(void 0, configPath);
-    return `${configPath}:${stats.size}:${stats.mtimeMs}`;
+    signature = `${configPath}:${stats.size}:${stats.mtimeMs}`;
   } catch (e2) {
-    return `${configPath}:missing`;
+    signature = `${configPath}:missing`;
   }
+  runtimeConfigSignatureCache.set(configPath, signature);
+  scheduleRuntimeConfigSignatureCacheClear();
+  return signature;
 }
 function getPatchTargetSignature(twPatcher) {
   const packageInfo = twPatcher.packageInfo;
-  return `${_nullishCoalesce(_optionalChain([packageInfo, 'optionalAccess', _5 => _5.rootPath]), () => ( "missing"))}:${_nullishCoalesce(_optionalChain([packageInfo, 'optionalAccess', _6 => _6.version]), () => ( "unknown"))}:${_nullishCoalesce(twPatcher.majorVersion, () => ( "unknown"))}`;
+  return `${_nullishCoalesce(_optionalChain([packageInfo, 'optionalAccess', _7 => _7.rootPath]), () => ( "missing"))}:${_nullishCoalesce(_optionalChain([packageInfo, 'optionalAccess', _8 => _8.version]), () => ( "unknown"))}:${_nullishCoalesce(twPatcher.majorVersion, () => ( "unknown"))}`;
 }
 function invalidateRuntimeClassSet(twPatcher) {
   if (!twPatcher) {
     return;
   }
+  const configPath = _optionalChain([twPatcher, 'access', _9 => _9.options, 'optionalAccess', _10 => _10.tailwind, 'optionalAccess', _11 => _11.config]);
+  if (typeof configPath === "string" && configPath.length > 0) {
+    runtimeConfigSignatureCache.delete(configPath);
+  }
   runtimeClassSetCache.delete(twPatcher);
 }
 function getRuntimeClassSetCacheEntry(twPatcher) {
@@ -234,7 +265,7 @@ async function collectRuntimeClassSet(twPatcher, options = {}) {
     const preferExtract = options.force === true;
     try {
       const result = await activePatcher.extract({ write: false });
-      if (_optionalChain([result, 'optionalAccess', _7 => _7.classSet])) {
+      if (_optionalChain([result, 'optionalAccess', _12 => _12.classSet])) {
         if (result.classSet.size > 0) {
           debug("runtime class set resolved via extract(), size=%d", result.classSet.size);
           return result.classSet;
@@ -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",
@@ -595,13 +626,13 @@ function createCache(options) {
         const nextHash = _nullishCoalesce(hash, () => ( cache.computeHash(rawSource)));
         cache.calcHashValueChanged(cacheHashKey, nextHash);
         const entry = cache.getHashValue(cacheHashKey);
-        hasChanged = _nullishCoalesce(_optionalChain([entry, 'optionalAccess', _8 => _8.changed]), () => ( true));
+        hasChanged = _nullishCoalesce(_optionalChain([entry, 'optionalAccess', _13 => _13.changed]), () => ( true));
       }
       const readCache = _nullishCoalesce(resolveCache, () => ( (() => cache.get(key))));
       if (!hasChanged) {
         const cached = readCache();
         if (cached !== void 0) {
-          await _optionalChain([onCacheHit, 'optionalCall', _9 => _9(cached)]);
+          await _optionalChain([onCacheHit, 'optionalCall', _14 => _14(cached)]);
           return cached;
         }
       }
@@ -646,7 +677,7 @@ function formatRelativeToBase(targetPath, baseDir) {
 }
 function resolveRecordLocation(baseDir) {
   const normalizedBase = _path2.default.normalize(baseDir);
-  const packageRoot = _nullishCoalesce(_chunkRYC23C3Kjs.findNearestPackageRoot.call(void 0, normalizedBase), () => ( normalizedBase));
+  const packageRoot = _nullishCoalesce(_chunk4LPOQMFSjs.findNearestPackageRoot.call(void 0, normalizedBase), () => ( normalizedBase));
   const packageJsonPath = _path2.default.join(packageRoot, "package.json");
   const hasPackageJson = _fs.existsSync.call(void 0, packageJsonPath);
   const recordKeySource = hasPackageJson ? packageJsonPath : normalizedBase;
@@ -723,22 +754,22 @@ function readPatchTargetRecord(baseDir) {
   return void 0;
 }
 async function saveCliPatchTargetRecord(baseDir, patcher, options) {
-  if (!baseDir || !_optionalChain([patcher, 'optionalAccess', _10 => _10.packageInfo, 'optionalAccess', _11 => _11.rootPath])) {
+  if (!baseDir || !_optionalChain([patcher, 'optionalAccess', _15 => _15.packageInfo, 'optionalAccess', _16 => _16.rootPath])) {
     return void 0;
   }
   const normalizedBase = _path2.default.normalize(baseDir);
   const location = resolveRecordLocation(normalizedBase);
-  const recordPath = _optionalChain([options, 'optionalAccess', _12 => _12.recordPath]) ? _path2.default.normalize(options.recordPath) : location.recordPath;
+  const recordPath = _optionalChain([options, 'optionalAccess', _17 => _17.recordPath]) ? _path2.default.normalize(options.recordPath) : location.recordPath;
   const record = {
     tailwindPackagePath: _path2.default.normalize(patcher.packageInfo.rootPath),
     packageVersion: patcher.packageInfo.version,
     recordedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    source: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _13 => _13.source]), () => ( "cli")),
+    source: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _18 => _18.source]), () => ( "cli")),
     tailwindcssBasedir: normalizedBase,
-    cwd: _optionalChain([options, 'optionalAccess', _14 => _14.cwd]) ? _path2.default.normalize(options.cwd) : normalizedBase,
+    cwd: _optionalChain([options, 'optionalAccess', _19 => _19.cwd]) ? _path2.default.normalize(options.cwd) : normalizedBase,
     patchVersion: WEAPP_TW_VERSION,
-    packageJsonPath: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _15 => _15.packageJsonPath]), () => ( location.packageJsonPath)),
-    recordKey: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _16 => _16.recordKey]), () => ( location.recordKey))
+    packageJsonPath: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _20 => _20.packageJsonPath]), () => ( location.packageJsonPath)),
+    recordKey: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _21 => _21.recordKey]), () => ( location.recordKey))
   };
   try {
     await _promises.mkdir.call(void 0, _path2.default.dirname(recordPath), { recursive: true });
@@ -779,7 +810,7 @@ function findPatchTargetRecord(baseDir) {
   return void 0;
 }
 function createPatchTargetRecorder(baseDir, patcher, options) {
-  if (!baseDir || !_optionalChain([patcher, 'optionalAccess', _17 => _17.packageInfo, 'optionalAccess', _18 => _18.rootPath]) || _optionalChain([options, 'optionalAccess', _19 => _19.recordTarget]) === false) {
+  if (!baseDir || !_optionalChain([patcher, 'optionalAccess', _22 => _22.packageInfo, 'optionalAccess', _23 => _23.rootPath]) || _optionalChain([options, 'optionalAccess', _24 => _24.recordTarget]) === false) {
     return void 0;
   }
   const normalizedBase = _path2.default.normalize(baseDir);
@@ -797,13 +828,13 @@ function createPatchTargetRecorder(baseDir, patcher, options) {
       reason = "migrate";
     } else if (!recorded.record.patchVersion || recorded.record.patchVersion !== WEAPP_TW_VERSION) {
       reason = "stale";
-    } else if (_optionalChain([options, 'optionalAccess', _20 => _20.cwd]) && recorded.record.cwd && _path2.default.normalize(recorded.record.cwd) !== _path2.default.normalize(options.cwd)) {
+    } else if (_optionalChain([options, 'optionalAccess', _25 => _25.cwd]) && recorded.record.cwd && _path2.default.normalize(recorded.record.cwd) !== _path2.default.normalize(options.cwd)) {
       reason = "metadata";
-    } else if (!recorded.record.cwd && _optionalChain([options, 'optionalAccess', _21 => _21.cwd])) {
+    } else if (!recorded.record.cwd && _optionalChain([options, 'optionalAccess', _26 => _26.cwd])) {
       reason = "metadata";
     }
   }
-  const shouldPersist = _optionalChain([options, 'optionalAccess', _22 => _22.alwaysRecord]) || !recorded || Boolean(reason);
+  const shouldPersist = _optionalChain([options, 'optionalAccess', _27 => _27.alwaysRecord]) || !recorded || Boolean(reason);
   if (!shouldPersist) {
     return void 0;
   }
@@ -823,8 +854,8 @@ function createPatchTargetRecorder(baseDir, patcher, options) {
       break;
   }
   const onPatched = async () => saveCliPatchTargetRecord(normalizedBase, patcher, {
-    cwd: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _23 => _23.cwd]), () => ( normalizedBase)),
-    source: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _24 => _24.source]), () => ( "cli")),
+    cwd: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _28 => _28.cwd]), () => ( normalizedBase)),
+    source: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _29 => _29.source]), () => ( "cli")),
     recordPath: location.recordPath,
     recordKey: location.recordKey,
     packageJsonPath: location.packageJsonPath
@@ -839,9 +870,9 @@ function createPatchTargetRecorder(baseDir, patcher, options) {
 
 // src/tailwindcss/targets.ts
 function logTailwindcssTarget(kind, patcher, baseDir) {
-  const packageInfo = _optionalChain([patcher, 'optionalAccess', _25 => _25.packageInfo]);
+  const packageInfo = _optionalChain([patcher, 'optionalAccess', _30 => _30.packageInfo]);
   const label = kind === "cli" ? "weapp-tw patch" : "tailwindcss-patcher";
-  if (!_optionalChain([packageInfo, 'optionalAccess', _26 => _26.rootPath])) {
+  if (!_optionalChain([packageInfo, 'optionalAccess', _31 => _31.rootPath])) {
     _logger.logger.warn(
       "%s \u672A\u627E\u5230 Tailwind CSS \u4F9D\u8D56\uFF0C\u8BF7\u68C0\u67E5\u5728 %s \u662F\u5426\u5DF2\u5B89\u88C5 tailwindcss",
       label,
@@ -859,13 +890,13 @@ var _buffer = require('buffer');
 
 
 
+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 = _nullishCoalesce(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 _optionalChain([opts, 'optionalAccess', _32 => _32.tailwindcssBasedir]) === "string" && opts.tailwindcssBasedir.length > 0;
+}
+function shouldProbeCallerLocation(opts) {
+  if (hasExplicitOptionBasedir(opts)) {
+    return false;
+  }
+  return !(_process2.default.env.WEAPP_TAILWINDCSS_BASEDIR || _process2.default.env.WEAPP_TAILWINDCSS_BASE_DIR || _process2.default.env.TAILWINDCSS_BASEDIR || _process2.default.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 = _nullishCoalesce(line.match(/\(([^)]+)\)/u), () => ( line.match(/at\s+(\S.*)$/u)));
-    const location = _optionalChain([match, 'optionalAccess', _27 => _27[1]]);
+    const match = _nullishCoalesce(line.match(PAREN_CONTENT_RE), () => ( line.match(AT_LOCATION_RE)));
+    const location = _optionalChain([match, 'optionalAccess', _33 => _33[1]]);
     if (!location) {
       continue;
     }
-    const candidatePath = location.replace(/:\d+(?::\d+)?$/u, "");
+    const candidatePath = location.replace(TRAILING_LINE_COL_RE, "");
     if (!candidatePath || !_path2.default.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: _process2.default.cwd(),
-    npm_package_json: _process2.default.env.npm_package_json,
+    init_cwd: _process2.default.env.INIT_CWD,
     npm_config_local_prefix: _process2.default.env.npm_config_local_prefix,
+    npm_package_json: _process2.default.env.npm_package_json,
     pnpm_package_name: _process2.default.env.PNPM_PACKAGE_NAME,
-    init_cwd: _process2.default.env.INIT_CWD,
     pwd: _process2.default.env.PWD,
-    weapp_tailwindcss_basedir: _process2.default.env.WEAPP_TAILWINDCSS_BASEDIR,
-    weapp_tailwindcss_base_dir: _process2.default.env.WEAPP_TAILWINDCSS_BASE_DIR,
-    tailwindcss_basedir: _process2.default.env.TAILWINDCSS_BASEDIR,
     tailwindcss_base_dir: _process2.default.env.TAILWINDCSS_BASE_DIR,
+    tailwindcss_basedir: _process2.default.env.TAILWINDCSS_BASEDIR,
+    uni_app_input_dir: _process2.default.env.UNI_APP_INPUT_DIR,
+    uni_cli_root: _process2.default.env.UNI_CLI_ROOT,
     uni_input_dir: _process2.default.env.UNI_INPUT_DIR,
     uni_input_root: _process2.default.env.UNI_INPUT_ROOT,
-    uni_cli_root: _process2.default.env.UNI_CLI_ROOT,
-    uni_app_input_dir: _process2.default.env.UNI_APP_INPUT_DIR,
-    caller: detectCallerLocation()
+    weapp_tailwindcss_base_dir: _process2.default.env.WEAPP_TAILWINDCSS_BASE_DIR,
+    weapp_tailwindcss_basedir: _process2.default.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: _nullishCoalesce(opts, () => ( {})),
+    runtime: getRuntimeCacheScope(opts)
   };
 }
 function normalizeOptionsValue(rawValue, stack = /* @__PURE__ */ new WeakSet()) {
@@ -982,28 +1061,32 @@ function normalizeOptionsValue(rawValue, stack = /* @__PURE__ */ new WeakSet())
   if (ArrayBuffer.isView(rawValue)) {
     const view = rawValue;
     const buffer = _buffer.Buffer.from(view.buffer, view.byteOffset, view.byteLength);
-    return encodeTaggedValue(_nullishCoalesce(_optionalChain([view, 'access', _28 => _28.constructor, 'optionalAccess', _29 => _29.name]), () => ( "ArrayBufferView")), buffer.toString("base64"));
+    return encodeTaggedValue(_nullishCoalesce(_optionalChain([view, 'access', _34 => _34.constructor, 'optionalAccess', _35 => _35.name]), () => ( "ArrayBufferView")), buffer.toString("base64"));
   }
   if (rawValue instanceof ArrayBuffer) {
     return encodeTaggedValue("ArrayBuffer", _buffer.Buffer.from(rawValue).toString("base64"));
   }
   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: _nullishCoalesce(opts, () => ( {})),
-      runtime: getRuntimeCacheScope()
-    });
-    const serialized = JSON.stringify(normalized);
-    return _node.md5.call(void 0, 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 = _node.md5.call(void 0, serializeNormalizedValue(normalized));
+    keyStore.set(runtimeCacheScopeKey, cacheKey);
+    return cacheKey;
   } catch (error) {
     _logger.logger.debug("skip compiler context cache: %O", error);
     return void 0;
@@ -1098,6 +1185,8 @@ var traverse = _interopDefaultCompat(_traverse2.default);
 
 // src/utils/nameMatcher.ts
 var _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;
@@ -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,13 +1224,37 @@ function createNameMatcher(list, { exact = false } = {}) {
       regexList.push(normaliseRegex(item));
     }
   }
+  if (exact) {
+    const exactStringCount = _nullishCoalesce(_optionalChain([exactStrings, 'optionalAccess', _36 => _36.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 (_optionalChain([exactStrings, 'optionalAccess', _37 => _37.has, 'call', _38 => _38(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 && _optionalChain([exactStrings, 'optionalAccess', _30 => _30.has, 'call', _31 => _31(value)])) {
-      return true;
-    }
-    if (_optionalChain([fuzzyMatcher, 'optionalCall', _32 => _32(value)])) {
+    if (_optionalChain([fuzzyMatcher, 'optionalCall', _39 => _39(value)])) {
       return true;
     }
     if (!hasRegex) {
@@ -1186,11 +1299,11 @@ var _magicstring = require('magic-string'); var _magicstring2 = _interopRequireD
 
 // src/js/handlers.ts
 var _escape = require('@ast-core/escape');
-
 var _extractors = require('@weapp-tailwindcss/shared/extractors');
 
 // src/wxml/shared.ts
 var _escape3 = require('@weapp-core/escape');
+var NEWLINE_RE = /[\n\r]+/g;
 function replaceWxml(original, options = {
   keepEOL: false,
   escapeMap: _escape3.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 = _escape3.escape.call(void 0, 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 (_optionalChain([jsPreserveClass, 'optionalCall', _33 => _33(candidate)])) {
-    return "skip";
+  if (_optionalChain([jsPreserveClass, 'optionalCall', _40 => _40(candidate)])) {
+    return SKIP_RESULT;
   }
-  if (_optionalChain([classNameSet, 'optionalAccess', _34 => _34.has, 'call', _35 => _35(candidate)])) {
-    return "direct";
+  if (_optionalChain([classNameSet, 'optionalAccess', _41 => _41.has, 'call', _42 => _42(candidate)])) {
+    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()) {
@@ -1317,7 +1517,7 @@ function readObjectKeyName(path5) {
     return path5.node.value;
   }
   if (path5.isTemplateLiteral() && path5.node.expressions.length === 0) {
-    return _nullishCoalesce(_optionalChain([path5, 'access', _36 => _36.node, 'access', _37 => _37.quasis, 'access', _38 => _38[0], 'optionalAccess', _39 => _39.value, 'access', _40 => _40.cooked]), () => ( _optionalChain([path5, 'access', _41 => _41.node, 'access', _42 => _42.quasis, 'access', _43 => _43[0], 'optionalAccess', _44 => _44.value, 'access', _45 => _45.raw])));
+    return _nullishCoalesce(_optionalChain([path5, 'access', _43 => _43.node, 'access', _44 => _44.quasis, 'access', _45 => _45[0], 'optionalAccess', _46 => _46.value, 'access', _47 => _47.cooked]), () => ( _optionalChain([path5, 'access', _48 => _48.node, 'access', _49 => _49.quasis, 'access', _50 => _50[0], 'optionalAccess', _51 => _51.value, 'access', _52 => _52.raw])));
   }
   return void 0;
 }
@@ -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(_regex.escapeStringRegexp.call(void 0, 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 = _optionalChain([arbitraryValues, 'optionalAccess', _46 => _46.allowDoubleQuotes]);
+  const allowDoubleQuotes = _optionalChain([arbitraryValues, 'optionalAccess', _53 => _53.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 = _extractors.splitCode.call(void 0, 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",
-    _nullishCoalesce(_optionalChain([classNameSet, 'optionalAccess', _47 => _47.size]), () => ( 0)),
-    fallbackDecisionCount > 0,
-    candidates.length,
-    matchedCandidateCount,
-    escapedDecisionCount,
-    skippedSamples.length,
-    _nullishCoalesce(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",
+      _nullishCoalesce(_optionalChain([classNameSet, 'optionalAccess', _54 => _54.size]), () => ( 0)),
+      fallbackDecisionCount > 0,
+      candidates.length,
+      matchedCandidateCount,
+      escapedDecisionCount,
+      _nullishCoalesce(_optionalChain([skippedSamples, 'optionalAccess', _55 => _55.length]), () => ( 0)),
+      _nullishCoalesce(options.filename, () => ( "unknown")),
+      _optionalChain([escapedSamples, 'optionalAccess', _56 => _56.join, 'call', _57 => _57(",")]) || "-",
+      _optionalChain([skippedSamples, 'optionalAccess', _58 => _58.join, 'call', _59 => _59(",")]) || "-"
+    );
+  }
   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 (0, _magicstring2.default)(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() ? _nullishCoalesce(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
 
+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,57 +1984,94 @@ 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 maybeTraverse = _optionalChain([path5, 'optionalAccess', _48 => _48.traverse]);
+  const stringHandlerOptions = getEvalStringHandlerOptions(options);
+  const templateHandlerOptions = getEvalTemplateHandlerOptions(options);
+  const maybeTraverse = _optionalChain([path5, 'optionalAccess', _60 => _60.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 = _nullishCoalesce(_optionalChain([error, 'optionalAccess', _49 => _49.message]), () => ( ""));
-      const scopeError = /pass a scope and parentPath|traversing a Program\/File/i.test(msg);
+      const msg = _nullishCoalesce(_optionalChain([error, 'optionalAccess', _61 => _61.message]), () => ( ""));
+      const scopeError = EVAL_SCOPE_ERROR_REGEXP.test(msg);
       if (!scopeError) {
         throw error;
       }
     }
   }
-  const getArgs = _optionalChain([path5, 'optionalAccess', _50 => _50.get, 'optionalCall', _51 => _51("arguments")]);
+  const getArgs = _optionalChain([path5, 'optionalAccess', _62 => _62.get, 'optionalCall', _63 => _63("arguments")]);
   if (Array.isArray(getArgs)) {
     for (const arg of getArgs) {
-      if (_optionalChain([arg, 'optionalAccess', _52 => _52.isStringLiteral, 'optionalCall', _53 => _53()])) {
-        handleEvalStringLiteral(arg, options, updater, handler);
+      if (_optionalChain([arg, 'optionalAccess', _64 => _64.isStringLiteral, 'optionalCall', _65 => _65()])) {
+        handleEvalStringLiteral(arg, stringHandlerOptions, updater, handler);
         continue;
       }
-      if (_optionalChain([arg, 'optionalAccess', _54 => _54.isTemplateLiteral, 'optionalCall', _55 => _55()])) {
+      if (_optionalChain([arg, 'optionalAccess', _66 => _66.isTemplateLiteral, 'optionalCall', _67 => _67()])) {
         for (const quasi of arg.get("quasis")) {
-          handleEvalTemplateElement(quasi, options, updater, handler);
+          handleEvalTemplateElement(quasi, templateHandlerOptions, updater, handler);
         }
       }
     }
     return;
   }
-  const nodeArgs = _optionalChain([path5, 'optionalAccess', _56 => _56.node, 'optionalAccess', _57 => _57.arguments]);
+  const nodeArgs = _optionalChain([path5, 'optionalAccess', _68 => _68.node, 'optionalAccess', _69 => _69.arguments]);
   if (Array.isArray(nodeArgs)) {
     for (const n of nodeArgs) {
-      if (_optionalChain([n, 'optionalAccess', _58 => _58.type]) === "StringLiteral") {
+      if (_optionalChain([n, 'optionalAccess', _70 => _70.type]) === "StringLiteral") {
         const stub = {
           node: n,
           isStringLiteral: () => true
         };
-        handleEvalStringLiteral(stub, options, updater, handler);
-      } else if (_optionalChain([n, 'optionalAccess', _59 => _59.type]) === "TemplateLiteral" && Array.isArray(n.quasis)) {
+        handleEvalStringLiteral(stub, stringHandlerOptions, updater, handler);
+      } else if (_optionalChain([n, 'optionalAccess', _71 => _71.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);
         }
       }
     }
@@ -1837,7 +2167,7 @@ var IgnoredExportsTracker = class {
         continue;
       }
       if (exportPath.isExportNamedDeclaration()) {
-        const source = _optionalChain([exportPath, 'access', _60 => _60.node, 'access', _61 => _61.source, 'optionalAccess', _62 => _62.value]);
+        const source = _optionalChain([exportPath, 'access', _72 => _72.node, 'access', _73 => _73.source, 'optionalAccess', _74 => _74.value]);
         if (typeof source === "string") {
           for (const spec of exportPath.get("specifiers")) {
             if (!spec.isExportSpecifier()) {
@@ -1904,7 +2234,7 @@ var IgnoredExportsTracker = class {
         continue;
       }
       if (exportPath.isExportAllDeclaration()) {
-        const source = _optionalChain([exportPath, 'access', _63 => _63.node, 'access', _64 => _64.source, 'optionalAccess', _65 => _65.value]);
+        const source = _optionalChain([exportPath, 'access', _75 => _75.node, 'access', _76 => _76.source, 'optionalAccess', _77 => _77.value]);
         if (typeof source === "string") {
           for (const exportName of names) {
             propagate.push({
@@ -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 };
       }
     }
@@ -2005,7 +2338,7 @@ var JsModuleGraph = class {
       }
       for (const exportPath of state.analysis.exportDeclarations) {
         if (exportPath.isExportAllDeclaration() || exportPath.isExportNamedDeclaration()) {
-          const source = _optionalChain([exportPath, 'access', _66 => _66.node, 'access', _67 => _67.source, 'optionalAccess', _68 => _68.value]);
+          const source = _optionalChain([exportPath, 'access', _78 => _78.node, 'access', _79 => _79.source, 'optionalAccess', _80 => _80.value]);
           if (typeof source === "string" && !dependencySpecifiers.has(source)) {
             dependencySpecifiers.set(source, []);
           }
@@ -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 = _nullishCoalesce(ignoreCallExpressionIdentifiers, () => ( []));
-    this.callback = _nullishCoalesce(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 = _nullishCoalesce(ignoreCallExpressionIdentifiers, () => ( EMPTY_IGNORE_CALL_EXPRESSION_IDENTIFIERS));
+    this.callback = _nullishCoalesce(callback, () => ( NOOP_STRING_PATH_CALLBACK));
+    this.isIgnoredCallIdentifier = this.hasIgnoredCallIdentifiers ? createNameMatcher(this.ignoreCallExpressionIdentifiers, { exact: true }) : NEVER_MATCH_NAME2;
+  }
+  get imports() {
+    return _nullishCoalesce(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,19 +2560,20 @@ 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 = _optionalChain([arg, 'optionalAccess', _69 => _69.scope, 'optionalAccess', _70 => _70.getBinding, 'optionalCall', _71 => _71(arg.node.name)]);
+      const binding = _optionalChain([arg, 'optionalAccess', _81 => _81.scope, 'optionalAccess', _82 => _82.getBinding, 'optionalCall', _83 => _83(arg.node.name)]);
       if (binding) {
         this.walkNode(binding.path);
       }
     } else if (arg.isMemberExpression()) {
       const objectPath = arg.get("object");
       if (objectPath.isIdentifier()) {
-        const binding = _optionalChain([arg, 'optionalAccess', _72 => _72.scope, 'optionalAccess', _73 => _73.getBinding, 'optionalCall', _74 => _74(objectPath.node.name)]);
+        const binding = _optionalChain([arg, 'optionalAccess', _84 => _84.scope, 'optionalAccess', _85 => _85.getBinding, 'optionalCall', _86 => _86(objectPath.node.name)]);
         if (binding) {
           if (binding.path.isVariableDeclarator()) {
             this.walkVariableDeclarator(binding.path);
@@ -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(
-    (_nullishCoalesce(names, () => ( []))).filter((item) => typeof item === "string")
-  );
+  const seenBindings = /* @__PURE__ */ new Set();
+  let singleCanonicalIgnoreName;
+  let canonicalIgnoreNames;
+  for (const item of _nullishCoalesce(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;
   };
@@ -2295,8 +2681,8 @@ function createTaggedTemplateIgnore({ matcher, names }) {
     }
     const objectPath = path5.get("object");
     if (objectPath.isIdentifier()) {
-      const scope = _optionalChain([objectPath, 'optionalAccess', _75 => _75.scope]);
-      const binding = _optionalChain([scope, 'optionalAccess', _76 => _76.getBinding, 'optionalCall', _77 => _77(objectPath.node.name)]);
+      const scope = _optionalChain([objectPath, 'optionalAccess', _87 => _87.scope]);
+      const binding = _optionalChain([scope, 'optionalAccess', _88 => _88.getBinding, 'optionalCall', _89 => _89(objectPath.node.name)]);
       if (binding) {
         return resolvesToWeappTwIgnore(binding, seen);
       }
@@ -2316,16 +2702,16 @@ 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()) {
       const init = bindingPath.get("init");
       if (init && init.node) {
         if (init.isIdentifier()) {
-          const target = _optionalChain([binding, 'optionalAccess', _78 => _78.scope, 'optionalAccess', _79 => _79.getBinding, 'optionalCall', _80 => _80(init.node.name)]);
+          const target = _optionalChain([binding, 'optionalAccess', _90 => _90.scope, 'optionalAccess', _91 => _91.getBinding, 'optionalCall', _92 => _92(init.node.name)]);
           if (target) {
             result = resolvesToWeappTwIgnore(target, seen);
           }
@@ -2341,7 +2727,7 @@ function createTaggedTemplateIgnore({ matcher, names }) {
   const getEffectiveTagPath = (tagPath) => {
     let current = tagPath;
     while (true) {
-      if (_optionalChain([current, 'access', _81 => _81.isParenthesizedExpression, 'optionalCall', _82 => _82()]) || current.node.type === "ParenthesizedExpression") {
+      if (_optionalChain([current, 'access', _93 => _93.isParenthesizedExpression, 'optionalCall', _94 => _94()]) || current.node.type === "ParenthesizedExpression") {
         current = current.get("expression");
         continue;
       }
@@ -2353,19 +2739,19 @@ function createTaggedTemplateIgnore({ matcher, names }) {
         current = current.get("expression");
         continue;
       }
-      if (_optionalChain([current, 'access', _83 => _83.isTypeCastExpression, 'optionalCall', _84 => _84()])) {
+      if (_optionalChain([current, 'access', _95 => _95.isTypeCastExpression, 'optionalCall', _96 => _96()])) {
         current = current.get("expression");
         continue;
       }
       if (current.isSequenceExpression()) {
         const expressions = current.get("expressions");
-        const last = expressions[expressions.length - 1];
+        const last = expressions.at(-1);
         if (last) {
           current = last;
           continue;
         }
       }
-      if (_optionalChain([current, 'access', _85 => _85.isCallExpression, 'optionalCall', _86 => _86()]) || current.node.type === "CallExpression") {
+      if (_optionalChain([current, 'access', _97 => _97.isCallExpression, 'optionalCall', _98 => _98()]) || current.node.type === "CallExpression") {
         const callee = current.get("callee");
         current = callee;
         continue;
@@ -2374,23 +2760,23 @@ function createTaggedTemplateIgnore({ matcher, names }) {
     }
     return current;
   };
-  const evaluateTagPath = (tagPath) => {
-    if (_optionalChain([tagPath, 'access', _87 => _87.isCallExpression, 'optionalCall', _88 => _88()]) || tagPath.node.type === "CallExpression") {
+  const evaluateTagPath = (tagPath, seen) => {
+    if (_optionalChain([tagPath, 'access', _99 => _99.isCallExpression, 'optionalCall', _100 => _100()]) || 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 = _optionalChain([tagPath, 'optionalAccess', _89 => _89.scope, 'optionalAccess', _90 => _90.getBinding, 'optionalCall', _91 => _91(tagPath.node.name)]);
+      const binding = _optionalChain([tagPath, 'optionalAccess', _101 => _101.scope, 'optionalAccess', _102 => _102.getBinding, 'optionalCall', _103 => _103(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 = _nullishCoalesce(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" }) && !_optionalChain([p, 'optionalAccess', _104 => _104.scope, 'optionalAccess', _105 => _105.hasBinding, 'optionalCall', _106 => _106("require")])) {
+      const args = p.get("arguments");
+      if (Array.isArray(args) && args.length > 0) {
+        const first = args[0];
+        if (_optionalChain([first, 'optionalAccess', _107 => _107.isStringLiteral, 'call', _108 => _108()])) {
+          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" }) && !_optionalChain([p, 'optionalAccess', _92 => _92.scope, 'optionalAccess', _93 => _93.hasBinding, 'optionalCall', _94 => _94("require")])) {
-          const args = p.get("arguments");
-          if (Array.isArray(args) && args.length > 0) {
-            const first = args[0];
-            if (_optionalChain([first, 'optionalAccess', _95 => _95.isStringLiteral, 'call', _96 => _96()])) {
-              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 = _nullishCoalesce(options2, () => ( {}));
-    const resolvedOptions = _chunkDYLQ6UOIjs.defuOverrideArray.call(void 0, 
+  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 _optionalChain([cache, 'optionalAccess', _109 => _109.get, 'call', _110 => _110(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 = _chunkDYLQ6UOIjs.defuOverrideArray.call(void 0, 
+        {
+          ...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 = _chunkDYLQ6UOIjs.defuOverrideArray.call(void 0, 
       {
         ...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;
 }
@@ -2691,10 +3211,16 @@ function shouldSkipLegacyStringLiteral(path5) {
     return true;
   }
   return Boolean(
-    t.isBinaryExpression(path5.parent) && (t.isConditionalExpression(_optionalChain([path5, 'access', _97 => _97.parentPath, 'optionalAccess', _98 => _98.parent])) || t.isLogicalExpression(_optionalChain([path5, 'access', _99 => _99.parentPath, 'optionalAccess', _100 => _100.parent])))
+    t.isBinaryExpression(path5.parent) && (t.isConditionalExpression(_optionalChain([path5, 'access', _111 => _111.parentPath, 'optionalAccess', _112 => _112.parent])) || t.isLogicalExpression(_optionalChain([path5, 'access', _113 => _113.parentPath, 'optionalAccess', _114 => _114.parent])))
   );
 }
 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 (0, _magicstring2.default)(match);
   const ast = _parser.parseExpression.call(void 0, match);
   const jsTokenUpdater = new JsTokenUpdater();
   traverse(ast, createLegacyTraverseOptions(options, jsTokenUpdater));
+  if (jsTokenUpdater.length === 0) {
+    return match;
+  }
+  const ms = new (0, _magicstring2.default)(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 (0, _magicstring2.default)(original);
-  const tokenizer = new Tokenizer();
-  const tokens = tokenizer.run(ms.original);
+  const tok = _nullishCoalesce(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
   } = _nullishCoalesce(options, () => ( {}));
-  const matchCustomAttribute = createAttributeMatcher(customAttributesEntities);
-  const s = new (0, _magicstring2.default)(rawSource);
+  const matchCustomAttribute = _nullishCoalesce(cachedMatcher, () => ( createAttributeMatcher(customAttributesEntities)));
+  const defaultTemplateHandlerEnabled = !disabledDefaultTemplateHandler;
+  let replaceOptions;
+  let cachedQuote;
+  let s;
   let tag = "";
-  const wxsArray = [];
+  let wxsArray;
+  function getMagicString() {
+    if (!s) {
+      s = new (0, _magicstring2.default)(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 (0, _htmlparser2.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 shouldHandleCustom = _nullishCoalesce(_optionalChain([matchCustomAttribute, 'optionalCall', _101 => _101(tag, name)]), () => ( false));
+        const shouldHandleDefault = defaultTemplateHandlerEnabled && isDefaultTemplateAttribute(name);
+        const shouldHandleCustom = _nullishCoalesce(_optionalChain([matchCustomAttribute, 'optionalCall', _115 => _115(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({
+          ;
+          (_nullishCoalesce(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 _nullishCoalesce(wxsArray, () => ( []))) {
     const { code } = await jsHandler2(data, runtimeSet);
-    s.update(startIndex, endIndex, code);
+    if (code !== data) {
+      getMagicString().update(startIndex, endIndex, code);
+    }
   }
-  return s.toString();
+  return _nullishCoalesce(_optionalChain([s, 'optionalAccess', _116 => _116.toString, 'call', _117 => _117()]), () => ( rawSource));
 }
 
 // src/wxml/utils.ts
 function createTemplateHandler(options = {}) {
-  return (rawSource, opt = {}) => {
-    return customTemplateHandler(rawSource, _chunkDYLQ6UOIjs.defuOverrideArray.call(void 0, opt, options));
+  const cachedMatcher = createAttributeMatcher(
+    options.customAttributesEntities
+  );
+  const defaultOptions = options;
+  let cachedRuntimeSet;
+  let cachedOptionsWithRuntimeSet;
+  return (rawSource, opt) => {
+    const runtimeSet = _optionalChain([opt, 'optionalAccess', _118 => _118.runtimeSet]);
+    if (runtimeSet === void 0) {
+      return customTemplateHandler(rawSource, defaultOptions, cachedMatcher);
+    }
+    if (cachedRuntimeSet !== runtimeSet || !cachedOptionsWithRuntimeSet) {
+      cachedRuntimeSet = runtimeSet;
+      cachedOptionsWithRuntimeSet = {
+        ...defaultOptions,
+        runtimeSet
+      };
+    }
+    return customTemplateHandler(rawSource, cachedOptionsWithRuntimeSet, cachedMatcher);
   };
 }
 
@@ -3147,7 +3725,7 @@ async function clearTailwindcssPatcherCache(patcher, options) {
   if (!patcher) {
     return;
   }
-  const cacheOptions = _optionalChain([patcher, 'access', _102 => _102.options, 'optionalAccess', _103 => _103.cache]);
+  const cacheOptions = _optionalChain([patcher, 'access', _119 => _119.options, 'optionalAccess', _120 => _120.cache]);
   if (cacheOptions == null || typeof cacheOptions === "object" && cacheOptions.enabled === false) {
     return;
   }
@@ -3158,19 +3736,19 @@ async function clearTailwindcssPatcherCache(patcher, options) {
       _logger.logger.debug("failed to clear tailwindcss patcher cache via clearCache(): %O", error);
     }
   }
-  if (!_optionalChain([options, 'optionalAccess', _104 => _104.removeDirectory])) {
+  if (!_optionalChain([options, 'optionalAccess', _121 => _121.removeDirectory])) {
     return;
   }
   const cachePaths = /* @__PURE__ */ new Map();
   const normalizedCacheOptions = typeof cacheOptions === "object" ? cacheOptions : void 0;
-  if (_optionalChain([normalizedCacheOptions, 'optionalAccess', _105 => _105.path])) {
+  if (_optionalChain([normalizedCacheOptions, 'optionalAccess', _122 => _122.path])) {
     cachePaths.set(normalizedCacheOptions.path, false);
   }
-  const privateCachePath = _optionalChain([patcher, 'optionalAccess', _106 => _106.cacheStore, 'optionalAccess', _107 => _107.options, 'optionalAccess', _108 => _108.path]);
+  const privateCachePath = _optionalChain([patcher, 'optionalAccess', _123 => _123.cacheStore, 'optionalAccess', _124 => _124.options, 'optionalAccess', _125 => _125.path]);
   if (privateCachePath) {
     cachePaths.set(privateCachePath, false);
   }
-  if (_optionalChain([options, 'optionalAccess', _109 => _109.removeDirectory]) && _optionalChain([normalizedCacheOptions, 'optionalAccess', _110 => _110.dir])) {
+  if (_optionalChain([options, 'optionalAccess', _126 => _126.removeDirectory]) && _optionalChain([normalizedCacheOptions, 'optionalAccess', _127 => _127.dir])) {
     cachePaths.set(normalizedCacheOptions.dir, true);
   }
   if (!cachePaths.size) {
@@ -3181,7 +3759,7 @@ async function clearTailwindcssPatcherCache(patcher, options) {
       await _promises.rm.call(void 0, cachePath, { force: true, recursive });
     } catch (error) {
       const err = error;
-      if (_optionalChain([err, 'optionalAccess', _111 => _111.code]) === "ENOENT") {
+      if (_optionalChain([err, 'optionalAccess', _128 => _128.code]) === "ENOENT") {
         continue;
       }
       _logger.logger.debug("failed to clear tailwindcss patcher cache: %s %O", cachePath, err);
@@ -3191,20 +3769,20 @@ async function clearTailwindcssPatcherCache(patcher, options) {
 function createInternalCompilerContext(opts) {
   const ctx = _chunkDYLQ6UOIjs.defuOverrideArray.call(void 0, 
     opts,
-    _chunk5U24PLVVjs.getDefaultOptions.call(void 0, ),
+    _chunkACTJYB33js.getDefaultOptions.call(void 0, ),
     {}
   );
   ctx.escapeMap = ctx.customReplaceDictionary;
   applyLoggerLevel(ctx.logLevel);
-  const twPatcher = _chunkRYC23C3Kjs.createTailwindcssPatcherFromContext.call(void 0, ctx);
+  const twPatcher = _chunk4LPOQMFSjs.createTailwindcssPatcherFromContext.call(void 0, ctx);
   logTailwindcssTarget("runtime", twPatcher, ctx.tailwindcssBasedir);
-  if (_optionalChain([twPatcher, 'access', _112 => _112.packageInfo, 'optionalAccess', _113 => _113.version])) {
+  if (_optionalChain([twPatcher, 'access', _129 => _129.packageInfo, 'optionalAccess', _130 => _130.version])) {
     _logger.logger.success(`\u5F53\u524D\u4F7F\u7528 ${_logger.pc.cyanBright("Tailwind CSS")} \u7248\u672C\u4E3A: ${_logger.pc.underline(_logger.pc.bold(_logger.pc.green(twPatcher.packageInfo.version)))}`);
   } else {
     _logger.logger.warn(`${_logger.pc.cyanBright("Tailwind CSS")} \u672A\u5B89\u88C5\uFF0C\u5DF2\u8DF3\u8FC7\u7248\u672C\u68C0\u6D4B\u4E0E\u8865\u4E01\u5E94\u7528\u3002`);
   }
-  _chunkRYC23C3Kjs.warnMissingCssEntries.call(void 0, ctx, twPatcher);
-  const cssCalcOptions = _chunkRYC23C3Kjs.applyV4CssCalcDefaults.call(void 0, ctx.cssCalc, twPatcher);
+  _chunk4LPOQMFSjs.warnMissingCssEntries.call(void 0, ctx, twPatcher);
+  const cssCalcOptions = _chunk4LPOQMFSjs.applyV4CssCalcDefaults.call(void 0, ctx.cssCalc, twPatcher);
   ctx.cssCalc = cssCalcOptions;
   const customAttributesEntities = toCustomAttributesEntities(ctx.customAttributes);
   const { styleHandler, jsHandler: jsHandler2, templateHandler } = createHandlersFromContext(
@@ -3220,11 +3798,11 @@ function createInternalCompilerContext(opts) {
   ctx.twPatcher = twPatcher;
   const refreshTailwindcssPatcher = async (options) => {
     const previousPatcher = ctx.twPatcher;
-    if (_optionalChain([options, 'optionalAccess', _114 => _114.clearCache]) !== false) {
+    if (_optionalChain([options, 'optionalAccess', _131 => _131.clearCache]) !== false) {
       await clearTailwindcssPatcherCache(previousPatcher);
     }
     invalidateRuntimeClassSet(previousPatcher);
-    const nextPatcher = _chunkRYC23C3Kjs.createTailwindcssPatcherFromContext.call(void 0, ctx);
+    const nextPatcher = _chunk4LPOQMFSjs.createTailwindcssPatcherFromContext.call(void 0, ctx);
     Object.assign(previousPatcher, nextPatcher);
     ctx.twPatcher = previousPatcher;
     return previousPatcher;
@@ -3258,4 +3836,6 @@ function getCompilerContext(opts) {
 
 
 
-exports.createDebug = createDebug; exports.getRuntimeClassSetSignature = getRuntimeClassSetSignature; exports.createTailwindPatchPromise = createTailwindPatchPromise; exports.refreshTailwindRuntimeState = refreshTailwindRuntimeState; exports.ensureRuntimeClassSet = ensureRuntimeClassSet; exports.collectRuntimeClassSet = collectRuntimeClassSet; exports.pluginName = pluginName; exports.vitePluginName = vitePluginName; exports.WEAPP_TW_REQUIRED_NODE_VERSION = WEAPP_TW_REQUIRED_NODE_VERSION; exports.createPatchTargetRecorder = createPatchTargetRecorder; exports.logTailwindcssTarget = logTailwindcssTarget; exports.toCustomAttributesEntities = toCustomAttributesEntities; exports.replaceWxml = replaceWxml; exports.createAttributeMatcher = createAttributeMatcher; exports.generateCode = generateCode; exports.clearTailwindcssPatcherCache = clearTailwindcssPatcherCache; exports.getCompilerContext = getCompilerContext;
+
+
+exports.createDebug = createDebug; exports.getRuntimeClassSetSignature = getRuntimeClassSetSignature; exports.createTailwindPatchPromise = createTailwindPatchPromise; exports.refreshTailwindRuntimeState = refreshTailwindRuntimeState; exports.ensureRuntimeClassSet = ensureRuntimeClassSet; exports.collectRuntimeClassSet = collectRuntimeClassSet; exports.pluginName = pluginName; exports.vitePluginName = vitePluginName; exports.WEAPP_TW_REQUIRED_NODE_VERSION = WEAPP_TW_REQUIRED_NODE_VERSION; exports.createPatchTargetRecorder = createPatchTargetRecorder; exports.logTailwindcssTarget = logTailwindcssTarget; exports.toCustomAttributesEntities = toCustomAttributesEntities; exports.traverse = traverse; exports.babelParse = babelParse; exports.replaceWxml = replaceWxml; exports.createAttributeMatcher = createAttributeMatcher; exports.generateCode = generateCode; exports.clearTailwindcssPatcherCache = clearTailwindcssPatcherCache; exports.getCompilerContext = getCompilerContext;