@weapp-tailwindcss/postcss 2.1.6 → 2.2.0-alpha.1

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.1/node_modules/es-toolkit/dist/object/omit.mjs
 function omit(obj, keys) {
   const result = { ...obj };
   for (let i = 0; i < keys.length; i++) {
@@ -667,13 +839,52 @@ function getRemTransformPlugin(options) {
 }
 
 // src/plugins/getUnitsToPxPlugin.ts
-var _postcssunitstopx = require('postcss-units-to-px'); var _postcssunitstopx2 = _interopRequireDefault(_postcssunitstopx);
+var _postcssruleunitconverter = require('postcss-rule-unit-converter'); var _postcssruleunitconverter2 = _interopRequireDefault(_postcssruleunitconverter);
 function getUnitsToPxPlugin(options) {
   if (!options.unitsToPx) {
     return null;
   }
   const userOptions = typeof options.unitsToPx === "object" ? options.unitsToPx : void 0;
-  return _postcssunitstopx2.default.call(void 0, userOptions);
+  if (_optionalChain([userOptions, 'optionalAccess', _24 => _24.disabled]) || _optionalChain([userOptions, 'optionalAccess', _25 => _25.transform]) === false) {
+    return _postcssruleunitconverter2.default.call(void 0, { disabled: true });
+  }
+  const presetOptions = {};
+  const converterOptions = {
+    rules: []
+  };
+  if (_optionalChain([userOptions, 'optionalAccess', _26 => _26.minValue]) !== void 0) {
+    presetOptions.minValue = userOptions.minValue;
+    converterOptions.minValue = userOptions.minValue;
+  }
+  if (_optionalChain([userOptions, 'optionalAccess', _27 => _27.to]) !== void 0) {
+    presetOptions.to = userOptions.to;
+  }
+  if (_optionalChain([userOptions, 'optionalAccess', _28 => _28.transform]) !== void 0) {
+    presetOptions.transform = userOptions.transform;
+  }
+  if (_optionalChain([userOptions, 'optionalAccess', _29 => _29.unitMap]) !== void 0) {
+    presetOptions.unitMap = userOptions.unitMap;
+  }
+  if (_optionalChain([userOptions, 'optionalAccess', _30 => _30.exclude]) !== void 0) {
+    converterOptions.exclude = userOptions.exclude;
+  }
+  if (_optionalChain([userOptions, 'optionalAccess', _31 => _31.mediaQuery]) !== void 0) {
+    converterOptions.mediaQuery = userOptions.mediaQuery;
+  }
+  if (_optionalChain([userOptions, 'optionalAccess', _32 => _32.propList]) !== void 0) {
+    converterOptions.propList = userOptions.propList;
+  }
+  if (_optionalChain([userOptions, 'optionalAccess', _33 => _33.replace]) !== void 0) {
+    converterOptions.replace = userOptions.replace;
+  }
+  if (_optionalChain([userOptions, 'optionalAccess', _34 => _34.selectorBlackList]) !== void 0) {
+    converterOptions.selectorBlackList = userOptions.selectorBlackList;
+  }
+  if (_optionalChain([userOptions, 'optionalAccess', _35 => _35.unitPrecision]) !== void 0) {
+    converterOptions.unitPrecision = userOptions.unitPrecision;
+  }
+  converterOptions.rules = _postcssruleunitconverter.presets.unitsToPx(presetOptions);
+  return _postcssruleunitconverter2.default.call(void 0, converterOptions);
 }
 
 // src/plugins/post.ts
@@ -682,7 +893,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', _36 => _36.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 +1080,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', _37 => _37.majorVersion]) === 4;
 }
 function testIfRootHostForV4(node) {
   return node.type === "rule" && node.selector.includes(":root") && node.selector.includes(":host");
@@ -919,7 +1130,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 +1140,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', _38 => _38.parent, 'optionalAccess', _39 => _39.length]) === 1) {
       if (BEFORE_PSEUDO_RE.test(s.value)) {
         state.before = true;
       }
@@ -1032,13 +1243,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', _40 => _40.parent, 'optionalAccess', _41 => _41.remove, 'call', _42 => _42()]);
         } 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', _43 => _43.nodes, 'access', _44 => _44[0], 'optionalAccess', _45 => _45.type]) === "selector") {
               selector.replaceWith(selector.nodes[0]);
             } else {
-              _optionalChain([selector, 'access', _23 => _23.parent, 'optionalAccess', _24 => _24.remove, 'call', _25 => _25()]);
+              _optionalChain([selector, 'access', _46 => _46.parent, 'optionalAccess', _47 => _47.remove, 'call', _48 => _48()]);
             }
           } else if (selector.value === ":not") {
             for (const x of selector.nodes) {
@@ -1061,7 +1272,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', _49 => _49.remove, 'call', _50 => _50()]);
           }
         }
       });
