postcss-calc 11.0.0-rc.2 → 11.0.0-rc.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "postcss-calc",
-  "version": "11.0.0-rc.2",
+  "version": "11.0.0-rc.3",
   "type": "module",
   "description": "PostCSS plugin to reduce calc()",
   "keywords": [
@@ -31,14 +31,20 @@
   "engines": {
     "node": "^22.18 || ^24.11 || >=26.0"
   },
+  "devEngines": {
+    "packageManager": {
+      "name": "pnpm",
+      "version": "11.21.0"
+    }
+  },
   "devDependencies": {
     "@csstools/css-calc": "^3.3.0",
     "@rmenke/css-tokenizer-tests": "^1.2.0",
-    "@types/node": "^26.1.2",
+    "@types/node": "^26.2.0",
     "fast-check": "^4.9.0",
-    "oxfmt": "^0.61.0",
-    "oxlint": "^1.76.0",
-    "postcss": "^8.5.25",
+    "oxfmt": "^0.63.0",
+    "oxlint": "^1.78.0",
+    "postcss": "^8.5.26",
     "typescript": "~7.0.2"
   },
   "dependencies": {

package/src/lib/node.js

@@ -5,7 +5,9 @@
 //     is `Num(-5)`, never `Sum([{sign:-1, Num(5)}])`. One form per value.
 //   - In a SumTerm with Num/Dim node, sign is always +1; the sign slot is
 //     reserved for opaque nodes (Ident, Call, Product, multi-term Sum).
-//   - No Sum directly contains another Sum (flattened on construction).
+//   - No ungrouped Sum directly contains another Sum (flattened on
+//     construction). A grouped Sum is retained so a later negative sign
+//     cannot be distributed across opaque terms.
 //   - No Product directly contains another Product (flattened).
 //   - A Sum/Product with one positive element collapses to that element.
 //   - A Sum/Product with no elements collapses to Num(0) / Num(1).
@@ -18,7 +20,7 @@
  * @typedef {{type: 'Ident', name: string}} Ident
  * @typedef {{type: 'Call', name: string, args: Node[]}} Call
  * @typedef {{sign: 1 | -1, node: Node}} SumTerm Sign is always +1 when node is Num or Dim.
- * @typedef {{type: 'Sum', terms: SumTerm[]}} Sum
+ * @typedef {{type: 'Sum', terms: SumTerm[], grouped?: boolean}} Sum
  * @typedef {{exponent: 1 | -1, node: Node}} ProductFactor exponent +1 = numerator, -1 = denominator.
  * @typedef {{type: 'Product', factors: ProductFactor[]}} Product
  * @typedef {Num | Dim | Ident | Call | Sum | Product} Node
@@ -85,7 +87,7 @@ function mkSum(rawTerms) {
 function pushSumTerm(out, term) {
   let { sign, node } = term;
 
-  if (node.type === 'Sum') {
+  if (node.type === 'Sum' && !node.grouped) {
     for (const inner of node.terms) {
       pushSumTerm(out, {
         sign: /** @type {1 | -1} */ (sign * inner.sign),
@@ -170,12 +172,15 @@ function negate(node) {
     return dim(-node.value, node.unit);
   }
   if (node.type === 'Sum') {
-    return mkSum(
+    const result = mkSum(
       node.terms.map((t) => ({
         sign: /** @type {1 | -1} */ (-t.sign),
         node: t.node,
       }))
     );
+    return node.grouped && result.type === 'Sum'
+      ? { ...result, grouped: true }
+      : result;
   }
   // Opaque (Ident, Call, Product): wrap as a single negative-sign term —
   // the only case where sign=-1 remains on a SumTerm.

package/src/lib/parser.js

@@ -1,6 +1,6 @@
 // Pratt parser. +/- emit Sum nodes; */÷ emit Product nodes. node.js
-// constructors flatten and normalize on construction, so the parser
-// never produces a Binary node.
+// constructors flatten and normalize on construction, while parenthesized
+// sums retain a grouping marker for the opaque-subtraction invariant.
 import { mkSum, mkProduct, negate } from './node.js';
 
 /**
@@ -266,7 +266,7 @@ const PREFIX = {
   '(': (p) => {
     const e = p.parseExpr(0);
     p.expect('punct', ')');
-    return e;
+    return e.type === 'Sum' ? { ...e, grouped: true } : e;
   },
 
   '-': (p) => negate(p.parseExpr(UNARY_BP)),

package/src/lib/serialize.js

@@ -77,6 +77,25 @@ function serialize(node, opts = {}) {
     return `${calcName}(${degenerateKeyword(node.value)} * 1${node.unit})`;
   }
 
+  // A grouped sum with a leading negative term is the canonical result of
+  // negating a parenthesized expression. Re-invert its terms for the body so
+  // the grouping survives as `-(...)` instead of becoming `-a - b`.
+  if (
+    node.type === 'Sum' &&
+    node.grouped &&
+    node.terms.length > 1 &&
+    displaySign(node.terms[0]).sign === -1
+  ) {
+    const body = /** @type {Sum} */ ({
+      type: 'Sum',
+      terms: node.terms.map((t) => ({
+        sign: /** @type {1 | -1} */ (-t.sign),
+        node: t.node,
+      })),
+    });
+    return `${calcName}(-(${serializeExpr(body, prec)}))`;
+  }
+
   if (
     node.type === 'Num' ||
     node.type === 'Dim' ||
@@ -166,13 +185,21 @@ function serializeSum(sum, prec) {
   for (const [i, t] of sum.terms.entries()) {
     const { sign, magnitude } = displaySign(t);
     if (i === 0) {
+      if (magnitude.type === 'Sum' && magnitude.grouped) {
+        const body = `(${serializeExpr(magnitude, prec)})`;
+        out = sign === 1 ? body : `-${body}`;
+        continue;
+      }
       out =
         sign === 1
           ? serializeExpr(magnitude, prec)
           : serializeLeadingNeg(magnitude, prec);
     } else {
       // `-` binds looser than `*`/`/` so the right side never needs parens.
-      const body = serializeExpr(magnitude, prec);
+      let body = serializeExpr(magnitude, prec);
+      if (magnitude.type === 'Sum' && magnitude.grouped) {
+        body = `(${body})`;
+      }
       out += sign === 1 ? ` + ${body}` : ` - ${body}`;
     }
   }

package/src/lib/simplify/sum.js

@@ -48,6 +48,17 @@ function simplifySum(sum, simplify) {
    */
   function processTerm(sign, n) {
     if (n.type === 'Sum') {
+      // Parentheses around a sum are normally algebraically disposable. Keep
+      // them only for an opaque sum used negatively: distributing that sign
+      // changes the CSS value when a var() contains a sum of its own.
+      if (
+        n.grouped &&
+        sign === -1 &&
+        n.terms.some((t) => t.node.type !== 'Num' && t.node.type !== 'Dim')
+      ) {
+        opaque.push({ sign, node: n });
+        return;
+      }
       for (const inner of n.terms) {
         processTerm(/** @type {1 | -1} */ (sign * inner.sign), inner.node);
       }
@@ -95,7 +106,13 @@ function simplifySum(sum, simplify) {
   }
   terms.push(...opaque);
 
-  return mkSum(terms);
+  const result = mkSum(terms);
+  // Keep the source grouping available to an enclosing subtraction. Numeric
+  // groups have already folded and therefore do not need the marker.
+  if (sum.grouped && result.type === 'Sum' && opaque.length > 0) {
+    return { ...result, grouped: true };
+  }
+  return result;
 }
 
 export { simplifySum };

package/types/lib/node.d.ts

@@ -23,6 +23,7 @@ export type SumTerm = {
 export type Sum = {
     type: 'Sum';
     terms: SumTerm[];
+    grouped?: boolean;
 };
 export type ProductFactor = {
     exponent: 1 | -1;
@@ -39,7 +40,7 @@ export type Node = Num | Dim | Ident | Call | Sum | Product;
  * @typedef {{type: 'Ident', name: string}} Ident
  * @typedef {{type: 'Call', name: string, args: Node[]}} Call
  * @typedef {{sign: 1 | -1, node: Node}} SumTerm Sign is always +1 when node is Num or Dim.
- * @typedef {{type: 'Sum', terms: SumTerm[]}} Sum
+ * @typedef {{type: 'Sum', terms: SumTerm[], grouped?: boolean}} Sum
  * @typedef {{exponent: 1 | -1, node: Node}} ProductFactor exponent +1 = numerator, -1 = denominator.
  * @typedef {{type: 'Product', factors: ProductFactor[]}} Product
  * @typedef {Num | Dim | Ident | Call | Sum | Product} Node

package/types/lib/type.d.ts

@@ -1,4 +1,11 @@
-export type BaseType = "length" | "angle" | "time" | "frequency" | "resolution" | "flex" | "percentage";
+export type BaseType =
+  | 'length'
+  | 'angle'
+  | 'time'
+  | 'frequency'
+  | 'resolution'
+  | 'flex'
+  | 'percentage';
 /**
  * @param {string} unit
  * @return {BaseType | null}