@weapp-tailwindcss/postcss 1.3.3 → 2.0.0

package/dist/index.mjs

@@ -34,7 +34,7 @@ function getDefaultOptions(options) {
   };
 }
 
-// src/plugins/index.ts
+// src/pipeline.ts
 import postcssPresetEnv from "postcss-preset-env";
 
 // src/plugins/ctx.ts
@@ -56,7 +56,7 @@ function createContext() {
 // src/plugins/getCalcPlugin.ts
 import postcssCalc from "@weapp-tailwindcss/postcss-calc";
 
-// ../../node_modules/.pnpm/es-toolkit@1.40.0/node_modules/es-toolkit/dist/object/omit.mjs
+// ../../node_modules/.pnpm/es-toolkit@1.41.0/node_modules/es-toolkit/dist/object/omit.mjs
 function omit(obj, keys) {
   const result = { ...obj };
   for (let i = 0; i < keys.length; i++) {
@@ -80,32 +80,41 @@ import { regExpTest } from "@weapp-tailwindcss/shared";
 import valueParser from "postcss-value-parser";
 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 = decl.parent?.nodes[idx - 1];
-        if (!prevNode || prevNode.prop !== decl.prop) {
+        if (prevNode.value === decl.value) {
+          decl.remove();
+          return;
+        }
+        if (!shouldMatchCustomProperties || !/--/.test(decl.value)) {
           return;
         }
         const parsed = valueParser(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" && regExpTest(includeCustomProperties, x.value);
           });
           if (match) {
-            decl.remove();
+            containsIncludedCustomProperty = true;
           }
         });
+        if (containsIncludedCustomProperty) {
+          decl.remove();
+        }
       });
     }
   };
