postcss-calc 11.2.2 → 11.2.3

package/src/lib/serialize/expression.js

@@ -1,62 +1,37 @@
 // Spec: https://www.w3.org/TR/css-values-4/#serialize-a-calculation-tree
-// Canonical AST expression emission: operator precedence, parenthesization,
-// sum terms, product factors, and function calls.
+// Canonical AST expression emission: node dispatch, sums, products, function
+// calls, and math results. These emitters recurse into each other, so they
+// share one module; precision and precedence rules live in sibling modules.
 
-import { serializeComponents } from '../opaque.js';
 import { num } from '../node.js';
+import { serializeComponents } from '../opaque.js';
 import {
-  round,
-  isDegenerate,
   degenerateKeyword,
-  roundedScalarValue,
+  emitBareSignedZero,
   emitRoundedScalar,
   emitScalar,
   emitSignedZero,
+  isDegenerate,
   isScalar,
   isSignedZero,
-  isEffectivelyNegative,
+  round,
+  roundedScalarValue,
 } from './precision.js';
+import {
+  needsParentheses,
+  PRODUCT_PRECEDENCE,
+  SUM_PRECEDENCE,
+  UNARY_PRECEDENCE,
+} from './precedence.js';
 
 /**
  * @typedef {import('../node.js').Node} Node
  * @typedef {import('../node.js').Sum} Sum
- * @typedef {import('../node.js').Product} Product
+ * @typedef {import('../node.js').SumTerm} SumTerm
  * @typedef {import('../node.js').ProductFactor} ProductFactor
  * @typedef {import('./precision.js').SerializeSession} SerializeSession
  */
 
-// The AST is canonical: sums and products are flat, except grouped nodes that
-// keep their parentheses, so these precedence levels cover every binary expression
-const SUM_PRECEDENCE = 1;
-const PRODUCT_PRECEDENCE = 2;
-const ATOMIC_PRECEDENCE = 3;
-// Negation (-1 * ...) binds more tightly than a sum but has the same atomic boundary
-// for deciding whether the operand needs parentheses.
-const UNARY_PRECEDENCE = ATOMIC_PRECEDENCE;
-
-/** @param {Node} node @return {number} */
-function precedence(node) {
-  if (node.type === 'Sum') return SUM_PRECEDENCE;
-  if (node.type === 'Product') return PRODUCT_PRECEDENCE;
-  return ATOMIC_PRECEDENCE;
-}
-
-/**
- * @param {Node} node
- * @param {number} parentPrecedence
- * @param {boolean} groupedRequired
- * @return {boolean}
- */
-function needsParentheses(node, parentPrecedence, groupedRequired) {
-  return (
-    precedence(node) < parentPrecedence ||
-    (node.type === 'Sum' &&
-      node.grouped === true &&
-      groupedRequired === true) ||
-    (node.type === 'Product' && node.grouped === true && parentPrecedence > 0)
-  );
-}
-
 /**
  * @param {Node} node
  * @param {SerializeSession} session
@@ -105,129 +80,88 @@ function emitNodeBody(node, session) {
       emitSum(node, session);
       return;
     case 'Product':
-      emitProduct(node, session);
+      emitProductFactors(node.factors, session);
       return;
   }
 }
 
-/**
- * @param {import('../node.js').Call} node
- * @param {SerializeSession} session
- * @param {string} [callNameOverride]
- * @return {void}
- */
-function emitCall(node, session, callNameOverride) {
-  const buffer = session.buffer;
-  buffer.push(callNameOverride ?? node.rawName ?? node.name, '(');
-  for (let i = 0; i < node.args.length; i++) {
-    if (i > 0) buffer.push(', ');
-    emitNode(node.args[i], session);
-  }
-  buffer.push(')');
-}
-
-/**
- * @param {import('../node.js').OpaqueCall} node
- * @param {SerializeSession} session
- * @param {string} [callNameOverride]
- * @return {void}
- */
-function emitOpaqueCall(node, session, callNameOverride) {
-  const buffer = session.buffer;
-  buffer.push(callNameOverride ?? node.rawName ?? node.name, '(');
-  serializeComponents(node.components, buffer, (child, childBuffer) => {
-    emitNestedMathResult(child, session, childBuffer);
-  });
-  buffer.push(')');
-}
-
-/**
- * @param {import('../node.js').SumTerm} term
- * @param {1 | -1} multiplier
- * @param {number | false} precision
- * @return {1 | -1}
- */
-function termSign(term, multiplier, precision) {
-  let sign = /** @type {1 | -1} */ (term.sign * multiplier);
-  if (isEffectivelyNegative(term.node, precision)) {
-    sign = /** @type {1 | -1} */ (-sign);
-  }
-  return sign;
-}
-
-/**
- * @param {import('../node.js').SumTerm} term
- * @param {SerializeSession} session
- * @param {1 | -1} sign
- * @return {void}
- */
-function emitSumTerm(term, session, sign) {
-  if (sign === 1) {
-    emitNode(term.node, session, SUM_PRECEDENCE, true);
-  } else {
-    emitLeadingNeg(term.node, session);
-  }
-}
-
 /**
  * @param {import('../node.js').Num | import('../node.js').Dim} termNode
  * @param {1 | -1} sign
- * @param {number} i
+ * @param {boolean} leading
  * @param {SerializeSession} session
  * @return {void}
  */
