@ac-kit/core 0.1.0

package/dist/number/is-finite-positive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-finite-positive.d.ts","sourceRoot":"","sources":["../../src/number/is-finite-positive.ts"],"names":[],"mappings":"AAAA,gEAAgE;AAChE,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEvD"}

package/dist/number/is-finite-positive.js

@@ -0,0 +1,5 @@
+/** Whether `value` is finite and strictly greater than zero. */
+export function isFinitePositive(value) {
+    return Number.isFinite(value) && value > 0;
+}
+//# sourceMappingURL=is-finite-positive.js.map

package/dist/number/is-finite-positive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-finite-positive.js","sourceRoot":"","sources":["../../src/number/is-finite-positive.ts"],"names":[],"mappings":"AAAA,gEAAgE;AAChE,MAAM,UAAU,gBAAgB,CAAC,KAAa;IAC7C,OAAO,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,CAAC;AAC5C,CAAC"}

package/dist/number/is-normal.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Whether `value` is a normal binary64 — finite, non-zero, and with a full
+ * 53-bit significand.
+ *
+ * Zero, subnormals, infinities and `NaN` are all excluded.
+ */
+export declare function isNormal(value: number): boolean;
+//# sourceMappingURL=is-normal.d.ts.map

package/dist/number/is-normal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-normal.d.ts","sourceRoot":"","sources":["../../src/number/is-normal.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAE/C"}

package/dist/number/is-normal.js

@@ -0,0 +1,11 @@
+import { DBL_MIN } from "../constants/float.js";
+/**
+ * Whether `value` is a normal binary64 — finite, non-zero, and with a full
+ * 53-bit significand.
+ *
+ * Zero, subnormals, infinities and `NaN` are all excluded.
+ */
+export function isNormal(value) {
+    return Number.isFinite(value) && Math.abs(value) >= DBL_MIN;
+}
+//# sourceMappingURL=is-normal.js.map

package/dist/number/is-normal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-normal.js","sourceRoot":"","sources":["../../src/number/is-normal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAEhD;;;;;GAKG;AACH,MAAM,UAAU,QAAQ,CAAC,KAAa;IACrC,OAAO,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,OAAO,CAAC;AAC7D,CAAC"}

package/dist/number/is-subnormal.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Whether `value` is a subnormal binary64 — non-zero, but too small to carry a
+ * full significand, so it has fewer significant bits than a normal number.
+ */
+export declare function isSubnormal(value: number): boolean;
+//# sourceMappingURL=is-subnormal.d.ts.map

package/dist/number/is-subnormal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-subnormal.d.ts","sourceRoot":"","sources":["../../src/number/is-subnormal.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAElD"}

package/dist/number/is-subnormal.js

@@ -0,0 +1,9 @@
+import { DBL_MIN } from "../constants/float.js";
+/**
+ * Whether `value` is a subnormal binary64 — non-zero, but too small to carry a
+ * full significand, so it has fewer significant bits than a normal number.
+ */
+export function isSubnormal(value) {
+    return value !== 0 && Math.abs(value) < DBL_MIN;
+}
+//# sourceMappingURL=is-subnormal.js.map

package/dist/number/is-subnormal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-subnormal.js","sourceRoot":"","sources":["../../src/number/is-subnormal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAEhD;;;GAGG;AACH,MAAM,UAAU,WAAW,CAAC,KAAa;IACxC,OAAO,KAAK,KAAK,CAAC,IAAI,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC;AACjD,CAAC"}

package/dist/number/minmax.d.ts

@@ -0,0 +1,21 @@
+export type MinMaxResult = {
+    min: number;
+    max: number;
+};
+/**
+ * Calculates the minimum and maximum values from a list of numbers.
+ *
+ * This function iterates through the provided numbers to find the smallest and
+ * largest values.
+ *
+ * Its equivalent to calling `Math.min` and `Math.max`, but does the iteration
+ * only once.
+ *
+ * @param values The values to calculate the min and max of, as an array or as
+ *   separate arguments.
+ * @returns An object containing the min and max values, or min = `Infinity` and
+ *   max = `-Infinity` if no values are provided.
+ */
+export declare function minmax(values: readonly number[]): MinMaxResult;
+export declare function minmax(...values: number[]): MinMaxResult;
+//# sourceMappingURL=minmax.d.ts.map

