@ac-kit/core 0.1.0

package/dist/number/integer/ilog2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ilog2.d.ts","sourceRoot":"","sources":["../../../src/number/integer/ilog2.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAM3C"}

package/dist/number/integer/ilog2.js

@@ -0,0 +1,14 @@
+import { bitLength } from "./bit-length.js";
+/**
+ * Floor of log₂ for a positive integer `value`, with none of the rounding
+ * `Math.log2` introduces near a power of two.
+ *
+ * @throws {RangeError} When `value` is zero or negative.
+ */
+export function ilog2(value) {
+    if (value <= 0) {
+        throw new RangeError("Logarithm of a non-positive integer is undefined");
+    }
+    return bitLength(value) - 1;
+}
+//# sourceMappingURL=ilog2.js.map

package/dist/number/integer/ilog2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ilog2.js","sourceRoot":"","sources":["../../../src/number/integer/ilog2.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C;;;;;GAKG;AACH,MAAM,UAAU,KAAK,CAAC,KAAa;IAClC,IAAI,KAAK,IAAI,CAAC,EAAE,CAAC;QAChB,MAAM,IAAI,UAAU,CAAC,kDAAkD,CAAC,CAAC;IAC1E,CAAC;IAED,OAAO,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;AAC7B,CAAC"}

package/dist/number/integer/ipow.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Exact integer power by square-and-multiply, completing `Math.pow`/`**`, which
+ * go through floats and stop being exact well before the safe-integer limit.
+ *
+ * O(log exponent) multiplications.
+ *
+ * @param base - An integer base.
+ * @param exponent - A non-negative integer exponent.
+ * @returns `base ** exponent`, or `null` when the exact result is not a safe
+ *   integer — the same overflow signal {@link ipow10} uses.
+ * @throws {RangeError} When `base` is not an integer, or `exponent` is negative
+ *   or not an integer.
+ */
+export declare function ipow(base: number, exponent: number): number | null;
+//# sourceMappingURL=ipow.d.ts.map

package/dist/number/integer/ipow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ipow.d.ts","sourceRoot":"","sources":["../../../src/number/integer/ipow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,wBAAgB,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAkClE"}

package/dist/number/integer/ipow.js

