weapp-tailwindcss 4.7.8 → 4.7.10-alpha.0

package/dist/{chunk-OQ5PKCFN.mjs → chunk-2WJGB2LE.mjs}

@@ -7,7 +7,7 @@ import {
   createTailwindPatchPromise,
   getCompilerContext,
   refreshTailwindRuntimeState
-} from "./chunk-G7MXWOBI.mjs";
+} from "./chunk-J7OY4W53.mjs";
 
 // src/bundlers/gulp/index.ts
 import { Buffer } from "buffer";

package/dist/{chunk-ZSTADQDZ.js → chunk-6MBTOUPD.js}

@@ -16,7 +16,7 @@ var _chunkLTJQUORKjs = require('./chunk-LTJQUORK.js');
 
 
 
-var _chunk6J63FRIYjs = require('./chunk-6J63FRIY.js');
+var _chunkAEIEPXO3js = require('./chunk-AEIEPXO3.js');
 
 
 var _chunkUW3WHSZ5js = require('./chunk-UW3WHSZ5.js');
@@ -25,10 +25,10 @@ var _chunkUW3WHSZ5js = require('./chunk-UW3WHSZ5.js');
 var _fs = require('fs'); var _fs2 = _interopRequireDefault(_fs);
 var _path = require('path'); var _path2 = _interopRequireDefault(_path);
 var _process = require('process'); var _process2 = _interopRequireDefault(_process);