package/dist/number/minmax.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"minmax.d.ts","sourceRoot":"","sources":["../../src/number/minmax.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,YAAY,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC;AAExD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,YAAY,CAAC;AAChE,wBAAgB,MAAM,CAAC,GAAG,MAAM,EAAE,MAAM,EAAE,GAAG,YAAY,CAAC"}

package/dist/number/minmax.js

@@ -0,0 +1,22 @@
+import { fromVariadicArgs } from "../function/variadic-args.js";
+export function minmax(...args) {
+    const values = fromVariadicArgs(args);
+    if (values[0] === undefined) {
+        return { min: Infinity, max: -Infinity };
+    }
+    let min = values[0];
+    let max = values[0];
+    // Indexed rather than `for…of`: the array iterator is not inlined here, and on
+    // a large array that dominates the comparison it is meant to be doing.
+    for (let index = 1; index < values.length; index++) {
+        const value = values[index];
+        if (value < min) {
+            min = value;
+        }
+        if (value > max) {
+            max = value;
+        }
+    }
+    return { min, max };
+}
+//# sourceMappingURL=minmax.js.map

package/dist/number/minmax.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"minmax.js","sourceRoot":"","sources":["../../src/number/minmax.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAoB9E,MAAM,UAAU,MAAM,CAAC,GAAG,IAA0B;IACnD,MAAM,MAAM,GAAG,gBAAgB,CAAC,IAAI,CAAC,CAAC;IACtC,IAAI,MAAM,CAAC,CAAC,CAAC,KAAK,SAAS,EAAE,CAAC;QAC7B,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAC;IAC1C,CAAC;IAED,IAAI,GAAG,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;IACpB,IAAI,GAAG,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;IAEpB,+EAA+E;IAC/E,uEAAuE;IACvE,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;QACpD,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAE,CAAC;QAC7B,IAAI,KAAK,GAAG,GAAG,EAAE,CAAC;YACjB,GAAG,GAAG,KAAK,CAAC;QACb,CAAC;QACD,IAAI,KAAK,GAAG,GAAG,EAAE,CAAC;YACjB,GAAG,GAAG,KAAK,CAAC;QACb,CAAC;IACF,CAAC;IAED,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC;AACrB,CAAC"}

package/dist/number/next-after.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The representable binary64 value adjacent to `value` in the direction of
+ * `direction` — C's `nextafter`.
+ *
+ * @param value - The starting value.
+ * @param direction - The value to step toward; returned as-is when it equals
+ *   `value`, so the sign of a zero result follows it.
+ * @returns The adjacent value, `direction` when the two are equal, or
+ *   `Number.NaN` when either is `NaN`.
+ */
+export declare function nextAfter(value: number, direction: number): number;
+//# sourceMappingURL=next-after.d.ts.map

package/dist/number/next-after.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"next-after.d.ts","sourceRoot":"","sources":["../../src/number/next-after.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAmBlE"}

package/dist/number/next-after.js

