weapp-tailwindcss 4.10.0 → 4.10.2

package/dist/{chunk-VTIOEDOK.js → chunk-I35XJD75.js}

@@ -16,10 +16,10 @@ var _chunkDYLQ6UOIjs = require('./chunk-DYLQ6UOI.js');
 var _debug2 = require('debug'); var _debug3 = _interopRequireDefault(_debug2);
 var _debug = _debug3.default.call(void 0, "weapp-tw");
 function createDebug(prefix) {
-  function debug2(formatter, ...args) {
+  function debug3(formatter, ...args) {
     return _debug((_nullishCoalesce(prefix, () => ( ""))) + formatter, ...args);
   }
-  return debug2;
+  return debug3;
 }
 
 // src/tailwindcss/runtime/cache.ts
@@ -285,7 +285,7 @@ async function collectRuntimeClassSet(twPatcher, options = {}) {
 // package.json
 var package_default = {
   name: "weapp-tailwindcss",
-  version: "4.10.0",
+  version: "4.10.2",
   description: "\u628A tailwindcss \u539F\u5B50\u5316\u6837\u5F0F\u601D\u60F3\uFF0C\u5E26\u7ED9\u5C0F\u7A0B\u5E8F\u5F00\u53D1\u8005\u4EEC! bring tailwindcss to miniprogram developers!",
   author: "ice breaker <1324318532@qq.com>",
   license: "MIT",
@@ -1189,68 +1189,80 @@ var _escape = require('@ast-core/escape');
 
 var _extractors = require('@weapp-tailwindcss/shared/extractors');
 
-// src/shared/classname-transform.ts
-var arbitraryClassTokenRE = /\[[^\]\r\n]+\]/;
-var utilityLikeClassRE = /^-?[@\w][\w:/.[\]()%#!,-]*$/;
-var escapableTokenRE = /[.[\]/:]/;
-function isArbitraryValueClassName(candidate) {
-  if (!arbitraryClassTokenRE.test(candidate)) {
-    return false;
+// src/wxml/shared.ts
+var _escape3 = require('@weapp-core/escape');
+function replaceWxml(original, options = {
+  keepEOL: false,
+  escapeMap: _escape3.MappingChars2String
+}) {
+  const { keepEOL, escapeMap, ignoreHead } = options;
+  let res = original;
+  if (!keepEOL) {
+    res = res.replaceAll(/[\n\r]+/g, "");
   }
-  return candidate.startsWith("[") || candidate.includes("-[") || candidate.includes(":[");
+  res = _escape3.escape.call(void 0, res, {
+    map: escapeMap,
+    ignoreHead
+  });
+  return res;
 }
-function shouldFallbackEscapeClassName(candidate) {
-  if (!candidate) {
-    return false;
-  }
-  if (candidate.startsWith("@")) {
-    return false;
-  }
-  if (candidate.includes("://")) {
-    return false;
-  }
-  if (candidate.includes("/")) {
+
+// src/shared/classname-transform.ts
+function isArbitraryValueCandidate(candidate) {
+  const normalized = candidate.trim();
+  if (!normalized.includes("[") || !normalized.includes("]")) {
     return false;
   }
-  if (!utilityLikeClassRE.test(candidate)) {
+  if (/^(?:https?:)?\/\//.test(normalized)) {
     return false;
   }
-  if (isArbitraryValueClassName(candidate)) {
+  return true;
+}
+function shouldEnableArbitraryValueFallback({
+  classNameSet,
+  jsArbitraryValueFallback,
+  tailwindcssMajorVersion
+}) {
+  if (jsArbitraryValueFallback === true) {
     return true;
   }
-  if (!escapableTokenRE.test(candidate)) {
+  if (jsArbitraryValueFallback === false) {
     return false;
   }
-  if (!candidate.includes(".")) {
-    return false;
-  }
-  return candidate.includes("-") || candidate.includes(":");
+  return tailwindcssMajorVersion === 4 && (!classNameSet || classNameSet.size === 0);
 }
-function shouldTransformClassNameCandidate(candidate, {
+function resolveClassNameTransformDecision(candidate, {
   alwaysEscape,
   classNameSet,
-  staleClassNameFallback,
-  jsPreserveClass
+  escapeMap,
+  jsArbitraryValueFallback,
+  jsPreserveClass,
+  tailwindcssMajorVersion,
+  classContext
 }) {
   if (alwaysEscape) {
-    return true;
+    return "direct";
   }
   if (_optionalChain([jsPreserveClass, 'optionalCall', _33 => _33(candidate)])) {
-    return false;
+    return "skip";
   }
-  if (!classNameSet || classNameSet.size === 0) {
-    if (!staleClassNameFallback) {
-      return false;
-    }
-    return shouldFallbackEscapeClassName(candidate);
+  if (_optionalChain([classNameSet, 'optionalAccess', _34 => _34.has, 'call', _35 => _35(candidate)])) {
+    return "direct";
   }
-  if (classNameSet.has(candidate)) {
-    return true;
+  if (classNameSet && classNameSet.size > 0) {
+    const escapedCandidate = replaceWxml(candidate, { escapeMap });
+    if (escapedCandidate !== candidate && classNameSet.has(escapedCandidate)) {
+      return "escaped";
+    }
   }
-  if (!staleClassNameFallback) {
-    return false;
+  if (classContext && isArbitraryValueCandidate(candidate) && shouldEnableArbitraryValueFallback({
+    classNameSet,
+    jsArbitraryValueFallback,
+    tailwindcssMajorVersion
+  })) {
+    return "fallback";
   }
-  return shouldFallbackEscapeClassName(candidate);
+  return "skip";
 }
 
 // src/utils/decode.ts
@@ -1276,25 +1288,105 @@ function decodeUnicode2(input) {
   }
 }
 
-// src/wxml/shared.ts
-var _escape3 = require('@weapp-core/escape');
-function replaceWxml(original, options = {
-  keepEOL: false,
-  escapeMap: _escape3.MappingChars2String
-}) {
-  const { keepEOL, escapeMap, ignoreHead } = options;
-  let res = original;
-  if (!keepEOL) {
-    res = res.replaceAll(/[\n\r]+/g, "");
+// src/js/class-context.ts
+var CLASS_LIKE_KEYWORDS = /* @__PURE__ */ new Set([
+  "class",
+  "classname",
+  "hoverclass",
+  "virtualhostclass",
+  "rootclass"
+]);
+var CLASS_HELPER_IDENTIFIERS = /* @__PURE__ */ new Set([
+  "cn",
+  "clsx",
+  "classnames",
+  "twmerge",
+  "cva",
+  "tv",
+  "cx",
+  "r"
+]);
+function normalizeKeyword(name) {
+  return name.replace(/[-_:]/g, "").toLowerCase();
+}
+function readObjectKeyName(path5) {
+  if (path5.isIdentifier()) {
+    return path5.node.name;
   }
-  res = _escape3.escape.call(void 0, res, {
-    map: escapeMap,
-    ignoreHead
-  });
-  return res;
+  if (path5.isStringLiteral()) {
+    return path5.node.value;
+  }
+  if (path5.isTemplateLiteral() && path5.node.expressions.length === 0) {
+    return _nullishCoalesce(_optionalChain([path5, 'access', _36 => _36.node, 'access', _37 => _37.quasis, 'access', _38 => _38[0], 'optionalAccess', _39 => _39.value, 'access', _40 => _40.cooked]), () => ( _optionalChain([path5, 'access', _41 => _41.node, 'access', _42 => _42.quasis, 'access', _43 => _43[0], 'optionalAccess', _44 => _44.value, 'access', _45 => _45.raw])));
+  }
+  return void 0;
+}
+function isClassLikeObjectProperty(path5, valuePath) {
+  if (!path5.isObjectProperty()) {
+    return false;
+  }
+  if (path5.get("value") !== valuePath) {
+    return false;
+  }
+  const keyName = readObjectKeyName(path5.get("key"));
+  if (!keyName) {
+    return false;
+  }
+  return CLASS_LIKE_KEYWORDS.has(normalizeKeyword(keyName));
+}
+function isClassLikeJsxAttribute(path5) {
+  if (!path5.isJSXAttribute()) {
+    return false;
+  }
+  const namePath = path5.get("name");
+  if (!namePath.isJSXIdentifier()) {
+    return false;
+  }
+  return CLASS_LIKE_KEYWORDS.has(normalizeKeyword(namePath.node.name));
+}
+function isClassLikeCallExpression(path5, valuePath) {
+  if (!path5.isCallExpression()) {
+    return false;
+  }
+  const args = path5.get("arguments");
+  if (!args.includes(valuePath)) {
+    return false;
+  }
+  const calleePath = path5.get("callee");
+  if (calleePath.isIdentifier()) {
+    return CLASS_HELPER_IDENTIFIERS.has(normalizeKeyword(calleePath.node.name));
+  }
+  if (calleePath.isMemberExpression()) {
+    const propertyPath = calleePath.get("property");
+    if (propertyPath.isIdentifier()) {
+      return CLASS_HELPER_IDENTIFIERS.has(normalizeKeyword(propertyPath.node.name));
+    }
+    if (propertyPath.isStringLiteral()) {
+      return CLASS_HELPER_IDENTIFIERS.has(normalizeKeyword(propertyPath.node.value));
+    }
+  }
+  return false;
+}
+function isClassContextLiteralPath(path5) {
+  let current = path5;
+  while (current.parentPath) {
+    const parent = current.parentPath;
+    if (isClassLikeObjectProperty(parent, current)) {
+      return true;
+    }
+    if (isClassLikeJsxAttribute(parent)) {
+      return true;
+    }
+    if (isClassLikeCallExpression(parent, current)) {
+      return true;
+    }
+    current = parent;
+  }
+  return false;
 }
 
 // src/js/handlers.ts
+var debug2 = createDebug("[js:handlers] ");
 var patternCache = /* @__PURE__ */ new Map();
 var replacementCacheByEscapeMap = /* @__PURE__ */ new WeakMap();
 var defaultReplacementCache = /* @__PURE__ */ new Map();
@@ -1331,7 +1423,7 @@ function hasIgnoreComment(node) {
   return Array.isArray(node.leadingComments) && node.leadingComments.some((comment) => comment.value.includes("weapp-tw") && comment.value.includes("ignore"));
 }
 function extractLiteralValue(path5, { unescapeUnicode, arbitraryValues }) {
-  const allowDoubleQuotes = _optionalChain([arbitraryValues, 'optionalAccess', _34 => _34.allowDoubleQuotes]);
+  const allowDoubleQuotes = _optionalChain([arbitraryValues, 'optionalAccess', _46 => _46.allowDoubleQuotes]);
   let offset = 0;
   let original;
   if (path5.isStringLiteral()) {
@@ -1359,7 +1451,9 @@ function replaceHandleValue(path5, options) {
     needEscaped = false
   } = options;
   const { classNameSet, alwaysEscape } = options;
-  if (!alwaysEscape && (!classNameSet || classNameSet.size === 0) && !options.staleClassNameFallback) {
+  const fallbackEnabled = shouldEnableArbitraryValueFallback(options);
+  const classContext = options.wrapExpression || isClassContextLiteralPath(path5);
+  if (!alwaysEscape && !fallbackEnabled && (!classNameSet || classNameSet.size === 0)) {
     return void 0;
   }
   const { literal, original, allowDoubleQuotes, offset } = extractLiteralValue(path5, options);
@@ -1372,10 +1466,24 @@ function replaceHandleValue(path5, options) {
   }
   let transformed = literal;
   let mutated = false;
+  let matchedCandidateCount = 0;
+  let escapedDecisionCount = 0;
+  let fallbackDecisionCount = 0;
   for (const candidate of candidates) {
-    if (!shouldTransformClassNameCandidate(candidate, options)) {
+    const decision = resolveClassNameTransformDecision(candidate, {
+      ...options,
+      classContext
+    });
+    if (decision === "skip") {
       continue;
     }
+    matchedCandidateCount += 1;
+    if (decision === "escaped") {
+      escapedDecisionCount += 1;
+    }
+    if (decision === "fallback") {
+      fallbackDecisionCount += 1;
+    }
     if (!transformed.includes(candidate)) {
       continue;
     }
@@ -1391,6 +1499,16 @@ function replaceHandleValue(path5, options) {
   if (!mutated || typeof node.start !== "number" || typeof node.end !== "number") {
     return void 0;
   }
+  if (debug2.enabled) {
+    debug2(
+      "runtimeSet size=%d fallbackTriggered=%s matchedCandidates=%d escapedHits=%d file=%s",
+      _nullishCoalesce(_optionalChain([classNameSet, 'optionalAccess', _47 => _47.size]), () => ( 0)),
+      fallbackDecisionCount > 0,
+      matchedCandidateCount,
+      escapedDecisionCount,
+      _nullishCoalesce(options.filename, () => ( "unknown"))
+    );
+  }
   const start = node.start + offset;
   const end = node.end - offset;
   if (start >= end || transformed === original) {
@@ -1564,7 +1682,7 @@ function handleEvalTemplateElement(path5, options, updater, handler) {
   }
 }
 function walkEvalExpression(path5, options, updater, handler) {
-  const maybeTraverse = _optionalChain([path5, 'optionalAccess', _35 => _35.traverse]);
+  const maybeTraverse = _optionalChain([path5, 'optionalAccess', _48 => _48.traverse]);
   if (typeof maybeTraverse === "function") {
     try {
       return maybeTraverse.call(path5, {
@@ -1576,21 +1694,21 @@ function walkEvalExpression(path5, options, updater, handler) {
         }
       });
     } catch (error) {
-      const msg = _nullishCoalesce(_optionalChain([error, 'optionalAccess', _36 => _36.message]), () => ( ""));
+      const msg = _nullishCoalesce(_optionalChain([error, 'optionalAccess', _49 => _49.message]), () => ( ""));
       const scopeError = /pass a scope and parentPath|traversing a Program\/File/i.test(msg);
       if (!scopeError) {
         throw error;
       }
     }
   }
-  const getArgs = _optionalChain([path5, 'optionalAccess', _37 => _37.get, 'optionalCall', _38 => _38("arguments")]);
+  const getArgs = _optionalChain([path5, 'optionalAccess', _50 => _50.get, 'optionalCall', _51 => _51("arguments")]);
   if (Array.isArray(getArgs)) {
     for (const arg of getArgs) {
-      if (_optionalChain([arg, 'optionalAccess', _39 => _39.isStringLiteral, 'optionalCall', _40 => _40()])) {
+      if (_optionalChain([arg, 'optionalAccess', _52 => _52.isStringLiteral, 'optionalCall', _53 => _53()])) {
         handleEvalStringLiteral(arg, options, updater, handler);
         continue;
       }
-      if (_optionalChain([arg, 'optionalAccess', _41 => _41.isTemplateLiteral, 'optionalCall', _42 => _42()])) {
+      if (_optionalChain([arg, 'optionalAccess', _54 => _54.isTemplateLiteral, 'optionalCall', _55 => _55()])) {
         for (const quasi of arg.get("quasis")) {
           handleEvalTemplateElement(quasi, options, updater, handler);
         }
@@ -1598,16 +1716,16 @@ function walkEvalExpression(path5, options, updater, handler) {
     }
     return;
   }
-  const nodeArgs = _optionalChain([path5, 'optionalAccess', _43 => _43.node, 'optionalAccess', _44 => _44.arguments]);
+  const nodeArgs = _optionalChain([path5, 'optionalAccess', _56 => _56.node, 'optionalAccess', _57 => _57.arguments]);
   if (Array.isArray(nodeArgs)) {
     for (const n of nodeArgs) {
-      if (_optionalChain([n, 'optionalAccess', _45 => _45.type]) === "StringLiteral") {
+      if (_optionalChain([n, 'optionalAccess', _58 => _58.type]) === "StringLiteral") {
         const stub = {
           node: n,
           isStringLiteral: () => true
         };
         handleEvalStringLiteral(stub, options, updater, handler);
-      } else if (_optionalChain([n, 'optionalAccess', _46 => _46.type]) === "TemplateLiteral" && Array.isArray(n.quasis)) {
+      } else if (_optionalChain([n, 'optionalAccess', _59 => _59.type]) === "TemplateLiteral" && Array.isArray(n.quasis)) {
         for (const q of n.quasis) {
           const stub = {
             node: q,
@@ -1709,7 +1827,7 @@ var IgnoredExportsTracker = class {
         continue;
       }
       if (exportPath.isExportNamedDeclaration()) {
-        const source = _optionalChain([exportPath, 'access', _47 => _47.node, 'access', _48 => _48.source, 'optionalAccess', _49 => _49.value]);
+        const source = _optionalChain([exportPath, 'access', _60 => _60.node, 'access', _61 => _61.source, 'optionalAccess', _62 => _62.value]);
         if (typeof source === "string") {
           for (const spec of exportPath.get("specifiers")) {
             if (!spec.isExportSpecifier()) {
@@ -1776,7 +1894,7 @@ var IgnoredExportsTracker = class {
         continue;
       }
       if (exportPath.isExportAllDeclaration()) {
-        const source = _optionalChain([exportPath, 'access', _50 => _50.node, 'access', _51 => _51.source, 'optionalAccess', _52 => _52.value]);
+        const source = _optionalChain([exportPath, 'access', _63 => _63.node, 'access', _64 => _64.source, 'optionalAccess', _65 => _65.value]);
         if (typeof source === "string") {
           for (const exportName of names) {
             propagate.push({
@@ -1877,7 +1995,7 @@ var JsModuleGraph = class {
       }
       for (const exportPath of state.analysis.exportDeclarations) {
         if (exportPath.isExportAllDeclaration() || exportPath.isExportNamedDeclaration()) {
-          const source = _optionalChain([exportPath, 'access', _53 => _53.node, 'access', _54 => _54.source, 'optionalAccess', _55 => _55.value]);
+          const source = _optionalChain([exportPath, 'access', _66 => _66.node, 'access', _67 => _67.source, 'optionalAccess', _68 => _68.value]);
           if (typeof source === "string" && !dependencySpecifiers.has(source)) {
             dependencySpecifiers.set(source, []);
           }
@@ -2083,14 +2201,14 @@ var NodePathWalker = class {
     }
     this.visited.add(arg);
     if (arg.isIdentifier()) {
-      const binding = _optionalChain([arg, 'optionalAccess', _56 => _56.scope, 'optionalAccess', _57 => _57.getBinding, 'optionalCall', _58 => _58(arg.node.name)]);
+      const binding = _optionalChain([arg, 'optionalAccess', _69 => _69.scope, 'optionalAccess', _70 => _70.getBinding, 'optionalCall', _71 => _71(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', _59 => _59.scope, 'optionalAccess', _60 => _60.getBinding, 'optionalCall', _61 => _61(objectPath.node.name)]);
+        const binding = _optionalChain([arg, 'optionalAccess', _72 => _72.scope, 'optionalAccess', _73 => _73.getBinding, 'optionalCall', _74 => _74(objectPath.node.name)]);
         if (binding) {
           if (binding.path.isVariableDeclarator()) {
             this.walkVariableDeclarator(binding.path);
@@ -2167,8 +2285,8 @@ function createTaggedTemplateIgnore({ matcher, names }) {
     }
     const objectPath = path5.get("object");
     if (objectPath.isIdentifier()) {
-      const scope = _optionalChain([objectPath, 'optionalAccess', _62 => _62.scope]);
-      const binding = _optionalChain([scope, 'optionalAccess', _63 => _63.getBinding, 'optionalCall', _64 => _64(objectPath.node.name)]);
+      const scope = _optionalChain([objectPath, 'optionalAccess', _75 => _75.scope]);
+      const binding = _optionalChain([scope, 'optionalAccess', _76 => _76.getBinding, 'optionalCall', _77 => _77(objectPath.node.name)]);
       if (binding) {
         return resolvesToWeappTwIgnore(binding, seen);
       }
@@ -2197,7 +2315,7 @@ function createTaggedTemplateIgnore({ matcher, names }) {
       const init = bindingPath.get("init");
       if (init && init.node) {
         if (init.isIdentifier()) {
-          const target = _optionalChain([binding, 'optionalAccess', _65 => _65.scope, 'optionalAccess', _66 => _66.getBinding, 'optionalCall', _67 => _67(init.node.name)]);
+          const target = _optionalChain([binding, 'optionalAccess', _78 => _78.scope, 'optionalAccess', _79 => _79.getBinding, 'optionalCall', _80 => _80(init.node.name)]);
           if (target) {
             result = resolvesToWeappTwIgnore(target, seen);
           }
@@ -2213,7 +2331,7 @@ function createTaggedTemplateIgnore({ matcher, names }) {
   const getEffectiveTagPath = (tagPath) => {
     let current = tagPath;
     while (true) {
-      if (_optionalChain([current, 'access', _68 => _68.isParenthesizedExpression, 'optionalCall', _69 => _69()]) || current.node.type === "ParenthesizedExpression") {
+      if (_optionalChain([current, 'access', _81 => _81.isParenthesizedExpression, 'optionalCall', _82 => _82()]) || current.node.type === "ParenthesizedExpression") {
         current = current.get("expression");
         continue;
       }
@@ -2225,7 +2343,7 @@ function createTaggedTemplateIgnore({ matcher, names }) {
         current = current.get("expression");
         continue;
       }
-      if (_optionalChain([current, 'access', _70 => _70.isTypeCastExpression, 'optionalCall', _71 => _71()])) {
+      if (_optionalChain([current, 'access', _83 => _83.isTypeCastExpression, 'optionalCall', _84 => _84()])) {
         current = current.get("expression");
         continue;
       }
@@ -2237,7 +2355,7 @@ function createTaggedTemplateIgnore({ matcher, names }) {
           continue;
         }
       }
-      if (_optionalChain([current, 'access', _72 => _72.isCallExpression, 'optionalCall', _73 => _73()]) || current.node.type === "CallExpression") {
+      if (_optionalChain([current, 'access', _85 => _85.isCallExpression, 'optionalCall', _86 => _86()]) || current.node.type === "CallExpression") {
         const callee = current.get("callee");
         current = callee;
         continue;
@@ -2247,7 +2365,7 @@ function createTaggedTemplateIgnore({ matcher, names }) {
     return current;
   };
   const evaluateTagPath = (tagPath) => {
-    if (_optionalChain([tagPath, 'access', _74 => _74.isCallExpression, 'optionalCall', _75 => _75()]) || tagPath.node.type === "CallExpression") {
+    if (_optionalChain([tagPath, 'access', _87 => _87.isCallExpression, 'optionalCall', _88 => _88()]) || tagPath.node.type === "CallExpression") {
       const calleePath = tagPath.get("callee");
       return evaluateTagPath(calleePath);
     }
@@ -2255,7 +2373,7 @@ function createTaggedTemplateIgnore({ matcher, names }) {
       if (matcher(tagPath.node.name)) {
         return true;
       }
-      const binding = _optionalChain([tagPath, 'optionalAccess', _76 => _76.scope, 'optionalAccess', _77 => _77.getBinding, 'optionalCall', _78 => _78(tagPath.node.name)]);
+      const binding = _optionalChain([tagPath, 'optionalAccess', _89 => _89.scope, 'optionalAccess', _90 => _90.getBinding, 'optionalCall', _91 => _91(tagPath.node.name)]);
       if (binding) {
         return resolvesToWeappTwIgnore(binding, /* @__PURE__ */ new Set());
       }
@@ -2351,11 +2469,11 @@ function analyzeSource(ast, options, handler) {
           return;
         }
         const calleePath = p.get("callee");
-        if (calleePath.isIdentifier({ name: "require" }) && !_optionalChain([p, 'optionalAccess', _79 => _79.scope, 'optionalAccess', _80 => _80.hasBinding, 'optionalCall', _81 => _81("require")])) {
+        if (calleePath.isIdentifier({ name: "require" }) && !_optionalChain([p, 'optionalAccess', _92 => _92.scope, 'optionalAccess', _93 => _93.hasBinding, 'optionalCall', _94 => _94("require")])) {
           const args = p.get("arguments");
           if (Array.isArray(args) && args.length > 0) {
             const first = args[0];
-            if (_optionalChain([first, 'optionalAccess', _82 => _82.isStringLiteral, 'call', _83 => _83()])) {
+            if (_optionalChain([first, 'optionalAccess', _95 => _95.isStringLiteral, 'call', _96 => _96()])) {
               requireCallPaths.push(first);
             }
           }
@@ -2440,6 +2558,8 @@ function createJsHandler(options) {
     arbitraryValues,
     escapeMap,
     staleClassNameFallback,
+    jsArbitraryValueFallback,
+    tailwindcssMajorVersion,
     jsPreserveClass,
     generateMap,
     needEscaped,
@@ -2462,6 +2582,8 @@ function createJsHandler(options) {
         classNameSet,
         escapeMap,
         staleClassNameFallback,
+        jsArbitraryValueFallback,
+        tailwindcssMajorVersion,
         arbitraryValues,
         jsPreserveClass,
         generateMap,
@@ -2559,7 +2681,7 @@ function shouldSkipLegacyStringLiteral(path5) {
     return true;
   }
   return Boolean(
-    t.isBinaryExpression(path5.parent) && (t.isConditionalExpression(_optionalChain([path5, 'access', _84 => _84.parentPath, 'optionalAccess', _85 => _85.parent])) || t.isLogicalExpression(_optionalChain([path5, 'access', _86 => _86.parentPath, 'optionalAccess', _87 => _87.parent])))
+    t.isBinaryExpression(path5.parent) && (t.isConditionalExpression(_optionalChain([path5, 'access', _97 => _97.parentPath, 'optionalAccess', _98 => _98.parent])) || t.isLogicalExpression(_optionalChain([path5, 'access', _99 => _99.parentPath, 'optionalAccess', _100 => _100.parent])))
   );
 }
 function createLegacyTraverseOptions(options, jsTokenUpdater) {
@@ -2860,7 +2982,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', _88 => _88(tag, name)]), () => ( false));
+        const shouldHandleCustom = _nullishCoalesce(_optionalChain([matchCustomAttribute, 'optionalCall', _101 => _101(tag, name)]), () => ( false));
         if (!shouldHandleDefault && !shouldHandleCustom) {
           return;
         }
@@ -2925,7 +3047,7 @@ function resolveRuntimePackageReplacements(option) {
   }
   return Object.keys(normalized).length > 0 ? normalized : void 0;
 }
-function createHandlersFromContext(ctx, customAttributesEntities, cssCalcOptions) {
+function createHandlersFromContext(ctx, customAttributesEntities, cssCalcOptions, tailwindcssMajorVersion) {
   const {
     cssPreflight,
     cssPreflightRange,
@@ -2944,6 +3066,7 @@ function createHandlersFromContext(ctx, customAttributesEntities, cssCalcOptions
     arbitraryValues,
     jsPreserveClass,
     staleClassNameFallback,
+    jsArbitraryValueFallback,
     babelParserOptions,
     ignoreCallExpressionIdentifiers,
     ignoreTaggedTemplateExpressionIdentifiers,
@@ -2974,6 +3097,8 @@ function createHandlersFromContext(ctx, customAttributesEntities, cssCalcOptions
     arbitraryValues,
     jsPreserveClass,
     staleClassNameFallback,
+    jsArbitraryValueFallback: _nullishCoalesce(jsArbitraryValueFallback, () => ( "auto")),
+    tailwindcssMajorVersion,
     generateMap: true,
     babelParserOptions,
     ignoreCallExpressionIdentifiers,
@@ -3012,7 +3137,7 @@ async function clearTailwindcssPatcherCache(patcher, options) {
   if (!patcher) {
     return;
   }
-  const cacheOptions = _optionalChain([patcher, 'access', _89 => _89.options, 'optionalAccess', _90 => _90.cache]);
+  const cacheOptions = _optionalChain([patcher, 'access', _102 => _102.options, 'optionalAccess', _103 => _103.cache]);
   if (cacheOptions == null || typeof cacheOptions === "object" && cacheOptions.enabled === false) {
     return;
   }
@@ -3023,19 +3148,19 @@ async function clearTailwindcssPatcherCache(patcher, options) {
       _logger.logger.debug("failed to clear tailwindcss patcher cache via clearCache(): %O", error);
     }
   }
-  if (!_optionalChain([options, 'optionalAccess', _91 => _91.removeDirectory])) {
+  if (!_optionalChain([options, 'optionalAccess', _104 => _104.removeDirectory])) {
     return;
   }
   const cachePaths = /* @__PURE__ */ new Map();
   const normalizedCacheOptions = typeof cacheOptions === "object" ? cacheOptions : void 0;
-  if (_optionalChain([normalizedCacheOptions, 'optionalAccess', _92 => _92.path])) {
+  if (_optionalChain([normalizedCacheOptions, 'optionalAccess', _105 => _105.path])) {
     cachePaths.set(normalizedCacheOptions.path, false);
   }
-  const privateCachePath = _optionalChain([patcher, 'optionalAccess', _93 => _93.cacheStore, 'optionalAccess', _94 => _94.options, 'optionalAccess', _95 => _95.path]);
+  const privateCachePath = _optionalChain([patcher, 'optionalAccess', _106 => _106.cacheStore, 'optionalAccess', _107 => _107.options, 'optionalAccess', _108 => _108.path]);
   if (privateCachePath) {
     cachePaths.set(privateCachePath, false);
   }
-  if (_optionalChain([options, 'optionalAccess', _96 => _96.removeDirectory]) && _optionalChain([normalizedCacheOptions, 'optionalAccess', _97 => _97.dir])) {
+  if (_optionalChain([options, 'optionalAccess', _109 => _109.removeDirectory]) && _optionalChain([normalizedCacheOptions, 'optionalAccess', _110 => _110.dir])) {
     cachePaths.set(normalizedCacheOptions.dir, true);
   }
   if (!cachePaths.size) {
@@ -3046,7 +3171,7 @@ async function clearTailwindcssPatcherCache(patcher, options) {
       await _promises.rm.call(void 0, cachePath, { force: true, recursive });
     } catch (error) {
       const err = error;
-      if (_optionalChain([err, 'optionalAccess', _98 => _98.code]) === "ENOENT") {
+      if (_optionalChain([err, 'optionalAccess', _111 => _111.code]) === "ENOENT") {
         continue;
       }
       _logger.logger.debug("failed to clear tailwindcss patcher cache: %s %O", cachePath, err);
@@ -3063,7 +3188,7 @@ function createInternalCompilerContext(opts) {
   applyLoggerLevel(ctx.logLevel);
   const twPatcher = _chunk5APD2MNVjs.createTailwindcssPatcherFromContext.call(void 0, ctx);
   logTailwindcssTarget("runtime", twPatcher, ctx.tailwindcssBasedir);
-  if (_optionalChain([twPatcher, 'access', _99 => _99.packageInfo, 'optionalAccess', _100 => _100.version])) {
+  if (_optionalChain([twPatcher, 'access', _112 => _112.packageInfo, 'optionalAccess', _113 => _113.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`);
@@ -3075,7 +3200,8 @@ function createInternalCompilerContext(opts) {
   const { styleHandler, jsHandler: jsHandler2, templateHandler } = createHandlersFromContext(
     ctx,
     customAttributesEntities,
-    cssCalcOptions
+    cssCalcOptions,
+    twPatcher.majorVersion
   );
   ctx.styleHandler = styleHandler;
   ctx.jsHandler = jsHandler2;
@@ -3084,7 +3210,7 @@ function createInternalCompilerContext(opts) {
   ctx.twPatcher = twPatcher;
   const refreshTailwindcssPatcher = async (options) => {
     const previousPatcher = ctx.twPatcher;
-    if (_optionalChain([options, 'optionalAccess', _101 => _101.clearCache]) !== false) {
+    if (_optionalChain([options, 'optionalAccess', _114 => _114.clearCache]) !== false) {
       await clearTailwindcssPatcherCache(previousPatcher);
     }
     invalidateRuntimeClassSet(previousPatcher);

package/dist/{chunk-TNAPEHNW.mjs → chunk-LHBUALTK.mjs}

@@ -10,7 +10,7 @@ import {
   isMpx,
   patchMpxLoaderResolve,
   setupMpxTailwindcssRedirect
-} from "./chunk-6QU7CMAG.mjs";
+} from "./chunk-ACNOEKQI.mjs";
 import {
   pushConcurrentTaskFactories,
   resolveDisabledOptions,
@@ -23,14 +23,14 @@ import {
 } from "./chunk-RRHPTTCP.mjs";
 import {
   setupPatchRecorder
-} from "./chunk-F6VHIO5B.mjs";
+} from "./chunk-BZCCVPSU.mjs";
 import {
   createDebug,
   ensureRuntimeClassSet,
   getCompilerContext,
   getRuntimeClassSetSignature,
   pluginName
-} from "./chunk-Q5IGGG5W.mjs";
+} from "./chunk-MPVAZKRB.mjs";
 import {
   getGroupedEntries
 } from "./chunk-OOHJLO5M.mjs";
@@ -205,6 +205,7 @@ function setupWebpackV5ProcessAssetsHook(options) {
                   const currentSource = typeof currentSourceValue === "string" ? currentSourceValue : currentSourceValue?.toString() ?? "";
                   const { code, linked } = await compilerOptions.jsHandler(currentSource, runtimeSet, {
                     staleClassNameFallback,
+                    tailwindcssMajorVersion: runtimeState.twPatcher.majorVersion,
                     filename: absoluteFile,
                     moduleGraph: moduleGraphOptions,
                     babelParserOptions: {