postcss-calc 10.1.0 → 11.0.0-rc.0

package/src/lib/simplify/cancel.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const { baseOf, convert } = require('../convertUnits.js');
+
+/**
+ * If `dims` contain exactly one numerator / one denominator pair with the
+ * same base type and convertible units, return the numeric factor produced
+ * by cancelling them and the list of remaining (uncancelled) dims.
+ * Otherwise return null. Used by `simplifyProduct` for typed division
+ * (§10.2). More complex cancellation (e.g. `px^2 / px`) is left
+ * unreduced — consumers rarely rely on it and the spec doesn't require it.
+ * @template {{ exponent: 1 | -1, value: number, unit: string }} D
+ * @param {D[]} dims
+ * @return {{ factor: number, remaining: D[] } | null}
+ */
+function tryCancelPair(dims) {
+  if (dims.length !== 2) {
+    return null;
+  }
+  const [a, b] = /** @type {[D, D]} */ (dims);
+  if (a.exponent === b.exponent) {
+    return null;
+  }
+  const numerator = a.exponent === 1 ? a : b;
+  const denominator = a.exponent === 1 ? b : a;
+  const numBase = baseOf(numerator.unit);
+  const denBase = baseOf(denominator.unit);
+  if (!numBase || numBase !== denBase) {
+    return null;
+  }
+  const converted = convert(numerator.value, numerator.unit, denominator.unit);
+  if (converted === null) {
+    return null;
+  }
+  // denominator.value === 0 yields ±Infinity / NaN naturally (§10.9.1).
+  return { factor: converted / denominator.value, remaining: [] };
+}
+
+module.exports = { tryCancelPair };

package/src/lib/simplify/clamp.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const { num, dim } = require('../node.js');
+const { foldConstArgs } = require('./fold.js');
+
+/** @typedef {import('../node.js').Node} Node */
+
+/**
+ * @param {Node[]} args
+ * @return {Node}
+ */
+function simplifyClamp(args) {
+  if (args.length === 3) {
+    const fold = foldConstArgs(args);
+    if (fold !== null) {
+      const [lo, v, hi] = /** @type {[number, number, number]} */ (fold.values);
+      // Spec §10.8: clamp(MIN, VAL, MAX) = max(MIN, min(VAL, MAX)). The
+      // outer max(MIN, …) means MIN wins when MIN > MAX — not MAX.
+      const clamped = Math.max(lo, Math.min(v, hi));
+      return fold.unit === '' ? num(clamped) : dim(clamped, fold.unit);
+    }
+  }
+  return { type: 'Call', name: 'clamp', args };
+}
+
+module.exports = { simplifyClamp };

package/src/lib/simplify/exp.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const { num } = require('../node.js');
+
+/** @typedef {import('../node.js').Node} Node */
+
+/**
+ * @param {Node[]} args
+ * @return {Node}
+ */
+function simplifyExp(args) {
+  if (args.length !== 1 || args[0].type !== 'Num') {
+    return { type: 'Call', name: 'exp', args };
+  }
+  return num(Math.exp(args[0].value));
+}
+
+module.exports = { simplifyExp };

package/src/lib/simplify/fold.js