@@ -0,0 +1,28 @@
+import { bitsToFloat64, float64ToBits } from "./float64-bits.js";
+/**
+ * The representable binary64 value adjacent to `value` in the direction of
+ * `direction` — C's `nextafter`.
+ *
+ * @param value - The starting value.
+ * @param direction - The value to step toward; returned as-is when it equals
+ *   `value`, so the sign of a zero result follows it.
+ * @returns The adjacent value, `direction` when the two are equal, or
+ *   `Number.NaN` when either is `NaN`.
+ */
+export function nextAfter(value, direction) {
+    if (Number.isNaN(value) || Number.isNaN(direction)) {
+        return Number.NaN;
+    }
+    if (value === direction) {
+        return direction;
+    }
+    if (value === 0) {
+        return direction > 0 ? Number.MIN_VALUE : -Number.MIN_VALUE;
+    }
+    // Magnitude bits ascend away from zero, so stepping away from zero is an
+    // increment and stepping toward it a decrement, whatever the sign.
+    const bits = float64ToBits(value);
+    const awayFromZero = direction > value === value > 0;
+    return bitsToFloat64(awayFromZero ? bits + 1n : bits - 1n);
+}
+//# sourceMappingURL=next-after.js.map

package/dist/number/next-after.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"next-after.js","sourceRoot":"","sources":["../../src/number/next-after.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEjE;;;;;;;;;GASG;AACH,MAAM,UAAU,SAAS,CAAC,KAAa,EAAE,SAAiB;IACzD,IAAI,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE,CAAC;QACpD,OAAO,MAAM,CAAC,GAAG,CAAC;IACnB,CAAC;IAED,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACzB,OAAO,SAAS,CAAC;IAClB,CAAC;IAED,IAAI,KAAK,KAAK,CAAC,EAAE,CAAC;QACjB,OAAO,SAAS,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC;IAC7D,CAAC;IAED,yEAAyE;IACzE,mEAAmE;IACnE,MAAM,IAAI,GAAG,aAAa,CAAC,KAAK,CAAC,CAAC;IAClC,MAAM,YAAY,GAAG,SAAS,GAAG,KAAK,KAAK,KAAK,GAAG,CAAC,CAAC;IAErD,OAAO,aAAa,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,GAAG,EAAE,CAAC,CAAC,CAAC,IAAI,GAAG,EAAE,CAAC,CAAC;AAC5D,CAAC"}

package/dist/number/precise-sum.d.ts

@@ -0,0 +1,62 @@
+/**
+ * An exactly-rounded running total: fold terms in one at a time with
+ * {@link PreciseSum.add}, then read {@link PreciseSum.value} for the binary64
+ * nearest the true mathematical sum of everything added so far — as if every
+ * addition had been performed at infinite precision and rounded once at the
+ * end.
+ *
+ * Shewchuk's partial-expansion algorithm (the one behind Python's `math.fsum`
+ * and the `Math.sumPrecise` proposal): each term is folded into a list of
+ * non-overlapping partial sums that together represent the running total
+ * exactly. Intermediate overflow is compensated the way the proposal's
+ * reference implementation does it, with a biased partial counting how many
+ * times `2 ** 1024` has been factored out — so a run that leaves the finite
+ * range and comes back still answers exactly.
+ *
+ * Prefer {@link sumPrecise} when the terms are already available as a single
+ * iterable; that is the common case and it reads better. Reach for this class
+ * when they are not — typically one loop feeding several totals at once (a
+ * polygon centroid accumulating `cx`, `cy` and the signed area together), where
+ * one iterable per total would mean re-deriving every term.
+ *
+ * Exact summation only removes the error of the **additions**. When the terms
+ * are themselves products, round each one first with `@ac-kit/math-scalar`'s
+ * `diffOfProducts` or `sumOfProducts`; a term that arrives already wrong cannot
+ * be recovered here.
+ *
+ * See {@link sumPrecise} for when exact summation is worth reaching for at all.
+ */
+export declare class PreciseSum {
+    private readonly partials;
+    private partialCount;
+    /** Net count of `2 ** 1024` units factored out by intermediate overflow. */
+    private overflowCount;
+    private sawPositiveInfinity;
+    private sawNegativeInfinity;
+    private sawNaN;
+    /**
+     * Folds `value` into the running total.
+     *
+     * O(k) additions, where k is the number of live partials — 1 or 2 for
+     * well-conditioned input, bounded by the exponent range at worst.
+     *
+     * @param value The term to add. Non-finite terms are recorded separately and
+     *   settled when {@link value} is read.
+     */
+    add(value: number): void;
+    /**
+     * The exactly-rounded total of every term added so far. Reading is O(k) and
+     * leaves the accumulator usable for further {@link add} calls.
+     *
+     * `-0` while no finite term has been added, matching `Math.sumPrecise` on an
+     * empty input; `NaN` if any term was `NaN` or if both infinities were seen.
+     */
+    get value(): number;
+    /**
+     * Settles a total that left the finite range along the way. The biased
+     * partial can only be brought back inside it by the single largest partial,
+     * and only when that partial opposes it; anything else is a real infinity.
+     */
+    private overflowValue_;
+}
+//# sourceMappingURL=precise-sum.d.ts.map

