@weapp-tailwindcss/postcss 2.1.5-beta.0 → 2.1.6-alpha.0

package/dist/index.mjs

@@ -69,26 +69,151 @@ 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) {
+  let isMainChunk = SIMPLE_OVERRIDE_UNSET;
+  let majorVersion = SIMPLE_OVERRIDE_UNSET;
+  let cssRemoveProperty = SIMPLE_OVERRIDE_UNSET;
+  let cssRemoveHoverPseudoClass = SIMPLE_OVERRIDE_UNSET;
+  let uniAppX = SIMPLE_OVERRIDE_UNSET;
+  let cssPreflightRange = SIMPLE_OVERRIDE_UNSET;
+  let injectAdditionalCssVarScope = SIMPLE_OVERRIDE_UNSET;
+  let rem2rpx = SIMPLE_OVERRIDE_UNSET;
+  let px2rpx = SIMPLE_OVERRIDE_UNSET;
+  let unitsToPx = SIMPLE_OVERRIDE_UNSET;
+  let cssCalc = SIMPLE_OVERRIDE_UNSET;
+  let cssChildCombinatorReplaceValue = SIMPLE_OVERRIDE_UNSET;
+  let cssPreflight = SIMPLE_OVERRIDE_UNSET;
+  for (const key of Object.keys(options)) {
+    const value = options[key];
+    switch (key) {
+      case "isMainChunk":
+        if (typeof value !== "boolean") {
+          return void 0;
+        }
+        isMainChunk = value ? "1" : "0";
+        break;
+      case "majorVersion":
+        if (typeof value !== "number") {
+          return void 0;
+        }
+        majorVersion = String(value);
+        break;
+      case "cssRemoveProperty":
+        if (typeof value !== "boolean") {
+          return void 0;
+        }
+        cssRemoveProperty = value ? "1" : "0";
+        break;
+      case "cssRemoveHoverPseudoClass":
+        if (typeof value !== "boolean") {
+          return void 0;
+        }
+        cssRemoveHoverPseudoClass = value ? "1" : "0";
+        break;
+      case "uniAppX":
+        if (typeof value !== "boolean") {
+          return void 0;
+        }
+        uniAppX = value ? "1" : "0";
+        break;
+      case "cssPreflightRange":
+        if (typeof value !== "string") {
+          return void 0;
+        }
+        cssPreflightRange = value;
+        break;
+      case "injectAdditionalCssVarScope":
+        if (typeof value !== "boolean") {
+          return void 0;
+        }
+        injectAdditionalCssVarScope = value ? "1" : "0";
+        break;
+      case "rem2rpx":
+        if (typeof value !== "boolean") {
+          return void 0;
+        }
+        rem2rpx = value ? "1" : "0";
+        break;
+      case "px2rpx":
+        if (typeof value !== "boolean") {
+          return void 0;
+        }
+        px2rpx = value ? "1" : "0";
+        break;
+      case "unitsToPx":
+        if (typeof value !== "boolean") {
+          return void 0;
+        }
+        unitsToPx = value ? "1" : "0";
+        break;
+      case "cssCalc":
+        if (typeof value !== "boolean") {
+          return void 0;
+        }
+        cssCalc = value ? "1" : "0";
+        break;
+      case "cssChildCombinatorReplaceValue":
+        if (typeof value !== "string") {
+          return void 0;
+        }
+        cssChildCombinatorReplaceValue = value;
+        break;
+      case "cssPreflight":
+        if (value !== false) {
+          return void 0;
+        }
+        cssPreflight = "0";
+        break;
+      default:
+        return void 0;
+    }
+  }
+  return [
+    "simple",
+    isMainChunk,
+    majorVersion,
+    cssRemoveProperty,
+    cssRemoveHoverPseudoClass,
+    uniAppX,
+    cssPreflightRange,
+    injectAdditionalCssVarScope,
+    rem2rpx,
+    px2rpx,
+    unitsToPx,
+    cssCalc,
+    cssChildCombinatorReplaceValue,
+    cssPreflight
+  ].join(":");
+}
 function hasOverrides(options) {
   return Boolean(options && Object.keys(options).length > 0);
 }
 function createOptionsResolver(baseOptions) {
   const cacheByKey = /* @__PURE__ */ new Map();
   const cacheByRef = /* @__PURE__ */ new WeakMap();
-  const fingerprintByRef = /* @__PURE__ */ new WeakMap();
+  const cacheKeyByRef = /* @__PURE__ */ new WeakMap();
+  const emptyOverrideRefs = /* @__PURE__ */ new WeakSet();
   cacheByKey.set(BASE_CACHE_KEY, baseOptions);
   const resolve = (overrides) => {
-    if (!hasOverrides(overrides)) {
+    if (!overrides) {
       return baseOptions;
     }
     const refCached = cacheByRef.get(overrides);
     if (refCached) {
       return refCached;
     }
-    let key = fingerprintByRef.get(overrides);
+    if (emptyOverrideRefs.has(overrides)) {
+      return baseOptions;
+    }
+    if (!hasOverrides(overrides)) {
+      emptyOverrideRefs.add(overrides);
+      return baseOptions;
+    }
+    let key = cacheKeyByRef.get(overrides);
     if (!key) {
-      key = fingerprintOptions(overrides);
-      fingerprintByRef.set(overrides, key);
+      key = getSimpleOverrideCacheKey(overrides) ?? fingerprintOptions(overrides);
+      cacheKeyByRef.set(overrides, key);
     }
     const cached = cacheByKey.get(key);
     if (cached) {
@@ -247,37 +372,38 @@ function createContext() {
 }
 
 // src/plugins/getCalcDuplicateCleaner.ts
+var calcDuplicateCleanerPlugin = {
+  postcssPlugin: "postcss-calc-duplicate-cleaner",
+  Rule(rule) {
+    rule.walkDecls((decl) => {
+      const prev = decl.prev();
+      if (!prev || prev.type !== "decl") {
+        return;
+      }
+      if (prev.prop !== decl.prop) {
+        return;
+      }
+      if (prev.important !== decl.important) {
+        return;
+      }
+      if (prev.value !== decl.value) {
+        return;
+      }
+      decl.remove();
+    });
+  }
+};
 function getCalcDuplicateCleaner(options) {
   if (!options.cssCalc) {
     return null;
   }
-  return {
-    postcssPlugin: "postcss-calc-duplicate-cleaner",
-    Rule(rule) {
-      rule.walkDecls((decl) => {
-        const prev = decl.prev();
-        if (!prev || prev.type !== "decl") {
-          return;
-        }
-        if (prev.prop !== decl.prop) {
-          return;
-        }
-        if (prev.important !== decl.important) {
-          return;
-        }
-        if (prev.value !== decl.value) {
-          return;
-        }
-        decl.remove();
-      });
-    }
-  };
+  return calcDuplicateCleanerPlugin;
 }
 
 // src/plugins/getCalcPlugin.ts
 import postcssCalc from "@weapp-tailwindcss/postcss-calc";
 
-// ../../node_modules/.pnpm/es-toolkit@1.44.0/node_modules/es-toolkit/dist/object/omit.mjs
+// ../../node_modules/.pnpm/es-toolkit@1.45.1/node_modules/es-toolkit/dist/object/omit.mjs
 function omit(obj, keys) {
   const result = { ...obj };
   for (let i = 0; i < keys.length; i++) {
@@ -288,12 +414,17 @@ function omit(obj, keys) {
 }
 
 // src/plugins/getCalcPlugin.ts
+var EMPTY_CALC_OPTIONS = {};
 function getCalcPlugin(options) {
   if (!options.cssCalc) {
     return null;
   }
-  const calcOptions = Array.isArray(options.cssCalc) ? {} : typeof options.cssCalc === "object" ? omit(options.cssCalc, ["includeCustomProperties"]) : {};
-  return postcssCalc(calcOptions);
+  if (options.cssCalc === true || Array.isArray(options.cssCalc)) {
+    return postcssCalc(EMPTY_CALC_OPTIONS);
+  }
+  return postcssCalc(
+    omit(options.cssCalc, ["includeCustomProperties"])
+  );
 }
 
 // src/plugins/getCustomPropertyCleaner.ts
@@ -305,6 +436,7 @@ function getCustomPropertyCleaner(options) {
   if (!shouldMatchCustomProperties) {
     return null;
   }
+  const shouldInspectValue = (value) => value.includes("var(") && value.includes("--");
   return {
     postcssPlugin: "postcss-remove-include-custom-properties",
     OnceExit(root) {
@@ -317,7 +449,7 @@ function getCustomPropertyCleaner(options) {
           decl.remove();
           return;
         }
-        if (!shouldMatchCustomProperties || !/--/.test(decl.value)) {
+        if (!shouldInspectValue(decl.value)) {
           return;
         }
         const parsed = valueParser2(decl.value);
@@ -365,10 +497,12 @@ function getPxTransformPlugin(options) {
   if (!options.px2rpx) {
     return null;
   }
-  const userOptions = typeof options.px2rpx === "object" ? options.px2rpx : {};
+  if (options.px2rpx === true) {
+    return postcssPxtrans(defaultPxTransformOptions);
+  }
   return postcssPxtrans(
     defuOverrideArray2(
-      userOptions,
+      options.px2rpx,
       defaultPxTransformOptions
     )
   );
@@ -385,13 +519,19 @@ var defaultRemOptions = {
 var defaultStage = {
   processorStage: "OnceExit"
 };
+var defaultRemTransformOptions = {
+  ...defaultRemOptions,
+  ...defaultStage
+};
 function getRemTransformPlugin(options) {
   if (!options.rem2rpx) {
     return null;
   }
-  const userOptions = typeof options.rem2rpx === "object" ? options.rem2rpx : defaultRemOptions;
+  if (options.rem2rpx === true) {
+    return postcssRem2rpx(defaultRemTransformOptions);
+  }
   const merged = defuOverrideArray3(
-    userOptions,
+    options.rem2rpx,
     defaultStage
   );
   return postcssRem2rpx(merged);
@@ -593,6 +733,12 @@ var OKLAB_SUFFIX = "in oklab";
 var INFINITY_CALC_REGEXP = /calc\(\s*infinity\s*\*\s*(?:\d+(?:\.\d*)?|\.\d+)r?px/;
 var RADIUS_THRESHOLD = 1e5;
 var CLAMP_PX = 9999;
+var MODERN_CHECK_WEBKIT_HYPHENS_RE = /-webkit-hyphens\s*:\s*none/;
+var MODERN_CHECK_MARGIN_TRIM_RE = /margin-trim\s*:\s*inline/;
+var MODERN_CHECK_MOZ_ORIENT_RE = /-moz-orient\s*:\s*inline/;
+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 options?.majorVersion === 4;
 }
@@ -602,10 +748,10 @@ function testIfRootHostForV4(node) {
 var cssVarsV4Nodes = createCssVarNodes(cssVarsV4_default);
 function isTailwindcssV4ModernCheck(atRule) {
   return atRule.name === "supports" && [
-    /-webkit-hyphens\s*:\s*none/,
-    /margin-trim\s*:\s*inline/,
-    /-moz-orient\s*:\s*inline/,
-    /color\s*:\s*rgb\(\s*from\s+red\s+r\s+g\s+b\s*\)/
+    MODERN_CHECK_WEBKIT_HYPHENS_RE,
+    MODERN_CHECK_MARGIN_TRIM_RE,
+    MODERN_CHECK_MOZ_ORIENT_RE,
+    MODERN_CHECK_COLOR_RGB_RE
   ].every((regex) => regex.test(atRule.params));
 }
 function normalizeTailwindcssV4Declaration(decl) {
@@ -618,14 +764,15 @@ function normalizeTailwindcssV4Declaration(decl) {
     return true;
   }
   if (decl.prop.includes("radius")) {
+    RADIUS_VALUE_RE.lastIndex = 0;
     const next = decl.value.replace(
-      /\b([+-]?(?:\d+(?:\.\d+)?|\.\d+)(?:e[+-]?\d+)?)\s*(r?px)\b/gi,
+      RADIUS_VALUE_RE,
       (m, num) => {
         const n = Number(num);
         if (!Number.isFinite(n)) {
           return `${CLAMP_PX}px`;
         }
-        if (/e/i.test(String(num)) || n > RADIUS_THRESHOLD) {
+        if (SCIENTIFIC_NOTATION_RE.test(String(num)) || n > RADIUS_THRESHOLD) {
           return `${CLAMP_PX}px`;
         }
         return m;
@@ -669,6 +816,8 @@ var postcssPlugin = "postcss-weapp-tailwindcss-rename-plugin";
 // src/selectorParser/before-after.ts
 import psp from "postcss-selector-parser";
 var beforeAfterStateRef = null;
+var BEFORE_PSEUDO_RE = /^:?:before$/;
+var AFTER_PSEUDO_RE = /^:?:after$/;
 var beforeAfterParser = psp((selectors) => {
   const state = beforeAfterStateRef;
   if (!state) {
@@ -676,10 +825,10 @@ var beforeAfterParser = psp((selectors) => {
   }
   selectors.walkPseudos((s) => {
     if (s.parent?.length === 1) {
-      if (/^:?:before$/.test(s.value)) {
+      if (BEFORE_PSEUDO_RE.test(s.value)) {
         state.before = true;
       }
-      if (/^:?:after$/.test(s.value)) {
+      if (AFTER_PSEUDO_RE.test(s.value)) {
         state.after = true;
       }
     }
@@ -701,6 +850,7 @@ import psp3 from "postcss-selector-parser";
 
 // src/selectorParser/utils.ts
 import psp2 from "postcss-selector-parser";
+var combinatorSelectorAstCache = /* @__PURE__ */ new WeakMap();
 function normalizeTransformOptions(options) {
   return {
     lossless: false,
@@ -738,12 +888,16 @@ function composeIsPseudoAst(strs) {
   }));
 }
 function getCombinatorSelectorAst(options) {
-  let childCombinatorReplaceValue = mklist(psp2.tag({ value: "view" }));
-  const { cssChildCombinatorReplaceValue } = options;
-  if (typeof cssChildCombinatorReplaceValue === "string" || Array.isArray(cssChildCombinatorReplaceValue) && cssChildCombinatorReplaceValue.length > 0) {
-    childCombinatorReplaceValue = composeIsPseudoAst(cssChildCombinatorReplaceValue);
+  let template = combinatorSelectorAstCache.get(options);
+  if (!template) {
+    template = mklist(psp2.tag({ value: "view" }));
+    const { cssChildCombinatorReplaceValue } = options;
+    if (typeof cssChildCombinatorReplaceValue === "string" || Array.isArray(cssChildCombinatorReplaceValue) && cssChildCombinatorReplaceValue.length > 0) {
+      template = composeIsPseudoAst(cssChildCombinatorReplaceValue);
+    }
+    combinatorSelectorAstCache.set(options, template);
   }
-  return childCombinatorReplaceValue;
+  return template.map((node) => node.clone());
 }
 
 // src/selectorParser/fallback.ts
@@ -754,8 +908,17 @@ function getFallbackRemove(_rule, options) {
   const cacheKey = options ?? fallbackDefaultKey;
   let entry = fallbackRemoveCache.get(cacheKey);
   if (!entry) {
+    let writeSelectorCache2 = function(selector, result) {
+      if (selectorCache.size >= selectorCacheLimit) {
+        selectorCache.clear();
+      }
+      selectorCache.set(selector, result);
+    };
+    var writeSelectorCache = writeSelectorCache2;
     const uniAppX = isUniAppXEnabled(options);
     let currentRule;
+    const selectorCache = /* @__PURE__ */ new Map();
+    const selectorCacheLimit = 5e4;
     const parser = psp3((selectors) => {
       const activeRule = currentRule;
       let maybeImportantId = false;
@@ -812,12 +975,33 @@ function getFallbackRemove(_rule, options) {
     });
     const rawTransformSync = parser.transformSync.bind(parser);
     const transform = (targetRule) => {
+      const sourceSelector = targetRule.selector;
+      if (!sourceSelector) {
+        return;
+      }
+      const cached = selectorCache.get(sourceSelector);
+      if (cached) {
+        if (cached.action === "remove") {
+          targetRule.remove();
+        } else if (cached.action === "update" && cached.selector && cached.selector !== sourceSelector) {
+          targetRule.selector = cached.selector;
+        }
+        return;
+      }
       currentRule = targetRule;
       try {
         rawTransformSync(targetRule, FALLBACK_TRANSFORM_OPTIONS);
       } finally {
         currentRule = void 0;
       }
+      const wasRemoved = targetRule.parent == null;
+      if (wasRemoved) {
+        writeSelectorCache2(sourceSelector, { action: "remove" });
+      } else if (targetRule.selector === sourceSelector) {
+        writeSelectorCache2(sourceSelector, { action: "keep" });
+      } else {
+        writeSelectorCache2(sourceSelector, { action: "update", selector: targetRule.selector });
+      }
     };
     parser.transformSync = ((input, opts) => {
       const transformOptions = opts ? normalizeTransformOptions(opts) : FALLBACK_TRANSFORM_OPTIONS;
@@ -848,15 +1032,21 @@ import psp4 from "postcss-selector-parser";
 
 // src/shared.ts
 import { escape, MappingChars2String } from "@weapp-core/escape";
-function internalCssSelectorReplacer(selectors, options = {
-  escapeMap: MappingChars2String
-}) {
-  const { escapeMap } = options;
-  const escapeOptions = {};
-  if (escapeMap !== void 0) {
-    escapeOptions["map"] = escapeMap;
+var escapeOptionsCache = /* @__PURE__ */ new WeakMap();
+function getEscapeOptions(escapeMap) {
+  let cached = escapeOptionsCache.get(escapeMap);
+  if (!cached) {
+    cached = { map: escapeMap };
+    escapeOptionsCache.set(escapeMap, cached);
   }
-  return escape(selectors, escapeOptions);
+  return cached;
+}
+function internalCssSelectorReplacer(selectors, options) {
+  const escapeMap = options?.escapeMap;
+  if (escapeMap === void 0 || escapeMap === MappingChars2String) {
+    return escape(selectors);
+  }
+  return escape(selectors, getEscapeOptions(escapeMap));
 }
 function composeIsPseudo(strs) {
   if (typeof strs === "string") {
@@ -896,7 +1086,7 @@ function reorderLiteralFirst(rule, declarations, isVariable) {
   if (alreadyOrdered) {
     return;
   }
-  const anchor = declarations[declarations.length - 1]?.next() ?? void 0;
+  const anchor = declarations.at(-1)?.next() ?? void 0;
   for (const decl of declarations) {
     decl.remove();
   }
@@ -935,49 +1125,32 @@ var LEGACY_WEBKIT_SPACING_PROPS = /* @__PURE__ */ new Set([
   "-webkit-margin-after"
 ]);
 var VAR_REFERENCE_PATTERN = /var\(/i;
-function dedupeSpacingProps(rule) {
-  const grouped = /* @__PURE__ */ new Map();
-  for (const node of rule.nodes) {
-    if (node.type !== "decl") {
-      continue;
-    }
-    if (!SPACING_PROP_SET.has(node.prop)) {
-      continue;
-    }
-    const list = grouped.get(node.prop);
-    if (list) {
-      list.push(node);
-    } else {
-      grouped.set(node.prop, [node]);
-    }
+function dedupeSpacingGroup(rule, declarations) {
+  if (declarations.length <= 1) {
+    return;
   }
-  for (const [, declarations] of grouped) {
-    if (declarations.length <= 1) {
+  const unique = [];
+  const seenValues = /* @__PURE__ */ new Set();
+  for (const decl of declarations) {
+    if (decl.parent !== rule) {
       continue;
     }
-    const unique = [];
-    const seenValues = /* @__PURE__ */ new Set();
-    for (const decl of declarations) {
-      if (decl.parent !== rule) {
-        continue;
-      }
-      const key = `${decl.important ? "!important@@" : ""}${decl.value}`;
-      if (seenValues.has(key)) {
-        decl.remove();
-        continue;
-      }
-      seenValues.add(key);
-      unique.push(decl);
-    }
-    if (unique.length <= 1) {
+    const key = `${decl.important ? "!important@@" : ""}${decl.value}`;
+    if (seenValues.has(key)) {
+      decl.remove();
       continue;
     }
-    reorderLiteralFirst(
-      rule,
-      unique,
-      (decl) => VAR_REFERENCE_PATTERN.test(decl.value)
-    );
+    seenValues.add(key);
+    unique.push(decl);
   }
+  if (unique.length <= 1) {
+    return;
+  }
+  reorderLiteralFirst(
+    rule,
+    unique,
+    (decl) => VAR_REFERENCE_PATTERN.test(decl.value)
+  );
 }
 function isNotLastChildPseudo(node) {
   if (!node || node.type !== "pseudo" || node.value !== ":not") {
@@ -1018,6 +1191,7 @@ function transformSpacingSelector(nodes2, options) {
   return false;
 }
 function normalizeSpacingDeclarations(rule) {
+  const grouped = /* @__PURE__ */ new Map();
   for (const node of [...rule.nodes]) {
     if (node.type !== "decl") {
       continue;
@@ -1030,8 +1204,19 @@ function normalizeSpacingDeclarations(rule) {
     if (mirror) {
       node.prop = mirror;
     }
+    if (!SPACING_PROP_SET.has(node.prop)) {
+      continue;
+    }
+    const declarations = grouped.get(node.prop);
+    if (declarations) {
+      declarations.push(node);
+    } else {
+      grouped.set(node.prop, [node]);
+    }
+  }
+  for (const declarations of grouped.values()) {
+    dedupeSpacingGroup(rule, declarations);
   }
-  dedupeSpacingProps(rule);
 }
 
 // src/selectorParser/rule-transformer.ts
@@ -1105,16 +1290,14 @@ function handleClassNode(node, context) {
   if (node.type !== "class") {
     return;
   }
-  const { escapeMap } = context.options;
-  node.value = escapeMap === void 0 ? internalCssSelectorReplacer(node.value, {}) : internalCssSelectorReplacer(node.value, { escapeMap });
+  node.value = context.selectorReplacerOptions === void 0 ? internalCssSelectorReplacer(node.value) : internalCssSelectorReplacer(node.value, context.selectorReplacerOptions);
 }
 function handleUniversalNode(node, context) {
   if (node.type !== "universal") {
     return;
   }
-  const replacement = context.options.cssSelectorReplacement?.universal;
-  if (replacement) {
-    node.value = composeIsPseudo(replacement);
+  if (context.universalReplacement) {
+    node.value = context.universalReplacement;
   }
 }
 function shouldRemoveHoverSelector(selector, options) {
@@ -1174,8 +1357,8 @@ function handlePseudoNode(node, index, context, parent) {
     stripUnsupportedRtlLanguagePseudo(node);
     return;
   }
-  if (node.value === ":root" && context.options.cssSelectorReplacement?.root) {
-    node.value = composeIsPseudo(context.options.cssSelectorReplacement.root);
+  if (node.value === ":root" && context.rootReplacement) {
+    node.value = context.rootReplacement;
     return;
   }
   if (node.value === ":where") {
@@ -1254,6 +1437,9 @@ function createRuleTransformer(options) {
   let context;
   const selectorResultCache = /* @__PURE__ */ new Map();
   const selectorResultCacheLimit = 5e4;
+  const rootReplacement = options.cssSelectorReplacement?.root ? composeIsPseudo(options.cssSelectorReplacement.root) : void 0;
+  const universalReplacement = options.cssSelectorReplacement?.universal ? composeIsPseudo(options.cssSelectorReplacement.universal) : void 0;
+  const selectorReplacerOptions = options.escapeMap ? { escapeMap: options.escapeMap } : void 0;
   function writeSelectorResultCache(selector, result) {
     if (selectorResultCache.size >= selectorResultCacheLimit) {
       selectorResultCache.clear();
@@ -1288,7 +1474,10 @@ function createRuleTransformer(options) {
     context = {
       options,
       requiresSpacingNormalization: false,
-      rule
+      rule,
+      rootReplacement,
+      universalReplacement,
+      selectorReplacerOptions
     };
     let wasRemoved = false;
     let requiresSpacingNormalization = false;
@@ -1360,6 +1549,8 @@ var variablePriorityProps = /* @__PURE__ */ new Set([
 function getCanonicalProp(prop) {
   return logicalPropMap.get(prop) ?? prop;
 }
+var NESTED_CALC_RE = /calc\(\s*calc\(/gi;
+var CALC_WRAP_RE = /calc\(\s*(1\s*-\s*var\([^()]+\))\s*\)/gi;
 function normalizeCalcValue(value) {
   if (!value.includes("calc")) {
     return value;
@@ -1368,9 +1559,11 @@ function normalizeCalcValue(value) {
   let prev;
   do {
     prev = next;
-    next = prev.replace(/calc\(\s*calc\(/gi, "calc((");
+    NESTED_CALC_RE.lastIndex = 0;
+    next = prev.replace(NESTED_CALC_RE, "calc((");
   } while (next !== prev);
-  return next.replace(/calc\(\s*(1\s*-\s*var\([^()]+\))\s*\)/gi, "($1)");
+  CALC_WRAP_RE.lastIndex = 0;
+  return next.replace(CALC_WRAP_RE, "($1)");
 }
 function hasVariableReference(value) {
   return value.includes("var(");
@@ -1515,16 +1708,19 @@ function normalizeRootSelectors(value) {
   }
   return Array.isArray(value) ? value.filter(Boolean) : [value];
 }
-function shouldAppendHostSelector(rule, options) {
-  const selectors = rule.selectors ?? [];
-  if (selectors.includes(":host")) {
-    return false;
-  }
+function createHostSelectorAppender(options) {
   const rootSelectors = normalizeRootSelectors(options.cssSelectorReplacement?.root);
-  if (rootSelectors.length !== DEFAULT_ROOT_SELECTORS.length || !rootSelectors.every((selector, index) => selector === DEFAULT_ROOT_SELECTORS[index])) {
-    return false;
+  const shouldAppendHostSelector = rootSelectors.length === DEFAULT_ROOT_SELECTORS.length && rootSelectors.every((selector, index) => selector === DEFAULT_ROOT_SELECTORS[index]);
+  if (!shouldAppendHostSelector) {
+    return void 0;
   }
-  return DEFAULT_ROOT_SELECTORS.every((selector) => selectors.includes(selector));
+  return (rule) => {
+    const selectors = rule.selectors ?? [];
+    if (selectors.includes(":host")) {
+      return false;
+    }
+    return DEFAULT_ROOT_SELECTORS.every((selector) => selectors.includes(selector));
+  };
 }
 var postcssWeappTailwindcssPostPlugin = (options) => {
   const opts = defu(options, {
@@ -1534,6 +1730,7 @@ var postcssWeappTailwindcssPostPlugin = (options) => {
     postcssPlugin
   };
   const cleanRootSpecificity = createRootSpecificityCleaner(opts);
+  const shouldAppendHostSelector = createHostSelectorAppender(opts);
   const enableMainChunkTransforms = opts.isMainChunk !== false;
   if (enableMainChunkTransforms || cleanRootSpecificity) {
     const fallbackRemove = enableMainChunkTransforms ? getFallbackRemove(void 0, opts) : void 0;
@@ -1543,7 +1740,7 @@ var postcssWeappTailwindcssPostPlugin = (options) => {
       }
       cleanRootSpecificity?.(rule);
       if (enableMainChunkTransforms) {
-        if (shouldAppendHostSelector(rule, opts)) {
+        if (shouldAppendHostSelector?.(rule)) {
           rule.selectors = [...rule.selectors, ":host"];
         }
         dedupeDeclarations(rule);
@@ -1884,8 +2081,11 @@ function commonChunkPreflight(node, options) {
 }
 
 // src/plugins/pre.ts
+var MEDIA_HOVER_NAME_RE = /media\(\s*hover\s*:\s*hover\s*\)/;
+var MEDIA_HOVER_PARAMS_RE = /\(\s*hover\s*:\s*hover\s*\)/;
+var COLOR_MIX_RE = /color-mix/;
 function isAtMediaHover(atRule) {
-  return /media\(\s*hover\s*:\s*hover\s*\)/.test(atRule.name) || atRule.name === "media" && /\(\s*hover\s*:\s*hover\s*\)/.test(atRule.params);
+  return MEDIA_HOVER_NAME_RE.test(atRule.name) || atRule.name === "media" && MEDIA_HOVER_PARAMS_RE.test(atRule.params);
 }
 var postcssWeappTailwindcssPrePlugin = (options) => {
   const opts = defu2(options, { isMainChunk: true });
@@ -1902,7 +2102,7 @@ var postcssWeappTailwindcssPrePlugin = (options) => {
           atRule.remove();
         }
       } else if (atRule.name === "supports") {
-        if (/color-mix/.test(atRule.params)) {
+        if (COLOR_MIX_RE.test(atRule.params)) {
           atRule.remove();
         }
       } else if (atRule.name === "layer") {
@@ -1947,7 +2147,6 @@ var postcssWeappTailwindcssPrePlugin = (options) => {
 postcssWeappTailwindcssPrePlugin.postcss = true;
 
 // src/pipeline.ts
-var STAGE_ORDER = ["pre", "normal", "post"];
 function normalizeUserPlugins(plugins) {
   if (!plugins) {
     return [];
@@ -1960,140 +2159,52 @@ function normalizeUserPlugins(plugins) {
   }
   return [];
 }
-function createStaticDefinition(id, stage, plugin) {
+function createPreparedNode(id, stage, createPlugin) {
   return {
     id,
     stage,
-    prepare: () => ({
-      id,
-      stage,
-      createPlugin: () => plugin
-    })
+    createPlugin
   };
 }
-function createPipelineDefinitions(options) {
-  const stages = {
-    pre: [],
-    normal: [],
-    post: []
-  };
+function createPreparedNodes(options) {
+  const preparedNodes = [];
   const userPlugins = normalizeUserPlugins(options.postcssOptions?.plugins);
   userPlugins.forEach((plugin, index) => {
-    stages.pre.push(createStaticDefinition(`pre:user-${index}`, "pre", plugin));
-  });
-  stages.pre.push({
-    id: "pre:core",
-    stage: "pre",
-    prepare: () => ({
-      id: "pre:core",
-      stage: "pre",
-      createPlugin: () => postcssWeappTailwindcssPrePlugin(options)
-    })
-  });
-  stages.normal.push({
-    id: "normal:preset-env",
-    stage: "normal",
-    prepare: () => ({
-      id: "normal:preset-env",
-      stage: "normal",
-      createPlugin: () => postcssPresetEnv(options.cssPresetEnv)
-    })
-  });
-  stages.normal.push({
-    id: "normal:color-functional-fallback",
-    stage: "normal",
-    prepare: () => ({
-      id: "normal:color-functional-fallback",
-      stage: "normal",
-      createPlugin: () => createColorFunctionalFallback()
-    })
-  });
-  stages.normal.push({
-    id: "normal:units-to-px",
-    stage: "normal",
-    prepare: () => {
-      const plugin = getUnitsToPxPlugin(options);
-      return plugin ? {
-        id: "normal:units-to-px",
-        stage: "normal",
-        createPlugin: () => plugin
-      } : void 0;
-    }
+    preparedNodes.push(createPreparedNode(`pre:user-${index}`, "pre", () => plugin));
   });
-  stages.normal.push({
-    id: "normal:px-transform",
-    stage: "normal",
-    prepare: () => {
-      const plugin = getPxTransformPlugin(options);
-      return plugin ? {
-        id: "normal:px-transform",
-        stage: "normal",
-        createPlugin: () => plugin
-      } : void 0;
-    }
-  });
-  stages.normal.push({
-    id: "normal:rem-transform",
-    stage: "normal",
-    prepare: () => {
-      const plugin = getRemTransformPlugin(options);
-      return plugin ? {
-        id: "normal:rem-transform",
-        stage: "normal",
-        createPlugin: () => plugin
-      } : void 0;
-    }
-  });
-  stages.normal.push({
-    id: "normal:calc",
-    stage: "normal",
-    prepare: () => {
-      const plugin = getCalcPlugin(options);
-      return plugin ? {
-        id: "normal:calc",
-        stage: "normal",
-        createPlugin: () => plugin
-      } : void 0;
-    }
-  });
-  stages.normal.push({
-    id: "normal:calc-duplicate-cleaner",
-    stage: "normal",
-    prepare: () => {
-      const plugin = getCalcDuplicateCleaner(options);
-      return plugin ? {
-        id: "normal:calc-duplicate-cleaner",
-        stage: "normal",
-        createPlugin: () => plugin
-      } : void 0;
-    }
-  });
-  stages.normal.push({
-    id: "normal:custom-property-cleaner",
-    stage: "normal",
-    prepare: () => {
-      const plugin = getCustomPropertyCleaner(options);
-      return plugin ? {
-        id: "normal:custom-property-cleaner",
-        stage: "normal",
-        createPlugin: () => plugin
-      } : void 0;
-    }
-  });
-  stages.post.push({
-    id: "post:core",
-    stage: "post",
-    prepare: () => ({
-      id: "post:core",
-      stage: "post",
-      createPlugin: () => postcssWeappTailwindcssPostPlugin(options)
-    })
-  });
-  return STAGE_ORDER.flatMap((stage) => stages[stage]);
+  preparedNodes.push(createPreparedNode("pre:core", "pre", () => postcssWeappTailwindcssPrePlugin(options)));
+  preparedNodes.push(createPreparedNode("normal:preset-env", "normal", () => postcssPresetEnv(options.cssPresetEnv)));
+  preparedNodes.push(createPreparedNode("normal:color-functional-fallback", "normal", () => createColorFunctionalFallback()));
+  const unitsToPxPlugin = getUnitsToPxPlugin(options);
+  if (unitsToPxPlugin) {
+    preparedNodes.push(createPreparedNode("normal:units-to-px", "normal", () => unitsToPxPlugin));
+  }
+  const pxTransformPlugin = getPxTransformPlugin(options);
+  if (pxTransformPlugin) {
+    preparedNodes.push(createPreparedNode("normal:px-transform", "normal", () => pxTransformPlugin));
+  }
+  const remTransformPlugin = getRemTransformPlugin(options);
+  if (remTransformPlugin) {
+    preparedNodes.push(createPreparedNode("normal:rem-transform", "normal", () => remTransformPlugin));
+  }
+  const calcPlugin = getCalcPlugin(options);
+  if (calcPlugin) {
+    preparedNodes.push(createPreparedNode("normal:calc", "normal", () => calcPlugin));
+  }
+  const calcDuplicateCleaner = getCalcDuplicateCleaner(options);
+  if (calcDuplicateCleaner) {
+    preparedNodes.push(createPreparedNode("normal:calc-duplicate-cleaner", "normal", () => calcDuplicateCleaner));
+  }
+  const customPropertyCleaner = getCustomPropertyCleaner(options);
+  if (customPropertyCleaner) {
+    preparedNodes.push(createPreparedNode("normal:custom-property-cleaner", "normal", () => customPropertyCleaner));
+  }
+  preparedNodes.push(createPreparedNode("post:core", "post", () => postcssWeappTailwindcssPostPlugin(options)));
+  return preparedNodes;
 }
 function createStylePipeline(options) {
   options.ctx = createContext();
-  const preparedNodes = createPipelineDefinitions(options).map((definition) => definition.prepare(options)).filter(Boolean);
+  const preparedNodes = createPreparedNodes(options);
   if (preparedNodes.length === 0) {
     return {
       nodes: [],
@@ -2155,6 +2266,35 @@ function createProcessOptions(options) {
     ...options.postcssOptions?.options ?? {}
   };
 }
+function getSimpleProcessOptionsCacheKey(options) {
+  const parts = ["simple"];
+  for (const key of Object.keys(options).sort()) {
+    const value = options[key];
+    switch (typeof value) {
+      case "string":
+        parts.push(`${key}:str:${value}`);
+        break;
+      case "number":
+        parts.push(`${key}:num:${value}`);
+        break;
+      case "boolean":
+        parts.push(`${key}:bool:${value ? "1" : "0"}`);
+        break;
+      case "undefined":
+        parts.push(`${key}:undefined`);
+        break;
+      case "object":
+        if (value === null) {
+          parts.push(`${key}:null`);
+          break;
+        }
+        return void 0;
+      default:
+        return void 0;
+    }
+  }
+  return parts.join("|");
+}
 var StyleProcessorCache = class {
   pipelineCache = /* @__PURE__ */ new WeakMap();
   processOptionsCache = /* @__PURE__ */ new WeakMap();
@@ -2187,11 +2327,11 @@ var StyleProcessorCache = class {
   }
   getProcessOptions(options) {
     const source = options.postcssOptions?.options;
-    const fingerprint = source ? fingerprintOptions(source) : void 0;
+    const cacheKey = source ? getSimpleProcessOptionsCacheKey(source) ?? fingerprintOptions(source) : void 0;
     const cached = this.processOptionsCache.get(options);
-    if (!cached || cached.fingerprint !== fingerprint) {
+    if (!cached || cached.cacheKey !== cacheKey) {
       const created = createProcessOptions(options);
-      this.processOptionsCache.set(options, { value: created, fingerprint });
+      this.processOptionsCache.set(options, { value: created, cacheKey });
       return { ...created };
     }
     return { ...cached.value };