@@ -0,0 +1,63 @@
+'use strict';
+
+// Fold args to a common numeric representation if they share a type.
+// Percentages never fold — ordering depends on property-context
+// resolution we don't have. Matches csstools.
+
+const { baseOf, convert } = require('../convertUnits.js');
+
+/** @typedef {import('../node.js').Node} Node */
+/** @typedef {import('../convertUnits.js').BaseType} BaseType */
+
+/**
+ * @param {Node[]} args
+ * @return {{ values: number[], unit: string } | null}
+ */
+function foldConstArgs(args) {
+  if (args.length === 0) {return null;}
+
+  const first = args[0];
+  if (first.type === 'Num') {
+    return foldNumberArgs(args);
+  }
+  if (first.type === 'Dim') {
+    const b = first.unit === '%' ? null : baseOf(first.unit);
+    if (!b) {return null;}
+    return foldDimArgs(args, first.unit, b);
+  }
+  return null;
+}
+
+/**
+ * @param {Node[]} args
+ * @return {{ values: number[], unit: '' } | null}
+ */
+function foldNumberArgs(args) {
+  /** @type {number[]} */ const values = [];
+  for (const a of args) {
+    if (a.type !== 'Num') {return null;}
+    values.push(a.value);
+  }
+  return { values, unit: '' };
+}
+
+/**
+ * @param {Node[]} args
+ * @param {string} unit
+ * @param {BaseType} base
+ * @return {{ values: number[], unit: string } | null}
+ */
+function foldDimArgs(args, unit, base) {
+  /** @type {number[]} */ const values = [];
+  for (const a of args) {
+    if (a.type !== 'Dim' || a.unit === '%' || baseOf(a.unit) !== base) {
+      return null;
+    }
+    const converted = convert(a.value, a.unit, unit);
+    if (converted === null) {return null;}
+    values.push(converted);
+  }
+  return { values, unit };
+}
+
+module.exports = { foldConstArgs };

package/src/lib/simplify/hypot.js

@@ -0,0 +1,22 @@
+'use strict';
+
+// §10.5 — hypot. Empty args return null from foldConstArgs naturally.
+
+const { num, dim } = require('../node.js');
+const { foldConstArgs } = require('./fold.js');
+
+/** @typedef {import('../node.js').Node} Node */
+
+/**
+ * @param {Node[]} args
+ * @return {Node}
+ */
+function simplifyHypot(args) {
+  const fold = foldConstArgs(args);
+  if (fold === null) {return { type: 'Call', name: 'hypot', args };}
+  const sumSq = fold.values.reduce((acc, v) => acc + v * v, 0);
+  const result = Math.sqrt(sumSq);
+  return fold.unit === '' ? num(result) : dim(result, fold.unit);
+}
+
+module.exports = { simplifyHypot };

package/src/lib/simplify/inverse-trig.js

@@ -0,0 +1,29 @@
+'use strict';
+
+// §10.4 — asin/acos/atan. Bare <number> in, <angle> in degrees out.
+
+const { num, dim } = require('../node.js');
+
+/** @typedef {import('../node.js').Node} Node */
+
+const INVERSE_TRIG_OPS = /** @type {const} */ ({
+  asin: Math.asin,
+  acos: Math.acos,
+  atan: Math.atan,
+});
+
+/**
+ * @param {'asin' | 'acos' | 'atan'} name
+ * @param {Node[]} args
+ * @return {Node}
+ */
+function simplifyInverseTrig(name, args) {
+  if (args.length !== 1) {return { type: 'Call', name, args };}
+  const a = args[0];
+  if (a.type !== 'Num') {return { type: 'Call', name, args };}
+  const radians = INVERSE_TRIG_OPS[name](a.value);
+  if (isNaN(radians)) {return num(NaN);}
+  return dim((radians * 180) / Math.PI, 'deg');
+}
+
+module.exports = { simplifyInverseTrig };

package/src/lib/simplify/log.js

@@ -0,0 +1,25 @@
+'use strict';
+
+const { num } = require('../node.js');
+
+/** @typedef {import('../node.js').Node} Node */
+
+/**
+ * @param {Node[]} args
+ * @return {Node}
+ */
+function simplifyLog(args) {
+  if (args.length === 1 && args[0].type === 'Num') {
+    return num(Math.log(args[0].value));
+  }
+  if (
+    args.length === 2 &&
+    args[0].type === 'Num' &&
+    args[1].type === 'Num'
+  ) {
+    return num(Math.log(args[0].value) / Math.log(args[1].value));
+  }
+  return { type: 'Call', name: 'log', args };
+}
+
+module.exports = { simplifyLog };

package/src/lib/simplify/min-max.js