@@ -0,0 +1,41 @@
+/**
+ * Exact integer power by square-and-multiply, completing `Math.pow`/`**`, which
+ * go through floats and stop being exact well before the safe-integer limit.
+ *
+ * O(log exponent) multiplications.
+ *
+ * @param base - An integer base.
+ * @param exponent - A non-negative integer exponent.
+ * @returns `base ** exponent`, or `null` when the exact result is not a safe
+ *   integer — the same overflow signal {@link ipow10} uses.
+ * @throws {RangeError} When `base` is not an integer, or `exponent` is negative
+ *   or not an integer.
+ */
+export function ipow(base, exponent) {
+    if (!Number.isInteger(base)) {
+        throw new RangeError("Base must be an integer");
+    }
+    if (!Number.isInteger(exponent) || exponent < 0) {
+        throw new RangeError("Exponent must be a non-negative integer");
+    }
+    let result = 1;
+    let factor = base;
+    let remaining = exponent;
+    while (remaining > 0) {
+        if (remaining % 2 === 1) {
+            result *= factor;
+            if (!Number.isSafeInteger(result)) {
+                return null;
+            }
+        }
+        remaining = Math.floor(remaining / 2);
+        if (remaining > 0) {
+            factor *= factor;
+            if (!Number.isSafeInteger(factor)) {
+                return null;
+            }
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=ipow.js.map

package/dist/number/integer/ipow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ipow.js","sourceRoot":"","sources":["../../../src/number/integer/ipow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,IAAI,CAAC,IAAY,EAAE,QAAgB;IAClD,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC;QAC7B,MAAM,IAAI,UAAU,CAAC,yBAAyB,CAAC,CAAC;IACjD,CAAC;IAED,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,QAAQ,GAAG,CAAC,EAAE,CAAC;QACjD,MAAM,IAAI,UAAU,CAAC,yCAAyC,CAAC,CAAC;IACjE,CAAC;IAED,IAAI,MAAM,GAAG,CAAC,CAAC;IACf,IAAI,MAAM,GAAG,IAAI,CAAC;IAClB,IAAI,SAAS,GAAG,QAAQ,CAAC;IAEzB,OAAO,SAAS,GAAG,CAAC,EAAE,CAAC;QACtB,IAAI,SAAS,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;YACzB,MAAM,IAAI,MAAM,CAAC;YAEjB,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,MAAM,CAAC,EAAE,CAAC;gBACnC,OAAO,IAAI,CAAC;YACb,CAAC;QACF,CAAC;QAED,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC;QAEtC,IAAI,SAAS,GAAG,CAAC,EAAE,CAAC;YACnB,MAAM,IAAI,MAAM,CAAC;YAEjB,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,MAAM,CAAC,EAAE,CAAC;gBACnC,OAAO,IAAI,CAAC;YACb,CAAC;QACF,CAAC;IACF,CAAC;IAED,OAAO,MAAM,CAAC;AACf,CAAC"}

package/dist/number/integer/ipow10.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Computes `10^exp` with `exp` an integer, returning a native `number` if the
+ * result is a safe integer, or `null` if the result would exceed
+ * `Number.MAX_SAFE_INTEGER`.
+ *
+ * Uses the pre-built 19-entry const table — O(1) lookup.
+ *
+ * @param exp - The exponent integer.
+ * @returns The result of `10^exp` as a native `number`, or `null` if the
+ */
+export declare function ipow10(exp: number): number | null;
+//# sourceMappingURL=ipow10.d.ts.map

package/dist/number/integer/ipow10.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ipow10.d.ts","sourceRoot":"","sources":["../../../src/number/integer/ipow10.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAMjD"}

package/dist/number/integer/ipow10.js

@@ -0,0 +1,18 @@
+import { POWERS_OF_TEN } from "./_powers-of-ten.js";
+/**
+ * Computes `10^exp` with `exp` an integer, returning a native `number` if the
+ * result is a safe integer, or `null` if the result would exceed
+ * `Number.MAX_SAFE_INTEGER`.
+ *
+ * Uses the pre-built 19-entry const table — O(1) lookup.
+ *
+ * @param exp - The exponent integer.
+ * @returns The result of `10^exp` as a native `number`, or `null` if the
+ */
+export function ipow10(exp) {
+    if (exp < 0 || exp >= POWERS_OF_TEN.length) {
+        return null;
+    }
+    return POWERS_OF_TEN[exp] ?? null;
+}
+//# sourceMappingURL=ipow10.js.map

package/dist/number/integer/ipow10.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ipow10.js","sourceRoot":"","sources":["../../../src/number/integer/ipow10.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEpD;;;;;;;;;GASG;AACH,MAAM,UAAU,MAAM,CAAC,GAAW;IACjC,IAAI,GAAG,GAAG,CAAC,IAAI,GAAG,IAAI,aAAa,CAAC,MAAM,EAAE,CAAC;QAC5C,OAAO,IAAI,CAAC;IACb,CAAC;IAED,OAAO,aAAa,CAAC,GAAG,CAAC,IAAI,IAAI,CAAC;AACnC,CAAC"}

package/dist/number/integer/isqrt.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Floor of the integer square root: the largest `r` with `r² ≤ value`.
+ *
+ * The `number` sibling of {@link bigIntSqrt}, completing `Math.sqrt`. Seeded
+ * from `Math.sqrt`, which is correctly rounded and so is off by at most one;
+ * past 2⁵² the correction cannot be checked by squaring in `number` arithmetic,
+ * so those values are settled on the `bigint` path.
+ *
+ * @throws {RangeError} When `value` is negative or not a safe integer.
+ */
+export declare function isqrt(value: number): number;
+//# sourceMappingURL=isqrt.d.ts.map

package/dist/number/integer/isqrt.d.ts.map

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

package/dist/number/integer/isqrt.js

@@ -0,0 +1,25 @@
+import { bigIntSqrt } from "../../big-int/sqrt.js";
+/**
+ * Floor of the integer square root: the largest `r` with `r² ≤ value`.
+ *
+ * The `number` sibling of {@link bigIntSqrt}, completing `Math.sqrt`. Seeded
+ * from `Math.sqrt`, which is correctly rounded and so is off by at most one;
+ * past 2⁵² the correction cannot be checked by squaring in `number` arithmetic,
+ * so those values are settled on the `bigint` path.
+ *
+ * @throws {RangeError} When `value` is negative or not a safe integer.
+ */
+export function isqrt(value) {
+    if (!Number.isSafeInteger(value)) {
+        throw new RangeError("Value must be a safe integer");
+    }
+    if (value < 0) {
+        throw new RangeError("Square root of a negative integer is not real");
+    }
+    if (value > 2 ** 52) {
+        return Number(bigIntSqrt(BigInt(value)));
+    }
+    const root = Math.floor(Math.sqrt(value));
+    return root * root > value ? root - 1 : root;
+}
+//# sourceMappingURL=isqrt.js.map

package/dist/number/integer/isqrt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isqrt.js","sourceRoot":"","sources":["../../../src/number/integer/isqrt.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAEnD;;;;;;;;;GASG;AACH,MAAM,UAAU,KAAK,CAAC,KAAa;IAClC,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC;QAClC,MAAM,IAAI,UAAU,CAAC,8BAA8B,CAAC,CAAC;IACtD,CAAC;IAED,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;QACf,MAAM,IAAI,UAAU,CAAC,+CAA+C,CAAC,CAAC;IACvE,CAAC;IAED,IAAI,KAAK,GAAG,CAAC,IAAI,EAAE,EAAE,CAAC;QACrB,OAAO,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAC1C,CAAC;IAED,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;IAE1C,OAAO,IAAI,GAAG,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;AAC9C,CAAC"}

package/dist/number/integer/mod-euclid.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Euclidean remainder — always in `[0, |modulus|)`, whatever the signs.
+ *
+ * Differs from {@link mod} only when `modulus` is negative, where the floored
+ * remainder follows the modulus' sign and this one stays non-negative: `mod(-7,
+ * -2)` is `-1`, `modEuclid(-7, -2)` is `1`.
+ *
+ * @throws {RangeError} When `modulus` is zero.
+ */
+export declare function modEuclid(value: number, modulus: number): number;
+//# sourceMappingURL=mod-euclid.d.ts.map

package/dist/number/integer/mod-euclid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod-euclid.d.ts","sourceRoot":"","sources":["../../../src/number/integer/mod-euclid.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAQhE"}

package/dist/number/integer/mod-euclid.js

@@ -0,0 +1,17 @@
+/**
+ * Euclidean remainder — always in `[0, |modulus|)`, whatever the signs.
+ *
+ * Differs from {@link mod} only when `modulus` is negative, where the floored
+ * remainder follows the modulus' sign and this one stays non-negative: `mod(-7,
+ * -2)` is `-1`, `modEuclid(-7, -2)` is `1`.
+ *
+ * @throws {RangeError} When `modulus` is zero.
+ */
+export function modEuclid(value, modulus) {
+    if (modulus === 0) {
+        throw new RangeError("Division by zero");
+    }
+    const remainder = value % modulus;
+    return remainder < 0 ? remainder + Math.abs(modulus) : remainder;
+}
+//# sourceMappingURL=mod-euclid.js.map

package/dist/number/integer/mod-euclid.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod-euclid.js","sourceRoot":"","sources":["../../../src/number/integer/mod-euclid.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,UAAU,SAAS,CAAC,KAAa,EAAE,OAAe;IACvD,IAAI,OAAO,KAAK,CAAC,EAAE,CAAC;QACnB,MAAM,IAAI,UAAU,CAAC,kBAAkB,CAAC,CAAC;IAC1C,CAAC;IAED,MAAM,SAAS,GAAG,KAAK,GAAG,OAAO,CAAC;IAElC,OAAO,SAAS,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;AAClE,CAAC"}

package/dist/number/integer/mod.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Floored remainder — takes the sign of the **divisor**, so it pairs with
+ * {@link divFloor}: `a === divFloor(a, m) * m + mod(a, m)`.
+ *
+ * This is what `mod` names in Knuth, Haskell, Lisp, Ada, Julia and Ruby, and
+ * what Python's `%` computes. It is not JavaScript's `%`, which takes the sign
+ * of the dividend: `-7 % 2` is `-1`, while `mod(-7, 2)` is `1`.
+ *
+ * For a remainder that stays non-negative even when the modulus is negative,
+ * use {@link modEuclid}.
+ *
+ * @param value The dividend, may be negative.
+ * @param modulus The divisor, may be negative.
+ * @returns `value` reduced into `[0, modulus)` for a positive `modulus`.
+ * @throws {RangeError} When `modulus` is zero.
+ */
+export declare function mod(value: number, modulus: number): number;
+//# sourceMappingURL=mod.d.ts.map

package/dist/number/integer/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../src/number/integer/mod.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAM1D"}

package/dist/number/integer/mod.js

@@ -0,0 +1,23 @@
+/**
+ * Floored remainder — takes the sign of the **divisor**, so it pairs with
+ * {@link divFloor}: `a === divFloor(a, m) * m + mod(a, m)`.
+ *
+ * This is what `mod` names in Knuth, Haskell, Lisp, Ada, Julia and Ruby, and
+ * what Python's `%` computes. It is not JavaScript's `%`, which takes the sign
+ * of the dividend: `-7 % 2` is `-1`, while `mod(-7, 2)` is `1`.
+ *
+ * For a remainder that stays non-negative even when the modulus is negative,
+ * use {@link modEuclid}.
+ *
+ * @param value The dividend, may be negative.
+ * @param modulus The divisor, may be negative.
+ * @returns `value` reduced into `[0, modulus)` for a positive `modulus`.
+ * @throws {RangeError} When `modulus` is zero.
+ */
+export function mod(value, modulus) {
+    if (modulus === 0) {
+        throw new RangeError("Division by zero");
+    }
+    return ((value % modulus) + modulus) % modulus;
+}
+//# sourceMappingURL=mod.js.map

package/dist/number/integer/mod.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.js","sourceRoot":"","sources":["../../../src/number/integer/mod.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,GAAG,CAAC,KAAa,EAAE,OAAe;IACjD,IAAI,OAAO,KAAK,CAAC,EAAE,CAAC;QACnB,MAAM,IAAI,UAAU,CAAC,kBAAkB,CAAC,CAAC;IAC1C,CAAC;IAED,OAAO,CAAC,CAAC,KAAK,GAAG,OAAO,CAAC,GAAG,OAAO,CAAC,GAAG,OAAO,CAAC;AAChD,CAAC"}

package/dist/number/integer/power-of-two.d.ts

@@ -0,0 +1,7 @@
+/** Returns `true` if `n` is a power of two, `false` otherwise. */
+export declare function isPowerOfTwo(n: number): boolean | null;
+/** Returns the smallest power of two greater than or equal to `n`. */
+export declare function nextPowerOfTwo(n: number): number | null;
+/** Returns the largest power of two less than or equal to `n`. */
+export declare function previousPowerOfTwo(n: number): number | null;
+//# sourceMappingURL=power-of-two.d.ts.map

package/dist/number/integer/power-of-two.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"power-of-two.d.ts","sourceRoot":"","sources":["../../../src/number/integer/power-of-two.ts"],"names":[],"mappings":"AAEA,kEAAkE;AAClE,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI,CAQtD;AAED,sEAAsE;AACtE,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAUvD;AAED,kEAAkE;AAClE,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAU3D"}

package/dist/number/integer/power-of-two.js

@@ -0,0 +1,41 @@
+import { DBL_MANT_DIG } from "../../constants/float.js";
+/** Returns `true` if `n` is a power of two, `false` otherwise. */
+export function isPowerOfTwo(n) {
+    if (n < 0)
+        throw new RangeError("Input must be a non-negative bigint.");
+    if (n === 0)
+        return false;
+    if (!Number.isSafeInteger(n))
+        return null;
+    let logValue = Math.log2(n);
+    return Number.isInteger(logValue) && Math.pow(2, logValue) === n;
+}
+/** Returns the smallest power of two greater than or equal to `n`. */
+export function nextPowerOfTwo(n) {
+    if (n < 0)
+        throw new RangeError("Input must be a non-negative bigint.");
+    if (n <= 1)
+        return 1;
+    if (!Number.isSafeInteger(n))
+        return null;
+    for (let i = 0; i < DBL_MANT_DIG; i++) {
+        if (n <= 2 ** i)
+            return 2 ** i;
+    }
+    return null;
+}
+/** Returns the largest power of two less than or equal to `n`. */
+export function previousPowerOfTwo(n) {
+    if (n <= 0)
+        throw new RangeError("Input must be a positive bigint.");
+    if (n === 1)
+        return 1;
+    if (!Number.isSafeInteger(n))
+        return null;
+    for (let i = DBL_MANT_DIG - 1; i >= 0; i--) {
+        if (n >= 2 ** i)
+            return 2 ** i;
+    }
+    return null;
+}
+//# sourceMappingURL=power-of-two.js.map

package/dist/number/integer/power-of-two.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"power-of-two.js","sourceRoot":"","sources":["../../../src/number/integer/power-of-two.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAExD,kEAAkE;AAClE,MAAM,UAAU,YAAY,CAAC,CAAS;IACrC,IAAI,CAAC,GAAG,CAAC;QAAE,MAAM,IAAI,UAAU,CAAC,sCAAsC,CAAC,CAAC;IACxE,IAAI,CAAC,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IAC1B,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC;QAAE,OAAO,IAAI,CAAC;IAE1C,IAAI,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAE5B,OAAO,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC;AAClE,CAAC;AAED,sEAAsE;AACtE,MAAM,UAAU,cAAc,CAAC,CAAS;IACvC,IAAI,CAAC,GAAG,CAAC;QAAE,MAAM,IAAI,UAAU,CAAC,sCAAsC,CAAC,CAAC;IACxE,IAAI,CAAC,IAAI,CAAC;QAAE,OAAO,CAAC,CAAC;IACrB,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC;QAAE,OAAO,IAAI,CAAC;IAE1C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,YAAY,EAAE,CAAC,EAAE,EAAE,CAAC;QACvC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC;YAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAChC,CAAC;IAED,OAAO,IAAI,CAAC;AACb,CAAC;AAED,kEAAkE;AAClE,MAAM,UAAU,kBAAkB,CAAC,CAAS;IAC3C,IAAI,CAAC,IAAI,CAAC;QAAE,MAAM,IAAI,UAAU,CAAC,kCAAkC,CAAC,CAAC;IACrE,IAAI,CAAC,KAAK,CAAC;QAAE,OAAO,CAAC,CAAC;IACtB,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC;QAAE,OAAO,IAAI,CAAC;IAE1C,KAAK,IAAI,CAAC,GAAG,YAAY,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAC5C,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC;YAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAChC,CAAC;IAED,OAAO,IAAI,CAAC;AACb,CAAC"}

package/dist/number/integer/sqrt-exact.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Exact integer square root, or `null` when `value` is not a perfect square.
+ *
+ * The `number` sibling of {@link bigIntSqrtExact}.
+ *
+ * @throws {RangeError} When `value` is negative or not a safe integer.
+ */
+export declare function sqrtExact(value: number): number | null;
+//# sourceMappingURL=sqrt-exact.d.ts.map

package/dist/number/integer/sqrt-exact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqrt-exact.d.ts","sourceRoot":"","sources":["../../../src/number/integer/sqrt-exact.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAItD"}

package/dist/number/integer/sqrt-exact.js

@@ -0,0 +1,13 @@
+import { isqrt } from "./isqrt.js";
+/**
+ * Exact integer square root, or `null` when `value` is not a perfect square.
+ *
+ * The `number` sibling of {@link bigIntSqrtExact}.
+ *
+ * @throws {RangeError} When `value` is negative or not a safe integer.
+ */
+export function sqrtExact(value) {
+    const root = isqrt(value);
+    return root * root === value ? root : null;
+}
+//# sourceMappingURL=sqrt-exact.js.map

package/dist/number/integer/sqrt-exact.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqrt-exact.js","sourceRoot":"","sources":["../../../src/number/integer/sqrt-exact.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC;;;;;;GAMG;AACH,MAAM,UAAU,SAAS,CAAC,KAAa;IACtC,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC;IAE1B,OAAO,IAAI,GAAG,IAAI,KAAK,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC;AAC5C,CAAC"}

package/dist/number/is-close-absolute.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Tests whether two numbers are within an absolute tolerance of each other: `|a
+ *
+ * - B| <= absTolerance`.
+ *
+ * The only form defined at the origin, and therefore the one to reach for when
+ * the operands may straddle zero — a determinant about to be divided by, a
+ * distance about to be normalised. It needs a tolerance meaningful in the
+ * caller's units, so it degrades once the operands are far from that scale;
+ * {@link isCloseTo} pairs it with a relative bound for that case.
+ *
+ * @param a - The first number to compare.
+ * @param b - The second number to compare.
+ * @param absTolerance - The absolute tolerance, in the operands' own units.
+ * @returns `true` if the numbers are within `absTolerance`, `false` otherwise.
+ */
+export declare function isCloseAbsolute(a: number, b: number, absTolerance: number): boolean;
+//# sourceMappingURL=is-close-absolute.d.ts.map

package/dist/number/is-close-absolute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-close-absolute.d.ts","sourceRoot":"","sources":["../../src/number/is-close-absolute.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAC9B,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,YAAY,EAAE,MAAM,GAClB,OAAO,CAYT"}

package/dist/number/is-close-absolute.js

@@ -0,0 +1,28 @@
+/**
+ * Tests whether two numbers are within an absolute tolerance of each other: `|a
+ *
+ * - B| <= absTolerance`.
+ *
+ * The only form defined at the origin, and therefore the one to reach for when
+ * the operands may straddle zero — a determinant about to be divided by, a
+ * distance about to be normalised. It needs a tolerance meaningful in the
+ * caller's units, so it degrades once the operands are far from that scale;
+ * {@link isCloseTo} pairs it with a relative bound for that case.
+ *
+ * @param a - The first number to compare.
+ * @param b - The second number to compare.
+ * @param absTolerance - The absolute tolerance, in the operands' own units.
+ * @returns `true` if the numbers are within `absTolerance`, `false` otherwise.
+ */
+export function isCloseAbsolute(a, b, absTolerance) {
+    if (a === b) {
+        // exact match, and handles +0 === -0 and ±Infinity against itself
+        return true;
+    }
+    if (!Number.isFinite(a) || !Number.isFinite(b)) {
+        // NaN is close to nothing, and an infinity only to the same infinity
+        return false;
+    }
+    return Math.abs(a - b) <= absTolerance;
+}
+//# sourceMappingURL=is-close-absolute.js.map

package/dist/number/is-close-absolute.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-close-absolute.js","sourceRoot":"","sources":["../../src/number/is-close-absolute.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,eAAe,CAC9B,CAAS,EACT,CAAS,EACT,YAAoB;IAEpB,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QACb,kEAAkE;QAClE,OAAO,IAAI,CAAC;IACb,CAAC;IAED,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC;QAChD,qEAAqE;QACrE,OAAO,KAAK,CAAC;IACd,CAAC;IAED,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,YAAY,CAAC;AACxC,CAAC"}

package/dist/number/is-close-relative.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Tests whether two numbers are within a relative tolerance of each other: `|a
+ *
+ * - B| <= relTolerance * max(|a|, |b|)`.
+ *
+ * Scale-free, and therefore undefined at the origin — the bound collapses to
+ * `|a| <= relTolerance * |a|`, false for every non-zero `a`. Nothing but `0` is
+ * ever relatively close to `0`. Use {@link isCloseAbsolute} for values that
+ * straddle zero, or {@link isCloseTo} to combine the two.
+ *
+ * No default: a relative tolerance is a claim about how much error the
+ * computation that produced `a` and `b` may have accumulated, which only the
+ * caller knows.
+ *
+ * @param a - The first number to compare.
+ * @param b - The second number to compare.
+ * @param relTolerance - The relative tolerance.
+ * @returns `true` if the numbers are close within the specified relative
+ *   tolerance, `false` otherwise.
+ */
+export declare function isCloseRelative(a: number, b: number, relTolerance: number): boolean;
+//# sourceMappingURL=is-close-relative.d.ts.map

package/dist/number/is-close-relative.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-close-relative.d.ts","sourceRoot":"","sources":["../../src/number/is-close-relative.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,eAAe,CAC9B,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,YAAY,EAAE,MAAM,GAClB,OAAO,CAYT"}

package/dist/number/is-close-relative.js

@@ -0,0 +1,32 @@
+/**
+ * Tests whether two numbers are within a relative tolerance of each other: `|a
+ *
+ * - B| <= relTolerance * max(|a|, |b|)`.
+ *
+ * Scale-free, and therefore undefined at the origin — the bound collapses to
+ * `|a| <= relTolerance * |a|`, false for every non-zero `a`. Nothing but `0` is
+ * ever relatively close to `0`. Use {@link isCloseAbsolute} for values that
+ * straddle zero, or {@link isCloseTo} to combine the two.
+ *
+ * No default: a relative tolerance is a claim about how much error the
+ * computation that produced `a` and `b` may have accumulated, which only the
+ * caller knows.
+ *
+ * @param a - The first number to compare.
+ * @param b - The second number to compare.
+ * @param relTolerance - The relative tolerance.
+ * @returns `true` if the numbers are close within the specified relative
+ *   tolerance, `false` otherwise.
+ */
+export function isCloseRelative(a, b, relTolerance) {
+    if (a === b) {
+        // exact match, and handles +0 === -0 and ±Infinity against itself
+        return true;
+    }
+    if (!Number.isFinite(a) || !Number.isFinite(b)) {
+        // NaN is close to nothing, and an infinity only to the same infinity
+        return false;
+    }
+    return Math.abs(a - b) <= relTolerance * Math.max(Math.abs(a), Math.abs(b));
+}
+//# sourceMappingURL=is-close-relative.js.map

package/dist/number/is-close-relative.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-close-relative.js","sourceRoot":"","sources":["../../src/number/is-close-relative.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,eAAe,CAC9B,CAAS,EACT,CAAS,EACT,YAAoB;IAEpB,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QACb,kEAAkE;QAClE,OAAO,IAAI,CAAC;IACb,CAAC;IAED,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC;QAChD,qEAAqE;QACrE,OAAO,KAAK,CAAC;IACd,CAAC;IAED,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,YAAY,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AAC7E,CAAC"}

package/dist/number/is-close-to.d.ts

@@ -0,0 +1,35 @@
+export type IsCloseToOptions = {
+    /** Bound proportional to the larger operand. Defaults to `0`. */
+    relTol?: number;
+    /**
+     * Bound in the operands' own units, the only one defined at zero. Defaults to
+     * `0`.
+     */
+    absTol?: number;
+};
+/**
+ * Tests whether two numbers are close under a relative bound, an absolute
+ * bound, or whichever of the two is looser: `|a - b| <= max(relTol * max(|a|,
+ * |b|), absTol)`.
+ *
+ * The general form, and the one to reach for by default: the relative bound
+ * carries across scales but collapses at the origin, while the absolute bound
+ * holds at the origin but stops meaning anything far from it. Because `|d| <=
+ * max(x, y)` is `|d| <= x || |d| <= y`, this is exactly `isCloseRelative(a, b,
+ * relTol) || isCloseAbsolute(a, b, absTol)`, evaluated in one pass.
+ *
+ * Symmetric, unlike NumPy's `atol + rtol * |b|` — swapping the operands never
+ * changes the answer.
+ *
+ * No defaults: a tolerance is a claim about the computation that produced `a`
+ * and `b`, which only the caller can make. Omitting both bounds asks for exact
+ * equality.
+ *
+ * @param a - The first number to compare.
+ * @param b - The second number to compare.
+ * @param tolerance - The relative and absolute bounds to accept.
+ * @returns `true` if the numbers are close under either bound, `false`
+ *   otherwise.
+ */
+export declare function isCloseTo(a: number, b: number, tolerance?: IsCloseToOptions): boolean;
+//# sourceMappingURL=is-close-to.d.ts.map

package/dist/number/is-close-to.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-close-to.d.ts","sourceRoot":"","sources":["../../src/number/is-close-to.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,gBAAgB,GAAG;IAC9B,iEAAiE;IACjE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,SAAS,CACxB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,SAAS,CAAC,EAAE,gBAAgB,GAC1B,OAAO,CAkBT"}

package/dist/number/is-close-to.js

@@ -0,0 +1,39 @@
+/**
+ * Tests whether two numbers are close under a relative bound, an absolute
+ * bound, or whichever of the two is looser: `|a - b| <= max(relTol * max(|a|,
+ * |b|), absTol)`.
+ *
+ * The general form, and the one to reach for by default: the relative bound
+ * carries across scales but collapses at the origin, while the absolute bound
+ * holds at the origin but stops meaning anything far from it. Because `|d| <=
+ * max(x, y)` is `|d| <= x || |d| <= y`, this is exactly `isCloseRelative(a, b,
+ * relTol) || isCloseAbsolute(a, b, absTol)`, evaluated in one pass.
+ *
+ * Symmetric, unlike NumPy's `atol + rtol * |b|` — swapping the operands never
+ * changes the answer.
+ *
+ * No defaults: a tolerance is a claim about the computation that produced `a`
+ * and `b`, which only the caller can make. Omitting both bounds asks for exact
+ * equality.
+ *
+ * @param a - The first number to compare.
+ * @param b - The second number to compare.
+ * @param tolerance - The relative and absolute bounds to accept.
+ * @returns `true` if the numbers are close under either bound, `false`
+ *   otherwise.
+ */
+export function isCloseTo(a, b, tolerance) {
+    if (a === b) {
+        // exact match, and handles +0 === -0 and ±Infinity against itself
+        return true;
+    }
+    if (!Number.isFinite(a) || !Number.isFinite(b)) {
+        // NaN is close to nothing, and an infinity only to the same infinity
+        return false;
+    }
+    const { relTol = 0, absTol = 0 } = tolerance ?? {};
+    const difference = Math.abs(a - b);
+    return (difference <= absTol ||
+        difference <= relTol * Math.max(Math.abs(a), Math.abs(b)));
+}
+//# sourceMappingURL=is-close-to.js.map

package/dist/number/is-close-to.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-close-to.js","sourceRoot":"","sources":["../../src/number/is-close-to.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,UAAU,SAAS,CACxB,CAAS,EACT,CAAS,EACT,SAA4B;IAE5B,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QACb,kEAAkE;QAClE,OAAO,IAAI,CAAC;IACb,CAAC;IAED,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC;QAChD,qEAAqE;QACrE,OAAO,KAAK,CAAC;IACd,CAAC;IAED,MAAM,EAAE,MAAM,GAAG,CAAC,EAAE,MAAM,GAAG,CAAC,EAAE,GAAG,SAAS,IAAI,EAAE,CAAC;IACnD,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IAEnC,OAAO,CACN,UAAU,IAAI,MAAM;QACpB,UAAU,IAAI,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CACzD,CAAC;AACH,CAAC"}

package/dist/number/is-close-ulp.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Tests whether two numbers are within `maxUlps` representable steps of each
+ * other.
+ *
+ * A test about float _representation_, not about a domain quantity: use it for
+ * round-trip checks, codec conformance and kernel validation. It cannot express
+ * "close to zero" — every normal number is astronomically many ULPs from `0`,
+ * so only `±0` and the first few subnormals ever pass. Reach for
+ * {@link isCloseTo} whenever the tolerance means something in the caller's
+ * units.
+ *
+ * Slower than the other forms, since the ULP distance needs `BigInt`.
+ *
+ * @param a - The first number to compare.
+ * @param b - The second number to compare.
+ * @param maxUlps - The maximum number of ULPs that the two numbers can differ
+ *   by to be considered close. Defaults to 4.
+ * @returns `true` if the numbers are close within the specified ULPs, `false`
+ *   otherwise. `NaN` is never close to anything, including itself.
+ */
+export declare function isCloseUlp(a: number, b: number, maxUlps?: number): boolean;
+//# sourceMappingURL=is-close-ulp.d.ts.map

package/dist/number/is-close-ulp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-close-ulp.d.ts","sourceRoot":"","sources":["../../src/number/is-close-ulp.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,OAAO,GAAE,MAAU,GAAG,OAAO,CAE7E"}

package/dist/number/is-close-ulp.js

@@ -0,0 +1,25 @@
+import { ulpDistance } from "./ulp-distance.js";
+/**
+ * Tests whether two numbers are within `maxUlps` representable steps of each
+ * other.
+ *
+ * A test about float _representation_, not about a domain quantity: use it for
+ * round-trip checks, codec conformance and kernel validation. It cannot express
+ * "close to zero" — every normal number is astronomically many ULPs from `0`,
+ * so only `±0` and the first few subnormals ever pass. Reach for
+ * {@link isCloseTo} whenever the tolerance means something in the caller's
+ * units.
+ *
+ * Slower than the other forms, since the ULP distance needs `BigInt`.
+ *
+ * @param a - The first number to compare.
+ * @param b - The second number to compare.
+ * @param maxUlps - The maximum number of ULPs that the two numbers can differ
+ *   by to be considered close. Defaults to 4.
+ * @returns `true` if the numbers are close within the specified ULPs, `false`
+ *   otherwise. `NaN` is never close to anything, including itself.
+ */
+export function isCloseUlp(a, b, maxUlps = 4) {
+    return ulpDistance(a, b) <= maxUlps;
+}
+//# sourceMappingURL=is-close-ulp.js.map

package/dist/number/is-close-ulp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-close-ulp.js","sourceRoot":"","sources":["../../src/number/is-close-ulp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,UAAU,CAAC,CAAS,EAAE,CAAS,EAAE,OAAO,GAAW,CAAC;IACnE,OAAO,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,OAAO,CAAC;AACrC,CAAC"}

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

@@ -0,0 +1,3 @@
+/** Whether `value` is finite and strictly greater than zero. */
+export declare function isFinitePositive(value: number): boolean;
+//# sourceMappingURL=is-finite-positive.d.ts.map