weapp-tailwindcss 4.3.3 → 4.4.0-alpha.0

package/dist/{chunk-3KMEJ2LM.js → chunk-AEJDBNAX.js}

@@ -3,20 +3,18 @@
 var _chunkPLMJW644js = require('./chunk-PLMJW644.js');
 
 
-var _chunkA75TB5TEjs = require('./chunk-A75TB5TE.js');
+var _chunkFOSGDQZ7js = require('./chunk-FOSGDQZ7.js');
 
 
 
+var _chunkUW3WHSZ5js = require('./chunk-UW3WHSZ5.js');
 
-var _chunkQXQOYYCRjs = require('./chunk-QXQOYYCR.js');
 
-
-var _chunkO3G5TVNDjs = require('./chunk-O3G5TVND.js');
+var _chunkRBRSMHFSjs = require('./chunk-RBRSMHFS.js');
 
 // src/context/index.ts
 var _logger = require('@weapp-tailwindcss/logger');
 var _mangle = require('@weapp-tailwindcss/mangle');
-var _postcss = require('@weapp-tailwindcss/postcss');
 
 // src/cache/index.ts
 var _lrucache = require('lru-cache');
@@ -28,6 +26,9 @@ function md5Hash(data) {
 }
 
 // src/cache/index.ts
+function isProcessResult(value) {
+  return typeof value === "object" && value !== null && "result" in value;
+}
 function createCache(options) {
   const disabled = options === false;
   const hashMap = /* @__PURE__ */ new Map();
@@ -37,7 +38,7 @@ function createCache(options) {
     ttl: 0,
     ttlAutopurge: false
   });