@@ -0,0 +1,23 @@
+'use strict';
+
+const { num, dim } = require('../node.js');
+const { foldConstArgs } = require('./fold.js');
+
+/** @typedef {import('../node.js').Node} Node */
+
+/**
+ * @param {string} name
+ * @param {Node[]} args
+ * @return {Node}
+ */
+function simplifyMinMax(name, args) {
+  const fold = foldConstArgs(args);
+  if (fold !== null) {
+    const fn = name.toLowerCase() === 'min' ? Math.min : Math.max;
+    const value = fn(...fold.values);
+    return fold.unit === '' ? num(value) : dim(value, fold.unit);
+  }
+  return { type: 'Call', name, args };
+}
+
+module.exports = { simplifyMinMax };

package/src/lib/simplify/mod-rem.js

@@ -0,0 +1,47 @@
+'use strict';
+
+const { num, dim } = require('../node.js');
+const { foldConstArgs } = require('./fold.js');
+
+/** @typedef {import('../node.js').Node} Node */
+
+/**
+ * @param {'mod' | 'rem'} name
+ * @param {Node[]} args
+ * @return {Node}
+ */
+function simplifyModRem(name, args) {
+  if (args.length !== 2) {return { type: 'Call', name, args };}
+  const fold = foldConstArgs(args);
+  if (fold === null) {return { type: 'Call', name, args };}
+  const [a, b] = /** @type {[number, number]} */ (fold.values);
+  const result = applyModRem(name, a, b);
+  // NaN results drop the unit (`mod(5px, 0px)` → `calc(NaN)`, not
+  // `calc(NaN * 1px)`). §10.12 unit-preserving form is a known divergence.
+  if (isNaN(result)) {return num(NaN);}
+  return fold.unit === '' ? num(result) : dim(result, fold.unit);
+}
+
+/**
+ * @param {'mod' | 'rem'} name
+ * @param {number} a
+ * @param {number} b
+ * @return {number}
+ */
+function applyModRem(name, a, b) {
+  if (b === 0) {return NaN;}
+  if (!isFinite(a)) {return NaN;}
+  if (!isFinite(b)) {
+    // mod: result is NaN when A has opposite sign to B; otherwise A.
+    // rem: result is A regardless of signs.
+    if (name === 'mod' && a !== 0 && Math.sign(a) !== Math.sign(b)) {return NaN;}
+    return a;
+  }
+  if (name === 'rem') {
+    return a % b; // sign follows dividend
+  }
+  const result = a - b * Math.floor(a / b); // sign follows divisor
+  return result === 0 ? b * 0 : result;
+}
+
+module.exports = { simplifyModRem };

package/src/lib/simplify/pow.js

@@ -0,0 +1,20 @@
+'use strict';
+
+// §10.5 — pow is <number>-only.
+
+const { num } = require('../node.js');
+
+/** @typedef {import('../node.js').Node} Node */
+
+/**
+ * @param {Node[]} args
+ * @return {Node}
+ */
+function simplifyPow(args) {
+  if (args.length !== 2 || args[0].type !== 'Num' || args[1].type !== 'Num') {
+    return { type: 'Call', name: 'pow', args };
+  }
+  return num(Math.pow(args[0].value, args[1].value));
+}
+
+module.exports = { simplifyPow };

package/src/lib/simplify/product.js