@@ -1147,7 +1358,7 @@ function getEscapeOptions(escapeMap) {
   return cached;
 }
 function internalCssSelectorReplacer(selectors, options) {
-  const escapeMap = _optionalChain([options, 'optionalAccess', _28 => _28.escapeMap]);
+  const escapeMap = _optionalChain([options, 'optionalAccess', _51 => _51.escapeMap]);
   if (escapeMap === void 0 || escapeMap === _escape.MappingChars2String) {
     return _escape.escape.call(void 0, selectors);
   }
@@ -1191,7 +1402,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', _52 => _52.at, 'call', _53 => _53(-1), 'optionalAccess', _54 => _54.next, 'call', _55 => _55()]), () => ( void 0));
   for (const decl of declarations) {
     decl.remove();
   }
@@ -1269,7 +1480,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', _56 => _56.nodes, 'optionalAccess', _57 => _57[0]]);
   return Boolean(target && target.type === "pseudo" && target.value === ":last-child");
 }
 function transformSpacingSelector(nodes2, options) {
@@ -1381,7 +1592,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', _58 => _58.nodes, 'optionalAccess', _59 => _59[0]]);
     if (targetSelector && targetSelector.type === "selector" && transformSpacingSelector(targetSelector.nodes, context.options)) {
       context.requiresSpacingNormalization = true;
     }
@@ -1449,7 +1660,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', _60 => _60.parent, 'optionalAccess', _61 => _61.nodes]);
   if (!nodes2) {
     return;
   }
@@ -1502,7 +1713,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', _62 => _62.parent, 'optionalAccess', _63 => _63.type]) === "selector" ? node.parent : void 0;
     switch (node.type) {
       case "class":
         handleClassNode(node, context);
@@ -1549,8 +1760,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', _64 => _64.cssSelectorReplacement, 'optionalAccess', _65 => _65.root]) ? composeIsPseudo(options.cssSelectorReplacement.root) : void 0;
+  const universalReplacement = _optionalChain([options, 'access', _66 => _66.cssSelectorReplacement, 'optionalAccess', _67 => _67.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 +1809,7 @@ function createRuleTransformer(options) {
     } finally {
       const currentContext = context;
       wasRemoved = rule.parent == null;
-      requiresSpacingNormalization = _optionalChain([currentContext, 'optionalAccess', _45 => _45.requiresSpacingNormalization]) === true;
+      requiresSpacingNormalization = _optionalChain([currentContext, 'optionalAccess', _68 => _68.requiresSpacingNormalization]) === true;
       context = void 0;
     }
     if (wasRemoved) {
@@ -1822,6 +2033,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 +2041,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', _69 => _69.cssPresetEnv, 'optionalAccess', _70 => _70.features, 'optionalAccess', _71 => _71["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', _72 => _72.cssSelectorReplacement, 'optionalAccess', _73 => _73.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', _74 => _74.trim, 'call', _75 => _75()])).filter((selector) => Boolean(_optionalChain([selector, 'optionalAccess', _76 => _76.length]))).map((selector) => ({
     match: `${selector}${suffix}`,
     spacedMatch: `${selector} ${suffix}`,
     replacement: selector
@@ -1887,7 +2138,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', _77 => _77.cssSelectorReplacement, 'optionalAccess', _78 => _78.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 +2159,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', _79 => _79.transformSync, 'call', _80 => _80(rule)]);
       }
-      _optionalChain([cleanRootSpecificity, 'optionalCall', _58 => _58(rule)]);
+      cleanFallbackPlaceholder(rule);
+      _optionalChain([cleanRootSpecificity, 'optionalCall', _81 => _81(rule)]);
       if (enableMainChunkTransforms) {
-        if (_optionalChain([shouldAppendHostSelector, 'optionalCall', _59 => _59(rule)])) {
+        if (_optionalChain([shouldAppendHostSelector, 'optionalCall', _82 => _82(rule)])) {
           appendRuleSelector(rule, ":host", {
             phase: "post",
             reason: "append-host-selector"
@@ -1947,7 +2200,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', _83 => _83.nodes, 'optionalAccess', _84 => _84.length]) === 0 && atRule.remove();
     };
   }
   return p;
@@ -2229,7 +2482,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', _85 => _85.cssSelectorReplacement, 'optionalAccess', _86 => _86.universal]);
   if (Array.isArray(universal) && universal.length > 0) {
     return [...universal];
   }
@@ -2241,7 +2494,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', _87 => _87.cssSelectorReplacement, 'optionalAccess', _88 => _88.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 +2506,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', _89 => _89.markVariablesScope, 'call', _90 => _90(node)]);
     assignRuleSelectors(node, uniAppXEnabled ? resolveUniAppXVariableScopeSelectors(options) : remakeCssVarSelector(node.selectors, options), {
       phase: "pre",
       reason: "rewrite-variable-scope"
@@ -2325,9 +2578,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', _91 => _91.nodes, 'optionalAccess', _92 => _92.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', _93 => _93.first, 'optionalAccess', _94 => _94.type]) === "atrule" && isTailwindcssV4ModernCheck(atRule.first)) {
               if (layerProperties) {
                 layerProperties.replaceWith(atRule.first.nodes);
                 atRule.remove();
@@ -2339,7 +2592,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', _95 => _95.first, 'optionalAccess', _96 => _96.type]) === "atrule" && atRule.first.name === "layer") {
             atRule.replaceWith(atRule.first.nodes);
           }
         }
@@ -2373,16 +2626,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', _97 => _97.postcssOptions, 'optionalAccess', _98 => _98.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', _99 => _99.postcssOptions, 'optionalAccess', _100 => _100.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 +2686,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 +2756,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', _101 => _101.postcssOptions, 'optionalAccess', _102 => _102.options]), () => ( {}))
   };
 }
 function getSimpleProcessOptionsCacheKey(options) {
@@ -2503,14 +2788,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', _103 => _103.postcssOptions, 'optionalAccess', _104 => _104.options, 'optionalAccess', _105 => _105.from]);
     if (from == null) {
       return fingerprintOptions(options);
     }
@@ -2519,22 +2803,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', _106 => _106.postcssOptions, 'optionalAccess', _107 => _107.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', _108 => _108.postcssOptions, 'optionalAccess', _109 => _109.options]);
     const cacheKey = source ? _nullishCoalesce(getSimpleProcessOptionsCacheKey(source), () => ( fingerprintOptions(source))) : void 0;
     const cached = this.processOptionsCache.get(options);
     if (!cached || cached.cacheKey !== cacheKey) {
@@ -2544,27 +2843,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 +2877,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', _110 => _110.postcssOptions, 'optionalAccess', _111 => _111.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 +2936,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;