@weapp-tailwindcss/postcss 1.3.4 → 2.0.1

package/dist/index.js

@@ -34,7 +34,7 @@ function getDefaultOptions(options) {
   };
 }
 
-// src/plugins/index.ts
+// src/pipeline.ts
 var _postcsspresetenv = require('postcss-preset-env'); var _postcsspresetenv2 = _interopRequireDefault(_postcsspresetenv);
 
 // src/plugins/ctx.ts
@@ -80,32 +80,41 @@ function getCalcPlugin(options) {
 var _postcssvalueparser = require('postcss-value-parser'); var _postcssvalueparser2 = _interopRequireDefault(_postcssvalueparser);
 function getCustomPropertyCleaner(options) {
   const includeCustomProperties = Array.isArray(options.cssCalc) ? options.cssCalc : typeof options.cssCalc === "object" ? options.cssCalc.includeCustomProperties : [];
-  if (!includeCustomProperties || includeCustomProperties.length === 0) {
+  const shouldMatchCustomProperties = Array.isArray(includeCustomProperties) && includeCustomProperties.length > 0;
+  if (!shouldMatchCustomProperties) {
     return null;
   }
   return {
     postcssPlugin: "postcss-remove-include-custom-properties",
     OnceExit(root) {
-      root.walkDecls((decl, idx) => {
-        if (idx === 0 || !/--/.test(decl.value)) {
+      root.walkDecls((decl) => {
+        const prevNode = decl.prev();
+        if (!prevNode || prevNode.type !== "decl" || prevNode.prop !== decl.prop) {
           return;
         }
-        const prevNode = _optionalChain([decl, 'access', _5 => _5.parent, 'optionalAccess', _6 => _6.nodes, 'access', _7 => _7[idx - 1]]);
-        if (!prevNode || prevNode.prop !== decl.prop) {
+        if (prevNode.value === decl.value) {
+          decl.remove();
+          return;
+        }
+        if (!shouldMatchCustomProperties || !/--/.test(decl.value)) {
           return;
         }
         const parsed = _postcssvalueparser2.default.call(void 0, decl.value);
+        let containsIncludedCustomProperty = false;
         parsed.walk((node) => {
-          if (node.type !== "function" || node.value !== "var") {
+          if (node.type !== "function" || node.value !== "var" || containsIncludedCustomProperty) {
             return;
           }
           const match = node.nodes.find((x) => {
             return x.type === "word" && _shared.regExpTest.call(void 0, includeCustomProperties, x.value);
           });
           if (match) {
-            decl.remove();
+            containsIncludedCustomProperty = true;
           }
         });
+        if (containsIncludedCustomProperty) {
+          decl.remove();
+        }
       });
     }
   };
@@ -181,7 +190,7 @@ var beforeAfterParser = _postcssselectorparser2.default.call(void 0, (selectors)
     return;
   }
   selectors.walkPseudos((s) => {
-    if (_optionalChain([s, 'access', _8 => _8.parent, 'optionalAccess', _9 => _9.length]) === 1) {
+    if (_optionalChain([s, 'access', _5 => _5.parent, 'optionalAccess', _6 => _6.length]) === 1) {
       if (/^:?:before$/.test(s.value)) {
         state.before = true;
       }
@@ -259,7 +268,7 @@ function getFallbackRemove(_rule, options) {
   const cacheKey = _nullishCoalesce(options, () => ( fallbackDefaultKey));
   let entry = fallbackRemoveCache.get(cacheKey);
   if (!entry) {
-    const uniAppX = Boolean(_optionalChain([options, 'optionalAccess', _10 => _10.uniAppX]));
+    const uniAppX = Boolean(_optionalChain([options, 'optionalAccess', _7 => _7.uniAppX]));
     let currentRule;
     const parser = _postcssselectorparser2.default.call(void 0, (selectors) => {
       const activeRule = currentRule;
@@ -269,13 +278,13 @@ function getFallbackRemove(_rule, options) {
           maybeImportantId = true;
         }
         if (selector.type === "universal") {
-          _optionalChain([selector, 'access', _11 => _11.parent, 'optionalAccess', _12 => _12.remove, 'call', _13 => _13()]);
+          _optionalChain([selector, 'access', _8 => _8.parent, 'optionalAccess', _9 => _9.remove, 'call', _10 => _10()]);
         } else if (selector.type === "pseudo") {
           if (selector.value === ":is") {
-            if (maybeImportantId && _optionalChain([selector, 'access', _14 => _14.nodes, 'access', _15 => _15[0], 'optionalAccess', _16 => _16.type]) === "selector") {
+            if (maybeImportantId && _optionalChain([selector, 'access', _11 => _11.nodes, 'access', _12 => _12[0], 'optionalAccess', _13 => _13.type]) === "selector") {
               selector.replaceWith(selector.nodes[0]);
             } else {
-              _optionalChain([selector, 'access', _17 => _17.parent, 'optionalAccess', _18 => _18.remove, 'call', _19 => _19()]);
+              _optionalChain([selector, 'access', _14 => _14.parent, 'optionalAccess', _15 => _15.remove, 'call', _16 => _16()]);
             }
           } else if (selector.value === ":not") {
             for (const x of selector.nodes) {
@@ -298,7 +307,7 @@ function getFallbackRemove(_rule, options) {
           }
         } else if (selector.type === "attribute") {
           if (selector.attribute === "hidden") {
-            _optionalChain([activeRule, 'optionalAccess', _20 => _20.remove, 'call', _21 => _21()]);
+            _optionalChain([activeRule, 'optionalAccess', _17 => _17.remove, 'call', _18 => _18()]);
           }
         }
       });
@@ -374,128 +383,306 @@ function composeIsPseudo(strs) {
 
 // src/selectorParser/rule-transformer.ts
 var ruleTransformCache = /* @__PURE__ */ new WeakMap();
-function createRuleTransformer(options) {
-  let currentRule;
-  const { escapeMap, cssSelectorReplacement, cssRemoveHoverPseudoClass, uniAppX } = options;
-  const transform = (selectors) => {
-    const rule = currentRule;
-    if (!rule) {
-      return;
+var MIRROR_PROP_PAIRS = [
+  ["margin-top", "margin-bottom"],
+  ["margin-left", "margin-right"],
+  ["margin-inline-start", "margin-inline-end"],
+  ["margin-block-start", "margin-block-end"],
+  ["border-top-width", "border-bottom-width"],
+  ["border-left-width", "border-right-width"],
+  ["border-inline-start-width", "border-inline-end-width"],
+  ["border-block-start-width", "border-block-end-width"]
+];
+var MIRROR_PROP_MAP = /* @__PURE__ */ new Map();
+var SPACING_PROP_SET = /* @__PURE__ */ new Set();
+for (const [a, b] of MIRROR_PROP_PAIRS) {
+  MIRROR_PROP_MAP.set(a, b);
+  MIRROR_PROP_MAP.set(b, a);
+  SPACING_PROP_SET.add(a);
+  SPACING_PROP_SET.add(b);
+}
+var LEGACY_WEBKIT_SPACING_PROPS = /* @__PURE__ */ new Set([
+  "-webkit-margin-start",
+  "-webkit-margin-end",
+  "-webkit-margin-before",
+  "-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;
     }
-    selectors.walk((selector, index) => {
-      if (selector.type === "class") {
-        selector.value = internalCssSelectorReplacer(selector.value, {
-          escapeMap
-        });
-      } else if (selector.type === "universal") {
-        if (_optionalChain([cssSelectorReplacement, 'optionalAccess', _22 => _22.universal])) {
-          selector.value = composeIsPseudo(cssSelectorReplacement.universal);
-        }
-      } else if (selector.type === "selector") {
-        if (cssRemoveHoverPseudoClass) {
-          const node = selector.nodes.find((x) => x.type === "pseudo" && x.value === ":hover");
-          if (node) {
-            selector.remove();
-          }
-        }
-      } else if (selector.type === "pseudo") {
-        if (selector.value === ":root" && _optionalChain([cssSelectorReplacement, 'optionalAccess', _23 => _23.root])) {
-          selector.value = composeIsPseudo(cssSelectorReplacement.root);
-        } else if (selector.value === ":where") {
-          if (uniAppX) {
-            selector.value = ":is";
-          }
-          if (index === 0 && selector.length === 1) {
-            selector.walk((node, idx) => {
-              if (idx === 0 && node.type === "class") {
-                const nodes2 = _optionalChain([node, 'access', _24 => _24.parent, 'optionalAccess', _25 => _25.nodes]);
-                if (nodes2) {
-                  const first = nodes2[idx + 1];
-                  if (first && first.type === "combinator" && first.value === ">") {
-                    const second = nodes2[idx + 2];
-                    if (second && second.type === "pseudo" && second.value === ":not" && second.first.first.type === "pseudo" && second.first.first.value === ":last-child") {
-                      const ast = getCombinatorSelectorAst(options);
-                      second.replaceWith(
-                        ...ast
-                      );
-                    }
-                  }
-                }
-              }
-            });
-            selector.replaceWith(...selector.nodes);
-            for (const node of rule.nodes) {
-              if (node.type === "decl") {
-                if (node.prop === "margin-block-start") {
-                  node.prop = "margin-block-end";
-                } else if (node.prop === "margin-block-end") {
-                  node.prop = "margin-block-start";
-                } else if (node.prop === "margin-inline-start") {
-                  node.prop = "margin-inline-end";
-                } else if (node.prop === "margin-inline-end") {
-                  node.prop = "margin-inline-start";
-                } else if (node.prop === "margin-top") {
-                  node.prop = "margin-bottom";
-                } else if (node.prop === "margin-bottom") {
-                  node.prop = "margin-top";
-                } else if (node.prop === "margin-left") {
-                  node.prop = "margin-right";
-                } else if (node.prop === "margin-right") {
-                  node.prop = "margin-left";
-                } else if (node.prop === "-webkit-margin-start" || node.prop === "-webkit-margin-end" || node.prop === "-webkit-margin-before" || node.prop === "-webkit-margin-after") {
-                  node.remove();
-                }
-              }
-            }
-          }
-        }
-      } else if (selector.type === "combinator") {
-        if (selector.value === ">") {
-          const nodes2 = _optionalChain([selector, 'access', _26 => _26.parent, 'optionalAccess', _27 => _27.nodes]);
-          if (nodes2) {
-            const first = nodes2[index + 1];
-            if (first && first.type === "pseudo" && first.value === ":not" && (first.first.first.type === "attribute" && first.first.first.attribute === "hidden" || first.first.first.type === "tag" && first.first.first.value === "template")) {
-              const second = nodes2[index + 2];
-              if (second && second.type === "combinator" && (second.value === "~" || second.value === "+")) {
-                const third = nodes2[index + 3];
-                if (third && third.type === "pseudo" && third.value === ":not" && (third.first.first.type === "attribute" && third.first.first.attribute === "hidden" || third.first.first.type === "tag" && third.first.first.value === "template")) {
-                  const ast = getCombinatorSelectorAst(options);
-                  _optionalChain([selector, 'access', _28 => _28.parent, 'optionalAccess', _29 => _29.nodes, 'access', _30 => _30.splice, 'call', _31 => _31(
-                    index + 1,
-                    3,
-                    ...ast
-                  )]);
-                }
-              }
-            }
-          }
-        }
-      } else if (selector.type === "tag") {
-        if (uniAppX) {
-          selector.remove();
-        }
-      } else if (selector.type === "attribute") {
-        if (uniAppX) {
-          selector.remove();
-        }
+    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]);
+    }
+  }
+  for (const [, declarations] of grouped) {
+    if (declarations.length <= 1) {
+      continue;
+    }
+    const unique = [];
+    const seenValues = /* @__PURE__ */ new Set();
+    for (const decl of declarations) {
+      if (decl.parent !== rule) {
+        continue;
       }
-    });
-    selectors.walk((selector) => {
-      if (selector.type === "selector") {
-        selector.length === 0 && selector.remove();
+      const key = `${decl.important ? "!important@@" : ""}${decl.value}`;
+      if (seenValues.has(key)) {
+        decl.remove();
+        continue;
       }
-    });
-    if (selectors.length === 0) {
-      rule.remove();
+      seenValues.add(key);
+      unique.push(decl);
     }
+    if (unique.length <= 1) {
+      continue;
+    }
+    const literals = unique.filter((decl) => !VAR_REFERENCE_PATTERN.test(decl.value));
+    const variables = unique.filter((decl) => VAR_REFERENCE_PATTERN.test(decl.value));
+    if (variables.length === 0 || literals.length === 0) {
+      continue;
+    }
+    const ordered = [...literals, ...variables];
+    const alreadyOrdered = ordered.every((decl, index) => decl === unique[index]);
+    if (alreadyOrdered) {
+      continue;
+    }
+    const anchor = _nullishCoalesce(_optionalChain([unique, 'access', _19 => _19[unique.length - 1], 'optionalAccess', _20 => _20.next, 'call', _21 => _21()]), () => ( void 0));
+    for (const decl of unique) {
+      decl.remove();
+    }
+    for (const decl of ordered) {
+      if (anchor) {
+        rule.insertBefore(anchor, decl);
+      } else {
+        rule.append(decl);
+      }
+    }
+  }
+}
+function isNotLastChildPseudo(node) {
+  if (!node || node.type !== "pseudo" || node.value !== ":not") {
+    return false;
+  }
+  const selectors = node.nodes;
+  if (!selectors || selectors.length !== 1) {
+    return false;
+  }
+  const firstSelector = selectors[0];
+  if (firstSelector.type !== "selector") {
+    return false;
+  }
+  const target = _optionalChain([firstSelector, 'access', _22 => _22.nodes, 'optionalAccess', _23 => _23[0]]);
+  return Boolean(target && target.type === "pseudo" && target.value === ":last-child");
+}
+function transformSpacingSelector(nodes2, options) {
+  if (!nodes2 || nodes2.length === 0) {
+    return false;
+  }
+  for (let idx = 0; idx < nodes2.length; idx++) {
+    const current = nodes2[idx];
+    if (current.type !== "class" && current.type !== "nesting") {
+      continue;
+    }
+    const combinator = nodes2[idx + 1];
+    if (!combinator || combinator.type !== "combinator" || combinator.value !== ">") {
+      continue;
+    }
+    const candidate = nodes2[idx + 2];
+    if (!isNotLastChildPseudo(candidate)) {
+      continue;
+    }
+    const ast = getCombinatorSelectorAst(options);
+    candidate.replaceWith(...ast);
+    return true;
+  }
+  return false;
+}
+function normalizeSpacingDeclarations(rule) {
+  for (const node of [...rule.nodes]) {
+    if (node.type !== "decl") {
+      continue;
+    }
+    if (LEGACY_WEBKIT_SPACING_PROPS.has(node.prop)) {
+      node.remove();
+      continue;
+    }
+    const mirror = MIRROR_PROP_MAP.get(node.prop);
+    if (mirror) {
+      node.prop = mirror;
+    }
+  }
+  dedupeSpacingProps(rule);
+}
+function flattenWherePseudo(node, context, index, parent) {
+  if (context.options.uniAppX) {
+    node.value = ":is";
+  }
+  if (index === 0 && node.length === 1) {
+    const targetSelector = _optionalChain([node, 'access', _24 => _24.nodes, 'optionalAccess', _25 => _25[0]]);
+    if (targetSelector && targetSelector.type === "selector" && transformSpacingSelector(targetSelector.nodes, context.options)) {
+      context.requiresSpacingNormalization = true;
+    }
+    node.replaceWith(...node.nodes);
+    if (parent && parent.type === "selector" && parent.length === 0) {
+      parent.remove();
+    }
+  }
+}
+function handleClassNode(node, context) {
+  if (node.type !== "class") {
+    return;
+  }
+  node.value = internalCssSelectorReplacer(node.value, { escapeMap: context.options.escapeMap });
+}
+function handleUniversalNode(node, context) {
+  if (node.type !== "universal") {
+    return;
+  }
+  const replacement = _optionalChain([context, 'access', _26 => _26.options, 'access', _27 => _27.cssSelectorReplacement, 'optionalAccess', _28 => _28.universal]);
+  if (replacement) {
+    node.value = composeIsPseudo(replacement);
+  }
+}
+function shouldRemoveHoverSelector(selector, options) {
+  if (!options.cssRemoveHoverPseudoClass) {
+    return false;
+  }
+  return selector.nodes.some((node) => node.type === "pseudo" && node.value === ":hover");
+}
+function isHiddenOrTemplateNotPseudo(node) {
+  if (!node || node.type !== "pseudo" || node.value !== ":not") {
+    return false;
+  }
+  const selector = node.first;
+  if (!selector || selector.type !== "selector") {
+    return false;
+  }
+  const first = selector.first;
+  if (!first) {
+    return false;
+  }
+  if (first.type === "attribute") {
+    return first.attribute === "hidden";
+  }
+  if (first.type === "tag") {
+    return first.value === "template";
+  }
+  return false;
+}
+function handleCombinatorNode(node, index, context) {
+  if (node.type !== "combinator" || node.value !== ">") {
+    return;
+  }
+  const nodes2 = _optionalChain([node, 'access', _29 => _29.parent, 'optionalAccess', _30 => _30.nodes]);
+  if (!nodes2) {
+    return;
+  }
+  const first = nodes2[index + 1];
+  const second = nodes2[index + 2];
+  const third = nodes2[index + 3];
+  if (isHiddenOrTemplateNotPseudo(first) && second && second.type === "combinator" && (second.value === "~" || second.value === "+") && isHiddenOrTemplateNotPseudo(third)) {
+    const ast = getCombinatorSelectorAst(context.options);
+    nodes2.splice(index + 1, 3, ...ast);
+  }
+}
+function handlePseudoNode(node, index, context, parent) {
+  if (node.type !== "pseudo") {
+    return;
+  }
+  if (node.value === ":root" && _optionalChain([context, 'access', _31 => _31.options, 'access', _32 => _32.cssSelectorReplacement, 'optionalAccess', _33 => _33.root])) {
+    node.value = composeIsPseudo(context.options.cssSelectorReplacement.root);
+    return;
+  }
+  if (node.value === ":where") {
+    flattenWherePseudo(node, context, index, parent);
+  }
+}
+function handleTagOrAttribute(node, context) {
+  if (!context.options.uniAppX) {
+    return;
+  }
+  if (node.type === "tag" || node.type === "attribute") {
+    node.remove();
+  }
+}
+function handleSelectorNode(selector, context) {
+  if (shouldRemoveHoverSelector(selector, context.options)) {
+    selector.remove();
+    return;
+  }
+  if (transformSpacingSelector(selector.nodes, context.options)) {
+    context.requiresSpacingNormalization = true;
+  }
+}
+function transformSelectors(selectors, context) {
+  selectors.walk((node, index) => {
+    const parent = _optionalChain([node, 'access', _34 => _34.parent, 'optionalAccess', _35 => _35.type]) === "selector" ? node.parent : void 0;
+    switch (node.type) {
+      case "class":
+        handleClassNode(node, context);
+        break;
+      case "universal":
+        handleUniversalNode(node, context);
+        break;
+      case "selector":
+        handleSelectorNode(node, context);
+        break;
+      case "pseudo":
+        if (!isNotLastChildPseudo(node)) {
+          handlePseudoNode(node, index, context, parent);
+        }
+        break;
+      case "combinator":
+        handleCombinatorNode(node, index, context);
+        break;
+      case "tag":
+      case "attribute":
+        handleTagOrAttribute(node, context);
+        break;
+      default:
+        break;
+    }
+  });
+  if (context.requiresSpacingNormalization) {
+    normalizeSpacingDeclarations(context.rule);
+  }
+  selectors.walk((node) => {
+    if (node.type === "selector" && node.length === 0) {
+      node.remove();
+    }
+  });
+  if (selectors.length === 0) {
+    context.rule.remove();
+  }
+}
+function createRuleTransformer(options) {
+  let context;
+  const transform = (selectors) => {
+    if (!context) {
+      return;
+    }
+    transformSelectors(selectors, context);
   };
   const parser = _postcssselectorparser2.default.call(void 0, transform);
   return (rule) => {
-    currentRule = rule;
+    context = {
+      options,
+      requiresSpacingNormalization: false,
+      rule
+    };
     try {
       parser.transformSync(rule, normalizeTransformOptions());
     } finally {
-      currentRule = void 0;
+      context = void 0;
     }
   };
 }
@@ -516,7 +703,7 @@ function normalizeSelectorList(value) {
   return Array.isArray(value) ? value.filter(Boolean) : [value];
 }
 function getSpecificityMatchingName(options) {
-  const feature = _optionalChain([options, 'access', _32 => _32.cssPresetEnv, 'optionalAccess', _33 => _33.features, 'optionalAccess', _34 => _34["is-pseudo-class"]]);
+  const feature = _optionalChain([options, 'access', _36 => _36.cssPresetEnv, 'optionalAccess', _37 => _37.features, 'optionalAccess', _38 => _38["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;
@@ -525,12 +712,12 @@ function getSpecificityMatchingName(options) {
 }
 function createRootSpecificityCleaner(options) {
   const specificityMatchingName = getSpecificityMatchingName(options);
-  const selectors = normalizeSelectorList(_optionalChain([options, 'access', _35 => _35.cssSelectorReplacement, 'optionalAccess', _36 => _36.root]));
+  const selectors = normalizeSelectorList(_optionalChain([options, 'access', _39 => _39.cssSelectorReplacement, 'optionalAccess', _40 => _40.root]));
   if (!specificityMatchingName || selectors.length === 0) {
     return void 0;
   }
   const suffix = `:not(.${specificityMatchingName})`;
-  const targets = selectors.map((selector) => _optionalChain([selector, 'optionalAccess', _37 => _37.trim, 'call', _38 => _38()])).filter((selector) => Boolean(_optionalChain([selector, 'optionalAccess', _39 => _39.length]))).map((selector) => ({
+  const targets = selectors.map((selector) => _optionalChain([selector, 'optionalAccess', _41 => _41.trim, 'call', _42 => _42()])).filter((selector) => Boolean(_optionalChain([selector, 'optionalAccess', _43 => _43.length]))).map((selector) => ({
     match: `${selector}${suffix}`,
     spacedMatch: `${selector} ${suffix}`,
     replacement: selector
@@ -559,14 +746,33 @@ function createRootSpecificityCleaner(options) {
 }
 var OklabSuffix = "in oklab";
 var logicalPropMap = /* @__PURE__ */ new Map([
+  // margin
   ["margin-inline-start", "margin-left"],
   ["margin-inline-end", "margin-right"],
   ["margin-block-start", "margin-top"],
   ["margin-block-end", "margin-bottom"],
+  // padding
   ["padding-inline-start", "padding-left"],
   ["padding-inline-end", "padding-right"],
   ["padding-block-start", "padding-top"],
-  ["padding-block-end", "padding-bottom"]
+  ["padding-block-end", "padding-bottom"],
+  // border
+  ["border-inline-start", "border-left"],
+  ["border-inline-end", "border-right"],
+  ["border-block-start", "border-top"],
+  ["border-block-end", "border-bottom"],
+  ["border-inline-start-width", "border-left-width"],
+  ["border-inline-end-width", "border-right-width"]
+]);
+var variablePriorityProps = /* @__PURE__ */ new Set([
+  "margin-left",
+  "margin-right",
+  "margin-top",
+  "margin-bottom",
+  "border-left-width",
+  "border-right-width",
+  "border-top-width",
+  "border-bottom-width"
 ]);
 function getCanonicalProp(prop) {
   return _nullishCoalesce(logicalPropMap.get(prop), () => ( prop));
@@ -583,6 +789,9 @@ function normalizeCalcValue(value) {
   } while (next !== prev);
   return next.replace(/calc\(\s*(1\s*-\s*var\([^()]+\))\s*\)/gi, "($1)");
 }
+function hasVariableReference(value) {
+  return value.includes("var(");
+}
 function dedupeDeclarations(rule) {
   const entries = [];
   for (const node of [...rule.nodes]) {
@@ -618,6 +827,73 @@ function dedupeDeclarations(rule) {
       entry.decl.remove();
     }
   }
+  const reorderGroups = /* @__PURE__ */ new Map();
+  for (const node of rule.nodes) {
+    if (node.type !== "decl") {
+      continue;
+    }
+    const canonical = getCanonicalProp(node.prop);
+    if (!variablePriorityProps.has(canonical)) {
+      continue;
+    }
+    const existing = reorderGroups.get(canonical);
+    if (existing) {
+      existing.push(node);
+    } else {
+      reorderGroups.set(canonical, [node]);
+    }
+  }
+  for (const declarations of reorderGroups.values()) {
+    if (declarations.length <= 1) {
+      continue;
+    }
+    const literals = declarations.filter((decl) => !hasVariableReference(decl.value));
+    const variables = declarations.filter((decl) => hasVariableReference(decl.value));
+    if (literals.length === 0 || variables.length === 0) {
+      continue;
+    }
+    const ordered = [...literals, ...variables];
+    let needReorder = false;
+    for (let index = 0; index < ordered.length; index++) {
+      if (ordered[index] !== declarations[index]) {
+        needReorder = true;
+        break;
+      }
+    }
+    if (!needReorder) {
+      continue;
+    }
+    const anchor = _nullishCoalesce(_optionalChain([declarations, 'access', _44 => _44[declarations.length - 1], 'optionalAccess', _45 => _45.next, 'call', _46 => _46()]), () => ( void 0));
+    for (const decl of declarations) {
+      decl.remove();
+    }
+    for (const decl of ordered) {
+      if (anchor) {
+        rule.insertBefore(anchor, decl);
+      } else {
+        rule.append(decl);
+      }
+    }
+  }
+  const literalSeen = /* @__PURE__ */ new Map();
+  for (const node of [...rule.nodes]) {
+    if (node.type !== "decl") {
+      continue;
+    }
+    const canonical = getCanonicalProp(node.prop);
+    if (!variablePriorityProps.has(canonical)) {
+      continue;
+    }
+    if (hasVariableReference(node.value)) {
+      continue;
+    }
+    const existing = literalSeen.get(canonical);
+    if (existing) {
+      node.remove();
+    } else {
+      literalSeen.set(canonical, node);
+    }
+  }
 }
 var postcssWeappTailwindcssPostPlugin = (options) => {
   const opts = _shared.defu.call(void 0, options, {
@@ -632,9 +908,9 @@ var postcssWeappTailwindcssPostPlugin = (options) => {
     const fallbackRemove = enableMainChunkTransforms ? getFallbackRemove(void 0, opts) : void 0;
     p.RuleExit = (rule) => {
       if (enableMainChunkTransforms) {
-        _optionalChain([fallbackRemove, 'optionalAccess', _40 => _40.transformSync, 'call', _41 => _41(rule)]);
+        _optionalChain([fallbackRemove, 'optionalAccess', _47 => _47.transformSync, 'call', _48 => _48(rule)]);
       }
-      _optionalChain([cleanRootSpecificity, 'optionalCall', _42 => _42(rule)]);
+      _optionalChain([cleanRootSpecificity, 'optionalCall', _49 => _49(rule)]);
       if (enableMainChunkTransforms) {
         dedupeDeclarations(rule);
         if (rule.selectors.length === 0 || rule.selectors.length === 1 && rule.selector.trim() === "") {
@@ -658,12 +934,7 @@ var postcssWeappTailwindcssPostPlugin = (options) => {
       if (opts.cssRemoveProperty && atRule.name === "property") {
         atRule.remove();
       }
-      _optionalChain([atRule, 'access', _43 => _43.nodes, 'optionalAccess', _44 => _44.length]) === 0 && atRule.remove();
-    };
-  }
-  if (typeof opts.customRuleCallback === "function") {
-    p.Rule = (rule) => {
-      _optionalChain([opts, 'access', _45 => _45.customRuleCallback, 'optionalCall', _46 => _46(rule, opts)]);
+      _optionalChain([atRule, 'access', _50 => _50.nodes, 'optionalAccess', _51 => _51.length]) === 0 && atRule.remove();
     };
   }
   return p;
@@ -1104,7 +1375,7 @@ function remakeCssVarSelector(selectors, options) {
 function commonChunkPreflight(node, options) {
   const { ctx, cssInjectPreflight, injectAdditionalCssVarScope } = options;
   if (testIfVariablesScope(node)) {
-    _optionalChain([ctx, 'optionalAccess', _47 => _47.markVariablesScope, 'call', _48 => _48(node)]);
+    _optionalChain([ctx, 'optionalAccess', _52 => _52.markVariablesScope, 'call', _53 => _53(node)]);
     node.selectors = remakeCssVarSelector(node.selectors, options);
     node.before(makePseudoVarRule());
     if (typeof cssInjectPreflight === "function") {
@@ -1169,9 +1440,9 @@ var postcssWeappTailwindcssPrePlugin = (options) => {
       root.walkAtRules((atRule) => {
         if (atRule.name === "layer") {
           if (atRule.params === "properties") {
-            if (atRule.nodes === void 0 || _optionalChain([atRule, 'access', _49 => _49.nodes, 'optionalAccess', _50 => _50.length]) === 0) {
+            if (atRule.nodes === void 0 || _optionalChain([atRule, 'access', _54 => _54.nodes, 'optionalAccess', _55 => _55.length]) === 0) {
               layerProperties = atRule;
-            } else if (_optionalChain([atRule, 'access', _51 => _51.first, 'optionalAccess', _52 => _52.type]) === "atrule" && isTailwindcssV4ModernCheck(atRule.first)) {
+            } else if (_optionalChain([atRule, 'access', _56 => _56.first, 'optionalAccess', _57 => _57.type]) === "atrule" && isTailwindcssV4ModernCheck(atRule.first)) {
               if (layerProperties) {
                 layerProperties.replaceWith(atRule.first.nodes);
                 atRule.remove();
@@ -1183,7 +1454,7 @@ var postcssWeappTailwindcssPrePlugin = (options) => {
             atRule.replaceWith(atRule.nodes);
           }
         } else if (isTailwindcssV4ModernCheck(atRule)) {
-          if (_optionalChain([atRule, 'access', _53 => _53.first, 'optionalAccess', _54 => _54.type]) === "atrule" && atRule.first.name === "layer") {
+          if (_optionalChain([atRule, 'access', _58 => _58.first, 'optionalAccess', _59 => _59.type]) === "atrule" && atRule.first.name === "layer") {
             atRule.replaceWith(atRule.first.nodes);
           }
         }
@@ -1197,39 +1468,163 @@ var postcssWeappTailwindcssPrePlugin = (options) => {
 };
 postcssWeappTailwindcssPrePlugin.postcss = true;
 
-// src/plugins/index.ts
-
-function normalizePlugins(options) {
-  const plugins = [];
-  const pxPlugin = getPxTransformPlugin(options);
-  if (pxPlugin) {
-    plugins.push(pxPlugin);
-  }
-  const remPlugin = getRemTransformPlugin(options);
-  if (remPlugin) {
-    plugins.push(remPlugin);
+// src/pipeline.ts
+var STAGE_ORDER = ["pre", "normal", "post"];
+function normalizeUserPlugins(plugins) {
+  if (!plugins) {
+    return [];
   }
-  const calcPlugin = getCalcPlugin(options);
-  if (calcPlugin) {
-    plugins.push(calcPlugin);
+  if (Array.isArray(plugins)) {
+    return plugins.filter(Boolean);
   }
-  const customPropertyCleaner = getCustomPropertyCleaner(options);
-  if (customPropertyCleaner) {
-    plugins.push(customPropertyCleaner);
+  if (typeof plugins === "object") {
+    return Object.values(plugins).filter(Boolean);
   }
-  return plugins;
+  return [];
+}
+function createStaticDefinition(id, stage, plugin) {
+  return {
+    id,
+    stage,
+    prepare: () => ({
+      id,
+      stage,
+      createPlugin: () => plugin
+    })
+  };
+}
+function createPipelineDefinitions(options) {
+  const stages = {
+    pre: [],
+    normal: [],
+    post: []
+  };
+  const userPlugins = normalizeUserPlugins(_optionalChain([options, 'access', _60 => _60.postcssOptions, 'optionalAccess', _61 => _61.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: () => _postcsspresetenv2.default.call(void 0, options.cssPresetEnv)
+    })
+  });
+  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: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]);
 }
-function getPlugins(options) {
-  const ctx = createContext();
-  options.ctx = ctx;
-  const plugins = [
-    ..._nullishCoalesce(_optionalChain([options, 'access', _55 => _55.postcssOptions, 'optionalAccess', _56 => _56.plugins]), () => ( [])),
-    postcssWeappTailwindcssPrePlugin(options),
-    _postcsspresetenv2.default.call(void 0, options.cssPresetEnv),
-    ...normalizePlugins(options),
-    postcssWeappTailwindcssPostPlugin(options)
-  ].filter(Boolean);
-  return plugins;
+function createStylePipeline(options) {
+  options.ctx = createContext();
+  const preparedNodes = createPipelineDefinitions(options).map((definition) => definition.prepare(options)).filter(Boolean);
+  if (preparedNodes.length === 0) {
+    return {
+      nodes: [],
+      plugins: []
+    };
+  }
+  const stageSizes = /* @__PURE__ */ new Map();
+  preparedNodes.forEach((node) => {
+    stageSizes.set(node.stage, (_nullishCoalesce(stageSizes.get(node.stage), () => ( 0))) + 1);
+  });
+  const stageIndices = /* @__PURE__ */ new Map();
+  const nodes2 = [];
+  const size = preparedNodes.length;
+  preparedNodes.forEach((node, index) => {
+    const stageIndex = _nullishCoalesce(stageIndices.get(node.stage), () => ( 0));
+    const context = {
+      stage: node.stage,
+      index,
+      size,
+      stageIndex,
+      stageSize: _nullishCoalesce(stageSizes.get(node.stage), () => ( 0)),
+      previous: index > 0 ? {
+        id: preparedNodes[index - 1].id,
+        stage: preparedNodes[index - 1].stage
+      } : void 0,
+      next: index < size - 1 ? {
+        id: preparedNodes[index + 1].id,
+        stage: preparedNodes[index + 1].stage
+      } : void 0
+    };
+    stageIndices.set(node.stage, stageIndex + 1);
+    nodes2.push({
+      id: node.id,
+      stage: node.stage,
+      plugin: node.createPlugin(context),
+      context
+    });
+  });
+  return {
+    nodes: nodes2,
+    plugins: nodes2.map((node) => node.plugin)
+  };
 }
 
 // src/preflight.ts
@@ -1255,22 +1650,22 @@ function createInjectPreflight(options) {
 function createProcessOptions(options) {
   return {
     from: void 0,
-    ..._nullishCoalesce(_optionalChain([options, 'access', _57 => _57.postcssOptions, 'optionalAccess', _58 => _58.options]), () => ( {}))
+    ..._nullishCoalesce(_optionalChain([options, 'access', _62 => _62.postcssOptions, 'optionalAccess', _63 => _63.options]), () => ( {}))
   };
 }
-var pluginCache = /* @__PURE__ */ new WeakMap();
+var pipelineCache = /* @__PURE__ */ new WeakMap();
 var processOptionsCache = /* @__PURE__ */ new WeakMap();
 var processOptionsSourceCache = /* @__PURE__ */ new WeakMap();
-function getCachedPlugins(options) {
-  let plugins = pluginCache.get(options);
-  if (!plugins) {
-    plugins = getPlugins(options);
-    pluginCache.set(options, plugins);
+function getCachedPipeline(options) {
+  let pipeline = pipelineCache.get(options);
+  if (!pipeline) {
+    pipeline = createStylePipeline(options);
+    pipelineCache.set(options, pipeline);
   }
-  return plugins;
+  return pipeline;
 }
 function getCachedProcessOptions(options) {
-  const source = _optionalChain([options, 'access', _59 => _59.postcssOptions, 'optionalAccess', _60 => _60.options]);
+  const source = _optionalChain([options, 'access', _64 => _64.postcssOptions, 'optionalAccess', _65 => _65.options]);
   let cached = processOptionsCache.get(options);
   const cachedSource = processOptionsSourceCache.get(options);
   if (!cached || cachedSource !== source) {
@@ -1281,7 +1676,7 @@ function getCachedProcessOptions(options) {
   return { ...cached };
 }
 function styleHandler(rawSource, options) {
-  const plugins = getCachedPlugins(options);
+  const plugins = getCachedPipeline(options).plugins;
   const processOptions = getCachedProcessOptions(options);
   return _postcss2.default.call(void 0, plugins).process(
     rawSource,
@@ -1294,18 +1689,27 @@ function createStyleHandler(options) {
     getDefaultOptions(options)
   );
   cachedOptions.cssInjectPreflight = createInjectPreflight(cachedOptions.cssPreflight);
-  getCachedPlugins(cachedOptions);
+  getCachedPipeline(cachedOptions);
   getCachedProcessOptions(cachedOptions);
-  return (rawSource, opt) => {
+  const handler = ((rawSource, opt) => {
     const resolvedOptions = _shared.defuOverrideArray.call(void 0, opt, cachedOptions);
     return styleHandler(
       rawSource,
       resolvedOptions
     );
+  });
+  handler.getPipeline = (opt) => {
+    if (!opt) {
+      return getCachedPipeline(cachedOptions);
+    }
+    const resolvedOptions = _shared.defuOverrideArray.call(void 0, opt, cachedOptions);
+    return getCachedPipeline(resolvedOptions);
   };
+  return handler;
 }
 
 
 
 
-exports.createInjectPreflight = createInjectPreflight; exports.createStyleHandler = createStyleHandler; exports.internalCssSelectorReplacer = internalCssSelectorReplacer;
+
+exports.createInjectPreflight = createInjectPreflight; exports.createStyleHandler = createStyleHandler; exports.createStylePipeline = createStylePipeline; exports.internalCssSelectorReplacer = internalCssSelectorReplacer;