@@ -0,0 +1,133 @@
+'use strict';
+
+const { mkSum, mkProduct, num, dim } = require('../node.js');
+const { tryCancelPair } = require('./cancel.js');
+
+/**
+ * @typedef {import('../node.js').Node} Node
+ * @typedef {import('../node.js').Product} Product
+ * @typedef {import('../node.js').ProductFactor} ProductFactor
+ * @typedef {import('../simplify.js').SimplifyFn} SimplifyFn
+ */
+
+/**
+ * @param {Product} product
+ * @param {SimplifyFn} simplify
+ * @return {Node}
+ */
+function simplifyProduct(product, simplify) {
+  let coeff = 1;
+  /** @type {{exponent: 1 | -1, value: number, unit: string}[]} */
+  const dims = [];
+  /** @type {ProductFactor[]} */
+  const opaque = [];
+  /** @type {{exponent: 1 | -1, value: number}[]} */
+  const scalarChain = [];
+
+  /**
+   * @param {1 | -1} exponent
+   * @param {Node} n
+   * @return {void}
+   */
+  function processFactor(exponent, n) {
+    if (n.type === 'Product') {
+      for (const inner of n.factors) {
+        processFactor(
+          /** @type {1 | -1} */ (exponent * inner.exponent),
+          inner.node
+        );
+      }
+      return;
+    }
+    // Canonical negation form (see node.js's `negate`); flatten through it
+    // like a nested Product so cancellation below can see what's inside.
+    if (n.type === 'Sum' && n.terms.length === 1) {
+      processFactor(exponent, num(-1));
+      processFactor(exponent, n.terms[0].node);
+      return;
+    }
+    if (n.type === 'Num') {
+      if (exponent === 1) {
+        coeff *= n.value;
+      } else {
+        coeff /= n.value; // §10.9.1: 1/0 → ±Infinity, 0/0 → NaN per IEEE-754
+      }
+      scalarChain.push({ exponent, value: n.value });
+      return;
+    }
+    if (n.type === 'Dim') {
+      dims.push({ exponent, value: n.value, unit: n.unit });
+      scalarChain.push({ exponent, value: n.value });
+      return;
+    }
+    opaque.push({ exponent, node: n });
+  }
+
+  for (const f of product.factors) {
+    processFactor(f.exponent, simplify(f.node));
+  }
+
+  // §10.2 typed division. Higher-power cancellation (`px^2 / px`) is left
+  // unreduced — consumers don't rely on it and the spec doesn't require it.
+  const cancelled = tryCancelPair(dims);
+  if (cancelled !== null) {
+    coeff *= cancelled.factor;
+  }
+  const remainingDims = cancelled ? cancelled.remaining : dims;
+
+  // §10.10 distributive multiplication: `0.5 * (100vw - 10px)` → `50vw - 5px`.
+  // Only distribute when every Sum term is Num/Dim — partial distribution
+  // over opaque terms matches neither the legacy implementation nor csstools.
+  if (
+    remainingDims.length === 0 &&
+    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'
+    )
+  ) {
+    const sum = opaque[0].node;
+    const distributed = sum.terms.map((t) => ({
+      sign: t.sign,
+      node: simplify(
+        mkProduct([
+          { exponent: 1, node: num(coeff) },
+          { exponent: 1, node: t.node },
+        ])
+      ),
+    }));
+    return mkSum(distributed);
+  }
+
+  if (
+    remainingDims.length === 1 &&
+    remainingDims[0].exponent === 1 &&
+    opaque.length === 0
+  ) {
+    const d = remainingDims[0];
+    const value = scalarChain.reduce(
+      (acc, f) => (f.exponent === 1 ? acc * f.value : acc / f.value),
+      1
+    );
+    return dim(value, d.unit);
+  }
+
+  if (remainingDims.length === 0 && opaque.length === 0) {
+    return num(coeff);
+  }
+
+  /** @type {ProductFactor[]} */
+  const factors = [];
+  if (coeff !== 1) {
+    factors.push({ exponent: 1, node: num(coeff) });
+  }
+  for (const d of remainingDims) {
+    factors.push({ exponent: d.exponent, node: dim(d.value, d.unit) });
+  }
+  factors.push(...opaque);
+
+  return mkProduct(factors);
+}
+
+module.exports = { simplifyProduct };

package/src/lib/simplify/round.js