package/dist/number/precise-sum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"precise-sum.d.ts","sourceRoot":"","sources":["../../src/number/precise-sum.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qBAAa,UAAU;IACtB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAgB;IACzC,OAAO,CAAC,YAAY,CAAK;IAEzB,4EAA4E;IAC5E,OAAO,CAAC,aAAa,CAAK;IAC1B,OAAO,CAAC,mBAAmB,CAAS;IACpC,OAAO,CAAC,mBAAmB,CAAS;IACpC,OAAO,CAAC,MAAM,CAAS;IAEvB;;;;;;;;OAQG;IACH,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CA4DvB;IAED;;;;;;OAMG;IACH,IAAI,KAAK,IAAI,MAAM,CA0BlB;IAED;;;;OAIG;IACH,OAAO,CAAC,cAAc;CAuDtB"}

package/dist/number/precise-sum.js

@@ -0,0 +1,209 @@
+/** `2 ** 1023` — half the value one intermediate overflow factors out. */
+const TWO_POW_1023_ = 2 ** 1023;
+/** One unit in the last place at `Number.MAX_VALUE`, i.e. `2 ** 971`. */
+const MAX_ULP_ = 2 ** 971;
+/**
+ * An exactly-rounded running total: fold terms in one at a time with
+ * {@link PreciseSum.add}, then read {@link PreciseSum.value} for the binary64
+ * nearest the true mathematical sum of everything added so far — as if every
+ * addition had been performed at infinite precision and rounded once at the
+ * end.
+ *
+ * Shewchuk's partial-expansion algorithm (the one behind Python's `math.fsum`
+ * and the `Math.sumPrecise` proposal): each term is folded into a list of
+ * non-overlapping partial sums that together represent the running total
+ * exactly. Intermediate overflow is compensated the way the proposal's
+ * reference implementation does it, with a biased partial counting how many
+ * times `2 ** 1024` has been factored out — so a run that leaves the finite
+ * range and comes back still answers exactly.
+ *
+ * Prefer {@link sumPrecise} when the terms are already available as a single
+ * iterable; that is the common case and it reads better. Reach for this class
+ * when they are not — typically one loop feeding several totals at once (a
+ * polygon centroid accumulating `cx`, `cy` and the signed area together), where
+ * one iterable per total would mean re-deriving every term.
+ *
+ * Exact summation only removes the error of the **additions**. When the terms
+ * are themselves products, round each one first with `@ac-kit/math-scalar`'s
+ * `diffOfProducts` or `sumOfProducts`; a term that arrives already wrong cannot
+ * be recovered here.
+ *
+ * See {@link sumPrecise} for when exact summation is worth reaching for at all.
+ */
+export class PreciseSum {
+    partials = [];
+    partialCount = 0;
+    /** Net count of `2 ** 1024` units factored out by intermediate overflow. */
+    overflowCount = 0;
+    sawPositiveInfinity = false;
+    sawNegativeInfinity = false;
+    sawNaN = false;
+    /**
+     * Folds `value` into the running total.
+     *
+     * O(k) additions, where k is the number of live partials — 1 or 2 for
+     * well-conditioned input, bounded by the exponent range at worst.
+     *
+     * @param value The term to add. Non-finite terms are recorded separately and
+     *   settled when {@link value} is read.
+     */
+    add(value) {
+        if (!Number.isFinite(value)) {
+            if (Number.isNaN(value)) {
+                this.sawNaN = true;
+            }
+            else if (value > 0) {
+                this.sawPositiveInfinity = true;
+            }
+            else {
+                this.sawNegativeInfinity = true;
+            }
+            return;
+        }
+        const { partials } = this;
+        let current = value;
+        let kept = 0;
+        for (let index = 0; index < this.partialCount; index++) {
+            let partial = partials[index];
+            if (Math.abs(current) < Math.abs(partial)) {
+                const swap = current;
+                current = partial;
+                partial = swap;
+            }
+            // `b - (sum - a)` is Dekker's fast two-sum, exact because the swap above
+            // establishes its `|a| >= |b|` precondition.
+            let high = current + partial;
+            let low = partial - (high - current);
+            if (!Number.isFinite(high)) {
+                const sign = high > 0 ? 1 : -1;
+                this.overflowCount += sign;
+                // Overflow forces |current| into [2**1023, 2**1024), which makes both
+                // subtractions exact; splitting them is what keeps 2**1024 — itself
+                // unrepresentable — out of the expression.
+                current = current - sign * TWO_POW_1023_ - sign * TWO_POW_1023_;
+                if (Math.abs(current) < Math.abs(partial)) {
+                    const swap = current;
+                    current = partial;
+                    partial = swap;
+                }
+                high = current + partial;
+                low = partial - (high - current);
+            }
+            if (low !== 0) {
+                partials[kept++] = low;
+            }
+            current = high;
+        }
+        partials[kept] = current;
+        this.partialCount = kept + 1;
+    }
+    /**
+     * The exactly-rounded total of every term added so far. Reading is O(k) and
+     * leaves the accumulator usable for further {@link add} calls.
+     *
+     * `-0` while no finite term has been added, matching `Math.sumPrecise` on an
+     * empty input; `NaN` if any term was `NaN` or if both infinities were seen.
+     */
+    get value() {
+        if (this.sawNaN || (this.sawPositiveInfinity && this.sawNegativeInfinity)) {
+            return Number.NaN;
+        }
+        if (this.sawPositiveInfinity) {
+            return Number.POSITIVE_INFINITY;
+        }
+        if (this.sawNegativeInfinity) {
+            return Number.NEGATIVE_INFINITY;
+        }
+        if (this.partialCount === 0) {
+            return -0;
+        }
+        if (this.overflowCount === 0) {
+            return reducePartials_(this.partials, this.partialCount - 2, this.partials[this.partialCount - 1]);
+        }
+        return this.overflowValue_();
+    }
+    /**
+     * Settles a total that left the finite range along the way. The biased
+     * partial can only be brought back inside it by the single largest partial,
+     * and only when that partial opposes it; anything else is a real infinity.
+     */
+    overflowValue_() {
+        const { overflowCount } = this;
+        const partials = this.partials.slice(0, this.partialCount);
+        let index = partials.length - 1;
+        const largest = partials[index];
+        index--;
+        if (Math.abs(overflowCount) > 1 ||
+            (overflowCount > 0 && largest > 0) ||
+            (overflowCount < 0 && largest < 0)) {
+            return overflowCount > 0
+                ? Number.POSITIVE_INFINITY
+                : Number.NEGATIVE_INFINITY;
+        }
+        // Halved so the two-sum itself stays finite, then doubled back.
+        const biased = overflowCount * TWO_POW_1023_;
+        const halved = largest / 2;
+        let high = biased + halved;
+        let low = (halved - (high - biased)) * 2;
+        if (Math.abs(2 * high) === Number.POSITIVE_INFINITY) {
+            // `MAX_VALUE`'s last significand bit is 1, so subtracting exactly half
+            // an ulp from 2**1024 rounds away from it under ties-to-even. A smaller
+            // partial of the opposite sign is the only thing that pulls it back.
+            if (high > 0) {
+                return high === TWO_POW_1023_ &&
+                    low === -(MAX_ULP_ / 2) &&
+                    index >= 0 &&
+                    partials[index] < 0
+                    ? Number.MAX_VALUE
+                    : Number.POSITIVE_INFINITY;
+            }
+            return high === -TWO_POW_1023_ &&
+                low === MAX_ULP_ / 2 &&
+                index >= 0 &&
+                partials[index] > 0
+                ? -Number.MAX_VALUE
+                : Number.NEGATIVE_INFINITY;
+        }
+        if (low !== 0) {
+            index++;
+            partials[index] = low;
+            low = 0;
+        }
+        high *= 2;
+        return reducePartials_(partials, index, high);
+    }
+}
+/**
+ * Adds the partials from smallest to largest starting at `startIndex`, then
+ * settles the one case that ordering alone gets wrong: a result exactly halfway
+ * between two binary64 values, where the partials still below it decide which
+ * way it breaks.
+ */
+function reducePartials_(partials, startIndex, seed) {
+    let index = startIndex;
+    let total = seed;
+    let error = 0;
+    while (index >= 0) {
+        const high = total;
+        const low = partials[index];
+        index--;
+        total = high + low;
+        error = low - (total - high);
+        if (error !== 0) {
+            break;
+        }
+    }
+    // Half-way ties round to even by default, which is the wrong way whenever a
+    // remaining partial pushes the true sum off the midpoint; doubling the
+    // error re-rounds only when that is what happened.
+    if (index >= 0 &&
+        ((error < 0 && partials[index] < 0) || (error > 0 && partials[index] > 0))) {
+        const doubled = error * 2;
+        const adjusted = total + doubled;
+        if (doubled === adjusted - total) {
+            total = adjusted;
+        }
+    }
+    return total;
+}
+//# sourceMappingURL=precise-sum.js.map

