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

package/dist/index.js

@@ -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 = _nullishCoalesce(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
 var _postcsscalc = require('@weapp-tailwindcss/postcss-calc'); var _postcsscalc2 = _interopRequireDefault(_postcsscalc);
 
-// ../../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 _postcsscalc2.default.call(void 0, calcOptions);
+  if (options.cssCalc === true || Array.isArray(options.cssCalc)) {
+    return _postcsscalc2.default.call(void 0, EMPTY_CALC_OPTIONS);
+  }
+  return _postcsscalc2.default.call(void 0, 
+    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 = _postcssvalueparser2.default.call(void 0, 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 _postcsspxtrans2.default.call(void 0, defaultPxTransformOptions);
+  }
   return _postcsspxtrans2.default.call(void 0, 
     _shared.defuOverrideArray.call(void 0, 
-      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 _postcssremtoresponsivepixel2.default.call(void 0, defaultRemTransformOptions);
+  }
   const merged = _shared.defuOverrideArray.call(void 0, 
-    userOptions,
+    options.rem2rpx,
     defaultStage
   );
   return _postcssremtoresponsivepixel2.default.call(void 0, 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 _optionalChain([options, 'optionalAccess', _13 => _13.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
 var _postcssselectorparser = require('postcss-selector-parser'); var _postcssselectorparser2 = _interopRequireDefault(_postcssselectorparser);
 var beforeAfterStateRef = null;
+var BEFORE_PSEUDO_RE = /^:?:before$/;
+var AFTER_PSEUDO_RE = /^:?:after$/;
 var beforeAfterParser = _postcssselectorparser2.default.call(void 0, (selectors) => {
   const state = beforeAfterStateRef;
   if (!state) {
@@ -676,10 +825,10 @@ var beforeAfterParser = _postcssselectorparser2.default.call(void 0, (selectors)
   }
   selectors.walkPseudos((s) => {
     if (_optionalChain([s, 'access', _15 => _15.parent, 'optionalAccess', _16 => _16.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 @@ function isOnlyBeforeAndAfterPseudoElement(node) {
 
 // src/selectorParser/utils.ts
 
+var combinatorSelectorAstCache = /* @__PURE__ */ new WeakMap();
 function normalizeTransformOptions(options) {
   return {
     lossless: false,
@@ -738,12 +888,16 @@ function composeIsPseudoAst(strs) {
   }));
 }
 function getCombinatorSelectorAst(options) {
-  let childCombinatorReplaceValue = mklist(_postcssselectorparser2.default.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(_postcssselectorparser2.default.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 = _nullishCoalesce(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 = _postcssselectorparser2.default.call(void 0, (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 @@ function getFallbackRemove(_rule, options) {
 
 // src/shared.ts
 var _escape = require('@weapp-core/escape');
-function internalCssSelectorReplacer(selectors, options = {
-  escapeMap: _escape.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.escape.call(void 0, selectors, escapeOptions);
+  return cached;
+}
+function internalCssSelectorReplacer(selectors, options) {
+  const escapeMap = _optionalChain([options, 'optionalAccess', _28 => _28.escapeMap]);
+  if (escapeMap === void 0 || escapeMap === _escape.MappingChars2String) {
+    return _escape.escape.call(void 0, selectors);
+  }
+  return _escape.escape.call(void 0, selectors, getEscapeOptions(escapeMap));
 }
 function composeIsPseudo(strs) {
   if (typeof strs === "string") {
@@ -896,7 +1086,7 @@ function reorderLiteralFirst(rule, declarations, isVariable) {
   if (alreadyOrdered) {
     return;
   }
-  const anchor = _nullishCoalesce(_optionalChain([declarations, 'access', _28 => _28[declarations.length - 1], 'optionalAccess', _29 => _29.next, 'call', _30 => _30()]), () => ( void 0));
+  const anchor = _nullishCoalesce(_optionalChain([declarations, 'access', _29 => _29.at, 'call', _30 => _30(-1), 'optionalAccess', _31 => _31.next, 'call', _32 => _32()]), () => ( 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") {
@@ -991,7 +1164,7 @@ function isNotLastChildPseudo(node) {
   if (!firstSelector || firstSelector.type !== "selector") {
     return false;
   }
-  const target = _optionalChain([firstSelector, 'access', _31 => _31.nodes, 'optionalAccess', _32 => _32[0]]);
+  const target = _optionalChain([firstSelector, 'access', _33 => _33.nodes, 'optionalAccess', _34 => _34[0]]);
   return Boolean(target && target.type === "pseudo" && target.value === ":last-child");
 }
 function transformSpacingSelector(nodes2, options) {
@@ -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
@@ -1091,7 +1276,7 @@ function flattenWherePseudo(node, context, index, parent) {
     node.value = ":is";
   }
   if (index === 0 && node.length === 1) {
-    const targetSelector = _optionalChain([node, 'access', _33 => _33.nodes, 'optionalAccess', _34 => _34[0]]);
+    const targetSelector = _optionalChain([node, 'access', _35 => _35.nodes, 'optionalAccess', _36 => _36[0]]);
     if (targetSelector && targetSelector.type === "selector" && transformSpacingSelector(targetSelector.nodes, context.options)) {
       context.requiresSpacingNormalization = true;
     }
@@ -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 = _optionalChain([context, 'access', _35 => _35.options, 'access', _36 => _36.cssSelectorReplacement, 'optionalAccess', _37 => _37.universal]);
-  if (replacement) {
-    node.value = composeIsPseudo(replacement);
+  if (context.universalReplacement) {
+    node.value = context.universalReplacement;
   }
 }
 function shouldRemoveHoverSelector(selector, options) {
@@ -1154,7 +1337,7 @@ function handleCombinatorNode(node, index, context) {
   if (node.type !== "combinator" || node.value !== ">") {
     return;
   }
-  const nodes2 = _optionalChain([node, 'access', _38 => _38.parent, 'optionalAccess', _39 => _39.nodes]);
+  const nodes2 = _optionalChain([node, 'access', _37 => _37.parent, 'optionalAccess', _38 => _38.nodes]);
   if (!nodes2) {
     return;
   }
@@ -1174,8 +1357,8 @@ function handlePseudoNode(node, index, context, parent) {
     stripUnsupportedRtlLanguagePseudo(node);
     return;
   }
-  if (node.value === ":root" && _optionalChain([context, 'access', _40 => _40.options, 'access', _41 => _41.cssSelectorReplacement, 'optionalAccess', _42 => _42.root])) {
-    node.value = composeIsPseudo(context.options.cssSelectorReplacement.root);
+  if (node.value === ":root" && context.rootReplacement) {
+    node.value = context.rootReplacement;
     return;
   }
   if (node.value === ":where") {
@@ -1207,7 +1390,7 @@ function canSkipRuleTransform(rule) {
 }
 function transformSelectors(selectors, context) {
   selectors.walk((node, index) => {
-    const parent = _optionalChain([node, 'access', _43 => _43.parent, 'optionalAccess', _44 => _44.type]) === "selector" ? node.parent : void 0;
+    const parent = _optionalChain([node, 'access', _39 => _39.parent, 'optionalAccess', _40 => _40.type]) === "selector" ? node.parent : void 0;
     switch (node.type) {
       case "class":
         handleClassNode(node, context);
@@ -1254,6 +1437,9 @@ 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 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 _nullishCoalesce(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 = _nullishCoalesce(rule.selectors, () => ( []));
-  if (selectors.includes(":host")) {
-    return false;
-  }
+function createHostSelectorAppender(options) {
   const rootSelectors = normalizeRootSelectors(_optionalChain([options, 'access', _54 => _54.cssSelectorReplacement, 'optionalAccess', _55 => _55.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 = _nullishCoalesce(rule.selectors, () => ( []));
+    if (selectors.includes(":host")) {
+      return false;
+    }
+    return DEFAULT_ROOT_SELECTORS.every((selector) => selectors.includes(selector));
+  };
 }
 var postcssWeappTailwindcssPostPlugin = (options) => {
   const opts = _shared.defu.call(void 0, 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) => {
       }
       _optionalChain([cleanRootSpecificity, 'optionalCall', _58 => _58(rule)]);
       if (enableMainChunkTransforms) {
-        if (shouldAppendHostSelector(rule, opts)) {
+        if (_optionalChain([shouldAppendHostSelector, 'optionalCall', _59 => _59(rule)])) {
           rule.selectors = [...rule.selectors, ":host"];
         }
         dedupeDeclarations(rule);
@@ -1569,7 +1766,7 @@ var postcssWeappTailwindcssPostPlugin = (options) => {
       if (opts.cssRemoveProperty && atRule.name === "property") {
         atRule.remove();
       }
-      _optionalChain([atRule, 'access', _59 => _59.nodes, 'optionalAccess', _60 => _60.length]) === 0 && atRule.remove();
+      _optionalChain([atRule, 'access', _60 => _60.nodes, 'optionalAccess', _61 => _61.length]) === 0 && atRule.remove();
     };
   }
   return p;
@@ -1852,7 +2049,7 @@ function remakeCssVarSelector(selectors, options) {
 }
 function commonChunkPreflight(node, options) {
   const { ctx, cssInjectPreflight, injectAdditionalCssVarScope } = options;
-  const rootOption = _optionalChain([options, 'access', _61 => _61.cssSelectorReplacement, 'optionalAccess', _62 => _62.root]);
+  const rootOption = _optionalChain([options, 'access', _62 => _62.cssSelectorReplacement, 'optionalAccess', _63 => _63.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"));
@@ -1861,7 +2058,7 @@ function commonChunkPreflight(node, options) {
     node.selectors = [...node.selectors, ":host"];
   }
   if (testIfVariablesScope(node)) {
-    _optionalChain([ctx, 'optionalAccess', _63 => _63.markVariablesScope, 'call', _64 => _64(node)]);
+    _optionalChain([ctx, 'optionalAccess', _64 => _64.markVariablesScope, 'call', _65 => _65(node)]);
     node.selectors = remakeCssVarSelector(node.selectors, options);
     node.before(makePseudoVarRule());
     if (typeof cssInjectPreflight === "function") {
@@ -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 = _shared.defu.call(void 0, 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") {
@@ -1918,9 +2118,9 @@ var postcssWeappTailwindcssPrePlugin = (options) => {
       root.walkAtRules((atRule) => {
         if (atRule.name === "layer") {
           if (atRule.params === "properties") {
-            if (atRule.nodes === void 0 || _optionalChain([atRule, 'access', _65 => _65.nodes, 'optionalAccess', _66 => _66.length]) === 0) {
+            if (atRule.nodes === void 0 || _optionalChain([atRule, 'access', _66 => _66.nodes, 'optionalAccess', _67 => _67.length]) === 0) {
               layerProperties = atRule;
-            } else if (_optionalChain([atRule, 'access', _67 => _67.first, 'optionalAccess', _68 => _68.type]) === "atrule" && isTailwindcssV4ModernCheck(atRule.first)) {
+            } else if (_optionalChain([atRule, 'access', _68 => _68.first, 'optionalAccess', _69 => _69.type]) === "atrule" && isTailwindcssV4ModernCheck(atRule.first)) {
               if (layerProperties) {
                 layerProperties.replaceWith(atRule.first.nodes);
                 atRule.remove();
@@ -1932,7 +2132,7 @@ var postcssWeappTailwindcssPrePlugin = (options) => {
             atRule.replaceWith(atRule.nodes);
           }
         } else if (isTailwindcssV4ModernCheck(atRule)) {
-          if (_optionalChain([atRule, 'access', _69 => _69.first, 'optionalAccess', _70 => _70.type]) === "atrule" && atRule.first.name === "layer") {
+          if (_optionalChain([atRule, 'access', _70 => _70.first, 'optionalAccess', _71 => _71.type]) === "atrule" && atRule.first.name === "layer") {
             atRule.replaceWith(atRule.first.nodes);
           }
         }
@@ -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,53 @@ 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: []
-  };
-  const userPlugins = normalizeUserPlugins(_optionalChain([options, 'access', _71 => _71.postcssOptions, 'optionalAccess', _72 => _72.plugins]));
+function createPreparedNodes(options) {
+  const preparedNodes = [];
+  const userPlugins = normalizeUserPlugins(_optionalChain([options, 'access', _72 => _72.postcssOptions, 'optionalAccess', _73 => _73.plugins]));
+  const presetEnvOptions = options.cssPresetEnv;
   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: () => _postcsspresetenv2.default.call(void 0, 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", () => _postcsspresetenv2.default.call(void 0, presetEnvOptions)));
+  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: [],
@@ -2152,9 +2264,38 @@ function createStylePipeline(options) {
 function createProcessOptions(options) {
   return {
     from: void 0,
-    ..._nullishCoalesce(_optionalChain([options, 'access', _73 => _73.postcssOptions, 'optionalAccess', _74 => _74.options]), () => ( {}))
+    ..._nullishCoalesce(_optionalChain([options, 'access', _74 => _74.postcssOptions, 'optionalAccess', _75 => _75.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 = 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()}
   __init2() {this.processOptionsCache = /* @__PURE__ */ new WeakMap()}
@@ -2162,7 +2303,7 @@ var StyleProcessorCache = (_class = class {constructor() { _class.prototype.__in
   __init4() {this.processorCacheByKey = /* @__PURE__ */ new Map()}
   __init5() {this.processorKeyCache = /* @__PURE__ */ new WeakMap()}
   createProcessorCacheKey(options) {
-    const from = _optionalChain([options, 'access', _75 => _75.postcssOptions, 'optionalAccess', _76 => _76.options, 'optionalAccess', _77 => _77.from]);
+    const from = _optionalChain([options, 'access', _76 => _76.postcssOptions, 'optionalAccess', _77 => _77.options, 'optionalAccess', _78 => _78.from]);
     if (from == null) {
       return fingerprintOptions(options);
     }
@@ -2171,7 +2312,7 @@ var StyleProcessorCache = (_class = class {constructor() { _class.prototype.__in
       postcssOptions: {
         ..._nullishCoalesce(options.postcssOptions, () => ( {})),
         options: {
-          ..._nullishCoalesce(_optionalChain([options, 'access', _78 => _78.postcssOptions, 'optionalAccess', _79 => _79.options]), () => ( {})),
+          ..._nullishCoalesce(_optionalChain([options, 'access', _79 => _79.postcssOptions, 'optionalAccess', _80 => _80.options]), () => ( {})),
           from: void 0
         }
       }
@@ -2186,12 +2327,12 @@ var StyleProcessorCache = (_class = class {constructor() { _class.prototype.__in
     return pipeline;
   }
   getProcessOptions(options) {
-    const source = _optionalChain([options, 'access', _80 => _80.postcssOptions, 'optionalAccess', _81 => _81.options]);
-    const fingerprint = source ? fingerprintOptions(source) : void 0;
+    const source = _optionalChain([options, 'access', _81 => _81.postcssOptions, 'optionalAccess', _82 => _82.options]);
+    const cacheKey = source ? _nullishCoalesce(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 };