@@ -0,0 +1,113 @@
+'use strict';
+
+const { num, dim } = require('../node.js');
+const { foldConstArgs } = require('./fold.js');
+
+/** @typedef {import('../node.js').Node} Node */
+
+const ROUND_STRATEGIES = new Set(['nearest', 'up', 'down', 'to-zero']);
+/** @typedef {'nearest' | 'up' | 'down' | 'to-zero'} RoundStrategy */
+
+/**
+ * @param {Node[]} args
+ * @return {Node}
+ */
+function simplifyRound(args) {
+  /** @type {RoundStrategy} */ let strategy = 'nearest';
+  let rest = args;
+  const first = args[0];
+  if (first?.type === 'Ident') {
+    const n = first.name.toLowerCase();
+    if (!ROUND_STRATEGIES.has(n)) {
+      // Unrecognized strategy ident — opaque rather than guessing intent.
+      return { type: 'Call', name: 'round', args };
+    }
+    strategy = /** @type {RoundStrategy} */ (n);
+    rest = args.slice(1);
+  }
+
+  /** @type {() => Node} */
+  const passthrough = () => ({
+    type: 'Call',
+    name: 'round',
+    args:
+      strategy === 'nearest'
+        ? rest
+        : [{ type: 'Ident', name: strategy }, ...rest],
+  });
+
+  // B omitted: defaults to 1 when A is <number>; else opaque.
+  const argsForFold = argsForRoundFold(rest);
+  const fold = argsForFold && foldConstArgs(argsForFold);
+  if (!fold) {return passthrough();}
+
+  const [a, b] = /** @type {[number, number]} */ (fold.values);
+  // Spec §10.7.1 non-finite step: NaN propagates; both infinite cancels to
+  // NaN. Infinite step with finite A is strategy-dependent — the multiples
+  // of an infinite step are {-∞, 0, +∞}, so `up` (ceiling) lands on +∞ for
+  // positive A and `down` (floor) lands on -∞ for negative A; every other
+  // case folds to ±0 carrying A's sign. Infinite-A / finite-B falls through
+  // to applyRound, where floor*b===ceil*b===±∞ collapses back to A
+  // (§10.3.1 "result is the same infinity").
+  if (isNaN(b)) {return num(NaN);}
+  if (!isFinite(b)) {
+    if (!isFinite(a)) {return num(NaN);}
+    let result;
+    if (strategy === 'up' && a > 0) {
+      result = Infinity;
+    } else if (strategy === 'down' && a < 0) {
+      result = -Infinity;
+    } else {
+      result = a < 0 || Object.is(a, -0) ? -0 : 0;
+    }
+    return fold.unit === '' ? num(result) : dim(result, fold.unit);
+  }
+
+  const result = applyRound(strategy, a, b);
+  if (isNaN(result)) {return num(NaN);}
+  return fold.unit === '' ? num(result) : dim(result, fold.unit);
+}
+
+/**
+ * @param {Node[]} args
+ * @return {Node[] | null}
+ */
+function argsForRoundFold(args) {
+  if (args.length === 2) {return args;}
+  if (args.length === 1 && args[0].type === 'Num') {
+    return [args[0], num(1)];
+  }
+  return null;
+}
+
+/**
+ * @param {RoundStrategy} strategy
+ * @param {number} a
+ * @param {number} b
+ * @return {number}
+ */
+function applyRound(strategy, a, b) {
+  if (b === 0) {return NaN;}
+  const q = a / b;
+  const c1 = Math.floor(q) * b;
+  const c2 = Math.ceil(q) * b;
+  // With negative B, floor*B > ceil*B; spec defines lower as closer to -∞.
+  const lower = Math.min(c1, c2);
+  const upper = Math.max(c1, c2);
+  if (lower === upper) {return a;}
+  switch (strategy) {
+    case 'up':
+      return upper;
+    case 'down':
+      return lower;
+    case 'to-zero':
+      return Math.abs(lower) <= Math.abs(upper) ? lower : upper;
+    case 'nearest': {
+      const dl = a - lower;
+      const du = upper - a;
+      return du <= dl ? upper : lower; // tie → upper (§10.3 line 978)
+    }
+  }
+}
+
+module.exports = { simplifyRound };