-function emitScalarSumTerm(termNode, sign, i, session) {
+function emitScalarSumTerm(termNode, sign, leading, session) {
   const buffer = session.buffer;
   const effectiveVal = sign * termNode.value;
   if (Object.is(effectiveVal, -0)) {
-    if (i > 0) buffer.push(' + ');
-    emitSignedZero(buffer, termNode);
+    // `x - 0` reparses as x + -(0), so subtraction round-trips negative zero.
+    // A leading term starts a <calc-product>, so `-1 * 0` needs no calc().
+    if (leading) {
+      emitBareSignedZero(buffer, termNode);
+    } else {
+      buffer.push(' - ');
+      emitRoundedScalar(termNode, buffer, 0);
+    }
     return;
   }
   if (isDegenerate(effectiveVal)) {
-    if (i === 0 && sign === -1) buffer.push('-');
-    else if (i > 0) buffer.push(sign === 1 ? ' + ' : ' - ');
+    if (!leading) buffer.push(sign === 1 ? ' + ' : ' - ');
+    else if (sign === -1) buffer.push('-');
     emitScalar(termNode, session);
     return;
   }
   const rounded = round(effectiveVal, session.precision);
   if (rounded < 0) {
-    buffer.push(i === 0 ? '-' : ' - ');
+    buffer.push(leading ? '-' : ' - ');
     emitRoundedScalar(termNode, buffer, -rounded);
   } else {
-    if (i > 0) buffer.push(' + ');
+    if (!leading) buffer.push(' + ');
     emitRoundedScalar(termNode, buffer, rounded);
   }
 }
 
 /**
- * @param {import('../node.js').SumTerm[]} terms
+ * @param {SumTerm} term
+ * @param {boolean} leading
  * @param {SerializeSession} session
- * @param {1 | -1} [multiplier]
  * @return {void}
  */
-function emitSumTerms(terms, session, multiplier = 1) {
-  const buffer = session.buffer;
-  for (let i = 0; i < terms.length; i++) {
-    const term = terms[i];
-    const termNode = term.node;
-    const sign = /** @type {1 | -1} */ (term.sign * multiplier);
-    if (isScalar(termNode)) {
-      emitScalarSumTerm(termNode, sign, i, session);
-      continue;
-    }
-    if (i === 0) {
-      emitSumTerm(term, session, sign);
-    } else {
-      buffer.push(sign === 1 ? ' + ' : ' - ');
-      emitNode(termNode, session, SUM_PRECEDENCE, true);
-    }
+function emitSumTerm(term, leading, session) {
+  const termNode = term.node;
+  if (isScalar(termNode)) {
+    emitScalarSumTerm(termNode, term.sign, leading, session);
+  } else if (leading && term.sign === -1) {
+    emitLeadingNeg(termNode, session);
+  } else {
+    if (!leading) session.buffer.push(term.sign === 1 ? ' + ' : ' - ');
+    emitNode(termNode, session, SUM_PRECEDENCE, true);
   }
 }
 
-/** @param {Sum} sum @param {SerializeSession} session @return {void} */
+/** @param {SumTerm} term @return {boolean} */
+function isNegativeZeroTerm(term) {
+  return isScalar(term.node) && Object.is(term.sign * term.node.value, -0);
+}
+
+/**
+ * @param {Sum} sum
+ * @param {SerializeSession} session
+ * @return {void}
+ */
 function emitSum(sum, session) {
-  emitSumTerms(sum.terms, session);
+  const terms = sum.terms;
+  // x + -0 is exactly x for every x, so leading negative zeros can move
+  // behind the first other term and use the shorter subtraction form. When
+  // every term is negative zero, keep the order so reducing again is stable.
+  let lead = 0;
+  while (lead < terms.length && isNegativeZeroTerm(terms[lead])) lead++;
+  if (lead === terms.length) lead = 0;
+  emitSumTerm(terms[lead], true, session);
+  for (let i = 0; i < terms.length; i++) {
+    if (i !== lead) emitSumTerm(terms[i], false, session);
+  }
 }
 
 /**
@@ -269,34 +203,64 @@ function emitProductFactors(
   coefficientNode
 ) {
   const buffer = session.buffer;
-  let first = true;
+  // Only the product's first multiplied scalar may print negative zero as a
+  // bare `-1 * 0`: reparsing folds the `-1` back into that same coefficient.
+  // After any operator, the `-1` would bind to the preceding operand instead.
+  let leading = true;
   if (coefficientValue !== undefined && coefficientValue !== 1) {
-    emitScalar(
-      /** @type {import('../node.js').Num} */ (coefficientNode),
-      session,
-      coefficientValue
+    const coefficient = /** @type {import('../node.js').Num} */ (
+      coefficientNode
     );
-    first = false;
+    emitScalar(coefficient, session, coefficientValue, true);
+    leading = false;
   }
   for (let i = start; i < factors.length; i++) {
     const factor = factors[i];
     const factorNode = factor.node;
-    if (first) {
-      if (factor.exponent === -1) buffer.push('1 / ');
-      if (isScalar(factorNode)) emitScalar(factorNode, session);
-      else emitNode(factorNode, session, PRODUCT_PRECEDENCE);
-      first = false;
+    const multiplied = factor.exponent === 1;
+    if (!leading) buffer.push(multiplied ? ' * ' : ' / ');
+    else if (!multiplied) buffer.push('1 / ');
+    if (isScalar(factorNode)) {
+      emitScalar(factorNode, session, undefined, leading && multiplied);
     } else {
-      buffer.push(factor.exponent === 1 ? ' * ' : ' / ');
-      if (isScalar(factorNode)) emitScalar(factorNode, session);
-      else emitNode(factorNode, session, PRODUCT_PRECEDENCE);
+      emitNode(factorNode, session, PRODUCT_PRECEDENCE);
     }
+    leading = false;
+  }
+}
+
+/**
+ * @param {import('../node.js').Call} node
+ * @param {SerializeSession} session
+ * @param {string} [callNameOverride]
+ * @return {void}
+ */
+function emitCall(node, session, callNameOverride) {
+  const buffer = session.buffer;
+  buffer.push(callNameOverride ?? node.rawName ?? node.name, '(');
+  for (let i = 0; i < node.args.length; i++) {
+    if (i > 0) buffer.push(', ');
+    const arg = node.args[i];
+    // Every math-function argument is a <calc-sum>, so it needs no calc()
+    if (isSignedZero(arg)) emitBareSignedZero(buffer, arg);
+    else emitNode(arg, session);
   }
+  buffer.push(')');
 }
 
-/** @param {Product} product @param {SerializeSession} session @return {void} */
-function emitProduct(product, session) {
-  emitProductFactors(product.factors, session);
+/**
+ * @param {import('../node.js').OpaqueCall} node
+ * @param {SerializeSession} session
+ * @param {string} [callNameOverride]
+ * @return {void}
+ */
+function emitOpaqueCall(node, session, callNameOverride) {
+  const buffer = session.buffer;
+  buffer.push(callNameOverride ?? node.rawName ?? node.name, '(');
+  serializeComponents(node.components, buffer, (child, childBuffer) => {
+    emitNestedMathResult(child, session, childBuffer);
+  });
+  buffer.push(')');
 }
 
 /**
@@ -356,21 +320,10 @@ function emitNestedMathResult(node, session, buffer = session.buffer) {
 }
 
 export {
-  SUM_PRECEDENCE,
-  PRODUCT_PRECEDENCE,
-  ATOMIC_PRECEDENCE,
-  UNARY_PRECEDENCE,
-  precedence,
-  needsParentheses,
   emitNode,
+  emitLeadingNeg,
   emitCall,
   emitOpaqueCall,
-  termSign,
-  emitSumTerms,
-  emitSum,
-  emitLeadingNeg,
-  emitProductFactors,
-  emitProduct,
   emitMathResult,
   emitNestedMathResult,
 };

package/src/lib/serialize/precedence.js

@@ -0,0 +1,47 @@
+// Spec: https://www.w3.org/TR/css-values-4/#serialize-a-calculation-tree
+// Operator precedence and parenthesization rules for canonical AST emission.
+
+/**
+ * @typedef {import('../node.js').Node} Node
+ */
+
+// The AST is canonical: sums and products are flat, except grouped nodes that
+// keep their parentheses, so these precedence levels cover every binary expression
+const SUM_PRECEDENCE = 1;
+const PRODUCT_PRECEDENCE = 2;
+const ATOMIC_PRECEDENCE = 3;
+// Negation (-1 * ...) binds more tightly than a sum but has the same atomic boundary
+// for deciding whether the operand needs parentheses.
+const UNARY_PRECEDENCE = ATOMIC_PRECEDENCE;
+
+/** @param {Node} node @return {number} */
+function precedence(node) {
+  if (node.type === 'Sum') return SUM_PRECEDENCE;
+  if (node.type === 'Product') return PRODUCT_PRECEDENCE;
+  return ATOMIC_PRECEDENCE;
+}
+
+/**
+ * @param {Node} node
+ * @param {number} parentPrecedence
+ * @param {boolean} groupedRequired
+ * @return {boolean}
+ */
+function needsParentheses(node, parentPrecedence, groupedRequired) {
+  return (
+    precedence(node) < parentPrecedence ||
+    (node.type === 'Sum' &&
+      node.grouped === true &&
+      groupedRequired === true) ||
+    (node.type === 'Product' && node.grouped === true && parentPrecedence > 0)
+  );
+}
+
+export {
+  SUM_PRECEDENCE,
+  PRODUCT_PRECEDENCE,
+  ATOMIC_PRECEDENCE,
+  UNARY_PRECEDENCE,
+  precedence,
+  needsParentheses,
+};

package/src/lib/serialize/precision.js

@@ -168,13 +168,16 @@ function emitFiniteScalar(node, session, value) {
  * @param {import('../node.js').Num | import('../node.js').Dim} node
  * @param {SerializeSession} session
  * @param {number} [value]
+ * @param {boolean} [bare] emit negative zero without its calc() wrapper
  * @return {void}
  */
-function emitScalar(node, session, value) {
+function emitScalar(node, session, value, bare = false) {
   const buffer = session.buffer;
   const effective = value ?? node.value;
-  if (Object.is(effective, -0)) emitSignedZero(buffer, node);
-  else if (isDegenerate(effective)) {
+  if (Object.is(effective, -0)) {
+    if (bare) emitBareSignedZero(buffer, node);
+    else emitSignedZero(buffer, node);
+  } else if (isDegenerate(effective)) {
     if (node.type === 'Dim') {
       buffer.push(
         'calc(',
@@ -195,8 +198,21 @@ function emitScalar(node, session, value) {
  * @return {void}
  */
 function emitSignedZero(buffer, node) {
+  buffer.push('calc(');
+  emitBareSignedZero(buffer, node);
+  buffer.push(')');
+}
+
+/**
+ * Negative zero as an unwrapped product, valid only where a `<calc-product>`
+ * may appear without changing how the surrounding expression parses.
+ * @param {string[]} buffer
+ * @param {import('../node.js').Num | import('../node.js').Dim} node
+ * @return {void}
+ */
+function emitBareSignedZero(buffer, node) {
   const unit = node.type === 'Dim' ? (node.rawUnit ?? node.unit) : '';
-  buffer.push('calc(-1 * 0', unit, ')');
+  buffer.push('-1 * 0', unit);
 }
 
 /** @param {Node} node @return {node is import('../node.js').Num | import('../node.js').Dim} */
@@ -209,22 +225,6 @@ function isSignedZero(node) {
   return isScalar(node) ? Object.is(node.value, -0) : false;
 }
 
-/**
- * Whether a scalar node is strictly negative after precision rounding
- * (excluding signed zero and sub-precision values that round to zero).
- * @param {Node} node
- * @param {number | false} precision
- * @return {node is import('../node.js').Num | import('../node.js').Dim}
- */
-function isEffectivelyNegative(node, precision) {
-  return (
-    isScalar(node) &&
-    !Object.is(node.value, -0) &&
-    Number.isFinite(node.value) &&
-    round(node.value, precision) < 0
-  );
-}
-
 export {
   NOISE_FLOOR,
   divideByPowerOfTen,
@@ -238,7 +238,7 @@ export {
   emitFiniteScalar,
   emitScalar,
   emitSignedZero,
+  emitBareSignedZero,
   isScalar,
   isSignedZero,
-  isEffectivelyNegative,
 };

package/src/lib/serialize.js

@@ -13,10 +13,10 @@ import {
 } from './serialize/precision.js';
 import {
   emitCall,
+  emitLeadingNeg,
   emitOpaqueCall,
   emitMathResult,
   emitNode,
-  emitLeadingNeg,
 } from './serialize/expression.js';
 
 /**

package/src/lib/simplify/product-barrier.js

@@ -0,0 +1,55 @@
+import { num } from '../node.js';
+
+/**
+ * @typedef {import('../node.js').Node} Node
+ * @typedef {import('../node.js').ProductFactor} ProductFactor
+ */
+
+/**
+ * A substitution function (`var()`, `env()`, `attr()`, ...) is replaced by
+ * tokens, not by a value, so factors cannot move or cancel across it. Any
+ * function the parser does not recognise (`anchor()`, `foo()`, ...) is also an
+ * OpaqueCall and is treated the same, conservatively. A grouped Product is a
+ * parenthesized substitution and is equally opaque.
+ * @param {Node} node
+ * @return {boolean}
+ */
+function isBarrier(node) {
+  return (
+    node.type === 'OpaqueCall' ||
+    (node.type === 'Product' && node.grouped === true)
+  );
+}
+
+/**
+ * Flatten a simplified factor through nested ungrouped Products and the
+ * canonical negation form, so barriers are visible at the top level.
+ * @param {ProductFactor[]} out
+ * @param {1 | -1} exponent
+ * @param {Node} node
+ * @return {boolean} Whether a barrier was pushed.
+ */
+function flattenFactor(out, exponent, node) {
+  if (node.type === 'Product' && !node.grouped) {
+    let barrier = false;
+    for (const inner of node.factors) {
+      if (
+        flattenFactor(
+          out,
+          /** @type {1 | -1} */ (exponent * inner.exponent),
+          inner.node
+        )
+      )
+        barrier = true;
+    }
+    return barrier;
+  }
+  if (node.type === 'Sum' && node.terms.length === 1) {
+    out.push({ exponent, node: num(-1) });
+    return flattenFactor(out, exponent, node.terms[0].node);
+  }
+  out.push({ exponent, node });
+  return isBarrier(node);
+}
+
+export { flattenFactor, isBarrier };

package/src/lib/simplify/product-quotient.js

@@ -0,0 +1,141 @@
+import { mkProduct, num, dim } from '../node.js';
+import { isExact } from './exact.js';
+
+/**
+ * @typedef {import('../node.js').Node} Node
+ * @typedef {import('../node.js').ProductFactor} ProductFactor
+ */
+
+/**
+ * @param {number} a non-negative
+ * @param {number} b non-negative
+ * @return {number}
+ */
+function gcd(a, b) {
+  let x = a;
+  let y = b;
+  while (y !== 0) {
+    [x, y] = [y, x % y];
+  }
+  return x || 1;
+}
+
+/**
+ * @param {{exponent: 1 | -1, value: number}[]} chain
+ * @return {number}
+ */
+function chainValue(chain) {
+  let value = 1;
+  for (const f of chain) {
+    value = f.exponent === 1 ? value * f.value : value / f.value;
+  }
+  return value;
+}
+
+/**
+ * Whether the opaque factors are a single Sum of only Num/Dim terms.
+ * @param {ProductFactor[]} opaque
+ * @return {boolean}
+ */
+function isScalarSum(opaque) {
+  return (
+    opaque.length === 1 &&
+    opaque[0].exponent === 1 &&
+    opaque[0].node.type === 'Sum' &&
+    opaque[0].node.terms.every(
+      (t) => t.node.type === 'Num' || t.node.type === 'Dim'
+    )
+  );
+}
+
+/**
+ * Whether a folded quotient prints exactly. A quotient distributed over a
+ * scalar Sum is judged term by term, so `(3px + 6em) / 3` still folds.
+ * @param {number} value
+ * @param {ProductFactor[]} opaque
+ * @param {boolean} distributable
+ * @param {number | false} precision
+ * @return {boolean}
+ */
+function foldsExactly(value, opaque, distributable, precision) {
+  if (!Number.isFinite(value) || isExact(value, precision)) {
+    return true;
+  }
+  if (!distributable) {
+    return false;
+  }
+  const sum = /** @type {import('../node.js').Sum} */ (opaque[0].node);
+  return sum.terms.every((t) =>
+    isExact(
+      value *
+        /** @type {import('../node.js').Num | import('../node.js').Dim} */ (
+          t.node
+        ).value,
+      precision
+    )
+  );
+}
+
+/**
+ * Emit an inexact quotient as `numerator * dims * opaque / denominator`, with
+ * integer parts reduced by their gcd. A lone Dim absorbs the numerator.
+ * @param {number} numerator
+ * @param {number} denominator
+ * @param {{value: number, unit: string, rawUnit?: string} | null} loneDim
+ * @param {{exponent: 1 | -1, value: number, unit: string, rawUnit?: string}[]} dims
+ * @param {ProductFactor[]} opaque
+ * @param {number | false} precision
+ * @return {Node | null} null when a part would be rounded on output
+ */
+function rationalProduct(
+  numerator,
+  denominator,
+  loneDim,
+  dims,
+  opaque,
+  precision
+) {
+  // Drop float noise (`1.9999999999999993 * 100`) so the parts print as
+  // written and the gcd below can reduce them.
+  let n = Number(
+    (loneDim === null ? numerator : numerator * loneDim.value).toPrecision(15)
+  );
+  let d = Number(denominator.toPrecision(15));
+  if (!isExact(n, precision) || !isExact(d, precision)) {
+    return null;
+  }
+  if (Number.isSafeInteger(n) && Number.isSafeInteger(d)) {
+    const g = gcd(Math.abs(n), Math.abs(d));
+    n /= g;
+    d /= g;
+  }
+  if (d < 0) {
+    n = -n;
+    d = -d;
+  }
+  /** @type {ProductFactor[]} */
+  const factors = [];
+  if (loneDim !== null) {
+    factors.push({
+      exponent: 1,
+      node: dim(n, loneDim.unit, loneDim.rawUnit),
+    });
+  } else {
+    if (n !== 1) {
+      factors.push({ exponent: 1, node: num(n) });
+    }
+    for (const dm of dims) {
+      factors.push({
+        exponent: dm.exponent,
+        node: dim(dm.value, dm.unit, dm.rawUnit),
+      });
+    }
+  }
+  factors.push(...opaque);
+  if (d !== 1) {
+    factors.push({ exponent: -1, node: num(d) });
+  }
+  return mkProduct(factors);
+}
+
+export { chainValue, foldsExactly, isScalarSum, rationalProduct };