weapp-tailwindcss 4.3.3 → 4.4.0-alpha.1

package/dist/{chunk-3KXFKRIX.mjs → chunk-D25XJJMP.mjs}

@@ -3,17 +3,15 @@ import {
 } from "./chunk-Q67IXIAH.mjs";
 import {
   getDefaultOptions
-} from "./chunk-5BTC4YQI.mjs";
+} from "./chunk-IHKVNALD.mjs";
 import {
   defuOverrideArray,
-  isMap,
-  regExpTest
-} from "./chunk-Y5AFAYKI.mjs";
+  isMap
+} from "./chunk-ZNKIYZRQ.mjs";
 
 // src/context/index.ts
-import { logger, pc } from "@weapp-tailwindcss/logger";
+import { logger as logger2, pc } from "@weapp-tailwindcss/logger";
 import { useMangleStore } from "@weapp-tailwindcss/mangle";
-import { createStyleHandler } from "@weapp-tailwindcss/postcss";
 
 // src/cache/index.ts
 import { LRUCache } from "lru-cache";
@@ -25,6 +23,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();
@@ -34,7 +35,7 @@ function createCache(options) {
     ttl: 0,
     ttlAutopurge: false
   });
-  return {
+  const cache = {
     hashMap,
     instance,
     hasHashKey(key) {
@@ -56,47 +57,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 = hashKey ?? key;
+      let hasChanged = true;
+      if (hash != null || rawSource != null) {
+        const nextHash = hash ?? cache.computeHash(rawSource);
+        cache.calcHashValueChanged(cacheHashKey, nextHash);
+        const entry = cache.getHashValue(cacheHashKey);
+        hasChanged = entry?.changed ?? true;
+      }
+      const readCache = resolveCache ?? (() => cache.get(key));
+      if (!hasChanged) {
+        const cached = readCache();
+        if (cached !== void 0) {
+          await onCacheHit?.(cached);
+          return cached;
         }
       }
+      const value = await transform();
+      const normalized = isProcessResult(value) ? value : { result: value };
+      const stored = normalized.cacheValue ?? normalized.result;
+      cache.set(key, stored);
+      return normalized.result;
     }
   };
+  return cache;
 }
 function initializeCache(cacheConfig) {
   if (typeof cacheConfig === "boolean" || cacheConfig === void 0) {
@@ -105,6 +119,19 @@ function initializeCache(cacheConfig) {
   return cacheConfig;
 }
 
+// src/context/custom-attributes.ts
+function toCustomAttributesEntities(customAttributes) {
+  if (isMap(customAttributes)) {
+    return [
+      ...customAttributes.entries()
+    ];
+  }
+  return Object.entries(customAttributes);
+}
+
+// src/context/handlers.ts
+import { createStyleHandler } from "@weapp-tailwindcss/postcss";
+
 // src/js/babel.ts
 import { jsStringEscape as jsStringEscape2 } from "@ast-core/escape";
 import { LRUCache as LRUCache2 } from "lru-cache";
@@ -118,101 +145,250 @@ function _interopDefaultCompat(e) {
 }
 var traverse = _interopDefaultCompat(_babelTraverse);
 
+// src/utils/nameMatcher.ts
+import { escapeStringRegexp } from "@weapp-core/regex";
+function buildFuzzyMatcher(fuzzyStrings) {
+  if (fuzzyStrings.length === 0) {
+    return void 0;
+  }
+  if (fuzzyStrings.length === 1) {
+    const [needle] = fuzzyStrings;
+    return (value) => value.includes(needle);
+  }
+  const unique = [...new Set(fuzzyStrings)];
+  const pattern = new RegExp(unique.map(escapeStringRegexp).join("|"));
+  return (value) => pattern.test(value);
+}
+function normaliseRegex(regex) {
+  const { source, flags } = regex;
+  if (!flags.includes("g")) {
+    return regex;
+  }
+  return new RegExp(source, flags.replace(/g/g, ""));
+}
+function createNameMatcher(list, { exact = false } = {}) {
+  if (!list || list.length === 0) {
+    return () => false;
+  }
+  const exactStrings = exact ? /* @__PURE__ */ new Set() : void 0;
+  const fuzzyStrings = [];
+  const regexList = [];
+  for (const item of list) {
+    if (typeof item === "string") {
+      if (exact) {
+        exactStrings.add(item);
+      } else {
+        fuzzyStrings.push(item);
+      }
+    } else {
+      regexList.push(normaliseRegex(item));
+    }
+  }
+  const fuzzyMatcher = exact ? void 0 : buildFuzzyMatcher(fuzzyStrings);
+  const hasRegex = regexList.length > 0;
+  return (value) => {
+    if (exact && exactStrings?.has(value)) {
+      return true;
+    }
+    if (fuzzyMatcher?.(value)) {
+      return true;
+    }
+    if (!hasRegex) {
+      return false;
+    }
+    return regexList.some((regex) => regex.test(value));
+  };
+}
+
 // src/js/handlers.ts
 import { jsStringEscape } from "@ast-core/escape";
-import { escapeStringRegexp } from "@weapp-core/regex";
+import { escapeStringRegexp as escapeStringRegexp2 } from "@weapp-core/regex";
 import { splitCode } from "@weapp-tailwindcss/shared/extractors";
 
 // src/utils/decode.ts
+var unicodeEscapeRE = /\\u([\dA-Fa-f]{4})/g;
+var unicodeEscapeTestRE = /\\u[\dA-Fa-f]{4}/;
+function decodeUnicode(value) {
+  if (!unicodeEscapeTestRE.test(value)) {
+    return value;
+  }
+  return value.replace(unicodeEscapeRE, (_match, hex) => {
+    const codePoint = Number.parseInt(hex, 16);
+    return Number.isNaN(codePoint) ? _match : String.fromCharCode(codePoint);
+  });
+}
 function decodeUnicode2(input) {
+  if (!unicodeEscapeTestRE.test(input)) {
+    return input;
+  }
   try {
     return JSON.parse(`"${input}"`);
   } catch (_error) {
-    return input;
+    return decodeUnicode(input);
   }
 }
 
 // src/js/handlers.ts
+var patternCache = /* @__PURE__ */ new Map();
+var replacementCacheByEscapeMap = /* @__PURE__ */ new WeakMap();
+var defaultReplacementCache = /* @__PURE__ */ new Map();
+function getPattern(candidate) {
+  let cached = patternCache.get(candidate);
+  if (!cached) {
+    cached = new RegExp(escapeStringRegexp2(candidate));
+    patternCache.set(candidate, cached);
+  }
+  return cached;
+}
+function getReplacement(candidate, escapeMap) {
+  if (!escapeMap) {
+    let cached2 = defaultReplacementCache.get(candidate);
+    if (cached2 === void 0) {
+      cached2 = replaceWxml(candidate, { escapeMap });
+      defaultReplacementCache.set(candidate, cached2);
+    }
+    return cached2;
+  }
+  let store = replacementCacheByEscapeMap.get(escapeMap);
+  if (!store) {
+    store = /* @__PURE__ */ new Map();
+    replacementCacheByEscapeMap.set(escapeMap, store);
+  }
+  let cached = store.get(candidate);
+  if (cached === void 0) {
+    cached = replaceWxml(candidate, { escapeMap });
+    store.set(candidate, cached);
+  }
+  return cached;
+}
+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 !jsPreserveClass?.(candidate);
+}
+function extractLiteralValue(path2, { unescapeUnicode, arbitraryValues }) {
+  const allowDoubleQuotes = arbitraryValues?.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 = arbitraryValues?.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 { classNameSet, alwaysEscape } = options;
+  if (!alwaysEscape && (!classNameSet || classNameSet.size === 0)) {
+    return void 0;
   }
-  const node = path2.node;
-  const arr = splitCode(rawStr, allowDoubleQuotes);
-  for (const v of arr) {
-    if (alwaysEscape || classNameSet && classNameSet.has(v) && !jsPreserveClass?.(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(escapeStringRegexp(v)),
-          replaceWxml(v, {
-            escapeMap
-          })
-        );
-        needUpdate = true;
+  const { literal, original, allowDoubleQuotes, offset } = extractLiteralValue(path2, options);
+  if (hasIgnoreComment(path2.node)) {
+    return void 0;
+  }
+  const candidates = splitCode(literal, allowDoubleQuotes);
+  if (candidates.length === 0) {
+    return void 0;
+  }
+  let transformed = literal;
+  let mutated = false;
+  let normalised = false;
+  for (const candidate of candidates) {
+    if (!shouldTransformClassName(candidate, options)) {
+      continue;
+    }
+    if (mangleContext && !normalised) {
+      const mangled = mangleContext.jsHandler(transformed);
+      if (mangled !== transformed) {
+        transformed = mangled;
+        mutated = true;
       }
+      normalised = 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 ? jsStringEscape(rawStr) : rawStr;
-      return {
-        start,
-        end,
-        value,
-        path: path2
-      };
+    if (!transformed.includes(candidate)) {
+      continue;
+    }
+    const pattern = getPattern(candidate);
+    const replacement = getReplacement(candidate, escapeMap);
+    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 ? jsStringEscape(transformed) : transformed;
+  return {
+    start,
+    end,
+    value,
+    path: path2
+  };
 }
 
 // src/js/JsTokenUpdater.ts
 var JsTokenUpdater = class {
   constructor({ value } = {}) {
-    this.value = 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;
@@ -220,13 +396,14 @@ var JsTokenUpdater = class {
 };
 
 // src/js/NodePathWalker.ts
-var walkedBindingWeakMap = /* @__PURE__ */ new WeakMap();
 var NodePathWalker = class {
   constructor({ ignoreCallExpressionIdentifiers, callback } = {}) {
     this.ignoreCallExpressionIdentifiers = ignoreCallExpressionIdentifiers ?? [];
     this.callback = callback ?? (() => {
     });
     this.imports = /* @__PURE__ */ new Set();
+    this.visited = /* @__PURE__ */ new WeakSet();
+    this.isIgnoredCallIdentifier = createNameMatcher(this.ignoreCallExpressionIdentifiers, { exact: true });
   }
   walkVariableDeclarator(path2) {
     const init = path2.get("init");
@@ -273,10 +450,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) {
@@ -336,14 +513,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() && regExpTest(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);
       }
@@ -431,19 +605,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() ? jsStringEscape2(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();
@@ -466,7 +709,7 @@ function analyzeSource(ast, options) {
           }
           if (ppp.isTaggedTemplateExpression()) {
             const tagPath = ppp.get("tag");
-            if (tagPath.isIdentifier() && regExpTest(options.ignoreTaggedTemplateExpressionIdentifiers ?? [], tagPath.node.name, { exact: true })) {
+            if (tagPath.isIdentifier() && isIgnoredTaggedTemplate(tagPath.node.name)) {
               return;
             }
           }
@@ -477,59 +720,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: jsStringEscape2(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);
@@ -553,46 +744,30 @@ function analyzeSource(ast, options) {
     ast,
     targetPaths,
     importDeclarations,
-    exportDeclarations
-    // jsTokens,
+    exportDeclarations,
+    ignoredPaths
   };
 }
 function processUpdatedSource(rawSource, options, analysis) {
   const ms = new MagicString(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: options.needEscaped ?? true
-          }
-        );
-      } else if (p.isTemplateElement()) {
-        return replaceHandleValue(
-          p,
-          {
-            ...options,
-            needEscaped: false
-          }
-        );
+    const token = replaceHandleValue(
+      path2,
+      {
+        ...options,
+        needEscaped: path2.isStringLiteral() ? 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) {
@@ -629,69 +804,69 @@ function createJsHandler(options) {
     uniAppX
   } = options;
   function handler(rawSource, classNameSet, options2) {
-    const opts = defuOverrideArray(options2, {
-      classNameSet,
-      escapeMap,
-      arbitraryValues,
-      mangleContext,
-      jsPreserveClass,
-      generateMap,
-      babelParserOptions,
-      ignoreCallExpressionIdentifiers,
-      ignoreTaggedTemplateExpressionIdentifiers,
-      uniAppX
-    });
-    return jsHandler(rawSource, opts);
+    const overrideOptions = options2 ?? {};
+    const resolvedOptions = defuOverrideArray(
+      {
+        ...overrideOptions,
+        classNameSet
+      },
+      {
+        classNameSet,
+        escapeMap,
+        arbitraryValues,
+        mangleContext,
+        jsPreserveClass,
+        generateMap,
+        babelParserOptions,
+        ignoreCallExpressionIdentifiers,
+        ignoreTaggedTemplateExpressionIdentifiers,
+        uniAppX
+      }
+    );
+    return jsHandler(rawSource, resolvedOptions);
   }
   return handler;
 }
 
-// src/tailwindcss/index.ts
-import { getPackageInfoSync } from "local-pkg";
-
-// src/tailwindcss/patcher.ts
-import path from "path";
-import process from "process";
-import { defuOverrideArray as defuOverrideArray2 } from "@weapp-tailwindcss/shared";
-import { TailwindcssPatcher } from "tailwindcss-patch";
-function createTailwindcssPatcher(options) {
-  const { basedir, cacheDir, supportCustomLengthUnitsPatch, tailwindcss, tailwindcssPatcherOptions } = options || {};
-  const cache = {};
-  if (cacheDir) {
-    if (path.isAbsolute(cacheDir)) {
-      cache.dir = cacheDir;
-    } else if (basedir) {
-      cache.dir = path.resolve(basedir, cacheDir);
-    } else {
-      cache.dir = path.resolve(process.cwd(), cacheDir);
-    }
-  }
-  return new TailwindcssPatcher(defuOverrideArray2(
-    tailwindcssPatcherOptions,
-    {
-      cache,
-      patch: {
-        basedir,
-        applyPatches: {
-          exportContext: true,
-          extendLengthUnits: supportCustomLengthUnitsPatch
-        },
-        tailwindcss,
-        resolve: {
-          paths: [
-            import.meta.url
-          ]
-        }
-      }
-    }
-  ));
-}
-
 // src/wxml/utils.ts
 import * as t from "@babel/types";
 import { Parser } from "htmlparser2";
 import MagicString2 from "magic-string";
 
+// 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() {
@@ -700,7 +875,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;
@@ -714,7 +889,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 = [];
@@ -756,7 +931,7 @@ var Tokenizer = class {
         }
         break;
       case 4 /* BRACES_COMPLETE */:
-        if (this.isWhitespace(char)) {
+        if (isWhitespace(char)) {
           this.tokens.push({
             start: this.bufferStartIndex,
             end: index,
@@ -794,9 +969,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 */;
@@ -807,9 +982,6 @@ var Tokenizer = class {
     this.expressionStartIndex = 0;
     this.expressions = [];
   }
-  isWhitespace(char) {
-    return /\s/.test(char);
-  }
 };
 
 // src/wxml/utils.ts
@@ -858,7 +1030,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, replaceWxml(gap, {
           keepEOL: false,
           escapeMap: options.escapeMap,
@@ -906,7 +1078,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, replaceWxml(gap, {
           keepEOL: false,
           escapeMap: options.escapeMap,
@@ -930,10 +1102,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") {
+        lowerAttr ?? (lowerAttr = attr.toLowerCase());
+        if (prop.toLowerCase() === lowerAttr) {
+          return true;
+        }
+      } else if (regTest(prop, attr)) {
+        return true;
       }
     }
     return false;
@@ -951,6 +1128,23 @@ async function customTemplateHandler(rawSource, options) {
     runtimeSet,
     jsHandler: jsHandler2
   } = 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 MagicString2(rawSource);
   let tag = "";
   const wxsArray = [];
@@ -961,7 +1155,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
@@ -975,21 +1175,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;
+              }
+            }
+          }
+          if (!updated) {
+            const tagRules = tagAttributeRuleMap.get(tag);
+            if (tagRules) {
+              for (const props of tagRules) {
+                if (isPropsMatch(props, name)) {
+                  update();
+                  break;
+                }
               }
-            } else if (typeof t2 === "string") {
-              if (t2 === tag && isPropsMatch(props, name)) {
-                update2();
+            }
+          }
+          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();
             }
           }
         }
@@ -1025,77 +1238,31 @@ function createTemplateHandler(options = {}) {
   };
 }
 
-// src/context/index.ts
-var loggerLevelMap = {
-  error: 0,
-  warn: 1,
-  info: 3,
-  silent: -999
-};
-function getCompilerContext(opts) {
-  const ctx = defuOverrideArray(
-    opts,
-    getDefaultOptions(),
-    {}
-  );
-  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.level = loggerLevelMap[logLevel] ?? loggerLevelMap.info;
-  const twPatcher = createTailwindcssPatcher(
-    {
-      basedir: tailwindcssBasedir,
-      cacheDir: appType === "mpx" ? "node_modules/tailwindcss-patch/.cache" : void 0,
-      supportCustomLengthUnitsPatch: supportCustomLengthUnitsPatch ?? true,
-      tailwindcss: defuOverrideArray(
-        tailwindcss,
-        {
-          v4: {
-            base: tailwindcssBasedir,
-            cssEntries
-          }
-        }
-      ),
-      tailwindcssPatcherOptions
-    }
-  );
-  logger.success(`\u5F53\u524D\u4F7F\u7528 ${pc.cyanBright("Tailwind CSS")} \u7248\u672C\u4E3A: ${pc.underline(pc.bold(pc.green(twPatcher.packageInfo.version)))}`);
-  const cssCalcOptions = cssCalc ?? twPatcher.majorVersion === 4;
-  const customAttributesEntities = isMap(customAttributes) ? [...customAttributes.entries()] : Object.entries(customAttributes);
-  const { initMangle, mangleContext, setMangleRuntimeSet } = useMangleStore();
-  initMangle(mangle);
   const styleHandler = createStyleHandler({
     cssPreflight,
     customRuleCallback,
@@ -1133,11 +1300,121 @@ function getCompilerContext(opts) {
     jsHandler: jsHandler2,
     disabledDefaultTemplateHandler
   });
+  return {
+    styleHandler,
+    jsHandler: jsHandler2,
+    templateHandler
+  };
+}
+
+// src/context/logger.ts
+import { logger } from "@weapp-tailwindcss/logger";
+var loggerLevelMap = {
+  error: 0,
+  warn: 1,
+  info: 3,
+  silent: -999
+};
+function applyLoggerLevel(logLevel) {
+  logger.level = loggerLevelMap[logLevel ?? "info"] ?? loggerLevelMap.info;
+}
+
+// src/tailwindcss/index.ts
+import { getPackageInfoSync } from "local-pkg";
+
+// src/tailwindcss/patcher.ts
+import path from "path";
+import process from "process";
+import { defuOverrideArray as defuOverrideArray2 } from "@weapp-tailwindcss/shared";
+import { TailwindcssPatcher } from "tailwindcss-patch";
+function createTailwindcssPatcher(options) {
+  const { basedir, cacheDir, supportCustomLengthUnitsPatch, tailwindcss, tailwindcssPatcherOptions } = options || {};
+  const cache = {};
+  if (cacheDir) {
+    if (path.isAbsolute(cacheDir)) {
+      cache.dir = cacheDir;
+    } else if (basedir) {
+      cache.dir = path.resolve(basedir, cacheDir);
+    } else {
+      cache.dir = path.resolve(process.cwd(), cacheDir);
+    }
+  }
+  return new TailwindcssPatcher(defuOverrideArray2(
+    tailwindcssPatcherOptions,
+    {
+      cache,
+      patch: {
+        basedir,
+        applyPatches: {
+          exportContext: true,
+          extendLengthUnits: supportCustomLengthUnitsPatch
+        },
+        tailwindcss,
+        resolve: {
+          paths: [
+            import.meta.url
+          ]
+        }
+      }
+    }
+  ));
+}
+
+// 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: supportCustomLengthUnitsPatch ?? true,
+      tailwindcss: defuOverrideArray(
+        tailwindcss,
+        {
+          v4: {
+            base: tailwindcssBasedir,
+            cssEntries
+          }
+        }
+      ),
+      tailwindcssPatcherOptions
+    }
+  );
+}
+
+// src/context/index.ts
+function getCompilerContext(opts) {
+  const ctx = defuOverrideArray(
+    opts,
+    getDefaultOptions(),
+    {}
+  );
+  ctx.escapeMap = ctx.customReplaceDictionary;
+  applyLoggerLevel(ctx.logLevel);
+  const twPatcher = createTailwindcssPatcherFromContext(ctx);
+  logger2.success(`\u5F53\u524D\u4F7F\u7528 ${pc.cyanBright("Tailwind CSS")} \u7248\u672C\u4E3A: ${pc.underline(pc.bold(pc.green(twPatcher.packageInfo.version)))}`);
+  const cssCalcOptions = ctx.cssCalc ?? twPatcher.majorVersion === 4;
+  const customAttributesEntities = toCustomAttributesEntities(ctx.customAttributes);
+  const { initMangle, mangleContext, setMangleRuntimeSet } = useMangleStore();
+  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;
 }