package/dist/number/precise-sum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"precise-sum.js","sourceRoot":"","sources":["../../src/number/precise-sum.ts"],"names":[],"mappings":"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"}

package/dist/number/round.d.ts

@@ -0,0 +1,35 @@
+/** Supported rounding methods. */
+export type RoundingMethod = "round" | "floor" | "ceil" | "trunc";
+/**
+ * How much precision to keep, expressed one way or the other — never both, as
+ * they disagree about what the digits are counted from.
+ */
+export type RoundOptions = {
+    /** Rounding method to use. */
+    roundingMethod?: RoundingMethod;
+} & ({
+    /** Number of digits to keep after the decimal point. */
+    fractionDigits?: number;
+    significantDigits?: never;
+} | {
+    fractionDigits?: never;
+    /**
+     * Number of digits to keep counting from the value's leading digit, so
+     * the precision follows its magnitude: `0.00123` to two significant
+     * digits is `0.0012` and `123456` is `120000`, which no single
+     * `fractionDigits` known in advance would give.
+     *
+     * Zero and non-finite values have no magnitude to be relative to, and are
+     * returned unchanged.
+     */
+    significantDigits: number;
+});
+/**
+ * Rounds a number to a given precision using the specified rounding method.
+ *
+ * @param value The number to round.
+ * @param options Rounding options.
+ * @returns The rounded number.
+ */
+export declare function round(value: number, options?: RoundOptions): number;
+//# sourceMappingURL=round.d.ts.map

