postcss-calc 11.2.1 → 11.2.3

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/src/reduce.js

@@ -61,11 +61,12 @@ function reduceCalc(value, opts) {
 
   /** @type {ResolvedReduceCalcOptions} */
   const options = {
-    precision: 5,
     warnWhenCannotResolve: false,
     unwrapSingleNegativeNumber: false,
     unwrapSingleValue: false,
     ...opts,
+    // An explicit `precision: undefined` keeps the default.
+    precision: opts?.precision ?? 5,
   };
   /** @type {import('@csstools/css-tokenizer').CSSToken[]} */
   let tokens;

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/node.d.ts

@@ -42,6 +42,7 @@ export type ProductFactor = {
 export type Product = {
     type: 'Product';
     factors: ProductFactor[];
+    grouped?: boolean;
 };
 export type Node = Num | Dim | Ident | Call | OpaqueCall | Sum | Product;
 /**
@@ -54,7 +55,7 @@ export type Node = Num | Dim | Ident | Call | OpaqueCall | Sum | Product;
  * @typedef {{sign: 1 | -1, node: Node}} SumTerm Sign is always +1 when node is Num or Dim.
  * @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 {{type: 'Product', factors: ProductFactor[], grouped?: boolean}} Product
  * @typedef {Num | Dim | Ident | Call | OpaqueCall | Sum | Product} Node
  */
 /**
@@ -99,10 +100,24 @@ declare function mkSum(rawTerms: SumTerm[]): Node;
  * @return {Node}
  */
 declare function mkProduct(rawFactors: ProductFactor[]): Node;
+/**
+ * Mark a node as a source parenthesized group. A Sum or Product keeps its
+ * structure; any other node becomes a single-factor grouped Product.
+ * @param {Node} node
+ * @return {Node}
+ */
+declare function mkGroup(node: Node): Node;
+/**
+ * Group a parenthesized expression when its tokens must stay bound: a sum, or
+ * a product around a substitution function.
+ * @param {Node} node
+ * @return {Node}
+ */
+declare function groupSubstitution(node: Node): Node;
 /**
  * Negate any node, preserving canonical form.
  * @param {Node} node
  * @return {Node}
  */
 declare function negate(node: Node): Node;
-export { num, dim, ident, call, opaqueCall, mkSum, mkProduct, negate };
+export { num, dim, ident, call, opaqueCall, mkSum, mkProduct, mkGroup, groupSubstitution, negate, };

package/types/lib/parser/opaque.d.ts

@@ -0,0 +1,12 @@
+export type CSSToken = import('@csstools/css-tokenizer').CSSToken;
+export type Node = import('../node.js').Node;
+export type OpaqueComponent = import('../node.js').OpaqueComponent;
+export type ParseInput = import('./tokens.js').ParseInput;
+export type Cursor = import('./tokens.js').Cursor;
+export type FunctionToken = import('./tokens.js').FunctionToken;
+export type ParseRange = (input: ParseInput, start: number, end: number) => Node;
+/** @param {ParseInput} input @param {Cursor} cursor @param {FunctionToken} token @param {string} name @param {string} rawName @param {ParseRange} parseRange @return {Node} */
+declare function parseOpaqueCall(input: ParseInput, cursor: Cursor, token: FunctionToken, name: string, rawName: string, parseRange: ParseRange): Node;
+/** @param {ParseInput} input @param {Cursor} cursor @param {FunctionToken} token @param {string} name @param {string} rawName @param {ParseRange} parseRange @return {Node} */
+declare function parseVar(input: ParseInput, cursor: Cursor, token: FunctionToken, name: string, rawName: string, parseRange: ParseRange): Node;
+export { parseOpaqueCall, parseVar };

package/types/lib/parser/tokens.d.ts

@@ -0,0 +1,83 @@
+export type CSSToken = import('@csstools/css-tokenizer').CSSToken;
+export type BlockIndex = ReturnType<typeof import('../block-index.js').indexBlocks>;
+export type TokenBase = {
+    raw: string;
+    pos: number;
+    ws: boolean;
+    index: number;
+};
+export type NumberToken = TokenBase & {
+    type: 'number';
+    value: number;
+    signCharacter?: '+' | '-';
+};
+export type DimensionToken = TokenBase & {
+    type: 'dimension';
+    value: number;
+    unit: string;
+    rawUnit: string;
+    signCharacter?: '+' | '-';
+};
+export type IdentToken = TokenBase & {
+    type: 'ident';
+    value: string;
+};
+export type FunctionToken = TokenBase & {
+    type: 'function';
+    value: string;
+};
+export type Punctuator = '(' | ')' | ',' | '+' | '-' | '*' | '/';
+export type PunctToken = TokenBase & {
+    type: 'punct';
+    value: Punctuator;
+};
+export type EofToken = TokenBase & {
+    type: 'eof';
+    value: '';
+    raw: '';
+};
+export type Token = NumberToken | DimensionToken | IdentToken | FunctionToken | PunctToken | EofToken;
+export type ParseInput = Readonly<{
+    tokens: CSSToken[];
+    end: number;
+    index: BlockIndex;
+}>;
+/** @param {string} raw @param {string} decoded */
+declare function sourceSpelling(raw: string, decoded: string): string | undefined;
+/**
+ * Mutable navigation state only. `index` is always the next native token
+ * position; trivia is intentionally left visible to `scanToken`.
+ */
+declare class Cursor {
+    /** @type {number} */
+    index: number;
+    /** @type {boolean} */
+    firstToken: boolean;
+    /** @type {Token | null} */
+    lookahead: Token | null;
+    /** @type {number} */
+    lookaheadNextIndex: number;
+    /** @param {number} start */
+    constructor(start: number);
+    /** @param {number} index @return {void} */
+    skipTo(index: number): void;
+}
+/** @param {ParseInput} input @param {number} index @return {number} */
+declare function eofPositionAt(input: ParseInput, index: number): number;
+/** @param {ParseInput} input @param {Cursor} cursor @return {Token} */
+declare function peekToken(input: ParseInput, cursor: Cursor): Token;
+/**
+ * Consume the cached token and advance to its native next index. This is one
+ * of the only two operations allowed to advance `cursor.index`.
+ * @param {ParseInput} input
+ * @param {Cursor} cursor
+ * @return {Token}
+ */
+declare function takeToken(input: ParseInput, cursor: Cursor): Token;
+/** @param {ParseInput} input @param {Cursor} cursor @param {Punctuator} value @param {Punctuator} [value2] @return {boolean} */
+declare function isPunct(input: ParseInput, cursor: Cursor, value: Punctuator, value2?: Punctuator): boolean;
+/** @param {ParseInput} input @param {Cursor} cursor @param {Punctuator} value @return {boolean} */
+declare function matchPunct(input: ParseInput, cursor: Cursor, value: Punctuator): boolean;
+/** @param {ParseInput} input @param {Cursor} cursor @param {Punctuator} value @return {PunctToken} */
+declare function expectPunct(input: ParseInput, cursor: Cursor, value: Punctuator): PunctToken;
+export { Cursor, eofPositionAt, expectPunct, isPunct, matchPunct, peekToken, sourceSpelling, takeToken, };

package/types/lib/parser.d.ts

@@ -1,49 +1,9 @@
 export type CSSToken = import('@csstools/css-tokenizer').CSSToken;
 export type Node = import('./node.js').Node;
-export type OpaqueComponent = import('./node.js').OpaqueComponent;
-export type BlockIndex = ReturnType<typeof import('./block-index.js').indexBlocks>;
-export type TokenBase = {
-    raw: string;
-    pos: number;
-    ws: boolean;
-    index: number;
-};
-export type NumberToken = TokenBase & {
-    type: 'number';
-    value: number;
-    signCharacter?: '+' | '-';
-};
-export type DimensionToken = TokenBase & {
-    type: 'dimension';
-    value: number;
-    unit: string;
-    rawUnit: string;
-    signCharacter?: '+' | '-';
-};
-export type IdentToken = TokenBase & {
-    type: 'ident';
-    value: string;
-};
-export type FunctionToken = TokenBase & {
-    type: 'function';
-    value: string;
-};
-export type Punctuator = '(' | ')' | ',' | '+' | '-' | '*' | '/';
-export type PunctToken = TokenBase & {
-    type: 'punct';
-    value: Punctuator;
-};
-export type EofToken = TokenBase & {
-    type: 'eof';
-    value: '';
-    raw: '';
-};
-export type Token = NumberToken | DimensionToken | IdentToken | FunctionToken | PunctToken | EofToken;
-export type ParseInput = Readonly<{
-    tokens: CSSToken[];
-    end: number;
-    index: BlockIndex;
-}>;
+export type BlockIndex = import('./parser/tokens.js').BlockIndex;
+export type ParseInput = import('./parser/tokens.js').ParseInput;
+export type Token = import('./parser/tokens.js').Token;
+export type FunctionToken = import('./parser/tokens.js').FunctionToken;
 /** @param {CSSToken[]} tokens @param {number} start @param {number} end @param {BlockIndex} index @return {Node} */
 declare function parse(tokens: CSSToken[], start: number, end: number, index: BlockIndex): Node;
 export { parse };

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

@@ -0,0 +1,55 @@
+export type Node = import('../node.js').Node;
+export type Sum = import('../node.js').Sum;
+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').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}
+ */
+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
+ * @param {string} [callNameOverride]
+ * @return {void}
+ */
+declare function emitCall(node: import('../node.js').Call, session: SerializeSession, callNameOverride?: string): void;
+/**
+ * @param {import('../node.js').OpaqueCall} node
+ * @param {SerializeSession} session
+ * @param {string} [callNameOverride]
+ * @return {void}
+ */
+declare function emitOpaqueCall(node: import('../node.js').OpaqueCall, session: SerializeSession, callNameOverride?: string): void;
+/**
+ * @param {Node} node
+ * @param {SerializeSession} session
+ * @param {string} wrapper
+ * @return {void}
+ */
+declare function emitMathResult(node: Node, session: SerializeSession, wrapper: string): void;
+/**
+ * @param {Node} node
+ * @param {SerializeSession} session
+ * @param {string[]} [buffer]
+ * @return {void}
+ */
+declare function emitNestedMathResult(node: Node, session: SerializeSession, buffer?: string[]): void;
+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

@@ -0,0 +1,102 @@
+export type Node = import('../node.js').Node;
+export type Num = import('../node.js').Num;
+export type Dim = import('../node.js').Dim;
+export type SerializeSession = {
+    buffer: string[];
+    precision: number | false;
+    scalarPolicy: 'standard' | 'unwrap-all';
+};
+/**
+ * @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
+ */
+declare 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}
+ */
+declare function divideByPowerOfTen(digits: string, k: number): string;
+/**
+ * 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}
+ */
+declare function roundDecimal(abs: number, p: number): number;
+/**
+ * @param {number} v
+ * @param {number | false} prec
+ * @return {number}
+ */
+declare function round(v: number, prec: number | false): number;
+/** @param {number} v @return {boolean} */
+declare function isDegenerate(v: number): boolean;
+/** @param {number} v @return {string} */
+declare function degenerateKeyword(v: number): string;
+/** @param {number} v @return {string} */
+declare function serializeNumber(v: number): string;
+/**
+ * @param {import('../node.js').Num | import('../node.js').Dim} node
+ * @param {number | false} precision
+ * @param {number} [value]
+ * @return {number}
+ */
+declare function roundedScalarValue(node: import('../node.js').Num | import('../node.js').Dim, precision: number | false, value?: number): number;
+/**
+ * @param {import('../node.js').Num | import('../node.js').Dim} node
+ * @param {string[]} buffer
+ * @param {number} value
+ * @return {void}
+ */
+declare function emitRoundedScalar(node: import('../node.js').Num | import('../node.js').Dim, buffer: string[], value: number): void;
+/**
+ * @param {import('../node.js').Num | import('../node.js').Dim} node
+ * @param {SerializeSession} session
+ * @param {number} [value]
+ * @return {number}
+ */
+declare function emitFiniteScalar(node: import('../node.js').Num | import('../node.js').Dim, session: SerializeSession, value?: number): number;
+/**
+ * @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, 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;
+export { NOISE_FLOOR, divideByPowerOfTen, roundDecimal, round, isDegenerate, degenerateKeyword, serializeNumber, roundedScalarValue, emitRoundedScalar, emitFiniteScalar, emitScalar, emitSignedZero, emitBareSignedZero, isScalar, isSignedZero, };

package/types/lib/simplify/bucket.d.ts

@@ -19,7 +19,10 @@ export type UnitBucket = {
 /** Mutates `buckets` in place — totals of survivor buckets accumulate the
  *  converted values of merged neighbors. Caller must not reuse the input.
  * @param {UnitBucket[]} buckets
+ * @param {number | false} [precision] A conversion that is not exact at this
+ *   precision is not merged. When only the reverse direction is exact, the
+ *   survivor switches to the other bucket's unit.
  * @return {UnitBucket[]}
  */
-declare function mergeConvertibleBuckets(buckets: UnitBucket[]): UnitBucket[];
+declare function mergeConvertibleBuckets(buckets: UnitBucket[], precision?: number | false): UnitBucket[];
 export { mergeConvertibleBuckets };

package/types/lib/simplify/cancel.d.ts

@@ -1,20 +1,24 @@
 /**
  * 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
+ * same base type and convertible units, return the two sides expressed in a
+ * common unit, so the caller can fold them into its own numerator and
+ * denominator. 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}
+ * @param {number | false} [precision] The denominator is converted into the
+ *   numerator's unit when that is exact at this precision (`1px / 1in` →
+ *   `1 / 96`); otherwise the numerator is converted (`1in / 1px` → `96 / 1`).
+ * @return {{ numerator: number, denominator: number, remaining: D[] } | null}
  */
 declare function tryCancelPair<D extends {
     exponent: 1 | -1;
     value: number;
     unit: string;
-}>(dims: D[]): {
-    factor: number;
+}>(dims: D[], precision?: number | false): {
+    numerator: number;
+    denominator: number;
     remaining: D[];
 } | null;
 export { tryCancelPair };

package/types/lib/simplify/exact.d.ts

@@ -0,0 +1,9 @@
+/**
+ * A value is exact at `precision` when rounding it for output loses nothing
+ * beyond float noise.
+ * @param {number} value
+ * @param {number | false} precision
+ * @return {boolean}
+ */
+declare function isExact(value: number, precision: number | false): boolean;
+export { isExact };

package/types/lib/simplify/fold.d.ts

@@ -15,6 +15,19 @@ export type BaseType = import('../convertUnits.js').BaseType;
 declare function foldResult(fold: {
     unit: string;
 }, value: number): Num | Dim;
+/**
+ * Return the argument that produced a folded min/max/clamp value, so the
+ * result keeps its own unit, spelling and zero sign. Falls back to a fresh
+ * node when no argument matches (NaN).
+ * @param {Node[]} args
+ * @param {{ values: number[], unit: string }} fold
+ * @param {number} value
+ * @return {Node}
+ */
+declare function chosenArg(args: Node[], fold: {
+    values: number[];
+    unit: string;
+}, value: number): Node;
 /**
  * @param {Node[]} args
  * @return {{ values: number[], unit: string } | null}
@@ -23,4 +36,4 @@ declare function foldConstArgs(args: Node[]): {
     values: number[];
     unit: string;
 } | null;
-export { foldConstArgs, foldResult };
+export { foldConstArgs, foldResult, chosenArg };

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 };