postcss-calc 11.2.2 → 11.2.3

package/src/lib/simplify/product.js

@@ -1,6 +1,12 @@
 import { mkSum, mkProduct, mkGroup, num, dim } from '../node.js';
 import { tryCancelPair } from './cancel.js';
-import { isExact } from './exact.js';
+import { flattenFactor, isBarrier } from './product-barrier.js';
+import {
+  chainValue,
+  foldsExactly,
+  isScalarSum,
+  rationalProduct,
+} from './product-quotient.js';
 
 /**
  * @typedef {import('../node.js').Node} Node
@@ -9,136 +15,6 @@ import { isExact } from './exact.js';
  * @typedef {import('../simplify.js').SimplifyFn} SimplifyFn
  */
 
-/**
- * @param {number} a non-negative
- * @param {number} b non-negative
- * @return {number}
- */
-function gcd(a, b) {
-  while (b !== 0) {
-    [a, b] = [b, a % b];
-  }
-  return a || 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);
-}
-
 /**
  * Fold a run of factors that contains no substitution barrier.
  * @param {ProductFactor[]} items Simplified factors, flattened by the caller.
@@ -266,53 +142,6 @@ function foldFactors(items, start, end, simplify, precision) {
   return mkProduct(factors);
 }
 
-/**
- * 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);
-}
-
 /**
  * @param {Product} product
  * @param {SimplifyFn} simplify

package/src/lib/types.js

@@ -0,0 +1,94 @@
+/**
+ * `percent` marks a value that resolves in the same percentage context as its
+ * peers (a pure percentage). It is only produced at leaves, by abs(), and by
+ * homogeneous sums and calls — never by a product, where an unpaired
+ * percentage could no longer cancel against anything.
+ * @typedef {{kind: 'number'} | {kind: 'dimension', base: string | null} | {kind: 'unknown', percent?: true} | {kind: 'failure'}} CalculationType
+ */
+
+/** @type {CalculationType} */ const numberType = { kind: 'number' };
+/** @type {CalculationType} */ const unknownType = { kind: 'unknown' };
+/** @type {CalculationType} */ const percentageType = {
+  kind: 'unknown',
+  percent: true,
+};
+/** @type {CalculationType} */ const failureType = { kind: 'failure' };
+
+/** @param {CalculationType} type @return {boolean} */
+function isFailure(type) {
+  return type.kind === 'failure';
+}
+
+/** @param {CalculationType} type @return {boolean} */
+function isPercentage(type) {
+  return type.kind === 'unknown' && type.percent === true;
+}
+
+/** @param {CalculationType} a @param {CalculationType} b @return {CalculationType} */
+function addTypes(a, b) {
+  if (isFailure(a) || isFailure(b)) return failureType;
+  if (a.kind === 'unknown' || b.kind === 'unknown') {
+    // A pure percentage keeps its contextual type so a surrounding product
+    // can cancel `% / %`; mixing it with any other opaque operand loses the
+    // guarantee that it resolves in the same context as its peers. A known
+    // number + percentage sum is likewise kept unknown and valid: the spec
+    // resolves the percentage against its surrounding context, which this
+    // coarse type model does not track.
+    return isPercentage(a) && isPercentage(b) ? percentageType : unknownType;
+  }
+  if (a.kind === 'number' && b.kind === 'number') return numberType;
+  if (a.kind === 'dimension' && b.kind === 'dimension') {
+    if (a.base === null || b.base === null) return unknownType;
+    return a.base === b.base ? a : failureType;
+  }
+  return failureType;
+}
+
+/**
+ * Check an all-number function without assuming anything about an unresolved
+ * operand. A concrete dimension can never become a number, so it is still a
+ * definite error when another argument is opaque.
+ * @param {CalculationType[]} args
+ * @param {number} min
+ * @param {number} max
+ * @return {CalculationType}
+ */
+function numberArguments(args, min, max) {
+  if (args.length < min || args.length > max) return failureType;
+  let hasUnknown = false;
+  for (const arg of args) {
+    if (arg.kind === 'dimension') return failureType;
+    hasUnknown = hasUnknown || arg.kind === 'unknown';
+  }
+  return hasUnknown ? unknownType : numberType;
+}
+
+/**
+ * Check values that must share a calculation type. Unknown operands remain
+ * unknown: they might resolve to the concrete type required by their peers.
+ * @param {CalculationType[]} args
+ * @param {number} min
+ * @param {number} max
+ * @return {CalculationType}
+ */
+function matchingArguments(args, min, max) {
+  if (args.length < min || args.length > max) return failureType;
+  let result = args[0];
+  for (let index = 1; index < args.length; index++) {
+    result = addTypes(result, args[index]);
+    if (isFailure(result)) return failureType;
+  }
+  return result;
+}
+
+export {
+  addTypes,
+  failureType,
+  isFailure,
+  isPercentage,
+  matchingArguments,
+  numberArguments,
+  numberType,
+  percentageType,
+  unknownType,
+};