package/dist/number/round.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"round.d.ts","sourceRoot":"","sources":["../../src/number/round.ts"],"names":[],"mappings":"AAAA,kCAAkC;AAClC,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,OAAO,GAAG,MAAM,GAAG,OAAO,CAAC;AAElE;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG;IAC1B,8BAA8B;IAC9B,cAAc,CAAC,EAAE,cAAc,CAAC;CAChC,GAAG,CACD;IACA,wDAAwD;IACxD,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,iBAAiB,CAAC,EAAE,KAAK,CAAC;CACzB,GACD;IACA,cAAc,CAAC,EAAE,KAAK,CAAC;IACvB;;;;;;;;OAQG;IACH,iBAAiB,EAAE,MAAM,CAAC;CACzB,CACH,CAAC;AAkBF;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM,CA8BnE"}

package/dist/number/round.js

@@ -0,0 +1,47 @@
+function applyRounding_(value, roundingMethod) {
+    switch (roundingMethod) {
+        case "floor":
+            return Math.floor(value);
+        case "ceil":
+            return Math.ceil(value);
+        case "trunc":
+            return Math.trunc(value);
+        default:
+            return Math.round(value);
+    }
+}
+/**
+ * Rounds a number to a given precision using the specified rounding method.
+ *
+ * @param value The number to round.
+ * @param options Rounding options.
+ * @returns The rounded number.
+ */
+export function round(value, options) {
+    const roundingMethod = options?.roundingMethod;
+    const significantDigits = options?.significantDigits;
+    let fractionDigits;
+    if (significantDigits === undefined) {
+        fractionDigits = options?.fractionDigits ?? 0;
+    }
+    else if (value === 0 || !Number.isFinite(value)) {
+        fractionDigits = 0;
+    }
+    else {
+        fractionDigits =
+            significantDigits - 1 - Math.floor(Math.log10(Math.abs(value)));
+    }
+    if (fractionDigits === 0) {
+        return applyRounding_(value, roundingMethod);
+    }
+    // Significant digits can ask to round above the decimal point. Scaling by an
+    // exact integer power of ten and dividing keeps that exact, where
+    // multiplying by an inexact negative power would not.
+    if (fractionDigits < 0) {
+        const factor = 10 ** -fractionDigits;
+        return applyRounding_(value / factor, roundingMethod) * factor;
+    }
+    const factor = 10 ** fractionDigits;
+    return applyRounding_(value * factor, roundingMethod) / factor;
+}
+//# sourceMappingURL=round.js.map