-var debug = _chunk6J63FRIYjs.createDebug.call(void 0, );
+var debug = _chunkAEIEPXO3js.createDebug.call(void 0, );
 var UnifiedWebpackPluginV5 = class {
   constructor(options = {}) {
-    this.options = _chunk6J63FRIYjs.getCompilerContext.call(void 0, options);
+    this.options = _chunkAEIEPXO3js.getCompilerContext.call(void 0, options);
     this.appType = this.options.appType;
   }
   apply(compiler) {
@@ -52,18 +52,18 @@ var UnifiedWebpackPluginV5 = class {
     }
     const runtimeState = {
       twPatcher: initialTwPatcher,
-      patchPromise: _chunk6J63FRIYjs.createTailwindPatchPromise.call(void 0, initialTwPatcher),
+      patchPromise: _chunkAEIEPXO3js.createTailwindPatchPromise.call(void 0, initialTwPatcher),
       refreshTailwindcssPatcher
     };
     const refreshRuntimeState = async (force) => {
-      await _chunk6J63FRIYjs.refreshTailwindRuntimeState.call(void 0, runtimeState, force);
+      await _chunkAEIEPXO3js.refreshTailwindRuntimeState.call(void 0, runtimeState, force);
     };
     const { Compilation, sources, NormalModule } = compiler.webpack;
     const { ConcatSource } = sources;
     async function getClassSetInLoader() {
       await refreshRuntimeState(true);
       await runtimeState.patchPromise;
-      await _chunk6J63FRIYjs.collectRuntimeClassSet.call(void 0, runtimeState.twPatcher, { force: true, skipRefresh: true });
+      await _chunkAEIEPXO3js.collectRuntimeClassSet.call(void 0, runtimeState.twPatcher, { force: true, skipRefresh: true });
     }
     onLoad();
     const loader = _nullishCoalesce(runtimeLoaderPath, () => ( _path2.default.resolve(__dirname, "./weapp-tw-runtime-loader.js")));
@@ -76,8 +76,8 @@ var UnifiedWebpackPluginV5 = class {
       ident: null,
       type: null
     };
-    compiler.hooks.compilation.tap(_chunk6J63FRIYjs.pluginName, (compilation) => {
-      NormalModule.getCompilationHooks(compilation).loader.tap(_chunk6J63FRIYjs.pluginName, (_loaderContext, module) => {
+    compiler.hooks.compilation.tap(_chunkAEIEPXO3js.pluginName, (compilation) => {
+      NormalModule.getCompilationHooks(compilation).loader.tap(_chunkAEIEPXO3js.pluginName, (_loaderContext, module) => {
         if (isExisted) {
           const idx = module.loaders.findIndex((x) => x.loader.includes("postcss-loader"));
           if (idx > -1) {
@@ -87,7 +87,7 @@ var UnifiedWebpackPluginV5 = class {
       });
       compilation.hooks.processAssets.tapPromise(
         {
-          name: _chunk6J63FRIYjs.pluginName,
+          name: _chunkAEIEPXO3js.pluginName,
           stage: Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE
         },
         async (assets) => {
@@ -156,7 +156,7 @@ var UnifiedWebpackPluginV5 = class {
           const groupedEntries = _chunkUW3WHSZ5js.getGroupedEntries.call(void 0, entries, this.options);
           await refreshRuntimeState(true);
           await runtimeState.patchPromise;
-          const runtimeSet = await _chunk6J63FRIYjs.collectRuntimeClassSet.call(void 0, runtimeState.twPatcher, { force: true, skipRefresh: true });
+          const runtimeSet = await _chunkAEIEPXO3js.collectRuntimeClassSet.call(void 0, runtimeState.twPatcher, { force: true, skipRefresh: true });
           debug("get runtimeSet, class count: %d", runtimeSet.size);
           const tasks = [];
           if (Array.isArray(groupedEntries.html)) {

package/dist/{chunk-6J63FRIY.js → chunk-AEIEPXO3.js}

@@ -1,6 +1,6 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
 
-var _chunkHPUZNQ4Gjs = require('./chunk-HPUZNQ4G.js');
+var _chunkKMCQEHJMjs = require('./chunk-KMCQEHJM.js');
 
 
 var _chunkSMYOFNHJjs = require('./chunk-SMYOFNHJ.js');
@@ -393,6 +393,177 @@ function initializeCache(cacheConfig) {
   return cacheConfig;
 }
 
+// src/context/compiler-context-cache.ts
+var _buffer = require('buffer');
+
+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);
+}
+function withCircularGuard(value, stack, factory) {
+  if (stack.has(value)) {
+    throw new TypeError("Cannot serialize circular structure in compiler context options");
+  }
+  stack.add(value);
+  try {
+    return factory();
+  } finally {
+    stack.delete(value);
+  }
+}
+function encodeTaggedValue(type, value) {
+  const record = { __type: type };
+  if (value !== void 0) {
+    record.value = value;
+  }
+  return record;
+}
+function normalizeOptionsValue(rawValue, stack = /* @__PURE__ */ new WeakSet()) {
+  if (rawValue === null) {
+    return null;
+  }
+  if (rawValue === void 0) {
+    return encodeTaggedValue("Undefined");
+  }
+  const type = typeof rawValue;
+  if (type === "string") {
+    return rawValue;
+  }
+  if (type === "boolean") {
+    return rawValue;
+  }
+  if (type === "number") {
+    const numericValue = rawValue;
+    if (Number.isNaN(numericValue)) {
+      return encodeTaggedValue("Number", "NaN");
+    }
+    if (!Number.isFinite(numericValue)) {
+      return encodeTaggedValue("Number", numericValue > 0 ? "Infinity" : "-Infinity");
+    }
+    if (Object.is(numericValue, -0)) {
+      return encodeTaggedValue("Number", "-0");
+    }
+    return numericValue;
+  }
+  if (type === "bigint") {
+    return encodeTaggedValue("BigInt", rawValue.toString());
+  }
+  if (type === "symbol") {
+    const symbolValue = rawValue;
+    return encodeTaggedValue("Symbol", _nullishCoalesce(symbolValue.description, () => ( String(symbolValue))));
+  }
+  if (type === "function") {
+    return encodeTaggedValue("Function", rawValue.toString());
+  }
+  if (Array.isArray(rawValue)) {
+    return withCircularGuard(rawValue, stack, () => rawValue.map((item) => normalizeOptionsValue(item, stack)));
+  }
+  if (rawValue instanceof Date) {
+    return encodeTaggedValue("Date", rawValue.toISOString());
+  }
+  if (rawValue instanceof RegExp) {
+    return {
+      __type: "RegExp",
+      source: rawValue.source,
+      flags: rawValue.flags
+    };
+  }
+  if (typeof _buffer.Buffer !== "undefined" && _buffer.Buffer.isBuffer(rawValue)) {
+    return encodeTaggedValue("Buffer", rawValue.toString("base64"));
+  }
+  if (ArrayBuffer.isView(rawValue)) {
+    const view = rawValue;
+    const buffer = _buffer.Buffer.from(view.buffer, view.byteOffset, view.byteLength);
+    return encodeTaggedValue(_nullishCoalesce(_optionalChain([view, 'access', _14 => _14.constructor, 'optionalAccess', _15 => _15.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);
+      return {
+        __type: "Set",
+        value: normalizedEntries
+      };
+    });
+  }
+  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));
+      return {
+        __type: "Map",
+        value: normalizedEntries.map((entry) => [entry.key, entry.value])
+      };
+    });
+  }
+  if (typeof URL !== "undefined" && rawValue instanceof URL) {
+    return encodeTaggedValue("URL", rawValue.toString());
+  }
+  if (rawValue instanceof Error) {
+    const errorValue = rawValue;
+    return {
+      __type: "Error",
+      name: errorValue.name,
+      message: errorValue.message,
+      stack: _nullishCoalesce(errorValue.stack, () => ( ""))
+    };
+  }
+  if (rawValue instanceof Promise) {
+    return encodeTaggedValue("Promise");
+  }
+  if (rawValue instanceof WeakMap) {
+    return encodeTaggedValue("WeakMap");
+  }
+  if (rawValue instanceof WeakSet) {
+    return encodeTaggedValue("WeakSet");
+  }
+  if (rawValue && typeof rawValue === "object") {
+    return withCircularGuard(rawValue, stack, () => {
+      const result = {};
+      const entries = Object.entries(rawValue);
+      entries.sort(([a], [b]) => a.localeCompare(b));
+      for (const [key, entryValue] of entries) {
+        result[key] = normalizeOptionsValue(entryValue, stack);
+      }
+      return result;
+    });
+  }
+  return encodeTaggedValue(typeof rawValue, String(rawValue));
+}
+function createCompilerContextCacheKey(opts) {
+  try {
+    const normalized = normalizeOptionsValue(_nullishCoalesce(opts, () => ( {})));
+    const serialized = JSON.stringify(normalized);
+    return _node.md5.call(void 0, serialized);
+  } catch (error) {
+    _logger.logger.debug("skip compiler context cache: %O", error);
+    return void 0;
+  }
+}
+function withCompilerContextCache(opts, factory) {
+  const cacheKey = createCompilerContextCacheKey(opts);
+  if (cacheKey) {
+    const cached = compilerContextCache.get(cacheKey);
+    if (cached) {
+      return cached;
+    }
+  }
+  const ctx = factory();
+  if (cacheKey) {
+    compilerContextCache.set(cacheKey, ctx);
+  }
+  return ctx;
+}
+
 // src/context/custom-attributes.ts
 function toCustomAttributesEntities(customAttributes) {
   if (!customAttributes) {
@@ -463,10 +634,10 @@ function createNameMatcher(list, { exact = false } = {}) {
   const fuzzyMatcher = exact ? void 0 : buildFuzzyMatcher(fuzzyStrings);
   const hasRegex = regexList.length > 0;
   return (value) => {
-    if (exact && _optionalChain([exactStrings, 'optionalAccess', _14 => _14.has, 'call', _15 => _15(value)])) {
+    if (exact && _optionalChain([exactStrings, 'optionalAccess', _16 => _16.has, 'call', _17 => _17(value)])) {
       return true;
     }
-    if (_optionalChain([fuzzyMatcher, 'optionalCall', _16 => _16(value)])) {
+    if (_optionalChain([fuzzyMatcher, 'optionalCall', _18 => _18(value)])) {
       return true;
     }
     if (!hasRegex) {
@@ -544,7 +715,7 @@ function handleEvalTemplateElement(path2, options, updater, handler) {
   }
 }
 function walkEvalExpression(path2, options, updater, handler) {
-  const maybeTraverse = _optionalChain([path2, 'optionalAccess', _17 => _17.traverse]);
+  const maybeTraverse = _optionalChain([path2, 'optionalAccess', _19 => _19.traverse]);
   if (typeof maybeTraverse === "function") {
     try {
       return maybeTraverse.call(path2, {
@@ -556,21 +727,21 @@ function walkEvalExpression(path2, options, updater, handler) {
         }
       });
     } catch (error) {
-      const msg = _nullishCoalesce(_optionalChain([error, 'optionalAccess', _18 => _18.message]), () => ( ""));
+      const msg = _nullishCoalesce(_optionalChain([error, 'optionalAccess', _20 => _20.message]), () => ( ""));
       const scopeError = /pass a scope and parentPath|traversing a Program\/File/i.test(msg);
       if (!scopeError) {
         throw error;
       }
     }
   }
-  const getArgs = _optionalChain([path2, 'optionalAccess', _19 => _19.get, 'optionalCall', _20 => _20("arguments")]);
+  const getArgs = _optionalChain([path2, 'optionalAccess', _21 => _21.get, 'optionalCall', _22 => _22("arguments")]);
   if (Array.isArray(getArgs)) {
     for (const arg of getArgs) {
-      if (_optionalChain([arg, 'optionalAccess', _21 => _21.isStringLiteral, 'optionalCall', _22 => _22()])) {
+      if (_optionalChain([arg, 'optionalAccess', _23 => _23.isStringLiteral, 'optionalCall', _24 => _24()])) {
         handleEvalStringLiteral(arg, options, updater, handler);
         continue;
       }
-      if (_optionalChain([arg, 'optionalAccess', _23 => _23.isTemplateLiteral, 'optionalCall', _24 => _24()])) {
+      if (_optionalChain([arg, 'optionalAccess', _25 => _25.isTemplateLiteral, 'optionalCall', _26 => _26()])) {
         for (const quasi of arg.get("quasis")) {
           handleEvalTemplateElement(quasi, options, updater, handler);
         }
@@ -578,16 +749,16 @@ function walkEvalExpression(path2, options, updater, handler) {
     }
     return;
   }
-  const nodeArgs = _optionalChain([path2, 'optionalAccess', _25 => _25.node, 'optionalAccess', _26 => _26.arguments]);
+  const nodeArgs = _optionalChain([path2, 'optionalAccess', _27 => _27.node, 'optionalAccess', _28 => _28.arguments]);
   if (Array.isArray(nodeArgs)) {
     for (const n of nodeArgs) {
-      if (_optionalChain([n, 'optionalAccess', _27 => _27.type]) === "StringLiteral") {
+      if (_optionalChain([n, 'optionalAccess', _29 => _29.type]) === "StringLiteral") {
         const stub = {
           node: n,
           isStringLiteral: () => true
         };
         handleEvalStringLiteral(stub, options, updater, handler);
-      } else if (_optionalChain([n, 'optionalAccess', _28 => _28.type]) === "TemplateLiteral" && Array.isArray(n.quasis)) {
+      } else if (_optionalChain([n, 'optionalAccess', _30 => _30.type]) === "TemplateLiteral" && Array.isArray(n.quasis)) {
         for (const q of n.quasis) {
           const stub = {
             node: q,
@@ -696,10 +867,10 @@ function shouldTransformClassName(candidate, {
   if (!classNameSet.has(candidate)) {
     return false;
   }
-  return !_optionalChain([jsPreserveClass, 'optionalCall', _29 => _29(candidate)]);
+  return !_optionalChain([jsPreserveClass, 'optionalCall', _31 => _31(candidate)]);
 }
 function extractLiteralValue(path2, { unescapeUnicode, arbitraryValues }) {
-  const allowDoubleQuotes = _optionalChain([arbitraryValues, 'optionalAccess', _30 => _30.allowDoubleQuotes]);
+  const allowDoubleQuotes = _optionalChain([arbitraryValues, 'optionalAccess', _32 => _32.allowDoubleQuotes]);
   let offset = 0;
   let original;
   if (path2.isStringLiteral()) {
@@ -899,7 +1070,7 @@ var JsModuleGraph = class {
         continue;
       }
       if (exportPath.isExportNamedDeclaration()) {
-        const source = _optionalChain([exportPath, 'access', _31 => _31.node, 'access', _32 => _32.source, 'optionalAccess', _33 => _33.value]);
+        const source = _optionalChain([exportPath, 'access', _33 => _33.node, 'access', _34 => _34.source, 'optionalAccess', _35 => _35.value]);
         if (typeof source === "string") {
           for (const spec of exportPath.get("specifiers")) {
             if (!spec.isExportSpecifier()) {
@@ -966,7 +1137,7 @@ var JsModuleGraph = class {
         continue;
       }
       if (exportPath.isExportAllDeclaration()) {
-        const source = _optionalChain([exportPath, 'access', _34 => _34.node, 'access', _35 => _35.source, 'optionalAccess', _36 => _36.value]);
+        const source = _optionalChain([exportPath, 'access', _36 => _36.node, 'access', _37 => _37.source, 'optionalAccess', _38 => _38.value]);
         if (typeof source === "string") {
           for (const exportName of names) {
             propagate.push({
@@ -1018,7 +1189,7 @@ var JsModuleGraph = class {
       }
       for (const exportPath of state.analysis.exportDeclarations) {
         if (exportPath.isExportAllDeclaration() || exportPath.isExportNamedDeclaration()) {
-          const source = _optionalChain([exportPath, 'access', _37 => _37.node, 'access', _38 => _38.source, 'optionalAccess', _39 => _39.value]);
+          const source = _optionalChain([exportPath, 'access', _39 => _39.node, 'access', _40 => _40.source, 'optionalAccess', _41 => _41.value]);
           if (typeof source === "string" && !dependencySpecifiers.has(source)) {
             dependencySpecifiers.set(source, []);
           }
@@ -1137,14 +1308,14 @@ var NodePathWalker = class {
     }
     this.visited.add(arg);
     if (arg.isIdentifier()) {
-      const binding = _optionalChain([arg, 'optionalAccess', _40 => _40.scope, 'optionalAccess', _41 => _41.getBinding, 'optionalCall', _42 => _42(arg.node.name)]);
+      const binding = _optionalChain([arg, 'optionalAccess', _42 => _42.scope, 'optionalAccess', _43 => _43.getBinding, 'optionalCall', _44 => _44(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', _43 => _43.scope, 'optionalAccess', _44 => _44.getBinding, 'optionalCall', _45 => _45(objectPath.node.name)]);
+        const binding = _optionalChain([arg, 'optionalAccess', _45 => _45.scope, 'optionalAccess', _46 => _46.getBinding, 'optionalCall', _47 => _47(objectPath.node.name)]);
         if (binding) {
           if (binding.path.isVariableDeclarator()) {
             this.walkVariableDeclarator(binding.path);
@@ -1344,8 +1515,8 @@ function createTaggedTemplateIgnore({ matcher, names }) {
     }
     const objectPath = path2.get("object");
     if (objectPath.isIdentifier()) {
-      const scope = _optionalChain([objectPath, 'optionalAccess', _46 => _46.scope]);
-      const binding = _optionalChain([scope, 'optionalAccess', _47 => _47.getBinding, 'optionalCall', _48 => _48(objectPath.node.name)]);
+      const scope = _optionalChain([objectPath, 'optionalAccess', _48 => _48.scope]);
+      const binding = _optionalChain([scope, 'optionalAccess', _49 => _49.getBinding, 'optionalCall', _50 => _50(objectPath.node.name)]);
       if (binding) {
         return resolvesToWeappTwIgnore(binding, seen);
       }
@@ -1374,7 +1545,7 @@ function createTaggedTemplateIgnore({ matcher, names }) {
       const init = bindingPath.get("init");
       if (init && init.node) {
         if (init.isIdentifier()) {
-          const target = _optionalChain([binding, 'optionalAccess', _49 => _49.scope, 'optionalAccess', _50 => _50.getBinding, 'optionalCall', _51 => _51(init.node.name)]);
+          const target = _optionalChain([binding, 'optionalAccess', _51 => _51.scope, 'optionalAccess', _52 => _52.getBinding, 'optionalCall', _53 => _53(init.node.name)]);
           if (target) {
             result = resolvesToWeappTwIgnore(target, seen);
           }
@@ -1390,7 +1561,7 @@ function createTaggedTemplateIgnore({ matcher, names }) {
   const getEffectiveTagPath = (tagPath) => {
     let current = tagPath;
     while (true) {
-      if (_optionalChain([current, 'access', _52 => _52.isParenthesizedExpression, 'optionalCall', _53 => _53()]) || current.node.type === "ParenthesizedExpression") {
+      if (_optionalChain([current, 'access', _54 => _54.isParenthesizedExpression, 'optionalCall', _55 => _55()]) || current.node.type === "ParenthesizedExpression") {
         current = current.get("expression");
         continue;
       }
@@ -1402,7 +1573,7 @@ function createTaggedTemplateIgnore({ matcher, names }) {
         current = current.get("expression");
         continue;
       }
-      if (_optionalChain([current, 'access', _54 => _54.isTypeCastExpression, 'optionalCall', _55 => _55()])) {
+      if (_optionalChain([current, 'access', _56 => _56.isTypeCastExpression, 'optionalCall', _57 => _57()])) {
         current = current.get("expression");
         continue;
       }
@@ -1414,7 +1585,7 @@ function createTaggedTemplateIgnore({ matcher, names }) {
           continue;
         }
       }
-      if (_optionalChain([current, 'access', _56 => _56.isCallExpression, 'optionalCall', _57 => _57()]) || current.node.type === "CallExpression") {
+      if (_optionalChain([current, 'access', _58 => _58.isCallExpression, 'optionalCall', _59 => _59()]) || current.node.type === "CallExpression") {
         const callee = current.get("callee");
         current = callee;
         continue;
@@ -1424,7 +1595,7 @@ function createTaggedTemplateIgnore({ matcher, names }) {
     return current;
   };
   const evaluateTagPath = (tagPath) => {
-    if (_optionalChain([tagPath, 'access', _58 => _58.isCallExpression, 'optionalCall', _59 => _59()]) || tagPath.node.type === "CallExpression") {
+    if (_optionalChain([tagPath, 'access', _60 => _60.isCallExpression, 'optionalCall', _61 => _61()]) || tagPath.node.type === "CallExpression") {
       const calleePath = tagPath.get("callee");
       return evaluateTagPath(calleePath);
     }
@@ -1432,7 +1603,7 @@ function createTaggedTemplateIgnore({ matcher, names }) {
       if (matcher(tagPath.node.name)) {
         return true;
       }
-      const binding = _optionalChain([tagPath, 'optionalAccess', _60 => _60.scope, 'optionalAccess', _61 => _61.getBinding, 'optionalCall', _62 => _62(tagPath.node.name)]);
+      const binding = _optionalChain([tagPath, 'optionalAccess', _62 => _62.scope, 'optionalAccess', _63 => _63.getBinding, 'optionalCall', _64 => _64(tagPath.node.name)]);
       if (binding) {
         return resolvesToWeappTwIgnore(binding, /* @__PURE__ */ new Set());
       }
@@ -1555,11 +1726,11 @@ function analyzeSource(ast, options, handler) {
           return;
         }
         const calleePath = p.get("callee");
-        if (calleePath.isIdentifier({ name: "require" }) && !_optionalChain([p, 'optionalAccess', _63 => _63.scope, 'optionalAccess', _64 => _64.hasBinding, 'optionalCall', _65 => _65("require")])) {
+        if (calleePath.isIdentifier({ name: "require" }) && !_optionalChain([p, 'optionalAccess', _65 => _65.scope, 'optionalAccess', _66 => _66.hasBinding, 'optionalCall', _67 => _67("require")])) {
           const args = p.get("arguments");
           if (Array.isArray(args) && args.length > 0) {
             const first = args[0];
-            if (_optionalChain([first, 'optionalAccess', _66 => _66.isStringLiteral, 'call', _67 => _67()])) {
+            if (_optionalChain([first, 'optionalAccess', _68 => _68.isStringLiteral, 'call', _69 => _69()])) {
               requireCallPaths.push(first);
             }
           }
@@ -1958,7 +2129,7 @@ function generateCode(match, options = {}) {
           if (t.isMemberExpression(path2.parent)) {
             return;
           }
-          if (t.isBinaryExpression(path2.parent) && (t.isConditionalExpression(_optionalChain([path2, 'access', _68 => _68.parentPath, 'optionalAccess', _69 => _69.parent])) || t.isLogicalExpression(_optionalChain([path2, 'access', _70 => _70.parentPath, 'optionalAccess', _71 => _71.parent])))) {
+          if (t.isBinaryExpression(path2.parent) && (t.isConditionalExpression(_optionalChain([path2, 'access', _70 => _70.parentPath, 'optionalAccess', _71 => _71.parent])) || t.isLogicalExpression(_optionalChain([path2, 'access', _72 => _72.parentPath, 'optionalAccess', _73 => _73.parent])))) {
             return;
           }
           jsTokenUpdater.addToken(
@@ -2071,7 +2242,7 @@ async function customTemplateHandler(rawSource, options) {
         }
         const lowerName = name.toLowerCase();
         const shouldHandleDefault = !disabledDefaultTemplateHandler && (lowerName === "class" || lowerName === "hover-class" || lowerName === "virtualhostclass");
-        const shouldHandleCustom = _nullishCoalesce(_optionalChain([matchCustomAttribute, 'optionalCall', _72 => _72(tag, name)]), () => ( false));
+        const shouldHandleCustom = _nullishCoalesce(_optionalChain([matchCustomAttribute, 'optionalCall', _74 => _74(tag, name)]), () => ( false));
         if (!shouldHandleDefault && !shouldHandleCustom) {
           return;
         }
@@ -2266,20 +2437,20 @@ async function clearTailwindcssPatcherCache(patcher, options) {
   if (!patcher) {
     return;
   }
-  const cacheOptions = _optionalChain([patcher, 'access', _73 => _73.options, 'optionalAccess', _74 => _74.cache]);
+  const cacheOptions = _optionalChain([patcher, 'access', _75 => _75.options, 'optionalAccess', _76 => _76.cache]);
   if (cacheOptions == null || typeof cacheOptions === "object" && cacheOptions.enabled === false) {
     return;
   }
   const cachePaths = /* @__PURE__ */ new Map();
   const normalizedCacheOptions = typeof cacheOptions === "object" ? cacheOptions : void 0;
-  if (_optionalChain([normalizedCacheOptions, 'optionalAccess', _75 => _75.path])) {
+  if (_optionalChain([normalizedCacheOptions, 'optionalAccess', _77 => _77.path])) {
     cachePaths.set(normalizedCacheOptions.path, false);
   }
-  const privateCachePath = _optionalChain([patcher, 'optionalAccess', _76 => _76.cacheStore, 'optionalAccess', _77 => _77.options, 'optionalAccess', _78 => _78.path]);
+  const privateCachePath = _optionalChain([patcher, 'optionalAccess', _78 => _78.cacheStore, 'optionalAccess', _79 => _79.options, 'optionalAccess', _80 => _80.path]);
   if (privateCachePath) {
     cachePaths.set(privateCachePath, false);
   }
-  if (_optionalChain([options, 'optionalAccess', _79 => _79.removeDirectory]) && _optionalChain([normalizedCacheOptions, 'optionalAccess', _80 => _80.dir])) {
+  if (_optionalChain([options, 'optionalAccess', _81 => _81.removeDirectory]) && _optionalChain([normalizedCacheOptions, 'optionalAccess', _82 => _82.dir])) {
     cachePaths.set(normalizedCacheOptions.dir, true);
   }
   if (!cachePaths.size) {
@@ -2290,14 +2461,14 @@ async function clearTailwindcssPatcherCache(patcher, options) {
       await _promises.rm.call(void 0, cachePath, { force: true, recursive });
     } catch (error) {
       const err = error;
-      if (_optionalChain([err, 'optionalAccess', _81 => _81.code]) === "ENOENT") {
+      if (_optionalChain([err, 'optionalAccess', _83 => _83.code]) === "ENOENT") {
         continue;
       }
       _logger.logger.debug("failed to clear tailwindcss patcher cache: %s %O", cachePath, err);
     }
   }
 }
-function getCompilerContext(opts) {
+function createInternalCompilerContext(opts) {
   const ctx = _chunkUW3WHSZ5js.defuOverrideArray.call(void 0, 
     opts,
     _chunkSMYOFNHJjs.getDefaultOptions.call(void 0, ),
@@ -2305,9 +2476,9 @@ function getCompilerContext(opts) {
   );
   ctx.escapeMap = ctx.customReplaceDictionary;
   applyLoggerLevel(ctx.logLevel);
-  const twPatcher = _chunkHPUZNQ4Gjs.createTailwindcssPatcherFromContext.call(void 0, ctx);
+  const twPatcher = _chunkKMCQEHJMjs.createTailwindcssPatcherFromContext.call(void 0, ctx);
   logTailwindcssTarget("runtime", twPatcher, ctx.tailwindcssBasedir);
-  if (_optionalChain([twPatcher, 'access', _82 => _82.packageInfo, 'optionalAccess', _83 => _83.version])) {
+  if (_optionalChain([twPatcher, 'access', _84 => _84.packageInfo, 'optionalAccess', _85 => _85.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`);
@@ -2331,11 +2502,11 @@ function getCompilerContext(opts) {
   ctx.twPatcher = twPatcher;
   const refreshTailwindcssPatcher = async (options) => {
     const previousPatcher = ctx.twPatcher;
-    if (_optionalChain([options, 'optionalAccess', _84 => _84.clearCache]) !== false) {
+    if (_optionalChain([options, 'optionalAccess', _86 => _86.clearCache]) !== false) {
       await clearTailwindcssPatcherCache(previousPatcher);
     }
     invalidateRuntimeClassSet(previousPatcher);
-    const nextPatcher = _chunkHPUZNQ4Gjs.createTailwindcssPatcherFromContext.call(void 0, ctx);
+    const nextPatcher = _chunkKMCQEHJMjs.createTailwindcssPatcherFromContext.call(void 0, ctx);
     Object.assign(previousPatcher, nextPatcher);
     ctx.twPatcher = previousPatcher;
     return previousPatcher;
@@ -2347,6 +2518,9 @@ function getCompilerContext(opts) {
   });
   return ctx;
 }
+function getCompilerContext(opts) {
+  return withCompilerContextCache(opts, () => createInternalCompilerContext(opts));
+}
 
 
 

package/dist/{chunk-DMJK47DW.mjs → chunk-BTPDRSHI.mjs}

@@ -5,7 +5,7 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
-// ../../node_modules/.pnpm/tsup@8.5.1_@microsoft+api-extractor@7.53.1_@types+node@24.10.1__@swc+core@1.15.1_@swc+h_d92aa008e7d0cb6e2dab5bcd2ea8592f/node_modules/tsup/assets/esm_shims.js
+// ../../node_modules/.pnpm/tsup@8.5.1_@microsoft+api-extractor@7.53.1_@types+node@24.10.1__@swc+core@1.15.2_@swc+h_714fe42112a7ecb62f8dfb6a41f9e513/node_modules/tsup/assets/esm_shims.js
 import path from "path";
 import { fileURLToPath } from "url";
 var getFilename = () => fileURLToPath(import.meta.url);

package/dist/{chunk-LJ5AQYTF.js → chunk-GRO26PCL.js}

@@ -7,7 +7,7 @@ var _chunkLTJQUORKjs = require('./chunk-LTJQUORK.js');
 
 
 
-var _chunk6J63FRIYjs = require('./chunk-6J63FRIY.js');
+var _chunkAEIEPXO3js = require('./chunk-AEIEPXO3.js');
 
 // src/bundlers/gulp/index.ts
 var _buffer = require('buffer');
@@ -15,21 +15,21 @@ var _fs = require('fs'); var _fs2 = _interopRequireDefault(_fs);
 var _path = require('path'); var _path2 = _interopRequireDefault(_path);
 var _process = require('process'); var _process2 = _interopRequireDefault(_process);
 var _stream = require('stream'); var _stream2 = _interopRequireDefault(_stream);
-var debug = _chunk6J63FRIYjs.createDebug.call(void 0, );
+var debug = _chunkAEIEPXO3js.createDebug.call(void 0, );
 var Transform = _stream2.default.Transform;
 function createPlugins(options = {}) {
-  const opts = _chunk6J63FRIYjs.getCompilerContext.call(void 0, options);
+  const opts = _chunkAEIEPXO3js.getCompilerContext.call(void 0, options);
   const { templateHandler, styleHandler, jsHandler, cache, twPatcher: initialTwPatcher, refreshTailwindcssPatcher } = opts;
   let runtimeSet = /* @__PURE__ */ new Set();
   const runtimeState = {
     twPatcher: initialTwPatcher,
-    patchPromise: _chunk6J63FRIYjs.createTailwindPatchPromise.call(void 0, initialTwPatcher),
+    patchPromise: _chunkAEIEPXO3js.createTailwindPatchPromise.call(void 0, initialTwPatcher),
     refreshTailwindcssPatcher
   };
   const MODULE_EXTENSIONS = [".js", ".mjs", ".cjs", ".ts", ".tsx", ".jsx"];
   let runtimeSetInitialized = false;
   async function refreshRuntimeState(force) {
-    await _chunk6J63FRIYjs.refreshTailwindRuntimeState.call(void 0, runtimeState, force);
+    await _chunkAEIEPXO3js.refreshTailwindRuntimeState.call(void 0, runtimeState, force);
   }
   async function refreshRuntimeSet(force = false) {
     await refreshRuntimeState(force);
@@ -37,7 +37,7 @@ function createPlugins(options = {}) {
     if (!force && runtimeSetInitialized && runtimeSet.size > 0) {
       return runtimeSet;
     }
-    runtimeSet = await _chunk6J63FRIYjs.collectRuntimeClassSet.call(void 0, runtimeState.twPatcher, { force, skipRefresh: force });
+    runtimeSet = await _chunkAEIEPXO3js.collectRuntimeClassSet.call(void 0, runtimeState.twPatcher, { force, skipRefresh: force });
     runtimeSetInitialized = true;
     return runtimeSet;
   }