package/types/lib/function-analyzers.d.ts

@@ -0,0 +1,27 @@
+export type Node = import('./node.js').Node;
+export type CalculationType = import('./types.js').CalculationType;
+/**
+ * @typedef {import('./node.js').Node} Node
+ * @typedef {import('./types.js').CalculationType} CalculationType
+ */
+/** @param {CalculationType[]} args @return {CalculationType} */
+declare function analyzeTrig(args: CalculationType[]): CalculationType;
+/** @param {CalculationType[]} args @return {CalculationType} */
+declare function analyzeInverseTrig(args: CalculationType[]): CalculationType;
+/** @param {CalculationType[]} args @return {CalculationType} */
+declare function analyzeIdentity(args: CalculationType[]): CalculationType;
+/** @param {CalculationType[]} args @return {CalculationType} */
+declare function analyzeSign(args: CalculationType[]): CalculationType;
+/** @param {CalculationType[]} args @param {Node[]} nodes @return {CalculationType} */
+declare function analyzeRound(args: CalculationType[], nodes: Node[]): CalculationType;
+/** @param {CalculationType[]} args @return {CalculationType} */
+declare function analyzeAtan2(args: CalculationType[]): CalculationType;
+/** @param {CalculationType[]} args @return {CalculationType} */
+declare function analyzeCalc(args: CalculationType[]): CalculationType;
+/** @param {Node} node @return {boolean} */
+declare function isRoundStrategy(node: Node): boolean;
+/** @param {Node} node @param {number} index @return {boolean} */
+declare function isClampKeyword(node: Node, index: number): boolean;
+/** @param {CalculationType[]} args @param {Node[]} nodes @return {CalculationType} */
+declare function analyzeClamp(args: CalculationType[], nodes: Node[]): CalculationType;
+export { analyzeAtan2, analyzeCalc, analyzeClamp, analyzeIdentity, analyzeInverseTrig, analyzeRound, analyzeSign, analyzeTrig, isClampKeyword, isRoundStrategy, };

package/types/lib/functions.d.ts

@@ -1,15 +1,6 @@
+import { addTypes, failureType, isFailure, isPercentage, numberType, percentageType, unknownType } from './types.js';
 export type Node = import('./node.js').Node;