@@ -357,10 +366,7 @@ import { escape, MappingChars2String } from "@weapp-core/escape";
 function internalCssSelectorReplacer(selectors, options = {
   escapeMap: MappingChars2String
 }) {
-  const { mangleContext, escapeMap } = options;
-  if (mangleContext) {
-    selectors = mangleContext.cssHandler(selectors);
-  }
+  const { escapeMap } = options;
   return escape(selectors, {
     map: escapeMap
   });
@@ -377,129 +383,306 @@ function composeIsPseudo(strs) {
 
 // src/selectorParser/rule-transformer.ts
 var ruleTransformCache = /* @__PURE__ */ new WeakMap();
-function createRuleTransformer(options) {
-  let currentRule;
-  const { escapeMap, mangleContext, 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,
-          mangleContext
-        });
-      } else if (selector.type === "universal") {
-        if (cssSelectorReplacement?.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" && cssSelectorReplacement?.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 = node.parent?.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 = selector.parent?.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);
-                  selector.parent?.nodes.splice(
-                    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 = unique[unique.length - 1]?.next() ?? 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 = firstSelector.nodes?.[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 = node.nodes?.[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 = context.options.cssSelectorReplacement?.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 = node.parent?.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" && context.options.cssSelectorReplacement?.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 = node.parent?.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 = psp4(transform);
   return (rule) => {
-    currentRule = rule;
+    context = {
+      options,
+      requiresSpacingNormalization: false,
+      rule
+    };
     try {
       parser.transformSync(rule, normalizeTransformOptions());
     } finally {
-      currentRule = void 0;
+      context = void 0;
     }
   };
 }
@@ -513,16 +696,83 @@ function ruleTransformSync(rule, options) {
 }
 
 // src/plugins/post.ts
+function normalizeSelectorList(value) {
+  if (value === void 0 || value === false) {
+    return [];
+  }
+  return Array.isArray(value) ? value.filter(Boolean) : [value];
+}
+function getSpecificityMatchingName(options) {
+  const feature = options.cssPresetEnv?.features?.["is-pseudo-class"];
+  if (feature && typeof feature === "object" && "specificityMatchingName" in feature) {
+    const specificityName = feature.specificityMatchingName;
+    return typeof specificityName === "string" && specificityName.length > 0 ? specificityName : void 0;
+  }
+  return void 0;
+}
+function createRootSpecificityCleaner(options) {
+  const specificityMatchingName = getSpecificityMatchingName(options);
+  const selectors = normalizeSelectorList(options.cssSelectorReplacement?.root);
+  if (!specificityMatchingName || selectors.length === 0) {
+    return void 0;
+  }
+  const suffix = `:not(.${specificityMatchingName})`;
+  const targets = selectors.map((selector) => selector?.trim()).filter((selector) => Boolean(selector?.length)).map((selector) => ({
+    match: `${selector}${suffix}`,
+    spacedMatch: `${selector} ${suffix}`,
+    replacement: selector
+  }));
+  if (!targets.length) {
+    return void 0;
+  }
+  return (rule) => {
+    if (!rule.selectors || rule.selectors.length === 0) {
+      return;
+    }
+    const next = rule.selectors.map((selector) => {
+      let updated = selector;
+      for (const target of targets) {
+        if (updated.includes(target.match)) {
+          updated = updated.split(target.match).join(target.replacement);
+        }
+        if (updated.includes(target.spacedMatch)) {
+          updated = updated.split(target.spacedMatch).join(target.replacement);
+        }
+      }
+      return updated;
+    });
+    rule.selectors = next;
+  };
+}
 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 logicalPropMap.get(prop) ?? prop;
@@ -539,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]) {
@@ -574,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 = declarations[declarations.length - 1]?.next() ?? 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 = defu(options, {
@@ -582,20 +902,27 @@ var postcssWeappTailwindcssPostPlugin = (options) => {
   const p = {
     postcssPlugin
   };
-  if (opts.isMainChunk) {
-    const fallbackRemove = getFallbackRemove(void 0, opts);
+  const cleanRootSpecificity = createRootSpecificityCleaner(opts);
+  const enableMainChunkTransforms = opts.isMainChunk !== false;
+  if (enableMainChunkTransforms || cleanRootSpecificity) {
+    const fallbackRemove = enableMainChunkTransforms ? getFallbackRemove(void 0, opts) : void 0;
     p.RuleExit = (rule) => {
-      fallbackRemove.transformSync(rule);
-      dedupeDeclarations(rule);
-      if (rule.selectors.length === 0 || rule.selectors.length === 1 && rule.selector.trim() === "") {
-        rule.remove();
+      if (enableMainChunkTransforms) {
+        fallbackRemove?.transformSync(rule);
       }
-      if (opts.uniAppX) {
-        if (rule.nodes.length === 0) {
+      cleanRootSpecificity?.(rule);
+      if (enableMainChunkTransforms) {
+        dedupeDeclarations(rule);
+        if (rule.selectors.length === 0 || rule.selectors.length === 1 && rule.selector.trim() === "") {
+          rule.remove();
+        }
+        if (opts.uniAppX && rule.nodes.length === 0) {
           rule.remove();
         }
       }
     };
+  }
+  if (enableMainChunkTransforms) {
     p.DeclarationExit = (decl) => {
       if (decl.prop === "--tw-gradient-position" && decl.value.endsWith(OklabSuffix)) {
         decl.value = decl.value.slice(0, decl.value.length - OklabSuffix.length);
@@ -1146,39 +1473,163 @@ var postcssWeappTailwindcssPrePlugin = (options) => {
 };
 postcssWeappTailwindcssPrePlugin.postcss = true;
 
-// src/plugins/index.ts
-import { default as default2 } from "postcss-rem-to-responsive-pixel";
-function normalizePlugins(options) {
-  const plugins = [];
-  const pxPlugin = getPxTransformPlugin(options);
-  if (pxPlugin) {
-    plugins.push(pxPlugin);
-  }
-  const remPlugin = getRemTransformPlugin(options);
-  if (remPlugin) {
-    plugins.push(remPlugin);
-  }
-  const calcPlugin = getCalcPlugin(options);
-  if (calcPlugin) {
-    plugins.push(calcPlugin);
-  }
-  const customPropertyCleaner = getCustomPropertyCleaner(options);
-  if (customPropertyCleaner) {
-    plugins.push(customPropertyCleaner);
-  }
-  return plugins;
+// src/pipeline.ts
+var STAGE_ORDER = ["pre", "normal", "post"];
+function normalizeUserPlugins(plugins) {
+  if (!plugins) {
+    return [];
+  }
+  if (Array.isArray(plugins)) {
+    return plugins.filter(Boolean);
+  }
+  if (typeof plugins === "object") {
+    return Object.values(plugins).filter(Boolean);
+  }
+  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(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: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 = [
-    ...options.postcssOptions?.plugins ?? [],
-    postcssWeappTailwindcssPrePlugin(options),
-    postcssPresetEnv(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, (stageSizes.get(node.stage) ?? 0) + 1);
+  });
+  const stageIndices = /* @__PURE__ */ new Map();
+  const nodes2 = [];
+  const size = preparedNodes.length;
+  preparedNodes.forEach((node, index) => {
+    const stageIndex = stageIndices.get(node.stage) ?? 0;
+    const context = {
+      stage: node.stage,
+      index,
+      size,
+      stageIndex,
+      stageSize: 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
@@ -1207,16 +1658,16 @@ function createProcessOptions(options) {
     ...options.postcssOptions?.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 = options.postcssOptions?.options;
@@ -1230,7 +1681,7 @@ function getCachedProcessOptions(options) {
   return { ...cached };
 }
 function styleHandler(rawSource, options) {
-  const plugins = getCachedPlugins(options);
+  const plugins = getCachedPipeline(options).plugins;
   const processOptions = getCachedProcessOptions(options);
   return postcss(plugins).process(
     rawSource,
@@ -1243,18 +1694,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 = defuOverrideArray3(opt, cachedOptions);
     return styleHandler(
       rawSource,
       resolvedOptions
     );
+  });
+  handler.getPipeline = (opt) => {
+    if (!opt) {
+      return getCachedPipeline(cachedOptions);
+    }
+    const resolvedOptions = defuOverrideArray3(opt, cachedOptions);
+    return getCachedPipeline(resolvedOptions);
   };
+  return handler;
 }
 export {
   createInjectPreflight,
   createStyleHandler,
+  createStylePipeline,
   internalCssSelectorReplacer
 };