@weapp-tailwindcss/postcss 2.1.6 → 2.2.0-next.0

package/dist/index.js

@@ -1,7 +1,11 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;require('./chunk-GGNOJ77I.js');
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;
+
+var _chunk2Y3ULRB3js = require('./chunk-2Y3ULRB3.js');
+require('./chunk-GGNOJ77I.js');
 
 // src/handler.ts
 var _shared = require('@weapp-tailwindcss/shared');
+var _lrucache = require('lru-cache');
 
 // src/compat/uni-app-x.ts
 var _postcss = require('postcss'); var _postcss2 = _interopRequireDefault(_postcss);
@@ -132,6 +136,145 @@ function shouldRemoveEmptyRuleForUniAppX(rule, options) {
   return isUniAppXEnabled(options) && rule.nodes.length === 0;
 }
 
+// src/compat/uni-app-x-uvue.ts
+var _postcssselectorparser = require('postcss-selector-parser'); var _postcssselectorparser2 = _interopRequireDefault(_postcssselectorparser);
+var ALLOWED_DISPLAY_VALUES = /* @__PURE__ */ new Set(["flex", "none"]);
+var FALLBACK_CLASS_RE = /\.((?:\\.|[\w-])+)/g;
+var IMPORTANT_SUFFIX_RE = /\s*!important$/i;
+function isUniAppXUvueTarget(options) {
+  return Boolean(_optionalChain([options, 'optionalAccess', _2 => _2.uniAppX])) && _optionalChain([options, 'optionalAccess', _3 => _3.uniAppXCssTarget]) === "uvue";
+}
+function normalizeUnsupportedMode(mode) {
+  return _nullishCoalesce(mode, () => ( "warn"));
+}
+function normalizeValue(value) {
+  return value.trim().toLowerCase().replace(IMPORTANT_SUFFIX_RE, "");
+}
+function getSourceFile(rule, result) {
+  return _nullishCoalesce(_nullishCoalesce(_optionalChain([rule, 'access', _4 => _4.source, 'optionalAccess', _5 => _5.input, 'access', _6 => _6.from]), () => ( result.opts.from)), () => ( "unknown source"));
+}
+function collectUtilityClassNames(rule) {
+  const classNames = /* @__PURE__ */ new Set();
+  for (const selector of _nullishCoalesce(rule.selectors, () => ( []))) {
+    try {
+      const ast = _postcssselectorparser2.default.call(void 0, ).astSync(selector);
+      ast.walkClasses((node) => {
+        if (node.value) {
+          classNames.add(node.value);
+        }
+      });
+    } catch (e) {
+      for (const match of selector.matchAll(FALLBACK_CLASS_RE)) {
+        if (match[1]) {
+          classNames.add(match[1].replaceAll("\\", ""));
+        }
+      }
+    }
+  }
+  return [...classNames];
+}
+function hasOnlyClassSelectors(rule) {
+  const selectors = _nullishCoalesce(rule.selectors, () => ( []));
+  if (selectors.length === 0) {
+    return false;
+  }
+  return selectors.every((selector) => {
+    try {
+      const ast = _postcssselectorparser2.default.call(void 0, ).astSync(selector);
+      return ast.nodes.every((node) => node.nodes.length > 0 && node.nodes.every((child) => child.type === "class"));
+    } catch (e2) {
+      return false;
+    }
+  });
+}
+function getUnsupportedDeclarationReason(prop, value) {
+  const normalizedProp = prop.trim().toLowerCase();
+  const normalizedValue = normalizeValue(value);
+  if (normalizedProp === "display" && !ALLOWED_DISPLAY_VALUES.has(normalizedValue)) {
+    return `${normalizedProp}: ${value}`;
+  }
+  if (normalizedProp === "min-height" && normalizedValue === "100vh") {
+    return `${normalizedProp}: ${value}`;
+  }
+  if (normalizedProp === "grid-template-columns" || normalizedProp === "grid-template-rows" || normalizedProp === "grid-auto-columns" || normalizedProp === "grid-auto-rows" || normalizedProp === "grid-auto-flow") {
+    return `${normalizedProp}: ${value}`;
+  }
+  if (normalizedProp === "gap" || normalizedProp === "row-gap" || normalizedProp === "column-gap") {
+    return `${normalizedProp}: ${value}`;
+  }
+}
+function reportUnsupportedRule(rule, result, mode, warningCache, reason) {
+  if (mode === "silent") {
+    return;
+  }
+  const classNames = collectUtilityClassNames(rule);
+  const classLabel = classNames.length > 0 ? classNames.join(", ") : rule.selector;
+  const source = getSourceFile(rule, result);
+  const message = `uni-app x uvue unsupported utility: ${classLabel} (${reason}) in ${source}`;
+  if (mode === "error") {
+    throw rule.error(message);
+  }
+  if (warningCache.has(message)) {
+    return;
+  }
+  warningCache.add(message);
+  rule.warn(result, message);
+}
+function applyUniAppXUvueCompatibility(result, options) {
+  if (!isUniAppXUvueTarget(options)) {
+    return result;
+  }
+  const mode = normalizeUnsupportedMode(_optionalChain([options, 'optionalAccess', _7 => _7.uniAppXUnsupported]));
+  const warningCache = /* @__PURE__ */ new Set();
+  result.root.walkRules((rule) => {
+    if (!hasOnlyClassSelectors(rule)) {
+      reportUnsupportedRule(rule, result, mode, warningCache, "selector must be class-only");
+      rule.remove();
+      return;
+    }
+    rule.walkDecls((decl) => {
+      const reason = getUnsupportedDeclarationReason(decl.prop, decl.value);
+      if (!reason) {
+        return;
+      }
+      reportUnsupportedRule(rule, result, mode, warningCache, reason);
+      decl.remove();
+    });
+    if ((_nullishCoalesce(_optionalChain([rule, 'access', _8 => _8.nodes, 'optionalAccess', _9 => _9.length]), () => ( 0))) === 0) {
+      rule.remove();
+    }
+  });
+  result.root.walkAtRules((atRule) => {
+    if ((_nullishCoalesce(_optionalChain([atRule, 'access', _10 => _10.nodes, 'optionalAccess', _11 => _11.length]), () => ( 0))) === 0) {
+      atRule.remove();
+    }
+  });
+  const nextResult = result.root.toResult(result.opts);
+  nextResult.messages.push(...result.messages);
+  return nextResult;
+}
+
+// src/content-probe.ts
+var EMPTY_SIGNAL = {
+  hasModernColorFunction: false,
+  hasPresetEnvFeatures: false
+};
+var MODERN_COLOR_RE = /rgb\w*\s*\([^),][^\s),]*\s[^),][^\s),]*\s[^),][^),/]*\/[^)]+\)/i;
+function probeFeatures(css) {
+  if (!css) {
+    return { ...EMPTY_SIGNAL };
+  }
+  const hasModernColorFunction = MODERN_COLOR_RE.test(css);
+  const hasPresetEnvFeatures = true;
+  return {
+    hasModernColorFunction,
+    hasPresetEnvFeatures
+  };
+}
+function signalToCacheKey(signal) {
+  return `signal:${signal.hasPresetEnvFeatures ? 1 : 0},${signal.hasModernColorFunction ? 1 : 0}`;
+}
+
 // src/defaults.ts
 function getDefaultOptions(options) {
   return {
@@ -144,9 +287,9 @@ function getDefaultOptions(options) {
         },
         "oklab-function": true,
         "color-mix": true,
-        "color-functional-notation": _nullishCoalesce(_optionalChain([options, 'optionalAccess', _2 => _2.cssPresetEnv, 'optionalAccess', _3 => _3.features, 'optionalAccess', _4 => _4["color-functional-notation"]]), () => ( { preserve: false })),
+        "color-functional-notation": _nullishCoalesce(_optionalChain([options, 'optionalAccess', _12 => _12.cssPresetEnv, 'optionalAccess', _13 => _13.features, 'optionalAccess', _14 => _14["color-functional-notation"]]), () => ( { preserve: false })),
         // 在 calc 下，这个需要开启
-        "custom-properties": _nullishCoalesce(_optionalChain([options, 'optionalAccess', _5 => _5.cssPresetEnv, 'optionalAccess', _6 => _6.features, 'optionalAccess', _7 => _7["custom-properties"]]), () => ( _optionalChain([options, 'optionalAccess', _8 => _8.cssCalc]))) ? { preserve: true } : false
+        "custom-properties": _nullishCoalesce(_optionalChain([options, 'optionalAccess', _15 => _15.cssPresetEnv, 'optionalAccess', _16 => _16.features, 'optionalAccess', _17 => _17["custom-properties"]]), () => ( _optionalChain([options, 'optionalAccess', _18 => _18.cssCalc]))) ? { preserve: true } : false
       },
       autoprefixer: {
         add: false
@@ -154,6 +297,7 @@ function getDefaultOptions(options) {
     },
     // 支付宝小程序不支持，所以默认关闭
     cssRemoveProperty: true,
+    uniAppXUnsupported: "warn",
     // cssRemoveAtSupports: true,
     // cssRemoveAtMedia: true,
     cssSelectorReplacement: {
@@ -163,9 +307,6 @@ function getDefaultOptions(options) {
   };
 }
 
-// src/options-resolver.ts
-
-
 // src/fingerprint.ts
 function fingerprintOptions(value, state = { map: /* @__PURE__ */ new WeakMap(), counter: 0 }) {
   if (value === null || value === void 0) {
@@ -197,6 +338,7 @@ function fingerprintOptions(value, state = { map: /* @__PURE__ */ new WeakMap(),
 }
 
 // src/options-resolver.ts
+
 var BASE_CACHE_KEY = "base";
 var SIMPLE_OVERRIDE_UNSET = "__unset__";
 function getSimpleOverrideCacheKey(options) {
@@ -213,6 +355,7 @@ function getSimpleOverrideCacheKey(options) {
   let cssCalc = SIMPLE_OVERRIDE_UNSET;
   let cssChildCombinatorReplaceValue = SIMPLE_OVERRIDE_UNSET;
   let cssPreflight = SIMPLE_OVERRIDE_UNSET;
+  let autoprefixer = SIMPLE_OVERRIDE_UNSET;
   for (const key of Object.keys(options)) {
     const value = options[key];
     switch (key) {
@@ -294,6 +437,12 @@ function getSimpleOverrideCacheKey(options) {
         }
         cssPreflight = "0";
         break;
+      case "autoprefixer":
+        if (typeof value !== "boolean") {
+          return void 0;
+        }
+        autoprefixer = value ? "1" : "0";
+        break;
       default:
         return void 0;
     }
@@ -312,7 +461,8 @@ function getSimpleOverrideCacheKey(options) {
     unitsToPx,
     cssCalc,
     cssChildCombinatorReplaceValue,
-    cssPreflight
+    cssPreflight,
+    autoprefixer
   ].join(":");
 }
 function hasOverrides(options) {
@@ -387,6 +537,28 @@ function createInjectPreflight(options) {
 // src/pipeline.ts
 var _postcsspresetenv = require('postcss-preset-env'); var _postcsspresetenv2 = _interopRequireDefault(_postcsspresetenv);
 
+// src/autoprefixer.ts
+var _autoprefixer = require('autoprefixer'); var _autoprefixer2 = _interopRequireDefault(_autoprefixer);
+var WEAPP_AUTOPREFIXER_BROWSERS = [
+  "iOS >= 8",
+  "Android >= 4.4",
+  "ChromeAndroid >= 37"
+];
+var AUTOPREFIXER_PLUGIN_NAME = "autoprefixer";
+function isAutoprefixerPlugin(plugin) {
+  return _optionalChain([plugin, 'optionalAccess', _19 => _19.postcssPlugin]) === AUTOPREFIXER_PLUGIN_NAME;
+}
+function resolveAutoprefixerPlugin(option) {
+  if (option === false) {
+    return void 0;
+  }
+  const userOptions = option === true || option === void 0 ? {} : option;
+  return _autoprefixer2.default.call(void 0, {
+    ...userOptions,
+    overrideBrowserslist: _nullishCoalesce(userOptions.overrideBrowserslist, () => ( WEAPP_AUTOPREFIXER_BROWSERS))
+  });
+}
+
 // src/plugins/colorFunctionalFallback.ts
 var _postcssvalueparser = require('postcss-value-parser'); var _postcssvalueparser2 = _interopRequireDefault(_postcssvalueparser);
 var RGB_FUNCTION_NAME = "rgb";
@@ -394,10 +566,10 @@ var isSlashDiv = (node) => node.type === "div" && node.value === "/";
 function trimNodes(nodes2) {
   let start = 0;
   let end = nodes2.length;
-  while (start < end && _optionalChain([nodes2, 'access', _9 => _9[start], 'optionalAccess', _10 => _10.type]) === "space") {
+  while (start < end && _optionalChain([nodes2, 'access', _20 => _20[start], 'optionalAccess', _21 => _21.type]) === "space") {
     start += 1;
   }
-  while (end > start && _optionalChain([nodes2, 'access', _11 => _11[end - 1], 'optionalAccess', _12 => _12.type]) === "space") {
+  while (end > start && _optionalChain([nodes2, 'access', _22 => _22[end - 1], 'optionalAccess', _23 => _23.type]) === "space") {
     end -= 1;
   }
   return nodes2.slice(start, end);
@@ -532,7 +704,7 @@ function getCalcDuplicateCleaner(options) {
 // src/plugins/getCalcPlugin.ts
 var _postcsscalc = require('@weapp-tailwindcss/postcss-calc'); var _postcsscalc2 = _interopRequireDefault(_postcsscalc);
 
-// ../../node_modules/.pnpm/es-toolkit@1.45.1/node_modules/es-toolkit/dist/object/omit.mjs
+// ../../node_modules/.pnpm/es-toolkit@1.46.0/node_modules/es-toolkit/dist/object/omit.mjs
 function omit(obj, keys) {
   const result = { ...obj };
   for (let i = 0; i < keys.length; i++) {
@@ -682,7 +854,7 @@ function getUnitsToPxPlugin(options) {
 // src/compat/tailwindcss-rpx.ts
 var LENGTH_VALUE_REGEXP = /^[+-]?(?:\d+(?:\.\d+)?|\.\d+)(?:e[+-]?\d+)?rpx$/i;
 function normalizeTailwindcssRpxDeclaration(decl, options) {
-  const majorVersion = _optionalChain([options, 'optionalAccess', _13 => _13.majorVersion]);
+  const majorVersion = _optionalChain([options, 'optionalAccess', _24 => _24.majorVersion]);
   const normalizedValue = decl.value.trim();
   if (LENGTH_VALUE_REGEXP.test(normalizedValue) && (majorVersion === void 0 || majorVersion === 2 || majorVersion === 3 || majorVersion === 4)) {
     const lowerProp = decl.prop.toLowerCase();
@@ -869,7 +1041,7 @@ var MODERN_CHECK_COLOR_RGB_RE = /color\s*:\s*rgb\(\s*from\s+red\s+r\s+g\s+b\s*\)
 var RADIUS_VALUE_RE = /\b([+-]?(?:\d+(?:\.\d+)?|\.\d+)(?:e[+-]?\d+)?)\s*(r?px)\b/gi;
 var SCIENTIFIC_NOTATION_RE = /e/i;
 function isTailwindcssV4(options) {
-  return _optionalChain([options, 'optionalAccess', _14 => _14.majorVersion]) === 4;
+  return _optionalChain([options, 'optionalAccess', _25 => _25.majorVersion]) === 4;
 }
 function testIfRootHostForV4(node) {
   return node.type === "rule" && node.selector.includes(":root") && node.selector.includes(":host");
@@ -919,7 +1091,7 @@ function normalizeTailwindcssV4Declaration(decl) {
 var postcssPlugin = "postcss-weapp-tailwindcss-rename-plugin";
 
 // src/selectorParser/before-after.ts
-var _postcssselectorparser = require('postcss-selector-parser'); var _postcssselectorparser2 = _interopRequireDefault(_postcssselectorparser);
+
 var beforeAfterStateRef = null;
 var BEFORE_PSEUDO_RE = /^:?:before$/;
 var AFTER_PSEUDO_RE = /^:?:after$/;
@@ -929,7 +1101,7 @@ var beforeAfterParser = _postcssselectorparser2.default.call(void 0, (selectors)
     return;
   }
   selectors.walkPseudos((s) => {
-    if (_optionalChain([s, 'access', _15 => _15.parent, 'optionalAccess', _16 => _16.length]) === 1) {
+    if (_optionalChain([s, 'access', _26 => _26.parent, 'optionalAccess', _27 => _27.length]) === 1) {
       if (BEFORE_PSEUDO_RE.test(s.value)) {
         state.before = true;
       }
@@ -1032,13 +1204,13 @@ function getFallbackRemove(_rule, options) {
           maybeImportantId = true;
         }
         if (selector.type === "universal") {
-          _optionalChain([selector, 'access', _17 => _17.parent, 'optionalAccess', _18 => _18.remove, 'call', _19 => _19()]);
+          _optionalChain([selector, 'access', _28 => _28.parent, 'optionalAccess', _29 => _29.remove, 'call', _30 => _30()]);
         } else if (selector.type === "pseudo") {
           if (selector.value === ":is") {
-            if (maybeImportantId && _optionalChain([selector, 'access', _20 => _20.nodes, 'access', _21 => _21[0], 'optionalAccess', _22 => _22.type]) === "selector") {
+            if (maybeImportantId && _optionalChain([selector, 'access', _31 => _31.nodes, 'access', _32 => _32[0], 'optionalAccess', _33 => _33.type]) === "selector") {
               selector.replaceWith(selector.nodes[0]);
             } else {
-              _optionalChain([selector, 'access', _23 => _23.parent, 'optionalAccess', _24 => _24.remove, 'call', _25 => _25()]);
+              _optionalChain([selector, 'access', _34 => _34.parent, 'optionalAccess', _35 => _35.remove, 'call', _36 => _36()]);
             }
           } else if (selector.value === ":not") {
             for (const x of selector.nodes) {
@@ -1061,7 +1233,7 @@ function getFallbackRemove(_rule, options) {
           }
         } else if (selector.type === "attribute") {
           if (selector.attribute === "hidden") {
-            _optionalChain([activeRule, 'optionalAccess', _26 => _26.remove, 'call', _27 => _27()]);
+            _optionalChain([activeRule, 'optionalAccess', _37 => _37.remove, 'call', _38 => _38()]);
           }
         }
       });
@@ -1147,7 +1319,7 @@ function getEscapeOptions(escapeMap) {
   return cached;
 }
 function internalCssSelectorReplacer(selectors, options) {
-  const escapeMap = _optionalChain([options, 'optionalAccess', _28 => _28.escapeMap]);
+  const escapeMap = _optionalChain([options, 'optionalAccess', _39 => _39.escapeMap]);
   if (escapeMap === void 0 || escapeMap === _escape.MappingChars2String) {
     return _escape.escape.call(void 0, selectors);
   }
@@ -1191,7 +1363,7 @@ function reorderLiteralFirst(rule, declarations, isVariable) {
   if (alreadyOrdered) {
     return;
   }
-  const anchor = _nullishCoalesce(_optionalChain([declarations, 'access', _29 => _29.at, 'call', _30 => _30(-1), 'optionalAccess', _31 => _31.next, 'call', _32 => _32()]), () => ( void 0));
+  const anchor = _nullishCoalesce(_optionalChain([declarations, 'access', _40 => _40.at, 'call', _41 => _41(-1), 'optionalAccess', _42 => _42.next, 'call', _43 => _43()]), () => ( void 0));
   for (const decl of declarations) {
     decl.remove();
   }
@@ -1269,7 +1441,7 @@ function isNotLastChildPseudo(node) {
   if (!firstSelector || firstSelector.type !== "selector") {
     return false;
   }
-  const target = _optionalChain([firstSelector, 'access', _33 => _33.nodes, 'optionalAccess', _34 => _34[0]]);
+  const target = _optionalChain([firstSelector, 'access', _44 => _44.nodes, 'optionalAccess', _45 => _45[0]]);
   return Boolean(target && target.type === "pseudo" && target.value === ":last-child");
 }
 function transformSpacingSelector(nodes2, options) {
@@ -1381,7 +1553,7 @@ function flattenWherePseudo(node, context, index, parent) {
     node.value = ":is";
   }
   if (index === 0 && node.length === 1) {
-    const targetSelector = _optionalChain([node, 'access', _35 => _35.nodes, 'optionalAccess', _36 => _36[0]]);
+    const targetSelector = _optionalChain([node, 'access', _46 => _46.nodes, 'optionalAccess', _47 => _47[0]]);
     if (targetSelector && targetSelector.type === "selector" && transformSpacingSelector(targetSelector.nodes, context.options)) {
       context.requiresSpacingNormalization = true;
     }
@@ -1449,7 +1621,7 @@ function handleCombinatorNode(node, index, context) {
   if (node.type !== "combinator" || node.value !== ">") {
     return;
   }
-  const nodes2 = _optionalChain([node, 'access', _37 => _37.parent, 'optionalAccess', _38 => _38.nodes]);
+  const nodes2 = _optionalChain([node, 'access', _48 => _48.parent, 'optionalAccess', _49 => _49.nodes]);
   if (!nodes2) {
     return;
   }
@@ -1502,7 +1674,7 @@ function canSkipRuleTransform(rule) {
 }
 function transformSelectors(selectors, context) {
   selectors.walk((node, index) => {
-    const parent = _optionalChain([node, 'access', _39 => _39.parent, 'optionalAccess', _40 => _40.type]) === "selector" ? node.parent : void 0;
+    const parent = _optionalChain([node, 'access', _50 => _50.parent, 'optionalAccess', _51 => _51.type]) === "selector" ? node.parent : void 0;
     switch (node.type) {
       case "class":
         handleClassNode(node, context);
@@ -1549,8 +1721,8 @@ function createRuleTransformer(options) {
   let context;
   const selectorResultCache = /* @__PURE__ */ new Map();
   const selectorResultCacheLimit = 5e4;
-  const rootReplacement = _optionalChain([options, 'access', _41 => _41.cssSelectorReplacement, 'optionalAccess', _42 => _42.root]) ? composeIsPseudo(options.cssSelectorReplacement.root) : void 0;
-  const universalReplacement = _optionalChain([options, 'access', _43 => _43.cssSelectorReplacement, 'optionalAccess', _44 => _44.universal]) ? composeIsPseudo(options.cssSelectorReplacement.universal) : void 0;
+  const rootReplacement = _optionalChain([options, 'access', _52 => _52.cssSelectorReplacement, 'optionalAccess', _53 => _53.root]) ? composeIsPseudo(options.cssSelectorReplacement.root) : void 0;
+  const universalReplacement = _optionalChain([options, 'access', _54 => _54.cssSelectorReplacement, 'optionalAccess', _55 => _55.universal]) ? composeIsPseudo(options.cssSelectorReplacement.universal) : void 0;
   const selectorReplacerOptions = options.escapeMap ? { escapeMap: options.escapeMap } : void 0;
   function writeSelectorResultCache(selector, result) {
     if (selectorResultCache.size >= selectorResultCacheLimit) {
@@ -1598,7 +1770,7 @@ function createRuleTransformer(options) {
     } finally {
       const currentContext = context;
       wasRemoved = rule.parent == null;
-      requiresSpacingNormalization = _optionalChain([currentContext, 'optionalAccess', _45 => _45.requiresSpacingNormalization]) === true;
+      requiresSpacingNormalization = _optionalChain([currentContext, 'optionalAccess', _56 => _56.requiresSpacingNormalization]) === true;
       context = void 0;
     }
     if (wasRemoved) {
@@ -1822,6 +1994,7 @@ function dedupeDeclarations(rule) {
 }
 
 // src/plugins/post/specificity-cleaner.ts
+var FALLBACK_PLACEHOLDER_SUFFIXES = [":not(#n)", ":not(#\\#)"];
 function normalizeSelectorList(value) {
   if (value === void 0 || value === false) {
     return [];
@@ -1829,21 +2002,60 @@ function normalizeSelectorList(value) {
   return Array.isArray(value) ? value.filter(Boolean) : [value];
 }
 function getSpecificityMatchingName(options) {
-  const feature = _optionalChain([options, 'access', _46 => _46.cssPresetEnv, 'optionalAccess', _47 => _47.features, 'optionalAccess', _48 => _48["is-pseudo-class"]]);
+  const feature = _optionalChain([options, 'access', _57 => _57.cssPresetEnv, 'optionalAccess', _58 => _58.features, 'optionalAccess', _59 => _59["is-pseudo-class"]]);
   if (feature && typeof feature === "object" && "specificityMatchingName" in feature) {
     const specificityName = feature.specificityMatchingName;
     return typeof specificityName === "string" && specificityName.length > 0 ? specificityName : void 0;
   }
   return void 0;
 }
+function replaceFallbackPlaceholder(selector) {
+  let output = selector;
+  for (const suffix of FALLBACK_PLACEHOLDER_SUFFIXES) {
+    if (output.includes(suffix)) {
+      output = output.split(suffix).join("");
+    }
+  }
+  return output;
+}
+function createFallbackPlaceholderReplacer() {
+  return (code) => {
+    let output = code;
+    for (const suffix of FALLBACK_PLACEHOLDER_SUFFIXES) {
+      if (output.includes(suffix)) {
+        output = output.split(suffix).join("");
+      }
+    }
+    return output;
+  };
+}
+function createFallbackPlaceholderCleaner() {
+  return (rule) => {
+    if (!rule.selectors || rule.selectors.length === 0) {
+      return;
+    }
+    let changed = false;
+    const next = rule.selectors.map((selector) => {
+      const updated = replaceFallbackPlaceholder(selector);
+      if (updated !== selector) {
+        changed = true;
+      }
+      return updated;
+    });
+    changed && assignRuleSelectors(rule, next, {
+      phase: "post",
+      reason: "clean-fallback-placeholder"
+    });
+  };
+}
 function createRootSpecificityCleaner(options) {
   const specificityMatchingName = getSpecificityMatchingName(options);
-  const selectors = normalizeSelectorList(_optionalChain([options, 'access', _49 => _49.cssSelectorReplacement, 'optionalAccess', _50 => _50.root]));
+  const selectors = normalizeSelectorList(_optionalChain([options, 'access', _60 => _60.cssSelectorReplacement, 'optionalAccess', _61 => _61.root]));
   if (!specificityMatchingName || selectors.length === 0) {
     return void 0;
   }
   const suffix = `:not(.${specificityMatchingName})`;
-  const targets = selectors.map((selector) => _optionalChain([selector, 'optionalAccess', _51 => _51.trim, 'call', _52 => _52()])).filter((selector) => Boolean(_optionalChain([selector, 'optionalAccess', _53 => _53.length]))).map((selector) => ({
+  const targets = selectors.map((selector) => _optionalChain([selector, 'optionalAccess', _62 => _62.trim, 'call', _63 => _63()])).filter((selector) => Boolean(_optionalChain([selector, 'optionalAccess', _64 => _64.length]))).map((selector) => ({
     match: `${selector}${suffix}`,
     spacedMatch: `${selector} ${suffix}`,
     replacement: selector
@@ -1887,7 +2099,7 @@ function normalizeRootSelectors(value) {
   return Array.isArray(value) ? value.filter(Boolean) : [value];
 }
 function createHostSelectorAppender(options) {
-  const rootSelectors = normalizeRootSelectors(_optionalChain([options, 'access', _54 => _54.cssSelectorReplacement, 'optionalAccess', _55 => _55.root]));
+  const rootSelectors = normalizeRootSelectors(_optionalChain([options, 'access', _65 => _65.cssSelectorReplacement, 'optionalAccess', _66 => _66.root]));
   const shouldAppendHostSelector = rootSelectors.length === DEFAULT_ROOT_SELECTORS.length && rootSelectors.every((selector, index) => selector === DEFAULT_ROOT_SELECTORS[index]);
   if (!shouldAppendHostSelector) {
     return void 0;
@@ -1908,17 +2120,19 @@ var postcssWeappTailwindcssPostPlugin = (options) => {
     postcssPlugin
   };
   const cleanRootSpecificity = createRootSpecificityCleaner(opts);
+  const cleanFallbackPlaceholder = createFallbackPlaceholderCleaner();
   const shouldAppendHostSelector = createHostSelectorAppender(opts);
   const enableMainChunkTransforms = opts.isMainChunk !== false;
   if (enableMainChunkTransforms || cleanRootSpecificity) {
     const fallbackRemove = enableMainChunkTransforms ? getFallbackRemove(void 0, opts) : void 0;
     p.RuleExit = (rule) => {
       if (enableMainChunkTransforms) {
-        _optionalChain([fallbackRemove, 'optionalAccess', _56 => _56.transformSync, 'call', _57 => _57(rule)]);
+        _optionalChain([fallbackRemove, 'optionalAccess', _67 => _67.transformSync, 'call', _68 => _68(rule)]);
       }
-      _optionalChain([cleanRootSpecificity, 'optionalCall', _58 => _58(rule)]);
+      cleanFallbackPlaceholder(rule);
+      _optionalChain([cleanRootSpecificity, 'optionalCall', _69 => _69(rule)]);
       if (enableMainChunkTransforms) {
-        if (_optionalChain([shouldAppendHostSelector, 'optionalCall', _59 => _59(rule)])) {
+        if (_optionalChain([shouldAppendHostSelector, 'optionalCall', _70 => _70(rule)])) {
           appendRuleSelector(rule, ":host", {
             phase: "post",
             reason: "append-host-selector"
@@ -1947,7 +2161,7 @@ var postcssWeappTailwindcssPostPlugin = (options) => {
       if (opts.cssRemoveProperty && atRule.name === "property") {
         atRule.remove();
       }
-      _optionalChain([atRule, 'access', _60 => _60.nodes, 'optionalAccess', _61 => _61.length]) === 0 && atRule.remove();
+      _optionalChain([atRule, 'access', _71 => _71.nodes, 'optionalAccess', _72 => _72.length]) === 0 && atRule.remove();
     };
   }
   return p;
@@ -2229,7 +2443,7 @@ function remakeCssVarSelector(selectors, options) {
   return selectors;
 }
 function resolveUniAppXVariableScopeSelectors(options) {
-  const universal = _optionalChain([options, 'access', _62 => _62.cssSelectorReplacement, 'optionalAccess', _63 => _63.universal]);
+  const universal = _optionalChain([options, 'access', _73 => _73.cssSelectorReplacement, 'optionalAccess', _74 => _74.universal]);
   if (Array.isArray(universal) && universal.length > 0) {
     return [...universal];
   }
@@ -2241,7 +2455,7 @@ function resolveUniAppXVariableScopeSelectors(options) {
 function commonChunkPreflight(node, options) {
   const { ctx, cssInjectPreflight, injectAdditionalCssVarScope } = options;
   const uniAppXEnabled = isUniAppXEnabled(options);
-  const rootOption = _optionalChain([options, 'access', _64 => _64.cssSelectorReplacement, 'optionalAccess', _65 => _65.root]);
+  const rootOption = _optionalChain([options, 'access', _75 => _75.cssSelectorReplacement, 'optionalAccess', _76 => _76.root]);
   const rootSelectors = rootOption === false || rootOption === void 0 ? [] : Array.isArray(rootOption) ? rootOption.filter(Boolean) : [rootOption];
   const hasHostSelector = node.selectors.some((selector) => selector.includes(":host"));
   const hasRootPseudoSelector = node.selectors.some((selector) => selector.includes(":root"));
@@ -2253,7 +2467,7 @@ function commonChunkPreflight(node, options) {
     });
   }
   if (testIfVariablesScope(node) || uniAppXEnabled && node.selectors.includes("*") && hasTwVars(node, 2)) {
-    _optionalChain([ctx, 'optionalAccess', _66 => _66.markVariablesScope, 'call', _67 => _67(node)]);
+    _optionalChain([ctx, 'optionalAccess', _77 => _77.markVariablesScope, 'call', _78 => _78(node)]);
     assignRuleSelectors(node, uniAppXEnabled ? resolveUniAppXVariableScopeSelectors(options) : remakeCssVarSelector(node.selectors, options), {
       phase: "pre",
       reason: "rewrite-variable-scope"
@@ -2325,9 +2539,9 @@ var postcssWeappTailwindcssPrePlugin = (options) => {
       root.walkAtRules((atRule) => {
         if (atRule.name === "layer") {
           if (atRule.params === "properties") {
-            if (atRule.nodes === void 0 || _optionalChain([atRule, 'access', _68 => _68.nodes, 'optionalAccess', _69 => _69.length]) === 0) {
+            if (atRule.nodes === void 0 || _optionalChain([atRule, 'access', _79 => _79.nodes, 'optionalAccess', _80 => _80.length]) === 0) {
               layerProperties = atRule;
-            } else if (_optionalChain([atRule, 'access', _70 => _70.first, 'optionalAccess', _71 => _71.type]) === "atrule" && isTailwindcssV4ModernCheck(atRule.first)) {
+            } else if (_optionalChain([atRule, 'access', _81 => _81.first, 'optionalAccess', _82 => _82.type]) === "atrule" && isTailwindcssV4ModernCheck(atRule.first)) {
               if (layerProperties) {
                 layerProperties.replaceWith(atRule.first.nodes);
                 atRule.remove();
@@ -2339,7 +2553,7 @@ var postcssWeappTailwindcssPrePlugin = (options) => {
             atRule.replaceWith(atRule.nodes);
           }
         } else if (isTailwindcssV4ModernCheck(atRule)) {
-          if (_optionalChain([atRule, 'access', _72 => _72.first, 'optionalAccess', _73 => _73.type]) === "atrule" && atRule.first.name === "layer") {
+          if (_optionalChain([atRule, 'access', _83 => _83.first, 'optionalAccess', _84 => _84.type]) === "atrule" && atRule.first.name === "layer") {
             atRule.replaceWith(atRule.first.nodes);
           }
         }
@@ -2373,16 +2587,42 @@ function createPreparedNode(id, stage, createPlugin) {
     createPlugin
   };
 }
-function createPreparedNodes(options) {
+function hasUserAutoprefixerPlugin(rawPlugins, plugins) {
+  if (plugins.some((plugin) => isAutoprefixerPlugin(plugin))) {
+    return true;
+  }
+  if (rawPlugins && !Array.isArray(rawPlugins) && typeof rawPlugins === "object") {
+    const autoprefixerEntry = rawPlugins["autoprefixer"];
+    return Boolean(autoprefixerEntry);
+  }
+  return false;
+}
+function shouldUseDefaultAutoprefixer(options, userPlugins) {
+  if (options.autoprefixer === false) {
+    return false;
+  }
+  if (hasUserAutoprefixerPlugin(_optionalChain([options, 'access', _85 => _85.postcssOptions, 'optionalAccess', _86 => _86.plugins]), userPlugins)) {
+    return false;
+  }
+  if (options.autoprefixer === true || typeof options.autoprefixer === "object") {
+    return true;
+  }
+  return options.majorVersion === 4;
+}
+function createPreparedNodes(options, signal) {
   const preparedNodes = [];
-  const userPlugins = normalizeUserPlugins(_optionalChain([options, 'access', _74 => _74.postcssOptions, 'optionalAccess', _75 => _75.plugins]));
+  const userPlugins = normalizeUserPlugins(_optionalChain([options, 'access', _87 => _87.postcssOptions, 'optionalAccess', _88 => _88.plugins]));
   const presetEnvOptions = options.cssPresetEnv;
   userPlugins.forEach((plugin, index) => {
     preparedNodes.push(createPreparedNode(`pre:user-${index}`, "pre", () => plugin));
   });
   preparedNodes.push(createPreparedNode("pre:core", "pre", () => postcssWeappTailwindcssPrePlugin(options)));
-  preparedNodes.push(createPreparedNode("normal:preset-env", "normal", () => _postcsspresetenv2.default.call(void 0, presetEnvOptions)));
-  preparedNodes.push(createPreparedNode("normal:color-functional-fallback", "normal", () => createColorFunctionalFallback()));
+  if (!signal || signal.hasPresetEnvFeatures) {
+    preparedNodes.push(createPreparedNode("normal:preset-env", "normal", () => _postcsspresetenv2.default.call(void 0, presetEnvOptions)));
+  }
+  if (!signal || signal.hasModernColorFunction) {
+    preparedNodes.push(createPreparedNode("normal:color-functional-fallback", "normal", () => createColorFunctionalFallback()));
+  }
   const unitsToPxPlugin = getUnitsToPxPlugin(options);
   if (unitsToPxPlugin) {
     preparedNodes.push(createPreparedNode("normal:units-to-px", "normal", () => unitsToPxPlugin));
@@ -2407,12 +2647,18 @@ function createPreparedNodes(options) {
   if (customPropertyCleaner) {
     preparedNodes.push(createPreparedNode("normal:custom-property-cleaner", "normal", () => customPropertyCleaner));
   }
+  if (shouldUseDefaultAutoprefixer(options, userPlugins)) {
+    const plugin = resolveAutoprefixerPlugin(options.autoprefixer);
+    if (plugin) {
+      preparedNodes.push(createPreparedNode("normal:autoprefixer", "normal", () => plugin));
+    }
+  }
   preparedNodes.push(createPreparedNode("post:core", "post", () => postcssWeappTailwindcssPostPlugin(options)));
   return preparedNodes;
 }
-function createStylePipeline(options) {
+function createStylePipeline(options, signal) {
   options.ctx = createContext();
-  const preparedNodes = createPreparedNodes(options);
+  const preparedNodes = createPreparedNodes(options, signal);
   if (preparedNodes.length === 0) {
     return {
       nodes: [],
@@ -2471,7 +2717,7 @@ function createStylePipeline(options) {
 function createProcessOptions(options) {
   return {
     from: void 0,
-    ..._nullishCoalesce(_optionalChain([options, 'access', _76 => _76.postcssOptions, 'optionalAccess', _77 => _77.options]), () => ( {}))
+    ..._nullishCoalesce(_optionalChain([options, 'access', _89 => _89.postcssOptions, 'optionalAccess', _90 => _90.options]), () => ( {}))
   };
 }
 function getSimpleProcessOptionsCacheKey(options) {
@@ -2503,14 +2749,13 @@ function getSimpleProcessOptionsCacheKey(options) {
   }
   return parts.join("|");
 }
-var StyleProcessorCache = (_class = class {constructor() { _class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this); }
-  __init() {this.pipelineCache = /* @__PURE__ */ new WeakMap()}
+var StyleProcessorCache = (_class = class {constructor() { _class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this); }
+  __init() {this.pipelineCacheByKey = /* @__PURE__ */ new Map()}
   __init2() {this.processOptionsCache = /* @__PURE__ */ new WeakMap()}
-  __init3() {this.processorCache = /* @__PURE__ */ new WeakMap()}
-  __init4() {this.processorCacheByKey = /* @__PURE__ */ new Map()}
-  __init5() {this.processorKeyCache = /* @__PURE__ */ new WeakMap()}
+  __init3() {this.processorCacheByKey = /* @__PURE__ */ new Map()}
+  __init4() {this.processorKeyCache = /* @__PURE__ */ new WeakMap()}
   createProcessorCacheKey(options) {
-    const from = _optionalChain([options, 'access', _78 => _78.postcssOptions, 'optionalAccess', _79 => _79.options, 'optionalAccess', _80 => _80.from]);
+    const from = _optionalChain([options, 'access', _91 => _91.postcssOptions, 'optionalAccess', _92 => _92.options, 'optionalAccess', _93 => _93.from]);
     if (from == null) {
       return fingerprintOptions(options);
     }
@@ -2519,22 +2764,37 @@ var StyleProcessorCache = (_class = class {constructor() { _class.prototype.__in
       postcssOptions: {
         ..._nullishCoalesce(options.postcssOptions, () => ( {})),
         options: {
-          ..._nullishCoalesce(_optionalChain([options, 'access', _81 => _81.postcssOptions, 'optionalAccess', _82 => _82.options]), () => ( {})),
+          ..._nullishCoalesce(_optionalChain([options, 'access', _94 => _94.postcssOptions, 'optionalAccess', _95 => _95.options]), () => ( {})),
           from: void 0
         }
       }
     });
   }
-  getPipeline(options) {
-    let pipeline = this.pipelineCache.get(options);
+  /**
+   * 构建包含信号的复合缓存键
+   */
+  createCompositeCacheKey(optionsFingerprint, signal) {
+    if (!signal) {
+      return optionsFingerprint;
+    }
+    return `${optionsFingerprint}|${signalToCacheKey(signal)}`;
+  }
+  getPipeline(options, signal) {
+    let optionsKey = this.processorKeyCache.get(options);
+    if (!optionsKey) {
+      optionsKey = this.createProcessorCacheKey(options);
+      this.processorKeyCache.set(options, optionsKey);
+    }
+    const compositeKey = this.createCompositeCacheKey(optionsKey, signal);
+    let pipeline = this.pipelineCacheByKey.get(compositeKey);
     if (!pipeline) {
-      pipeline = createStylePipeline(options);
-      this.pipelineCache.set(options, pipeline);
+      pipeline = createStylePipeline(options, signal);
+      this.pipelineCacheByKey.set(compositeKey, pipeline);
     }
     return pipeline;
   }
   getProcessOptions(options) {
-    const source = _optionalChain([options, 'access', _83 => _83.postcssOptions, 'optionalAccess', _84 => _84.options]);
+    const source = _optionalChain([options, 'access', _96 => _96.postcssOptions, 'optionalAccess', _97 => _97.options]);
     const cacheKey = source ? _nullishCoalesce(getSimpleProcessOptionsCacheKey(source), () => ( fingerprintOptions(source))) : void 0;
     const cached = this.processOptionsCache.get(options);
     if (!cached || cached.cacheKey !== cacheKey) {
@@ -2544,27 +2804,33 @@ var StyleProcessorCache = (_class = class {constructor() { _class.prototype.__in
     }
     return { ...cached.value };
   }
-  getProcessor(options) {
-    let processor = this.processorCache.get(options);
+  getProcessor(options, signal) {
+    let optionsKey = this.processorKeyCache.get(options);
+    if (!optionsKey) {
+      optionsKey = this.createProcessorCacheKey(options);
+      this.processorKeyCache.set(options, optionsKey);
+    }
+    const compositeKey = this.createCompositeCacheKey(optionsKey, signal);
+    let processor = this.processorCacheByKey.get(compositeKey);
     if (!processor) {
-      let cacheKey = this.processorKeyCache.get(options);
-      if (!cacheKey) {
-        cacheKey = this.createProcessorCacheKey(options);
-        this.processorKeyCache.set(options, cacheKey);
-      }
-      processor = this.processorCacheByKey.get(cacheKey);
-      if (!processor) {
-        const pipeline = this.getPipeline(options);
-        processor = _postcss2.default.call(void 0, pipeline.plugins);
-        this.processorCacheByKey.set(cacheKey, processor);
-      }
-      this.processorCache.set(options, processor);
+      const pipeline = this.getPipeline(options, signal);
+      processor = _postcss2.default.call(void 0, pipeline.plugins);
+      this.processorCacheByKey.set(compositeKey, processor);
     }
     return processor;
   }
 }, _class);
 
 // src/handler.ts
+var CSS_RESULT_CACHE_MAX = 256;
+function simpleHash(str) {
+  let hash = 2166136261 | 0;
+  for (let i = 0; i < str.length; i++) {
+    hash ^= str.charCodeAt(i);
+    hash = hash * 16777619 | 0;
+  }
+  return (hash >>> 0).toString(36);
+}
 function createStyleHandler(options) {
   const cachedOptions = _shared.defuOverrideArray.call(void 0, 
     options,
@@ -2572,22 +2838,57 @@ function createStyleHandler(options) {
   );
   cachedOptions.cssInjectPreflight = createInjectPreflight(cachedOptions.cssPreflight);
   const resolver = createOptionsResolver(cachedOptions);
-  const cache = new StyleProcessorCache();
+  const processorCache = new StyleProcessorCache();
   const base = resolver.resolve();
-  cache.getProcessor(base);
-  cache.getProcessOptions(base);
+  processorCache.getProcessor(base);
+  processorCache.getProcessOptions(base);
+  const optionsFingerprintCache = /* @__PURE__ */ new WeakMap();
+  function getOptionsFingerprint(opts) {
+    const cached = optionsFingerprintCache.get(opts);
+    if (cached) {
+      return cached;
+    }
+    const fp = fingerprintOptions(opts);
+    optionsFingerprintCache.set(opts, fp);
+    return fp;
+  }
+  const resultCache = new (0, _lrucache.LRUCache)({ max: CSS_RESULT_CACHE_MAX });
+  const hasUserPlugins = Boolean(
+    _optionalChain([cachedOptions, 'access', _98 => _98.postcssOptions, 'optionalAccess', _99 => _99.plugins]) && (Array.isArray(cachedOptions.postcssOptions.plugins) ? cachedOptions.postcssOptions.plugins.length > 0 : typeof cachedOptions.postcssOptions.plugins === "object" && Object.keys(cachedOptions.postcssOptions.plugins).length > 0)
+  );
   const handler = ((rawSource, opt) => {
     const resolvedOptions = resolver.resolve(opt);
-    const processor = cache.getProcessor(resolvedOptions);
-    const processOptions = cache.getProcessOptions(resolvedOptions);
+    let signal;
+    if (!hasUserPlugins) {
+      try {
+        signal = probeFeatures(rawSource);
+      } catch (e3) {
+        signal = void 0;
+      }
+    }
+    const optsFp = getOptionsFingerprint(resolvedOptions);
+    const signalKey = signal ? signalToCacheKey(signal) : "";
+    const contentHash = simpleHash(rawSource);
+    const cacheKey = `${optsFp}|${signalKey}|${contentHash}`;
+    const cachedResult = resultCache.get(cacheKey);
+    if (cachedResult) {
+      return Promise.resolve(cachedResult);
+    }
+    const processor = processorCache.getProcessor(resolvedOptions, signal);
+    const processOptions = processorCache.getProcessOptions(resolvedOptions);
     return processor.process(
       rawSource,
       processOptions
-    ).async().then((result) => applyUniAppXBaseCompatibility(result, resolvedOptions));
+    ).async().then((result) => {
+      const baseCompatible = applyUniAppXBaseCompatibility(result, resolvedOptions);
+      const finalResult = applyUniAppXUvueCompatibility(baseCompatible, resolvedOptions);
+      resultCache.set(cacheKey, finalResult);
+      return finalResult;
+    });
   });
   handler.getPipeline = (opt) => {
     const resolvedOptions = resolver.resolve(opt);
-    return cache.getPipeline(resolvedOptions);
+    return processorCache.getPipeline(resolvedOptions);
   };
   return handler;
 }
@@ -2596,4 +2897,6 @@ function createStyleHandler(options) {
 
 
 
-exports.createInjectPreflight = createInjectPreflight; exports.createStyleHandler = createStyleHandler; exports.createStylePipeline = createStylePipeline; exports.internalCssSelectorReplacer = internalCssSelectorReplacer;
+
+
+exports.createFallbackPlaceholderReplacer = createFallbackPlaceholderReplacer; exports.createInjectPreflight = createInjectPreflight; exports.createStyleHandler = createStyleHandler; exports.createStylePipeline = createStylePipeline; exports.internalCssSelectorReplacer = internalCssSelectorReplacer; exports.postcssHtmlTransform = _chunk2Y3ULRB3js.html_transform_default;