package/dist/number/round.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"round.js","sourceRoot":"","sources":["../../src/number/round.ts"],"names":[],"mappings":"AA+BA,SAAS,cAAc,CACtB,KAAa,EACb,cAA0C;IAE1C,QAAQ,cAAc,EAAE,CAAC;QACxB,KAAK,OAAO;YACX,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAC1B,KAAK,MAAM;YACV,OAAO,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACzB,KAAK,OAAO;YACX,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAC1B;YACC,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAC3B,CAAC;AACF,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,KAAK,CAAC,KAAa,EAAE,OAAsB;IAC1D,MAAM,cAAc,GAAG,OAAO,EAAE,cAAc,CAAC;IAC/C,MAAM,iBAAiB,GAAG,OAAO,EAAE,iBAAiB,CAAC;IAErD,IAAI,cAAsB,CAAC;IAC3B,IAAI,iBAAiB,KAAK,SAAS,EAAE,CAAC;QACrC,cAAc,GAAG,OAAO,EAAE,cAAc,IAAI,CAAC,CAAC;IAC/C,CAAC;SAAM,IAAI,KAAK,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;QACnD,cAAc,GAAG,CAAC,CAAC;IACpB,CAAC;SAAM,CAAC;QACP,cAAc;YACb,iBAAiB,GAAG,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAClE,CAAC;IAED,IAAI,cAAc,KAAK,CAAC,EAAE,CAAC;QAC1B,OAAO,cAAc,CAAC,KAAK,EAAE,cAAc,CAAC,CAAC;IAC9C,CAAC;IAED,6EAA6E;IAC7E,kEAAkE;IAClE,sDAAsD;IACtD,IAAI,cAAc,GAAG,CAAC,EAAE,CAAC;QACxB,MAAM,MAAM,GAAG,EAAE,IAAI,CAAC,cAAc,CAAC;QAErC,OAAO,cAAc,CAAC,KAAK,GAAG,MAAM,EAAE,cAAc,CAAC,GAAG,MAAM,CAAC;IAChE,CAAC;IAED,MAAM,MAAM,GAAG,EAAE,IAAI,cAAc,CAAC;IAEpC,OAAO,cAAc,CAAC,KAAK,GAAG,MAAM,EAAE,cAAc,CAAC,GAAG,MAAM,CAAC;AAChE,CAAC"}

