postcss-calc 11.2.1 → 11.2.3

package/src/lib/serialize/expression.js

@@ -0,0 +1,329 @@
+// Spec: https://www.w3.org/TR/css-values-4/#serialize-a-calculation-tree
+// 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 { num } from '../node.js';
+import { serializeComponents } from '../opaque.js';
+import {
+  degenerateKeyword,
+  emitBareSignedZero,
+  emitRoundedScalar,
+  emitScalar,
+  emitSignedZero,
+  isDegenerate,
+  isScalar,
+  isSignedZero,
+  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').SumTerm} SumTerm
+ * @typedef {import('../node.js').ProductFactor} ProductFactor
+ * @typedef {import('./precision.js').SerializeSession} SerializeSession
+ */
+
+/**
+ * @param {Node} node
+ * @param {SerializeSession} session
+ * @param {number} [parentPrecedence]
+ * @param {boolean} [groupedRequired]
+ * @return {void}
+ */
+function emitNode(
+  node,
+  session,
+  parentPrecedence = 0,
+  groupedRequired = false
+) {
+  const parenthesized = needsParentheses(
+    node,
+    parentPrecedence,
+    groupedRequired
+  );
+  if (parenthesized) session.buffer.push('(');
+  emitNodeBody(node, session);
+  if (parenthesized) session.buffer.push(')');
+}
+
+/**
+ * @param {Node} node
+ * @param {SerializeSession} session
+ * @return {void}
+ */
+function emitNodeBody(node, session) {
+  const buffer = session.buffer;
+  switch (node.type) {
+    case 'Num':
+    case 'Dim':
+      emitScalar(node, session);
+      return;
+    case 'Ident':
+      buffer.push(node.rawName ?? node.name);
+      return;
+    case 'Call':
+      emitCall(node, session);
+      return;
+    case 'OpaqueCall':
+      emitOpaqueCall(node, session);
+      return;
+    case 'Sum':
+      emitSum(node, session);
+      return;
+    case 'Product':
+      emitProductFactors(node.factors, session);
+      return;
+  }
+}
+
+/**
+ * @param {import('../node.js').Num | import('../node.js').Dim} termNode
+ * @param {1 | -1} sign
+ * @param {boolean} leading
+ * @param {SerializeSession} session
+ * @return {void}
+ */
+function emitScalarSumTerm(termNode, sign, leading, session) {
+  const buffer = session.buffer;
+  const effectiveVal = sign * termNode.value;
+  if (Object.is(effectiveVal, -0)) {
+    // `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 (!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(leading ? '-' : ' - ');
+    emitRoundedScalar(termNode, buffer, -rounded);
+  } else {
+    if (!leading) buffer.push(' + ');
+    emitRoundedScalar(termNode, buffer, rounded);
+  }
+}
+
+/**
+ * @param {SumTerm} term
+ * @param {boolean} leading
+ * @param {SerializeSession} session
+ * @return {void}
+ */
+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 {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) {
+  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);
+  }
+}
+
+/**
+ * @param {Node} node
+ * @param {SerializeSession} session
+ * @return {void}
+ */
+function emitLeadingNeg(node, session) {
+  if (node.type === 'Product' && !node.grouped) {
+    if (
+      node.factors.length > 0 &&
+      node.factors[0].exponent === 1 &&
+      node.factors[0].node.type === 'Num'
+    ) {
+      const head = node.factors[0].node;
+      emitProductFactors(node.factors, session, 1, -head.value, head);
+      return;
+    }
+    emitProductFactors(node.factors, session, 0, -1, num(-1));
+    return;
+  }
+  session.buffer.push('-1 * ');
+  emitNode(node, session, UNARY_PRECEDENCE, false);
+}
+
+/**
+ * @param {ProductFactor[]} factors
+ * @param {SerializeSession} session
+ * @param {number} [start]
+ * @param {number} [coefficientValue]
+ * @param {import('../node.js').Num} [coefficientNode]
+ * @return {void}
+ */
+function emitProductFactors(
+  factors,
+  session,
+  start = 0,
+  coefficientValue,
+  coefficientNode
+) {
+  const buffer = session.buffer;
+  // 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) {
+    const coefficient = /** @type {import('../node.js').Num} */ (
+      coefficientNode
+    );
+    emitScalar(coefficient, session, coefficientValue, true);
+    leading = false;
+  }
+  for (let i = start; i < factors.length; i++) {
+    const factor = factors[i];
+    const factorNode = factor.node;
+    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 {
+      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 {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 {Node} node
+ * @param {SerializeSession} session
+ * @param {string} wrapper
+ * @return {void}
+ */
+function emitMathResult(node, session, wrapper) {
+  if (isScalar(node)) {
+    const scalarValue = roundedScalarValue(node, session.precision);
+    const buffer = session.buffer;
+    if (isDegenerate(scalarValue)) {
+      buffer.push(wrapper, '(', degenerateKeyword(scalarValue));
+      if (node.type === 'Dim') buffer.push(' * 1', node.rawUnit ?? node.unit);
+      buffer.push(')');
+    } else if (session.scalarPolicy === 'standard') {
+      buffer.push(wrapper, '(');
+      emitRoundedScalar(node, buffer, scalarValue);
+      buffer.push(')');
+    } else {
+      emitRoundedScalar(node, buffer, scalarValue);
+    }
+    return;
+  }
+  if (
+    node.type === 'Ident' ||
+    node.type === 'Call' ||
+    node.type === 'OpaqueCall'
+  ) {
+    emitNode(node, session);
+    return;
+  }
+  if (node.type === 'Sum' && node.terms.length === 1) {
+    session.buffer.push(wrapper, '(');
+    emitLeadingNeg(node.terms[0].node, session);
+    session.buffer.push(')');
+    return;
+  }
+  session.buffer.push(wrapper, '(');
+  emitNode(node, session);
+  session.buffer.push(')');
+}
+
+/**
+ * @param {Node} node
+ * @param {SerializeSession} session
+ * @param {string[]} [buffer]
+ * @return {void}
+ */
+function emitNestedMathResult(node, session, buffer = session.buffer) {
+  if (isSignedZero(node)) {
+    emitSignedZero(buffer, node);
+    return;
+  }
+  emitMathResult(node, session, 'calc');
+}
+
+export {
+  emitNode,
+  emitLeadingNeg,
+  emitCall,
+  emitOpaqueCall,
+  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

@@ -0,0 +1,244 @@
+// Spec: https://www.w3.org/TR/css-values-4/#serialize-a-calculation-tree
+// Precision rounding, degenerate keyword serialization (NaN, Infinity), and
+// scalar number/dimension formatting.
+
+/**
+ * @typedef {import('../node.js').Node} Node
+ * @typedef {import('../node.js').Num} Num
+ * @typedef {import('../node.js').Dim} Dim
+ * @typedef {object} SerializeSession
+ * @property {string[]} buffer
+ * @property {number | false} precision
+ * @property {'standard' | 'unwrap-all'} scalarPolicy
+ */
+
+const NOISE_FLOOR = 1e-12;
+
+/**
+ * Divide a decimal digit string by 10^k, rounding half away from zero, and
+ * return the resulting integer digit string. `digits` has no leading zeros.
+ * @param {string} digits
+ * @param {number} k
+ * @return {string}
+ */
+function divideByPowerOfTen(digits, k) {
+  // 0x30/0x35/0x39 are the char codes of '0'/'5'/'9'.
+  if (digits.length <= k) {
+    return digits.length === k && digits.charCodeAt(0) >= 0x35 ? '1' : '0';
+  }
+  const cut = digits.length - k;
+  if (digits.charCodeAt(cut) < 0x35) return digits.slice(0, cut);
+  // Round up and propagate the carry through trailing nines.
+  let index = cut - 1;
+  while (index >= 0 && digits.charCodeAt(index) === 0x39) index--;
+  if (index < 0) return `1${'0'.repeat(cut)}`;
+  return `${digits.slice(0, index)}${String.fromCharCode(
+    digits.charCodeAt(index) + 1
+  )}${'0'.repeat(cut - index - 1)}`;
+}
+
+/**
+ * Round the shortest decimal representation of a non-negative double to `p`
+ * fractional digits, half away from zero.
+ *
+ * `Number(text + 'e' + p)` reads the exact intended decimal (so `1.005` at
+ * precision 2 becomes `1.01`), but it is only exact while the shifted value
+ * fits in `Number.MAX_SAFE_INTEGER`; beyond that the intermediate double
+ * rounds and can move the rounding boundary (e.g. `312834450754803.44` at
+ * precision 1 or 6 drifted to `312834450754803.5`). Round the decimal digits
+ * directly instead.
+ *
+ * @param {number} abs
+ * @param {number} p
+ * @return {number}
+ */
+function roundDecimal(abs, p) {
+  const text = String(abs);
+  const eIdx = text.indexOf('e');
+  const mantissa = eIdx === -1 ? text : text.slice(0, eIdx);
+  let exponent = eIdx === -1 ? 0 : Number(text.slice(eIdx + 1));
+  const dot = mantissa.indexOf('.');
+  let digits = mantissa;
+  if (dot !== -1) {
+    digits = mantissa.slice(0, dot) + mantissa.slice(dot + 1);
+    exponent -= mantissa.length - dot - 1;
+  }
+
+  // value = digits * 10^exponent, so the shortest decimal has -exponent
+  // fractional digits when it is smaller than 1.
+  if (exponent >= -p) return abs;
+
+  let start = 0;
+  while (start < digits.length - 1 && digits.charCodeAt(start) === 0x30)
+    start++;
+  const rounded = divideByPowerOfTen(digits.slice(start), -(exponent + p));
+  return Number(`${rounded}e-${p}`);
+}
+
+/**
+ * @param {number} v
+ * @param {number | false} prec
+ * @return {number}
+ */
+function round(v, prec) {
+  if (prec === false || !Number.isFinite(v)) return v;
+  if (Object.is(v, -0) || v === 0) return v;
+  const abs = Math.abs(v);
+  // Numbers >= MAX_SAFE_INTEGER (2^53 - 1) cannot represent fractional values, and
+  // integers already have 0 fractional places. Bypassing them avoids float drift.
+  if (abs >= Number.MAX_SAFE_INTEGER || Number.isInteger(v)) return v;
+
+  // Clamp precision to [0, 100] integer to prevent NaN from fractional precisions
+  // or exponent overflows into Infinity/NaN (e.g. exponent + prec > 308).
+  const p = Math.min(100, Math.max(0, Math.trunc(prec)));
+  const sign = v < 0 ? -1 : 1;
+  // Values below 1 keep `p` significant digits (at least one) rather than `p`
+  // decimals, so small magnitudes lose precision evenly. The exponent comes
+  // from the decimal text, not log10, so powers of ten cannot land off by one.
+  if (abs < 1) {
+    const exponent = Number(abs.toExponential().split('e')[1]);
+    const rounded = roundDecimal(abs, Math.max(p, 1) - 1 - exponent);
+    // Snap true floating-point dust (<= 1e-12) to zero, unless the precision
+    // is high enough to represent it as a fractional value.
+    if (abs <= NOISE_FLOOR && roundDecimal(abs, p) === 0) {
+      return sign === -1 ? -0 : 0;
+    }
+    return sign * rounded;
+  }
+  return sign * roundDecimal(abs, p);
+}
+
+// §10.13 / §10.7.2: Infinity/NaN serialize as canonical keywords.
+/** @param {number} v @return {boolean} */
+function isDegenerate(v) {
+  return !Number.isFinite(v) || Number.isNaN(v);
+}
+
+/** @param {number} v @return {string} */
+function degenerateKeyword(v) {
+  if (Number.isNaN(v)) return 'NaN';
+  return v > 0 ? 'infinity' : '-infinity';
+}
+
+/** @param {number} v @return {string} */
+function serializeNumber(v) {
+  if (Object.is(v, -0)) return '0';
+  const text = String(v);
+  if (text.startsWith('0.')) return text.slice(1);
+  if (text.startsWith('-0.')) return `-${text.slice(2)}`;
+  return text;
+}
+
+/**
+ * @param {import('../node.js').Num | import('../node.js').Dim} node
+ * @param {number | false} precision
+ * @param {number} [value]
+ * @return {number}
+ */
+function roundedScalarValue(node, precision, value) {
+  return round(value ?? node.value, precision);
+}
+
+/**
+ * @param {import('../node.js').Num | import('../node.js').Dim} node
+ * @param {string[]} buffer
+ * @param {number} value
+ * @return {void}
+ */
+function emitRoundedScalar(node, buffer, value) {
+  buffer.push(serializeNumber(value));
+  if (node.type === 'Dim') {
+    buffer.push(node.rawUnit ?? node.unit);
+  }
+}
+
+/**
+ * @param {import('../node.js').Num | import('../node.js').Dim} node
+ * @param {SerializeSession} session
+ * @param {number} [value]
+ * @return {number}
+ */
+function emitFiniteScalar(node, session, value) {
+  const rounded = roundedScalarValue(node, session.precision, value);
+  emitRoundedScalar(node, session.buffer, rounded);
+  return rounded;
+}
+
+/**
+ * @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, bare = false) {
+  const buffer = session.buffer;
+  const effective = value ?? node.value;
+  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(',
+        degenerateKeyword(effective),
+        ' * 1',
+        node.rawUnit ?? node.unit,
+        ')'
+      );
+    } else {
+      buffer.push(degenerateKeyword(effective));
+    }
+  } else emitFiniteScalar(node, session, effective);
+}
+
+/**
+ * @param {string[]} buffer
+ * @param {import('../node.js').Num | import('../node.js').Dim} node
+ * @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('-1 * 0', unit);
+}
+
+/** @param {Node} node @return {node is import('../node.js').Num | import('../node.js').Dim} */
+function isScalar(node) {
+  return node.type === 'Num' || node.type === 'Dim';
+}
+
+/** @param {Node} node @return {node is import('../node.js').Num | import('../node.js').Dim} */
+function isSignedZero(node) {
+  return isScalar(node) ? Object.is(node.value, -0) : false;
+}
+
+export {
+  NOISE_FLOOR,
+  divideByPowerOfTen,
+  roundDecimal,
+  round,
+  isDegenerate,
+  degenerateKeyword,
+  serializeNumber,
+  roundedScalarValue,
+  emitRoundedScalar,
+  emitFiniteScalar,
+  emitScalar,
+  emitSignedZero,
+  emitBareSignedZero,
+  isScalar,
+  isSignedZero,
+};