package/src/lib/simplify/sign.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const { num } = require('../node.js');
+
+/** @typedef {import('../node.js').Node} Node */
+
+/**
+ * @param {Node[]} args
+ * @return {Node}
+ */
+function simplifySign(args) {
+  if (args.length !== 1) {
+    return { type: 'Call', name: 'sign', args };
+  }
+  const a = args[0];
+  if (a.type === 'Num') {return num(Math.sign(a.value));}
+  // %: sign is property-context-dependent (§10.6) — opaque.
+  if (a.type === 'Dim' && a.unit !== '%') {return num(Math.sign(a.value));}
+  return { type: 'Call', name: 'sign', args: [a] };
+}
+
+module.exports = { simplifySign };

package/src/lib/simplify/sqrt.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const { num } = require('../node.js');
+
+/** @typedef {import('../node.js').Node} Node */
+
+/**
+ * @param {Node[]} args
+ * @return {Node}
+ */
+function simplifySqrt(args) {
+  if (args.length !== 1 || args[0].type !== 'Num') {
+    return { type: 'Call', name: 'sqrt', args };
+  }
+  return num(Math.sqrt(args[0].value));
+}
+
+module.exports = { simplifySqrt };

package/src/lib/simplify/sum.js

@@ -0,0 +1,83 @@
+'use strict';
+
+const { mkSum, num, dim } = require('../node.js');
+const { baseOf } = require('../convertUnits.js');
+const { mergeConvertibleBuckets } = require('./bucket.js');
+
+/**
+ * @typedef {import('../node.js').Node} Node
+ * @typedef {import('../node.js').Sum} Sum
+ * @typedef {import('../node.js').SumTerm} SumTerm
+ * @typedef {import('../simplify.js').SimplifyFn} SimplifyFn
+ * @typedef {import('./bucket.js').UnitBucket} UnitBucket
+ */
+
+/**
+ * @param {Sum} sum
+ * @param {SimplifyFn} simplify
+ * @return {Node}
+ */
+function simplifySum(sum, simplify) {
+  // §10.10 two-phase dim handling: phase 1 buckets by exact unit (`1em + 1em`
+  // → `2em`); phase 2 merges convertible same-base buckets into the first-
+  // encountered unit. `100vh - 5rem - 10rem - 100px` → `-15rem` in phase 1,
+  // then vh/rem/px stay separate in phase 2 (none convert to each other).
+  let numTotal = 0;
+  /** @type {Map<string, UnitBucket>} */
+  const byUnit = new Map();
+  /** @type {SumTerm[]} */
+  const opaque = [];
+  let bucketOrder = 0;
+
+  /**
+   * @param {1 | -1} sign
+   * @param {Node} n
+   * @return {void}
+   */
+  function processTerm(sign, n) {
+    if (n.type === 'Sum') {
+      for (const inner of n.terms) {
+        processTerm(/** @type {1 | -1} */ (sign * inner.sign), inner.node);
+      }
+      return;
+    }
+    if (n.type === 'Num') {
+      numTotal += sign * n.value;
+      return;
+    }
+    if (n.type === 'Dim') {
+      const key = n.unit.toLowerCase();
+      const existing = byUnit.get(key);
+      if (existing) {
+        existing.total += sign * n.value;
+      } else {
+        byUnit.set(key, {
+          unit: n.unit,
+          total: sign * n.value,
+          base: baseOf(n.unit),
+          order: bucketOrder++,
+        });
+      }
+      return;
+    }
+    opaque.push({ sign, node: n });
+  }
+
+  for (const t of sum.terms) {
+    processTerm(t.sign, simplify(t.node));
+  }
+
+  // mkSum drops zero-valued Nums, so pushing the numeric total
+  // unconditionally is harmless. Zero-valued unit buckets are kept for
+  // type info (WPT calc-serialization-002).
+  /** @type {SumTerm[]} */
+  const terms = [{ sign: 1, node: num(numTotal) }];
+  for (const bucket of mergeConvertibleBuckets([...byUnit.values()])) {
+    terms.push({ sign: 1, node: dim(bucket.total, bucket.unit) });
+  }
+  terms.push(...opaque);
+
+  return mkSum(terms);
+}
+
+module.exports = { simplifySum };