package/dist/number/to-fixed-length.d.ts

@@ -0,0 +1,50 @@
+import { type RoundingMethod } from "../number/round.js";
+export type ToFixedLengthOptions = {
+    /** Maximum number of fraction digits to include in the output. Default is `0`. */
+    maxFractionDigits?: number;
+    /**
+     * Whether to always include the maximum number of fraction digits, even if it
+     * means adding trailing zeros. Default is `false`.
+     *
+     * If `false`, the function will try to reduce the number of fraction digits
+     * to fit the specified length.
+     */
+    fixedFractionDigits?: boolean;
+    /** Rounding method to use when rounding the number. Default is `"round"`. */
+    roundingMethod?: RoundingMethod;
+};
+/**
+ * Format a number to a fixed length string, with options for maximum fraction
+ * digits, fixed fraction digits, and rounding method. If the number exceeds the
+ * maximum value that can be represented with the given length and fraction
+ * digits, it will be clamped to that maximum value.
+ *
+ * Examples with fixedLength=5, fractionDigits=2, fixedFractionDigits=true :
+ * 0.012 => 00.01 (rounded) 0.123 => 00.12 (rounded) 1.234 => 01.23 (rounded)
+ * 12.345 => 12.35 (rounded) 123.456 => 99.99 (max) .. 123456.789 => 99.99
+ * (max)
+ *
+ * Examples with fixedLength=5, fractionDigits=2, fixedFractionDigits=false :
+ * 0.012 => 00.01 (rounded) 0.123 => 00.12 (rounded) 1.234 => 01.23 (rounded)
+ * 12.345 => 12.35 (rounded) 123.456 => 123.5 (rounded) 1234.567 => 999.9 (max)
+ * 12345.678 => 12346 (rounded) 123456.789 => 99999 (max)
+ *
+ * Examples with fixedLength=5, fractionDigits=3, fixedFractionDigits=false :
+ * 0.012 => 0.012 0.123 => 0.123 1.234 => 1.234 12.345 => 12.35 (rounded)
+ * 123.456 => 123.5 (rounded) 1234.567 => 999.9 (max) 12345.678 => 12346
+ * (rounded) 123456.789 => 99999 (max)
+ *
+ * Examples with fixedLength=6, fractionDigits=2, fixedFractionDigits=false :
+ * 0.012 => 000.01 (rounded) 0.123 => 000.12 (rounded) 1.234 => 001.23 (rounded)
+ * 12.345 => 012.35 (rounded) 123.456 => 123.46 (rounded) 1234.567 => 1234.6
+ * (rounded) 12345.678 => 9999.9 (max) 123456.789 => 123457 (rounded)
+ * 1234567.891 => 999999 (max)
+ *
+ * @param value The number to format.
+ * @param length The fixed length of the output string (including decimal point
+ *   if any).
+ * @param options Options for formatting.
+ * @returns The formatted number as a string.
+ */
+export declare function toFixedLength(value: number, length: number, options?: ToFixedLengthOptions): string;
+//# sourceMappingURL=to-fixed-length.d.ts.map

package/dist/number/to-fixed-length.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-fixed-length.d.ts","sourceRoot":"","sources":["../../src/number/to-fixed-length.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAGhE,MAAM,MAAM,oBAAoB,GAAG;IAClC,kFAAkF;IAClF,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAE3B;;;;;;OAMG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAE9B,6EAA6E;IAC7E,cAAc,CAAC,EAAE,cAAc,CAAC;CAChC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,aAAa,CAC5B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,oBAAoB,GAC5B,MAAM,CAiER"}