-  return {
+  const cache = {
     hashMap,
     instance,
     hasHashKey(key) {
@@ -59,47 +60,60 @@ function createCache(options) {
       return md5Hash(message);
     },
     calcHashValueChanged(key, hash) {
-      const hit = this.getHashValue(key);
+      const hit = hashMap.get(key);
       if (hit) {
-        this.setHashValue(key, {
-          // new file should be changed
+        hashMap.set(key, {
           changed: hash !== hit.hash,
-          // new hash
           hash
         });
       } else {
-        this.setHashValue(key, {
-          // new file should be changed
+        hashMap.set(key, {
           changed: true,
           hash
         });
       }
-      return this;
+      return cache;
     },
     has(key) {
       return instance.has(key);
     },
-    async process(key, callback, fallback) {
+    async process({
+      key,
+      hashKey,
+      rawSource,
+      hash,
+      resolveCache,
+      transform,
+      onCacheHit
+    }) {
       if (disabled) {
-        const res = await fallback();
-        if (res) {
-          this.set(res.key, res.source);
-        }
-      } else {
-        const hit = this.getHashValue(key);
-        if (hit && !hit.changed) {
-          const returnFlag = await callback();
-          if (returnFlag !== false) {
-            return;
-          }
-        }
-        const res = await fallback();
-        if (res) {
-          this.set(res.key, res.source);
+        const value2 = await transform();
+        return isProcessResult(value2) ? value2.result : value2;
+      }
+      const cacheHashKey = _nullishCoalesce(hashKey, () => ( key));
+      let hasChanged = true;
+      if (hash != null || rawSource != null) {
+        const nextHash = _nullishCoalesce(hash, () => ( cache.computeHash(rawSource)));
+        cache.calcHashValueChanged(cacheHashKey, nextHash);
+        const entry = cache.getHashValue(cacheHashKey);
+        hasChanged = _nullishCoalesce(_optionalChain([entry, 'optionalAccess', _2 => _2.changed]), () => ( true));
+      }
+      const readCache = _nullishCoalesce(resolveCache, () => ( (() => cache.get(key))));
+      if (!hasChanged) {
+        const cached = readCache();
+        if (cached !== void 0) {
+          await _optionalChain([onCacheHit, 'optionalCall', _3 => _3(cached)]);
+          return cached;
         }
       }
+      const value = await transform();
+      const normalized = isProcessResult(value) ? value : { result: value };
+      const stored = _nullishCoalesce(normalized.cacheValue, () => ( normalized.result));
+      cache.set(key, stored);
+      return normalized.result;
     }
   };
+  return cache;
 }
 function initializeCache(cacheConfig) {
   if (typeof cacheConfig === "boolean" || cacheConfig === void 0) {
@@ -108,6 +122,19 @@ function initializeCache(cacheConfig) {
   return cacheConfig;
 }
 
+// src/context/custom-attributes.ts
+function toCustomAttributesEntities(customAttributes) {
+  if (_chunkUW3WHSZ5js.isMap.call(void 0, customAttributes)) {
+    return [
+      ...customAttributes.entries()
+    ];
+  }
+  return Object.entries(customAttributes);
+}
+
+// src/context/handlers.ts
+var _postcss = require('@weapp-tailwindcss/postcss');
+
 // src/js/babel.ts
 var _escape = require('@ast-core/escape');
 
@@ -121,101 +148,198 @@ function _interopDefaultCompat(e) {
 }
 var traverse = _interopDefaultCompat(_traverse2.default);
 
+// src/utils/nameMatcher.ts
+function createNameMatcher(list, { exact = false } = {}) {
+  if (!list || list.length === 0) {
+    return () => false;
+  }
+  const exactStrings = /* @__PURE__ */ new Set();
+  const fuzzyStrings = [];
+  const regexList = [];
+  for (const item of list) {
+    if (typeof item === "string") {
+      if (exact) {
+        exactStrings.add(item);
+      } else {
+        fuzzyStrings.push(item);
+      }
+    } else {
+      regexList.push(item);
+    }
+  }
+  return (value) => {
+    if (exact && exactStrings.has(value)) {
+      return true;
+    }
+    if (!exact) {
+      for (const candidate of fuzzyStrings) {
+        if (value.includes(candidate)) {
+          return true;
+        }
+      }
+    }
+    for (const regex of regexList) {
+      regex.lastIndex = 0;
+      if (regex.test(value)) {
+        return true;
+      }
+    }
+    return false;
+  };
+}
+
 // src/js/handlers.ts
 
 var _regex = require('@weapp-core/regex');
 var _extractors = require('@weapp-tailwindcss/shared/extractors');
 
 // src/utils/decode.ts
+var unicodeEscapeRE = /\\u([\dA-Fa-f]{4})/g;
+function decodeUnicode(value) {
+  return value.replace(unicodeEscapeRE, (_match, hex) => {
+    const codePoint = Number.parseInt(hex, 16);
+    return Number.isNaN(codePoint) ? _match : String.fromCharCode(codePoint);
+  });
+}
 function decodeUnicode2(input) {
   try {
     return JSON.parse(`"${input}"`);
   } catch (_error) {
-    return input;
+    return decodeUnicode(input);
   }
 }
 
 // src/js/handlers.ts
+function hasIgnoreComment(node) {
+  return Array.isArray(node.leadingComments) && node.leadingComments.some((comment) => comment.value.includes("weapp-tw") && comment.value.includes("ignore"));
+}
+function shouldTransformClassName(candidate, {
+  alwaysEscape,
+  classNameSet,
+  jsPreserveClass
+}) {
+  if (alwaysEscape) {
+    return true;
+  }
+  if (!classNameSet) {
+    return false;
+  }
+  if (!classNameSet.has(candidate)) {
+    return false;
+  }
+  return !_optionalChain([jsPreserveClass, 'optionalCall', _4 => _4(candidate)]);
+}
+function extractLiteralValue(path2, { unescapeUnicode, arbitraryValues }) {
+  const allowDoubleQuotes = _optionalChain([arbitraryValues, 'optionalAccess', _5 => _5.allowDoubleQuotes]);
+  let offset = 0;
+  let original;
+  if (path2.isStringLiteral()) {
+    offset = 1;
+    original = path2.node.value;
+  } else if (path2.isTemplateElement()) {
+    original = path2.node.value.raw;
+  } else {
+    original = "";
+  }
+  let literal = original;
+  if (unescapeUnicode && original.includes("\\u")) {
+    literal = decodeUnicode2(original);
+  }
+  return {
+    allowDoubleQuotes,
+    literal,
+    offset,
+    original
+  };
+}
 function replaceHandleValue(path2, options) {
   const {
-    classNameSet,
     escapeMap,
-    mangleContext: ctx,
-    needEscaped = false,
-    jsPreserveClass,
-    arbitraryValues,
-    alwaysEscape,
-    unescapeUnicode
+    mangleContext,
+    needEscaped = false
   } = options;
-  const allowDoubleQuotes = _optionalChain([arbitraryValues, 'optionalAccess', _2 => _2.allowDoubleQuotes]);
-  const offset = path2.isStringLiteral() ? 1 : 0;
-  const str = path2.isStringLiteral() ? path2.node.value : path2.isTemplateElement() ? path2.node.value.raw : "";
-  let rawStr = str;
-  let needUpdate = false;
-  if (unescapeUnicode && rawStr.includes("\\u")) {
-    rawStr = decodeUnicode2(rawStr);
+  const { literal, original, allowDoubleQuotes, offset } = extractLiteralValue(path2, options);
+  if (hasIgnoreComment(path2.node)) {
+    return void 0;
   }
-  const node = path2.node;
-  const arr = _extractors.splitCode.call(void 0, rawStr, allowDoubleQuotes);
-  for (const v of arr) {
-    if (alwaysEscape || classNameSet && classNameSet.has(v) && !_optionalChain([jsPreserveClass, 'optionalCall', _3 => _3(v)])) {
-      let ignoreFlag = false;
-      if (Array.isArray(node.leadingComments)) {
-        ignoreFlag = node.leadingComments.findIndex((x) => x.value.includes("weapp-tw") && x.value.includes("ignore")) > -1;
-      }
-      if (!ignoreFlag) {
-        if (ctx) {
-          rawStr = ctx.jsHandler(rawStr);
-        }
-        rawStr = rawStr.replace(
-          new RegExp(_regex.escapeStringRegexp.call(void 0, v)),
-          _chunkPLMJW644js.replaceWxml.call(void 0, v, {
-            escapeMap
-          })
-        );
-        needUpdate = true;
+  const candidates = _extractors.splitCode.call(void 0, literal, allowDoubleQuotes);
+  if (candidates.length === 0) {
+    return void 0;
+  }
+  let transformed = literal;
+  let mutated = false;
+  const replacementCache = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    if (!shouldTransformClassName(candidate, options)) {
+      continue;
+    }
+    if (mangleContext) {
+      const mangled = mangleContext.jsHandler(transformed);
+      if (mangled !== transformed) {
+        transformed = mangled;
+        mutated = true;
       }
     }
-  }
-  if (needUpdate && typeof node.start === "number" && typeof node.end === "number") {
-    const start = node.start + offset;
-    const end = node.end - offset;
-    if (start < end && str !== rawStr) {
-      const value = needEscaped ? _escape.jsStringEscape.call(void 0, rawStr) : rawStr;
-      return {
-        start,
-        end,
-        value,
-        path: path2
+    if (!transformed.includes(candidate)) {
+      continue;
+    }
+    let cached = replacementCache.get(candidate);
+    if (!cached) {
+      cached = {
+        pattern: new RegExp(_regex.escapeStringRegexp.call(void 0, candidate)),
+        replacement: _chunkPLMJW644js.replaceWxml.call(void 0, candidate, { escapeMap })
       };
+      replacementCache.set(candidate, cached);
     }
+    const { pattern, replacement } = cached;
+    const replaced = transformed.replace(pattern, replacement);
+    if (replaced !== transformed) {
+      transformed = replaced;
+      mutated = true;
+    }
+  }
+  const node = path2.node;
+  if (!mutated || typeof node.start !== "number" || typeof node.end !== "number") {
+    return void 0;
   }
+  const start = node.start + offset;
+  const end = node.end - offset;
+  if (start >= end || transformed === original) {
+    return void 0;
+  }
+  const value = needEscaped ? _escape.jsStringEscape.call(void 0, transformed) : transformed;
+  return {
+    start,
+    end,
+    value,
+    path: path2
+  };
 }
 
 // src/js/JsTokenUpdater.ts
 var JsTokenUpdater = class {
   constructor({ value } = {}) {
-    this.value = _nullishCoalesce(value, () => ( []));
+    this.tokens = value ? [...value] : [];
   }
   addToken(token) {
     if (token) {
-      this.value.push(token);
+      this.tokens.push(token);
     }
   }
   push(...args) {
-    this.value.push(...args);
+    this.tokens.push(...args);
     return this;
   }
   map(callbackfn) {
-    this.value = this.value.map(callbackfn);
+    this.tokens = this.tokens.map(callbackfn);
     return this;
   }
   filter(callbackfn) {
-    this.value = this.value.filter(callbackfn);
+    this.tokens = this.tokens.filter(callbackfn);
     return this;
   }
   updateMagicString(ms) {
-    for (const { start, end, value } of this.value) {
+    for (const { start, end, value } of this.tokens) {
       ms.update(start, end, value);
     }
     return ms;
@@ -223,13 +347,14 @@ var JsTokenUpdater = class {
 };
 
 // src/js/NodePathWalker.ts
-var walkedBindingWeakMap = /* @__PURE__ */ new WeakMap();
 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 });
   }
   walkVariableDeclarator(path2) {
     const init = path2.get("init");
@@ -276,10 +401,10 @@ var NodePathWalker = class {
     }
   }
   walkNode(arg) {
-    if (walkedBindingWeakMap.get(arg)) {
+    if (this.visited.has(arg)) {
       return;
     }
-    walkedBindingWeakMap.set(arg, true);
+    this.visited.add(arg);
     if (arg.isIdentifier()) {
       const binding = arg.scope.getBinding(arg.node.name);
       if (binding) {
@@ -339,14 +464,11 @@ var NodePathWalker = class {
     }
   }
   /**
-   * @description main 方法
-   * @param path
+   * Walk the arguments of a desired call expression so their bindings can be analysed.
    */
   walkCallExpression(path2) {
     const calleePath = path2.get("callee");
-    if (calleePath.isIdentifier() && _chunkQXQOYYCRjs.regExpTest.call(void 0, this.ignoreCallExpressionIdentifiers, calleePath.node.name, {
-      exact: true
-    })) {
+    if (calleePath.isIdentifier() && this.isIgnoredCallIdentifier(calleePath.node.name)) {
       for (const arg of path2.get("arguments")) {
         this.walkNode(arg);
       }
@@ -434,19 +556,88 @@ function isEvalPath(p) {
   }
   return false;
 }
-var ignoreFlagMap = /* @__PURE__ */ new WeakMap();
+function createEvalReplacementToken(path2, updated) {
+  const node = path2.node;
+  let offset = 0;
+  let original;
+  if (path2.isStringLiteral()) {
+    offset = 1;
+    original = path2.node.value;
+  } else if (path2.isTemplateElement()) {
+    original = path2.node.value.raw;
+  } else {
+    original = "";
+  }
+  if (typeof node.start !== "number" || typeof node.end !== "number") {
+    return void 0;
+  }
+  const start = node.start + offset;
+  const end = node.end - offset;
+  if (start >= end) {
+    return void 0;
+  }
+  if (original === updated) {
+    return void 0;
+  }
+  const value = path2.isStringLiteral() ? _escape.jsStringEscape.call(void 0, updated) : updated;
+  return {
+    start,
+    end,
+    value,
+    path: path2
+  };
+}
+function handleEvalStringLiteral(path2, options, updater) {
+  const { code } = jsHandler(path2.node.value, {
+    ...options,
+    needEscaped: false,
+    generateMap: false
+  });
+  if (!code) {
+    return;
+  }
+  const token = createEvalReplacementToken(path2, code);
+  if (token) {
+    updater.addToken(token);
+  }
+}
+function handleEvalTemplateElement(path2, options, updater) {
+  const { code } = jsHandler(path2.node.value.raw, {
+    ...options,
+    generateMap: false
+  });
+  if (!code) {
+    return;
+  }
+  const token = createEvalReplacementToken(path2, code);
+  if (token) {
+    updater.addToken(token);
+  }
+}
+function walkEvalExpression(path2, options, updater) {
+  path2.traverse({
+    StringLiteral(innerPath) {
+      handleEvalStringLiteral(innerPath, options, updater);
+    },
+    TemplateElement(innerPath) {
+      handleEvalTemplateElement(innerPath, options, updater);
+    }
+  });
+}
 function analyzeSource(ast, options) {
   const jsTokenUpdater = new JsTokenUpdater();
+  const ignoredPaths = /* @__PURE__ */ new WeakSet();
   const walker = new NodePathWalker(
     {
       ignoreCallExpressionIdentifiers: options.ignoreCallExpressionIdentifiers,
       callback(path2) {
         if (path2.isStringLiteral() || path2.isTemplateElement()) {
-          ignoreFlagMap.set(path2, true);
+          ignoredPaths.add(path2);
         }
       }
     }
   );
+  const isIgnoredTaggedTemplate = createNameMatcher(options.ignoreTaggedTemplateExpressionIdentifiers, { exact: true });
   const targetPaths = [];
   const importDeclarations = /* @__PURE__ */ new Set();
   const exportDeclarations = /* @__PURE__ */ new Set();
@@ -469,7 +660,7 @@ function analyzeSource(ast, options) {
           }
           if (ppp.isTaggedTemplateExpression()) {
             const tagPath = ppp.get("tag");
-            if (tagPath.isIdentifier() && _chunkQXQOYYCRjs.regExpTest.call(void 0, _nullishCoalesce(options.ignoreTaggedTemplateExpressionIdentifiers, () => ( [])), tagPath.node.name, { exact: true })) {
+            if (tagPath.isIdentifier() && isIgnoredTaggedTemplate(tagPath.node.name)) {
               return;
             }
           }
@@ -480,59 +671,7 @@ function analyzeSource(ast, options) {
     CallExpression: {
       enter(p) {
         if (isEvalPath(p)) {
-          p.traverse({
-            StringLiteral: {
-              enter(path2) {
-                const { code } = jsHandler(path2.node.value, {
-                  ...options,
-                  needEscaped: false,
-                  generateMap: false
-                });
-                if (code) {
-                  const node = path2.node;
-                  if (typeof node.start === "number" && typeof node.end === "number") {
-                    const start = node.start + 1;
-                    const end = node.end - 1;
-                    if (start < end && path2.node.value !== code) {
-                      jsTokenUpdater.addToken(
-                        {
-                          start,
-                          end,
-                          value: _escape.jsStringEscape.call(void 0, code),
-                          path: path2
-                        }
-                      );
-                    }
-                  }
-                }
-              }
-            },
-            TemplateElement: {
-              enter(path2) {
-                const { code } = jsHandler(path2.node.value.raw, {
-                  ...options,
-                  generateMap: false
-                });
-                if (code) {
-                  const node = path2.node;
-                  if (typeof node.start === "number" && typeof node.end === "number") {
-                    const start = node.start;
-                    const end = node.end;
-                    if (start < end && path2.node.value.raw !== code) {
-                      jsTokenUpdater.addToken(
-                        {
-                          start,
-                          end,
-                          value: code,
-                          path: path2
-                        }
-                      );
-                    }
-                  }
-                }
-              }
-            }
-          });
+          walkEvalExpression(p, options, jsTokenUpdater);
           return;
         }
         walker.walkCallExpression(p);
@@ -556,46 +695,30 @@ function analyzeSource(ast, options) {
     ast,
     targetPaths,
     importDeclarations,
-    exportDeclarations
-    // jsTokens,
+    exportDeclarations,
+    ignoredPaths
   };
 }
 function processUpdatedSource(rawSource, options, analysis) {
   const ms = new (0, _magicstring2.default)(rawSource);
-  const { targetPaths, jsTokenUpdater } = analysis;
-  const tokens = targetPaths.filter(
-    (x) => {
-      return !ignoreFlagMap.get(x);
+  const { targetPaths, jsTokenUpdater, ignoredPaths } = analysis;
+  const replacementTokens = [];
+  for (const path2 of targetPaths) {
+    if (ignoredPaths.has(path2)) {
+      continue;
     }
-  ).map(
-    (p) => {
-      if (p.isStringLiteral()) {
-        return replaceHandleValue(
-          p,
-          {
-            ...options,
-            needEscaped: _nullishCoalesce(options.needEscaped, () => ( true))
-          }
-        );
-      } else if (p.isTemplateElement()) {
-        return replaceHandleValue(
-          p,
-          {
-            ...options,
-            needEscaped: false
-          }
-        );
+    const token = replaceHandleValue(
+      path2,
+      {
+        ...options,
+        needEscaped: path2.isStringLiteral() ? _nullishCoalesce(options.needEscaped, () => ( true)) : false
       }
-      return void 0;
-    }
-  ).filter(Boolean);
-  jsTokenUpdater.push(
-    ...tokens
-  ).filter(
-    (x) => {
-      return !ignoreFlagMap.get(x.path);
+    );
+    if (token) {
+      replacementTokens.push(token);
     }
-  ).updateMagicString(ms);
+  }
+  jsTokenUpdater.push(...replacementTokens).filter((token) => !ignoredPaths.has(token.path)).updateMagicString(ms);
   return ms;
 }
 function jsHandler(rawSource, options) {
@@ -632,69 +755,69 @@ function createJsHandler(options) {
     uniAppX
   } = options;
   function handler(rawSource, classNameSet, options2) {
-    const opts = _chunkQXQOYYCRjs.defuOverrideArray.call(void 0, options2, {
-      classNameSet,
-      escapeMap,
-      arbitraryValues,
-      mangleContext,
-      jsPreserveClass,
-      generateMap,
-      babelParserOptions,
-      ignoreCallExpressionIdentifiers,
-      ignoreTaggedTemplateExpressionIdentifiers,
-      uniAppX
-    });
-    return jsHandler(rawSource, opts);
+    const overrideOptions = _nullishCoalesce(options2, () => ( {}));
+    const resolvedOptions = _chunkUW3WHSZ5js.defuOverrideArray.call(void 0, 
+      {
+        ...overrideOptions,
+        classNameSet
+      },
+      {
+        classNameSet,
+        escapeMap,
+        arbitraryValues,
+        mangleContext,
+        jsPreserveClass,
+        generateMap,
+        babelParserOptions,
+        ignoreCallExpressionIdentifiers,
+        ignoreTaggedTemplateExpressionIdentifiers,
+        uniAppX
+      }
+    );
+    return jsHandler(rawSource, resolvedOptions);
   }
   return handler;
 }
 
-// src/tailwindcss/index.ts
-var _localpkg = require('local-pkg');
-
-// src/tailwindcss/patcher.ts
-var _path = require('path'); var _path2 = _interopRequireDefault(_path);
-var _process = require('process'); var _process2 = _interopRequireDefault(_process);
-var _shared = require('@weapp-tailwindcss/shared');
-var _tailwindcsspatch = require('tailwindcss-patch');
-function createTailwindcssPatcher(options) {
-  const { basedir, cacheDir, supportCustomLengthUnitsPatch, tailwindcss, tailwindcssPatcherOptions } = options || {};
-  const cache = {};
-  if (cacheDir) {
-    if (_path2.default.isAbsolute(cacheDir)) {
-      cache.dir = cacheDir;
-    } else if (basedir) {
-      cache.dir = _path2.default.resolve(basedir, cacheDir);
-    } else {
-      cache.dir = _path2.default.resolve(_process2.default.cwd(), cacheDir);
-    }
-  }
-  return new (0, _tailwindcsspatch.TailwindcssPatcher)(_shared.defuOverrideArray.call(void 0, 
-    tailwindcssPatcherOptions,
-    {
-      cache,
-      patch: {
-        basedir,
-        applyPatches: {
-          exportContext: true,
-          extendLengthUnits: supportCustomLengthUnitsPatch
-        },
-        tailwindcss,
-        resolve: {
-          paths: [
-            _chunkO3G5TVNDjs.importMetaUrl
-          ]
-        }
-      }
-    }
-  ));
-}
-
 // src/wxml/utils.ts
 var _types = require('@babel/types'); var t = _interopRequireWildcard(_types);
 var _htmlparser2 = require('htmlparser2');
 
 
+// src/wxml/whitespace.ts
+var WHITESPACE_CODES = /* @__PURE__ */ new Set([
+  9,
+  // \t
+  10,
+  // \n
+  11,
+  // \v
+  12,
+  // \f
+  13,
+  // \r
+  32,
+  // space
+  160,
+  // \u00A0
+  65279
+  // \uFEFF
+]);
+function isWhitespace(char) {
+  if (char.length === 0) {
+    return false;
+  }
+  return WHITESPACE_CODES.has(char.charCodeAt(0));
+}
+function isAllWhitespace(value) {
+  for (let i = 0; i < value.length; i++) {
+    if (!WHITESPACE_CODES.has(value.charCodeAt(i))) {
+      return false;
+    }
+  }
+  return true;
+}
+
 // src/wxml/Tokenizer.ts
 var Tokenizer = class {
   constructor() {
@@ -703,7 +826,7 @@ var Tokenizer = class {
   processChar(char, index) {
     switch (this.state) {
       case 0 /* START */:
-        if (this.isWhitespace(char)) {
+        if (isWhitespace(char)) {
         } else if (char === "{") {
           this.state = 2 /* OPEN_BRACE */;
           this.bufferStartIndex = index;
@@ -717,7 +840,7 @@ var Tokenizer = class {
         }
         break;
       case 1 /* TEXT */:
-        if (this.isWhitespace(char)) {
+        if (isWhitespace(char)) {
           this.tokens.push({ start: this.bufferStartIndex, end: index, value: this.buffer, expressions: this.expressions });
           this.buffer = "";
           this.expressions = [];
@@ -759,7 +882,7 @@ var Tokenizer = class {
         }
         break;
       case 4 /* BRACES_COMPLETE */:
-        if (this.isWhitespace(char)) {
+        if (isWhitespace(char)) {
           this.tokens.push({
             start: this.bufferStartIndex,
             end: index,
@@ -797,9 +920,9 @@ var Tokenizer = class {
         expressions: this.expressions
       });
     }
-    const result = this.tokens.slice();
+    const tokens = this.tokens;
     this.reset();
-    return result;
+    return tokens;
   }
   reset() {
     this.state = 0 /* START */;
@@ -810,9 +933,6 @@ var Tokenizer = class {
     this.expressionStartIndex = 0;
     this.expressions = [];
   }
-  isWhitespace(char) {
-    return /\s/.test(char);
-  }
 };
 
 // src/wxml/utils.ts
@@ -831,7 +951,7 @@ function generateCode(match, options = {}) {
           if (t.isMemberExpression(path2.parent)) {
             return;
           }
-          if (t.isBinaryExpression(path2.parent) && (t.isConditionalExpression(_optionalChain([path2, 'access', _4 => _4.parentPath, 'optionalAccess', _5 => _5.parent])) || t.isLogicalExpression(_optionalChain([path2, 'access', _6 => _6.parentPath, 'optionalAccess', _7 => _7.parent])))) {
+          if (t.isBinaryExpression(path2.parent) && (t.isConditionalExpression(_optionalChain([path2, 'access', _6 => _6.parentPath, 'optionalAccess', _7 => _7.parent])) || t.isLogicalExpression(_optionalChain([path2, 'access', _8 => _8.parentPath, 'optionalAccess', _9 => _9.parent])))) {
             return;
           }
           jsTokenUpdater.addToken(
@@ -861,7 +981,7 @@ function handleEachClassFragment(ms, tokens, options = {}) {
   for (const token of tokens) {
     if (token.start > previousEnd) {
       const gap = ms.slice(previousEnd, token.start);
-      if (gap.trim() === "") {
+      if (isAllWhitespace(gap)) {
         ms.update(previousEnd, token.start, _chunkPLMJW644js.replaceWxml.call(void 0, gap, {
           keepEOL: false,
           escapeMap: options.escapeMap,
@@ -909,7 +1029,7 @@ function handleEachClassFragment(ms, tokens, options = {}) {
     const lastToken = tokens[tokens.length - 1];
     if (lastToken.end < ms.original.length) {
       const gap = ms.slice(lastToken.end, ms.original.length);
-      if (gap.trim() === "") {
+      if (isAllWhitespace(gap)) {
         ms.update(lastToken.end, ms.original.length, _chunkPLMJW644js.replaceWxml.call(void 0, gap, {
           keepEOL: false,
           escapeMap: options.escapeMap,
@@ -933,10 +1053,15 @@ function regTest(reg, str) {
 }
 function isPropsMatch(props, attr) {
   if (Array.isArray(props)) {
+    let lowerAttr;
     for (const prop of props) {
-      const res = typeof prop === "string" ? prop.toLowerCase() === attr.toLowerCase() : regTest(prop, attr);
-      if (res) {
-        return res;
+      if (typeof prop === "string") {
+        _nullishCoalesce(lowerAttr, () => ( (lowerAttr = attr.toLowerCase())));
+        if (prop.toLowerCase() === lowerAttr) {
+          return true;
+        }
+      } else if (regTest(prop, attr)) {
+        return true;
       }
     }
     return false;
@@ -954,6 +1079,23 @@ async function customTemplateHandler(rawSource, options) {
     runtimeSet,
     jsHandler: jsHandler2
   } = _nullishCoalesce(options, () => ( {}));
+  const wildcardAttributeRules = [];
+  const tagAttributeRuleMap = /* @__PURE__ */ new Map();
+  const regexpAttributeRules = [];
+  for (const [selector, props] of customAttributesEntities) {
+    if (selector === "*") {
+      wildcardAttributeRules.push(props);
+    } else if (typeof selector === "string") {
+      const list = tagAttributeRuleMap.get(selector);
+      if (list) {
+        list.push(props);
+      } else {
+        tagAttributeRuleMap.set(selector, [props]);
+      }
+    } else {
+      regexpAttributeRules.push([selector, props]);
+    }
+  }
   const s = new (0, _magicstring2.default)(rawSource);
   let tag = "";
   const wxsArray = [];
@@ -964,7 +1106,13 @@ async function customTemplateHandler(rawSource, options) {
       },
       onattribute(name, value, quote) {
         if (value) {
-          let update2 = function() {
+          const lowerName = name.toLowerCase();
+          let updated = false;
+          const update = () => {
+            if (updated) {
+              return;
+            }
+            updated = true;
             s.update(
               parser.startIndex + name.length + 2,
               // !important
@@ -978,21 +1126,34 @@ async function customTemplateHandler(rawSource, options) {
               })
             );
           };
-          var update = update2;
-          if (!disabledDefaultTemplateHandler && ["class", "hover-class", "virtualhostclass"].includes(name.toLocaleLowerCase())) {
-            update2();
+          if (!disabledDefaultTemplateHandler && (lowerName === "class" || lowerName === "hover-class" || lowerName === "virtualhostclass")) {
+            update();
           }
-          for (const [t2, props] of customAttributesEntities) {
-            if (t2 === "*") {
+          if (!updated) {
+            for (const props of wildcardAttributeRules) {
               if (isPropsMatch(props, name)) {
-                update2();
+                update();
+                break;
               }
-            } else if (typeof t2 === "string") {
-              if (t2 === tag && isPropsMatch(props, name)) {
-                update2();
+            }
+          }
+          if (!updated) {
+            const tagRules = tagAttributeRuleMap.get(tag);
+            if (tagRules) {
+              for (const props of tagRules) {
+                if (isPropsMatch(props, name)) {
+                  update();
+                  break;
+                }
+              }
+            }
+          }
+          if (!updated) {
+            for (const [selector, props] of regexpAttributeRules) {
+              if (regTest(selector, tag) && isPropsMatch(props, name)) {
+                update();
+                break;
               }
-            } else if (regTest(t2, tag) && isPropsMatch(props, name)) {
-              update2();
             }
           }
         }
@@ -1024,81 +1185,35 @@ async function customTemplateHandler(rawSource, options) {
 }
 function createTemplateHandler(options = {}) {
   return (rawSource, opt = {}) => {
-    return customTemplateHandler(rawSource, _chunkQXQOYYCRjs.defuOverrideArray.call(void 0, opt, options));
+    return customTemplateHandler(rawSource, _chunkUW3WHSZ5js.defuOverrideArray.call(void 0, opt, options));
   };
 }
 
-// src/context/index.ts
-var loggerLevelMap = {
-  error: 0,
-  warn: 1,
-  info: 3,
-  silent: -999
-};
-function getCompilerContext(opts) {
-  const ctx = _chunkQXQOYYCRjs.defuOverrideArray.call(void 0, 
-    opts,
-    _chunkA75TB5TEjs.getDefaultOptions.call(void 0, ),
-    {}
-  );
-  ctx.escapeMap = ctx.customReplaceDictionary;
+// src/context/handlers.ts
+function createHandlersFromContext(ctx, mangleContext, customAttributesEntities, cssCalcOptions) {
   const {
     cssPreflight,
     customRuleCallback,
     cssPreflightRange,
-    customAttributes,
-    supportCustomLengthUnitsPatch,
-    arbitraryValues,
+    escapeMap,
     cssChildCombinatorReplaceValue,
-    inlineWxs,
     injectAdditionalCssVarScope,
-    jsPreserveClass,
-    disabledDefaultTemplateHandler,
     cssSelectorReplacement,
     rem2rpx,
-    cache,
-    babelParserOptions,
     postcssOptions,
     cssRemoveProperty,
     cssRemoveHoverPseudoClass,
-    escapeMap,
-    mangle,
-    tailwindcssBasedir,
-    appType,
-    ignoreCallExpressionIdentifiers,
-    ignoreTaggedTemplateExpressionIdentifiers,
     cssPresetEnv,
-    tailwindcss,
-    tailwindcssPatcherOptions,
     uniAppX,
-    cssEntries,
-    cssCalc,
     px2rpx,
-    logLevel
+    arbitraryValues,
+    jsPreserveClass,
+    babelParserOptions,
+    ignoreCallExpressionIdentifiers,
+    ignoreTaggedTemplateExpressionIdentifiers,
+    inlineWxs,
+    disabledDefaultTemplateHandler
   } = ctx;
-  _logger.logger.level = _nullishCoalesce(loggerLevelMap[logLevel], () => ( loggerLevelMap.info));
-  const twPatcher = createTailwindcssPatcher(
-    {
-      basedir: tailwindcssBasedir,
-      cacheDir: appType === "mpx" ? "node_modules/tailwindcss-patch/.cache" : void 0,
-      supportCustomLengthUnitsPatch: _nullishCoalesce(supportCustomLengthUnitsPatch, () => ( true)),
-      tailwindcss: _chunkQXQOYYCRjs.defuOverrideArray.call(void 0, 
-        tailwindcss,
-        {
-          v4: {
-            base: tailwindcssBasedir,
-            cssEntries
-          }
-        }
-      ),
-      tailwindcssPatcherOptions
-    }
-  );
-  _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)))}`);
-  const cssCalcOptions = _nullishCoalesce(cssCalc, () => ( twPatcher.majorVersion === 4));
-  const customAttributesEntities = _chunkQXQOYYCRjs.isMap.call(void 0, customAttributes) ? [...customAttributes.entries()] : Object.entries(customAttributes);
-  const { initMangle, mangleContext, setMangleRuntimeSet } = _mangle.useMangleStore.call(void 0, );
-  initMangle(mangle);
   const styleHandler = _postcss.createStyleHandler.call(void 0, {
     cssPreflight,
     customRuleCallback,
@@ -1136,11 +1251,121 @@ function getCompilerContext(opts) {
     jsHandler: jsHandler2,
     disabledDefaultTemplateHandler
   });
+  return {
+    styleHandler,
+    jsHandler: jsHandler2,
+    templateHandler
+  };
+}
+
+// src/context/logger.ts
+
+var loggerLevelMap = {
+  error: 0,
+  warn: 1,
+  info: 3,
+  silent: -999
+};
+function applyLoggerLevel(logLevel) {
+  _logger.logger.level = _nullishCoalesce(loggerLevelMap[_nullishCoalesce(logLevel, () => ( "info"))], () => ( loggerLevelMap.info));
+}
+
+// src/tailwindcss/index.ts
+var _localpkg = require('local-pkg');
+
+// src/tailwindcss/patcher.ts
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+var _process = require('process'); var _process2 = _interopRequireDefault(_process);
+var _shared = require('@weapp-tailwindcss/shared');
+var _tailwindcsspatch = require('tailwindcss-patch');
+function createTailwindcssPatcher(options) {
+  const { basedir, cacheDir, supportCustomLengthUnitsPatch, tailwindcss, tailwindcssPatcherOptions } = options || {};
+  const cache = {};
+  if (cacheDir) {
+    if (_path2.default.isAbsolute(cacheDir)) {
+      cache.dir = cacheDir;
+    } else if (basedir) {
+      cache.dir = _path2.default.resolve(basedir, cacheDir);
+    } else {
+      cache.dir = _path2.default.resolve(_process2.default.cwd(), cacheDir);
+    }
+  }
+  return new (0, _tailwindcsspatch.TailwindcssPatcher)(_shared.defuOverrideArray.call(void 0, 
+    tailwindcssPatcherOptions,
+    {
+      cache,
+      patch: {
+        basedir,
+        applyPatches: {
+          exportContext: true,
+          extendLengthUnits: supportCustomLengthUnitsPatch
+        },
+        tailwindcss,
+        resolve: {
+          paths: [
+            _chunkRBRSMHFSjs.importMetaUrl
+          ]
+        }
+      }
+    }
+  ));
+}
+
+// src/context/tailwindcss.ts
+function createTailwindcssPatcherFromContext(ctx) {
+  const {
+    tailwindcssBasedir,
+    supportCustomLengthUnitsPatch,
+    tailwindcss,
+    tailwindcssPatcherOptions,
+    cssEntries,
+    appType
+  } = ctx;
+  return createTailwindcssPatcher(
+    {
+      basedir: tailwindcssBasedir,
+      cacheDir: appType === "mpx" ? "node_modules/tailwindcss-patch/.cache" : void 0,
+      supportCustomLengthUnitsPatch: _nullishCoalesce(supportCustomLengthUnitsPatch, () => ( true)),
+      tailwindcss: _chunkUW3WHSZ5js.defuOverrideArray.call(void 0, 
+        tailwindcss,
+        {
+          v4: {
+            base: tailwindcssBasedir,
+            cssEntries
+          }
+        }
+      ),
+      tailwindcssPatcherOptions
+    }
+  );
+}
+
+// src/context/index.ts
+function getCompilerContext(opts) {
+  const ctx = _chunkUW3WHSZ5js.defuOverrideArray.call(void 0, 
+    opts,
+    _chunkFOSGDQZ7js.getDefaultOptions.call(void 0, ),
+    {}
+  );
+  ctx.escapeMap = ctx.customReplaceDictionary;
+  applyLoggerLevel(ctx.logLevel);
+  const twPatcher = createTailwindcssPatcherFromContext(ctx);
+  _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)))}`);
+  const cssCalcOptions = _nullishCoalesce(ctx.cssCalc, () => ( twPatcher.majorVersion === 4));
+  const customAttributesEntities = toCustomAttributesEntities(ctx.customAttributes);
+  const { initMangle, mangleContext, setMangleRuntimeSet } = _mangle.useMangleStore.call(void 0, );
+  initMangle(ctx.mangle);
+  const { styleHandler, jsHandler: jsHandler2, templateHandler } = createHandlersFromContext(
+    ctx,
+    mangleContext,
+    customAttributesEntities,
+    cssCalcOptions
+  );
   ctx.styleHandler = styleHandler;
   ctx.jsHandler = jsHandler2;
   ctx.templateHandler = templateHandler;
   ctx.setMangleRuntimeSet = setMangleRuntimeSet;
-  ctx.cache = initializeCache(cache);
+  ctx.cache = initializeCache(ctx.cache);
   ctx.twPatcher = twPatcher;
   return ctx;
 }