postcss-calc 11.2.1 → 11.2.3

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

@@ -2,16 +2,12 @@ export type Node = import('../node.js').Node;
 export type Product = import('../node.js').Product;
 export type ProductFactor = import('../node.js').ProductFactor;
 export type SimplifyFn = import('../simplify.js').SimplifyFn;
-/**
- * @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
+ * @param {number | false} [precision] A quotient that is not exact at this
+ *   precision stays symbolic (`100% / 3`) instead of being rounded.
  * @return {Node}
  */
-declare function simplifyProduct(product: Product, simplify: SimplifyFn): Node;
+declare function simplifyProduct(product: Product, simplify: SimplifyFn, precision?: number | false): Node;
 export { simplifyProduct };

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

@@ -6,7 +6,8 @@ export type UnitBucket = import('./bucket.js').UnitBucket;
 /**
  * @param {Sum} sum
  * @param {SimplifyFn} simplify
+ * @param {number | false} [precision]
  * @return {Node}
  */
-declare function simplifySum(sum: Sum, simplify: SimplifyFn): Node;
+declare function simplifySum(sum: Sum, simplify: SimplifyFn, precision?: number | false): Node;
 export { simplifySum };

package/types/lib/simplify.d.ts

@@ -1,18 +1,13 @@
 export type Node = import('./node.js').Node;
 export type SimplifyFn = (node: Node) => Node;
-/**
- * @typedef {import('./node.js').Node} Node
- *
- * Recursive simplifier reference, threaded into Sum/Product/Call/OpaqueCall. Lets
- * leaf fold modules avoid circular imports of the entry function.
- * @typedef {(node: Node) => Node} SimplifyFn
- */
 /**
  * Simplify is an independent, composable AST transformation. It may
  * synthesize canonical nodes while preserving the Node -> Node contract.
  * @param {Node} node
+ * @param {number | false} [precision] When set, divisions and unit
+ *   conversions that are not exact at this precision stay symbolic.
  * @param {number} [depth]
  * @return {Node}
  */
-declare function simplify(node: Node, depth?: number): Node;
+declare function simplify(node: Node, precision?: number | false, depth?: number): Node;
 export { simplify };

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