-export type CalculationType = {
-    kind: 'number';
-} | {
-    kind: 'dimension';
-    base: string | null;
-} | {
-    kind: 'unknown';
-    percent?: true;
-} | {
-    kind: 'failure';
-};
+export type CalculationType = import('./types.js').CalculationType;
 export type MathSimplifier = (name: string, args: Node[]) => Node;
 export type TypeAnalyzer = (args: CalculationType[], nodes: Node[]) => CalculationType;
 export type MathFunction = {
@@ -19,26 +10,10 @@ export type MathFunction = {
     calculation?: boolean;
 };
 /** @typedef {import('./node.js').Node} Node */
-/**
- * `percent` marks a value that resolves in the same percentage context as its
- * peers (a pure percentage). It is only produced at leaves, by abs(), and by
- * homogeneous sums and calls — never by a product, where an unpaired
- * percentage could no longer cancel against anything.
- * @typedef {{kind: 'number'} | {kind: 'dimension', base: string | null} | {kind: 'unknown', percent?: true} | {kind: 'failure'}} CalculationType
- */
+/** @typedef {import('./types.js').CalculationType} CalculationType */
 /** @typedef {(name: string, args: Node[]) => Node} MathSimplifier */
 /** @typedef {(args: CalculationType[], nodes: Node[]) => CalculationType} TypeAnalyzer */
 /** @typedef {{analyze: TypeAnalyzer, simplify?: MathSimplifier, isKeyword?: (node: Node, index: number) => boolean, calculation?: boolean}} MathFunction */
-/** @type {CalculationType} */ declare const numberType: CalculationType;
-/** @type {CalculationType} */ declare const unknownType: CalculationType;
-/** @type {CalculationType} */ declare const percentageType: CalculationType;
-/** @type {CalculationType} */ declare const failureType: CalculationType;
-/** @param {CalculationType} type @return {boolean} */
-declare function isFailure(type: CalculationType): boolean;
-/** @param {CalculationType} type @return {boolean} */
-declare function isPercentage(type: CalculationType): boolean;
-/** @param {CalculationType} a @param {CalculationType} b @return {CalculationType} */
-declare function addTypes(a: CalculationType, b: CalculationType): CalculationType;
 declare const mathFunctions: Map<string, MathFunction>;
 /**
  * @param {string} name

package/types/lib/serialize/expression.d.ts

@@ -1,28 +1,15 @@
 export type Node = import('../node.js').Node;
 export type Sum = import('../node.js').Sum;
-export type Product = import('../node.js').Product;
+export type SumTerm = import('../node.js').SumTerm;
 export type ProductFactor = import('../node.js').ProductFactor;
 export type SerializeSession = import('./precision.js').SerializeSession;
 /**
  * @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
  */
-declare const SUM_PRECEDENCE = 1;
-declare const PRODUCT_PRECEDENCE = 2;
-declare const ATOMIC_PRECEDENCE = 3;
-declare const UNARY_PRECEDENCE = 3;
-/** @param {Node} node @return {number} */
-declare function precedence(node: Node): number;
-/**
- * @param {Node} node
- * @param {number} parentPrecedence
- * @param {boolean} groupedRequired
- * @return {boolean}
- */
-declare function needsParentheses(node: Node, parentPrecedence: number, groupedRequired: boolean): boolean;
 /**
  * @param {Node} node
  * @param {SerializeSession} session
@@ -31,6 +18,12 @@ declare function needsParentheses(node: Node, parentPrecedence: number, groupedR
  * @return {void}
  */
 declare function emitNode(node: Node, session: SerializeSession, parentPrecedence?: number, groupedRequired?: boolean): void;
+/**
+ * @param {Node} node
+ * @param {SerializeSession} session
+ * @return {void}
+ */
+declare function emitLeadingNeg(node: Node, session: SerializeSession): void;
 /**
  * @param {import('../node.js').Call} node
  * @param {SerializeSession} session
@@ -45,39 +38,6 @@ declare function emitCall(node: import('../node.js').Call, session: SerializeSes
  * @return {void}
  */
 declare function emitOpaqueCall(node: import('../node.js').OpaqueCall, session: SerializeSession, callNameOverride?: string): void;
-/**
- * @param {import('../node.js').SumTerm} term
- * @param {1 | -1} multiplier
- * @param {number | false} precision
- * @return {1 | -1}
- */
-declare function termSign(term: import('../node.js').SumTerm, multiplier: 1 | -1, precision: number | false): 1 | -1;
-/**
- * @param {import('../node.js').SumTerm[]} terms
- * @param {SerializeSession} session
- * @param {1 | -1} [multiplier]
- * @return {void}
- */
-declare function emitSumTerms(terms: import('../node.js').SumTerm[], session: SerializeSession, multiplier?: 1 | -1): void;
-/** @param {Sum} sum @param {SerializeSession} session @return {void} */
-declare function emitSum(sum: Sum, session: SerializeSession): void;
-/**
- * @param {Node} node
- * @param {SerializeSession} session
- * @return {void}
- */
-declare function emitLeadingNeg(node: Node, session: SerializeSession): void;
-/**
- * @param {ProductFactor[]} factors
- * @param {SerializeSession} session
- * @param {number} [start]
- * @param {number} [coefficientValue]
- * @param {import('../node.js').Num} [coefficientNode]
- * @return {void}
- */
-declare function emitProductFactors(factors: ProductFactor[], session: SerializeSession, start?: number, coefficientValue?: number, coefficientNode?: import('../node.js').Num): void;
-/** @param {Product} product @param {SerializeSession} session @return {void} */
-declare function emitProduct(product: Product, session: SerializeSession): void;
 /**
  * @param {Node} node
  * @param {SerializeSession} session
@@ -92,4 +52,4 @@ declare function emitMathResult(node: Node, session: SerializeSession, wrapper:
  * @return {void}
  */
 declare function emitNestedMathResult(node: Node, session: SerializeSession, buffer?: string[]): void;
-export { SUM_PRECEDENCE, PRODUCT_PRECEDENCE, ATOMIC_PRECEDENCE, UNARY_PRECEDENCE, precedence, needsParentheses, emitNode, emitCall, emitOpaqueCall, termSign, emitSumTerms, emitSum, emitLeadingNeg, emitProductFactors, emitProduct, emitMathResult, emitNestedMathResult, };
+export { emitNode, emitLeadingNeg, emitCall, emitOpaqueCall, emitMathResult, emitNestedMathResult, };

package/types/lib/serialize/precedence.d.ts

@@ -0,0 +1,18 @@
+export type Node = import('../node.js').Node;
+/**
+ * @typedef {import('../node.js').Node} Node
+ */
+declare const SUM_PRECEDENCE = 1;
+declare const PRODUCT_PRECEDENCE = 2;
+declare const ATOMIC_PRECEDENCE = 3;
+declare const UNARY_PRECEDENCE = 3;
+/** @param {Node} node @return {number} */
+declare function precedence(node: Node): number;
+/**
+ * @param {Node} node
+ * @param {number} parentPrecedence
+ * @param {boolean} groupedRequired
+ * @return {boolean}
+ */
+declare function needsParentheses(node: Node, parentPrecedence: number, groupedRequired: boolean): boolean;
+export { SUM_PRECEDENCE, PRODUCT_PRECEDENCE, ATOMIC_PRECEDENCE, UNARY_PRECEDENCE, precedence, needsParentheses, };

package/types/lib/serialize/precision.d.ts

@@ -77,25 +77,26 @@ declare function emitFiniteScalar(node: import('../node.js').Num | import('../no
  * @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}
  */
-declare function emitScalar(node: import('../node.js').Num | import('../node.js').Dim, session: SerializeSession, value?: number): void;
+declare function emitScalar(node: import('../node.js').Num | import('../node.js').Dim, session: SerializeSession, value?: number, bare?: boolean): void;
 /**
  * @param {string[]} buffer
  * @param {import('../node.js').Num | import('../node.js').Dim} node
  * @return {void}
  */
 declare function emitSignedZero(buffer: string[], node: import('../node.js').Num | import('../node.js').Dim): void;
+/**
+ * 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}
+ */
+declare function emitBareSignedZero(buffer: string[], node: import('../node.js').Num | import('../node.js').Dim): void;
 /** @param {Node} node @return {node is import('../node.js').Num | import('../node.js').Dim} */
 declare function isScalar(node: Node): node is import('../node.js').Num | import('../node.js').Dim;
 /** @param {Node} node @return {node is import('../node.js').Num | import('../node.js').Dim} */
 declare function isSignedZero(node: Node): node is import('../node.js').Num | import('../node.js').Dim;
-/**
- * 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}
- */
-declare function isEffectivelyNegative(node: Node, precision: number | false): node is import('../node.js').Num | import('../node.js').Dim;
-export { NOISE_FLOOR, divideByPowerOfTen, roundDecimal, round, isDegenerate, degenerateKeyword, serializeNumber, roundedScalarValue, emitRoundedScalar, emitFiniteScalar, emitScalar, emitSignedZero, isScalar, isSignedZero, isEffectivelyNegative, };
+export { NOISE_FLOOR, divideByPowerOfTen, roundDecimal, round, isDegenerate, degenerateKeyword, serializeNumber, roundedScalarValue, emitRoundedScalar, emitFiniteScalar, emitScalar, emitSignedZero, emitBareSignedZero, isScalar, isSignedZero, };

package/types/lib/simplify/product-barrier.d.ts

@@ -0,0 +1,26 @@
+export type Node = import('../node.js').Node;
+export type ProductFactor = import('../node.js').ProductFactor;
+/**
+ * @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}
+ */
+declare function isBarrier(node: Node): boolean;
+/**
+ * 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.
+ */
+declare function flattenFactor(out: ProductFactor[], exponent: 1 | -1, node: Node): boolean;
+export { flattenFactor, isBarrier };

package/types/lib/simplify/product-quotient.d.ts

@@ -0,0 +1,48 @@
+export type Node = import('../node.js').Node;
+export type ProductFactor = import('../node.js').ProductFactor;
+/**
+ * @param {{exponent: 1 | -1, value: number}[]} chain
+ * @return {number}
+ */
+declare function chainValue(chain: {
+    exponent: 1 | -1;
+    value: number;
+}[]): number;
+/**
+ * Whether the opaque factors are a single Sum of only Num/Dim terms.
+ * @param {ProductFactor[]} opaque
+ * @return {boolean}
+ */
+declare function isScalarSum(opaque: ProductFactor[]): boolean;
+/**
+ * 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}
+ */
+declare function foldsExactly(value: number, opaque: ProductFactor[], distributable: boolean, precision: number | false): boolean;
+/**
+ * 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
+ */
+declare function rationalProduct(numerator: number, denominator: number, loneDim: {
+    value: number;
+    unit: string;
+    rawUnit?: string;
+} | null, dims: {
+    exponent: 1 | -1;
+    value: number;
+    unit: string;
+    rawUnit?: string;
+}[], opaque: ProductFactor[], precision: number | false): Node | null;
+export { chainValue, foldsExactly, isScalarSum, rationalProduct };

package/types/lib/types.d.ts

@@ -0,0 +1,48 @@
+/**
+ * `percent` marks a value that resolves in the same percentage context as its
+ * peers (a pure percentage). It is only produced at leaves, by abs(), and by
+ * homogeneous sums and calls — never by a product, where an unpaired
+ * percentage could no longer cancel against anything.
+ * @typedef {{kind: 'number'} | {kind: 'dimension', base: string | null} | {kind: 'unknown', percent?: true} | {kind: 'failure'}} CalculationType
+ */
+export type CalculationType = {
+    kind: 'number';
+} | {
+    kind: 'dimension';
+    base: string | null;
+} | {
+    kind: 'unknown';
+    percent?: true;
+} | {
+    kind: 'failure';
+};
+/** @type {CalculationType} */ declare const numberType: CalculationType;
+/** @type {CalculationType} */ declare const unknownType: CalculationType;
+/** @type {CalculationType} */ declare const percentageType: CalculationType;
+/** @type {CalculationType} */ declare const failureType: CalculationType;
+/** @param {CalculationType} type @return {boolean} */
+declare function isFailure(type: CalculationType): boolean;
+/** @param {CalculationType} type @return {boolean} */
+declare function isPercentage(type: CalculationType): boolean;
+/** @param {CalculationType} a @param {CalculationType} b @return {CalculationType} */
+declare function addTypes(a: CalculationType, b: CalculationType): CalculationType;
+/**
+ * Check an all-number function without assuming anything about an unresolved
+ * operand. A concrete dimension can never become a number, so it is still a
+ * definite error when another argument is opaque.
+ * @param {CalculationType[]} args
+ * @param {number} min
+ * @param {number} max
+ * @return {CalculationType}
+ */
+declare function numberArguments(args: CalculationType[], min: number, max: number): CalculationType;
+/**
+ * Check values that must share a calculation type. Unknown operands remain
+ * unknown: they might resolve to the concrete type required by their peers.
+ * @param {CalculationType[]} args
+ * @param {number} min
+ * @param {number} max
+ * @return {CalculationType}
+ */
+declare function matchingArguments(args: CalculationType[], min: number, max: number): CalculationType;
+export { addTypes, failureType, isFailure, isPercentage, matchingArguments, numberArguments, numberType, percentageType, unknownType, };

package/types/lib/calculation-type.d.ts

@@ -1,18 +0,0 @@
-import { analyze } from './analyze.js';
-import { MAX_CALCULATION_DEPTH, checkCalculationDepth } from './limits.js';
-export type Node = import('./node.js').Node;
-export type CalculationType = {
-    kind: 'number';
-} | {
-    kind: 'dimension';
-    base: string | null;
-} | {
-    kind: 'unknown';
-} | {
-    kind: 'failure';
-};
-/** @typedef {import('./node.js').Node} Node */
-/** @typedef {{kind: 'number'} | {kind: 'dimension', base: string | null} | {kind: 'unknown'} | {kind: 'failure'}} CalculationType */
-/** @param {Node} node @return {CalculationType} */
-declare function checkCalculationType(node: Node): CalculationType;
-export { MAX_CALCULATION_DEPTH, checkCalculationDepth, checkCalculationType, analyze, };