@ac-kit/core 0.1.0

package/dist/big-int/bit/shift-right-unsigned64.js

@@ -0,0 +1,26 @@
+import { mask64 } from "./mask64.js";
+/**
+ * Logical right shift of the low 64 bits — JavaScript's missing `>>>` for
+ * `bigint`, which only has the sign-propagating `>>`.
+ *
+ * The value is taken as an unsigned 64-bit word first, so a negative operand
+ * shifts in zeros from its two's complement pattern rather than ones. A shift
+ * of 64 or more clears the word, matching what a 64-bit machine instruction
+ * would leave behind rather than C's undefined behaviour.
+ *
+ * @param value The word to shift; only its low 64 bits are considered.
+ * @param count Bit positions to shift by. Zero or less returns the word
+ *   unchanged apart from the masking.
+ * @returns The shifted word, always non-negative.
+ */
+export function shiftRightUnsigned64(value, count) {
+    const word = mask64(value);
+    if (count <= 0) {
+        return word;
+    }
+    if (count >= 64) {
+        return 0n;
+    }
+    return word >> BigInt(count);
+}
+//# sourceMappingURL=shift-right-unsigned64.js.map

package/dist/big-int/bit/shift-right-unsigned64.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shift-right-unsigned64.js","sourceRoot":"","sources":["../../../src/big-int/bit/shift-right-unsigned64.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,oBAAoB,CAAC,KAAa,EAAE,KAAa;IAChE,MAAM,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;IAE3B,IAAI,KAAK,IAAI,CAAC,EAAE,CAAC;QAChB,OAAO,IAAI,CAAC;IACb,CAAC;IAED,IAAI,KAAK,IAAI,EAAE,EAAE,CAAC;QACjB,OAAO,EAAE,CAAC;IACX,CAAC;IAED,OAAO,IAAI,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC;AAC9B,CAAC"}

package/dist/big-int/bit/xorshift64.d.ts

@@ -0,0 +1,3 @@
+/** XOR-shift a `bigint` value by a given `shift` amount. */
+export declare function xorshift64(value: bigint, shift: bigint): bigint;
+//# sourceMappingURL=xorshift64.d.ts.map

package/dist/big-int/bit/xorshift64.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xorshift64.d.ts","sourceRoot":"","sources":["../../../src/big-int/bit/xorshift64.ts"],"names":[],"mappings":"AAAA,4DAA4D;AAC5D,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAE/D"}

package/dist/big-int/bit/xorshift64.js

@@ -0,0 +1,5 @@
+/** XOR-shift a `bigint` value by a given `shift` amount. */
+export function xorshift64(value, shift) {
+    return value ^ (value >> shift);
+}
+//# sourceMappingURL=xorshift64.js.map

package/dist/big-int/bit/xorshift64.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"xorshift64.js","sourceRoot":"","sources":["../../../src/big-int/bit/xorshift64.ts"],"names":[],"mappings":"AAAA,4DAA4D;AAC5D,MAAM,UAAU,UAAU,CAAC,KAAa,EAAE,KAAa;IACtD,OAAO,KAAK,GAAG,CAAC,KAAK,IAAI,KAAK,CAAC,CAAC;AACjC,CAAC"}

package/dist/big-int/bit-length.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Number of bits in `|value|`, which is `⌊log₂|value|⌋ + 1`. Zero for `0n`.
+ *
+ * Computed from the hexadecimal string rather than by shifting, so the cost is
+ * linear in the width rather than quadratic.
+ */
+export declare function bigIntBitLength(value: bigint): number;
+//# sourceMappingURL=bit-length.d.ts.map

package/dist/big-int/bit-length.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bit-length.d.ts","sourceRoot":"","sources":["../../src/big-int/bit-length.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAWrD"}

package/dist/big-int/bit-length.js

@@ -0,0 +1,17 @@
+import { bigIntAbs } from "./abs.js";
+/**
+ * Number of bits in `|value|`, which is `⌊log₂|value|⌋ + 1`. Zero for `0n`.
+ *
+ * Computed from the hexadecimal string rather than by shifting, so the cost is
+ * linear in the width rather than quadratic.
+ */
+export function bigIntBitLength(value) {
+    const magnitude = bigIntAbs(value);
+    if (magnitude === 0n) {
+        return 0;
+    }
+    const hex = magnitude.toString(16);
+    // The leading hex digit contributes between 1 and 4 bits.
+    return (hex.length - 1) * 4 + (32 - Math.clz32(Number.parseInt(hex[0], 16)));
+}
+//# sourceMappingURL=bit-length.js.map

package/dist/big-int/bit-length.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bit-length.js","sourceRoot":"","sources":["../../src/big-int/bit-length.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAErC;;;;;GAKG;AACH,MAAM,UAAU,eAAe,CAAC,KAAa;IAC5C,MAAM,SAAS,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;IAEnC,IAAI,SAAS,KAAK,EAAE,EAAE,CAAC;QACtB,OAAO,CAAC,CAAC;IACV,CAAC;IAED,MAAM,GAAG,GAAG,SAAS,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;IAEnC,0DAA0D;IAC1D,OAAO,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAE,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;AAC/E,CAAC"}

package/dist/big-int/clamp.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Clamps `value` into `[min, max]` — the `bigint` sibling of {@link clamp}.
+ *
+ * @throws {RangeError} When `min` is greater than `max`.
+ */
+export declare function bigIntClamp(value: bigint, min: bigint, max: bigint): bigint;
+//# sourceMappingURL=clamp.d.ts.map

package/dist/big-int/clamp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clamp.d.ts","sourceRoot":"","sources":["../../src/big-int/clamp.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAM3E"}

package/dist/big-int/clamp.js

@@ -0,0 +1,13 @@
+import { bigIntMax, bigIntMin } from "./min-max.js";
+/**
+ * Clamps `value` into `[min, max]` — the `bigint` sibling of {@link clamp}.
+ *
+ * @throws {RangeError} When `min` is greater than `max`.
+ */
+export function bigIntClamp(value, min, max) {
+    if (min > max) {
+        throw new RangeError("min must not be greater than max");
+    }
+    return bigIntMin(bigIntMax(value, min), max);
+}
+//# sourceMappingURL=clamp.js.map

package/dist/big-int/clamp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clamp.js","sourceRoot":"","sources":["../../src/big-int/clamp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEpD;;;;GAIG;AACH,MAAM,UAAU,WAAW,CAAC,KAAa,EAAE,GAAW,EAAE,GAAW;IAClE,IAAI,GAAG,GAAG,GAAG,EAAE,CAAC;QACf,MAAM,IAAI,UAAU,CAAC,kCAAkC,CAAC,CAAC;IAC1D,CAAC;IAED,OAAO,SAAS,CAAC,SAAS,CAAC,KAAK,EAAE,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC;AAC9C,CAAC"}

package/dist/big-int/div-euclid.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Euclidean division — the quotient whose remainder is {@link bigIntModEuclid},
+ * so `dividend === quotient * divisor + bigIntModEuclid(dividend, divisor)`.
+ *
+ * Derived from the remainder rather than by flooring, because flooring and
+ * Euclidean division agree only when the divisor is positive.
+ *
+ * @throws {RangeError} When `divisor` is zero.
+ */
+export declare function bigIntDivEuclid(dividend: bigint, divisor: bigint): bigint;
+//# sourceMappingURL=div-euclid.d.ts.map

package/dist/big-int/div-euclid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"div-euclid.d.ts","sourceRoot":"","sources":["../../src/big-int/div-euclid.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAEzE"}

package/dist/big-int/div-euclid.js

@@ -0,0 +1,14 @@
+import { bigIntModEuclid } from "./mod-euclid.js";
+/**
+ * Euclidean division — the quotient whose remainder is {@link bigIntModEuclid},
+ * so `dividend === quotient * divisor + bigIntModEuclid(dividend, divisor)`.
+ *
+ * Derived from the remainder rather than by flooring, because flooring and
+ * Euclidean division agree only when the divisor is positive.
+ *
+ * @throws {RangeError} When `divisor` is zero.
+ */
+export function bigIntDivEuclid(dividend, divisor) {
+    return (dividend - bigIntModEuclid(dividend, divisor)) / divisor;
+}
+//# sourceMappingURL=div-euclid.js.map

package/dist/big-int/div-euclid.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"div-euclid.js","sourceRoot":"","sources":["../../src/big-int/div-euclid.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAElD;;;;;;;;GAQG;AACH,MAAM,UAAU,eAAe,CAAC,QAAgB,EAAE,OAAe;IAChE,OAAO,CAAC,QAAQ,GAAG,eAAe,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC,GAAG,OAAO,CAAC;AAClE,CAAC"}

package/dist/big-int/div-floor.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Flooring division — rounds toward negative infinity.
+ *
+ * `bigIntDivFloor(-7n, 2n) === -4n`, where {@link bigIntDivTrunc} gives `-3n`.
+ *
+ * @throws {RangeError} When `divisor` is zero.
+ */
+export declare function bigIntDivFloor(dividend: bigint, divisor: bigint): bigint;
+//# sourceMappingURL=div-floor.d.ts.map

package/dist/big-int/div-floor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"div-floor.d.ts","sourceRoot":"","sources":["../../src/big-int/div-floor.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CASxE"}

package/dist/big-int/div-floor.js

@@ -0,0 +1,17 @@
+import { bigIntDivTrunc } from "./div-trunc.js";
+/**
+ * Flooring division — rounds toward negative infinity.
+ *
+ * `bigIntDivFloor(-7n, 2n) === -4n`, where {@link bigIntDivTrunc} gives `-3n`.
+ *
+ * @throws {RangeError} When `divisor` is zero.
+ */
+export function bigIntDivFloor(dividend, divisor) {
+    const quotient = bigIntDivTrunc(dividend, divisor);
+    const remainder = dividend % divisor;
+    if (remainder !== 0n && remainder < 0n !== divisor < 0n) {
+        return quotient - 1n;
+    }
+    return quotient;
+}
+//# sourceMappingURL=div-floor.js.map

package/dist/big-int/div-floor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"div-floor.js","sourceRoot":"","sources":["../../src/big-int/div-floor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAEhD;;;;;;GAMG;AACH,MAAM,UAAU,cAAc,CAAC,QAAgB,EAAE,OAAe;IAC/D,MAAM,QAAQ,GAAG,cAAc,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;IACnD,MAAM,SAAS,GAAG,QAAQ,GAAG,OAAO,CAAC;IAErC,IAAI,SAAS,KAAK,EAAE,IAAI,SAAS,GAAG,EAAE,KAAK,OAAO,GAAG,EAAE,EAAE,CAAC;QACzD,OAAO,QAAQ,GAAG,EAAE,CAAC;IACtB,CAAC;IAED,OAAO,QAAQ,CAAC;AACjB,CAAC"}

package/dist/big-int/div-trunc.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Truncating division — rounds toward zero, as `bigint`'s own `/` does.
+ *
+ * `bigIntDivTrunc(-7n, 2n) === -3n`.
+ *
+ * @throws {RangeError} When `divisor` is zero.
+ */
+export declare function bigIntDivTrunc(dividend: bigint, divisor: bigint): bigint;
+//# sourceMappingURL=div-trunc.d.ts.map

package/dist/big-int/div-trunc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"div-trunc.d.ts","sourceRoot":"","sources":["../../src/big-int/div-trunc.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAMxE"}

package/dist/big-int/div-trunc.js

@@ -0,0 +1,14 @@
+/**
+ * Truncating division — rounds toward zero, as `bigint`'s own `/` does.
+ *
+ * `bigIntDivTrunc(-7n, 2n) === -3n`.
+ *
+ * @throws {RangeError} When `divisor` is zero.
+ */
+export function bigIntDivTrunc(dividend, divisor) {
+    if (divisor === 0n) {
+        throw new RangeError("Division by zero");
+    }
+    return dividend / divisor;
+}
+//# sourceMappingURL=div-trunc.js.map

package/dist/big-int/div-trunc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"div-trunc.js","sourceRoot":"","sources":["../../src/big-int/div-trunc.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,UAAU,cAAc,CAAC,QAAgB,EAAE,OAAe;IAC/D,IAAI,OAAO,KAAK,EAAE,EAAE,CAAC;QACpB,MAAM,IAAI,UAAU,CAAC,kBAAkB,CAAC,CAAC;IAC1C,CAAC;IAED,OAAO,QAAQ,GAAG,OAAO,CAAC;AAC3B,CAAC"}

package/dist/big-int/log10.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Floor of log₁₀ for a **positive `bigint`**.
+ *
+ * Algorithm (O(log log n)):
+ *
+ * 1. Compute the bit length of `n`.
+ * 2. Approximate `t = ⌊bitLength × kOneOverLog2Ten / 2^63⌋`.
+ * 3. Correct by +1 if `n >= 10^(t+1)`.
+ *
+ * @example
+ * 	```ts
+ * 	bigIntLog10(1n); // → 0
+ * 	bigIntLog10(10n); // → 1
+ * 	bigIntLog10(10n ** 38n - 1n); // → 37
+ * 	bigIntLog10(10n ** 38n); // → 38
+ * 	```;
+ *
+ * @param n - Must satisfy `n >= 1n`; negative / zero input is undefined.
+ * @returns Floor of log₁₀(n) as a `number`.
+ */
+export declare function bigIntLog10(n: bigint): number;
+//# sourceMappingURL=log10.d.ts.map

package/dist/big-int/log10.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log10.d.ts","sourceRoot":"","sources":["../../src/big-int/log10.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAkB7C"}

package/dist/big-int/log10.js

@@ -0,0 +1,42 @@
+import { bigIntBitLength } from "./bit-length.js";
+import { bigIntPow10 } from "./pow10.js";
+// ---------------------------------------------------------------------------
+// Constant: ⌊2^63 / log₂(10)⌋
+// Used to convert bit-length to a decimal-digit approximation in O(1).
+// ---------------------------------------------------------------------------
+const ONE_OVER_LOG2_TEN_ = 2776511644261678566n;
+const ONE_OVER_LOG2_TEN_SHIFT_ = 63n;
+/**
+ * Floor of log₁₀ for a **positive `bigint`**.
+ *
+ * Algorithm (O(log log n)):
+ *
+ * 1. Compute the bit length of `n`.
+ * 2. Approximate `t = ⌊bitLength × kOneOverLog2Ten / 2^63⌋`.
+ * 3. Correct by +1 if `n >= 10^(t+1)`.
+ *
+ * @example
+ * 	```ts
+ * 	bigIntLog10(1n); // → 0
+ * 	bigIntLog10(10n); // → 1
+ * 	bigIntLog10(10n ** 38n - 1n); // → 37
+ * 	bigIntLog10(10n ** 38n); // → 38
+ * 	```;
+ *
+ * @param n - Must satisfy `n >= 1n`; negative / zero input is undefined.
+ * @returns Floor of log₁₀(n) as a `number`.
+ */
+export function bigIntLog10(n) {
+    const bitLen = BigInt(bigIntBitLength(n));
+    // Approximate: t ≈ ⌊bitLen / log₂(10)⌋
+    const approx = Number((bitLen * ONE_OVER_LOG2_TEN_) >> ONE_OVER_LOG2_TEN_SHIFT_);
+    // Correct off-by-one: the approximation may be 1 too large or 1 too small
+    if (n < bigIntPow10(approx)) {
+        return approx - 1;
+    }
+    if (n >= bigIntPow10(approx + 1)) {
+        return approx + 1;
+    }
+    return approx;
+}
+//# sourceMappingURL=log10.js.map

package/dist/big-int/log10.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"log10.js","sourceRoot":"","sources":["../../src/big-int/log10.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEzC,8EAA8E;AAC9E,8BAA8B;AAC9B,uEAAuE;AACvE,8EAA8E;AAC9E,MAAM,kBAAkB,GAAG,oBAAmC,CAAC;AAC/D,MAAM,wBAAwB,GAAG,GAAY,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,WAAW,CAAC,CAAS;IACpC,MAAM,MAAM,GAAG,MAAM,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;IAE1C,uCAAuC;IACvC,MAAM,MAAM,GAAG,MAAM,CACpB,CAAC,MAAM,GAAG,kBAAkB,CAAC,IAAI,wBAAwB,CACzD,CAAC;IAEF,0EAA0E;IAC1E,IAAI,CAAC,GAAG,WAAW,CAAC,MAAM,CAAC,EAAE,CAAC;QAC7B,OAAO,MAAM,GAAG,CAAC,CAAC;IACnB,CAAC;IAED,IAAI,CAAC,IAAI,WAAW,CAAC,MAAM,GAAG,CAAC,CAAC,EAAE,CAAC;QAClC,OAAO,MAAM,GAAG,CAAC,CAAC;IACnB,CAAC;IAED,OAAO,MAAM,CAAC;AACf,CAAC"}

package/dist/big-int/log2.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Floor of log₂ for a positive `value`, with none of the rounding `Math.log2`
+ * introduces once the value leaves the exactly-representable range.
+ *
+ * @throws {RangeError} When `value` is zero or negative.
+ */
+export declare function bigIntLog2(value: bigint): number;
+//# sourceMappingURL=log2.d.ts.map

package/dist/big-int/log2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log2.d.ts","sourceRoot":"","sources":["../../src/big-int/log2.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAMhD"}

package/dist/big-int/log2.js

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

package/dist/big-int/log2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"log2.js","sourceRoot":"","sources":["../../src/big-int/log2.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAElD;;;;;GAKG;AACH,MAAM,UAAU,UAAU,CAAC,KAAa;IACvC,IAAI,KAAK,IAAI,EAAE,EAAE,CAAC;QACjB,MAAM,IAAI,UAAU,CAAC,kDAAkD,CAAC,CAAC;IAC1E,CAAC;IAED,OAAO,eAAe,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;AACnC,CAAC"}

package/dist/big-int/min-max.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Smallest of `values` — the `bigint` equivalent `Math.min` does not accept.
+ *
+ * `Math.min()` answers `Infinity` for an empty list; `bigint` has no infinity
+ * to answer with, so an empty list throws instead of inventing a sentinel.
+ *
+ * @param values The values to compare, as an array or as separate arguments.
+ * @throws {RangeError} When no value is given.
+ */
+export declare function bigIntMin(values: readonly bigint[]): bigint;
+export declare function bigIntMin(...values: bigint[]): bigint;
+/**
+ * Largest of `values` — the `bigint` equivalent `Math.max` does not accept.
+ *
+ * @param values The values to compare, as an array or as separate arguments.
+ * @throws {RangeError} When no value is given.
+ */
+export declare function bigIntMax(values: readonly bigint[]): bigint;
+export declare function bigIntMax(...values: bigint[]): bigint;
+//# sourceMappingURL=min-max.d.ts.map

package/dist/big-int/min-max.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"min-max.d.ts","sourceRoot":"","sources":["../../src/big-int/min-max.ts"],"names":[],"mappings":"AAKA;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAAC;AAC7D,wBAAgB,SAAS,CAAC,GAAG,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC;AAoBvD;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAAC;AAC7D,wBAAgB,SAAS,CAAC,GAAG,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC"}

package/dist/big-int/min-max.js

@@ -0,0 +1,30 @@
+import { fromVariadicArgs, } from "../function/variadic-args.js";
+export function bigIntMin(...args) {
+    const values = fromVariadicArgs(args);
+    let smallest = values[0];
+    if (smallest === undefined) {
+        throw new RangeError("bigIntMin needs at least one value");
+    }
+    for (let index = 1; index < values.length; index++) {
+        const value = values[index];
+        if (value < smallest) {
+            smallest = value;
+        }
+    }
+    return smallest;
+}
+export function bigIntMax(...args) {
+    const values = fromVariadicArgs(args);
+    let largest = values[0];
+    if (largest === undefined) {
+        throw new RangeError("bigIntMax needs at least one value");
+    }
+    for (let index = 1; index < values.length; index++) {
+        const value = values[index];
+        if (value > largest) {
+            largest = value;
+        }
+    }
+    return largest;
+}
+//# sourceMappingURL=min-max.js.map

package/dist/big-int/min-max.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"min-max.js","sourceRoot":"","sources":["../../src/big-int/min-max.ts"],"names":[],"mappings":"AAAA,OAAO,EAEN,gBAAgB,GAChB,MAAM,8BAA8B,CAAC;AAatC,MAAM,UAAU,SAAS,CAAC,GAAG,IAA0B;IACtD,MAAM,MAAM,GAAG,gBAAgB,CAAC,IAAI,CAAC,CAAC;IACtC,IAAI,QAAQ,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;IAEzB,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;QAC5B,MAAM,IAAI,UAAU,CAAC,oCAAoC,CAAC,CAAC;IAC5D,CAAC;IAED,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;QAE7B,IAAI,KAAK,GAAG,QAAQ,EAAE,CAAC;YACtB,QAAQ,GAAG,KAAK,CAAC;QAClB,CAAC;IACF,CAAC;IAED,OAAO,QAAQ,CAAC;AACjB,CAAC;AAUD,MAAM,UAAU,SAAS,CAAC,GAAG,IAA0B;IACtD,MAAM,MAAM,GAAG,gBAAgB,CAAC,IAAI,CAAC,CAAC;IACtC,IAAI,OAAO,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;IAExB,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;QAC3B,MAAM,IAAI,UAAU,CAAC,oCAAoC,CAAC,CAAC;IAC5D,CAAC;IAED,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;QAE7B,IAAI,KAAK,GAAG,OAAO,EAAE,CAAC;YACrB,OAAO,GAAG,KAAK,CAAC;QACjB,CAAC;IACF,CAAC;IAED,OAAO,OAAO,CAAC;AAChB,CAAC"}

package/dist/big-int/mod-euclid.d.ts

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

package/dist/big-int/mod-euclid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod-euclid.d.ts","sourceRoot":"","sources":["../../src/big-int/mod-euclid.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAQzE"}

package/dist/big-int/mod-euclid.js

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

package/dist/big-int/mod-euclid.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod-euclid.js","sourceRoot":"","sources":["../../src/big-int/mod-euclid.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAErC;;;;;;;;GAQG;AACH,MAAM,UAAU,eAAe,CAAC,QAAgB,EAAE,OAAe;IAChE,IAAI,OAAO,KAAK,EAAE,EAAE,CAAC;QACpB,MAAM,IAAI,UAAU,CAAC,kBAAkB,CAAC,CAAC;IAC1C,CAAC;IAED,MAAM,SAAS,GAAG,QAAQ,GAAG,OAAO,CAAC;IAErC,OAAO,SAAS,GAAG,EAAE,CAAC,CAAC,CAAC,SAAS,GAAG,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;AACpE,CAAC"}

package/dist/big-int/mod.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Floored remainder — takes the sign of the **divisor**, so it pairs with
+ * {@link bigIntDivFloor}: `dividend === bigIntDivFloor(a, b) * b + bigIntMod(a,
+ * b)`.
+ *
+ * This is what `mod` names in Knuth, Haskell, Lisp, Ada, Julia and Ruby, and
+ * what Python's `%` computes. It is not `bigint`'s `%`, which takes the sign of
+ * the dividend: `-7n % 2n` is `-1n`, while `bigIntMod(-7n, 2n)` is `1n`.
+ *
+ * For a remainder that stays non-negative even when the divisor is negative,
+ * use {@link bigIntModEuclid}.
+ *
+ * @throws {RangeError} When `divisor` is zero.
+ */
+export declare function bigIntMod(dividend: bigint, divisor: bigint): bigint;
+//# sourceMappingURL=mod.d.ts.map

package/dist/big-int/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../src/big-int/mod.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAYnE"}

package/dist/big-int/mod.js

@@ -0,0 +1,25 @@
+/**
+ * Floored remainder — takes the sign of the **divisor**, so it pairs with
+ * {@link bigIntDivFloor}: `dividend === bigIntDivFloor(a, b) * b + bigIntMod(a,
+ * b)`.
+ *
+ * This is what `mod` names in Knuth, Haskell, Lisp, Ada, Julia and Ruby, and
+ * what Python's `%` computes. It is not `bigint`'s `%`, which takes the sign of
+ * the dividend: `-7n % 2n` is `-1n`, while `bigIntMod(-7n, 2n)` is `1n`.
+ *
+ * For a remainder that stays non-negative even when the divisor is negative,
+ * use {@link bigIntModEuclid}.
+ *
+ * @throws {RangeError} When `divisor` is zero.
+ */
+export function bigIntMod(dividend, divisor) {
+    if (divisor === 0n) {
+        throw new RangeError("Division by zero");
+    }
+    const remainder = dividend % divisor;
+    if (remainder !== 0n && remainder < 0n !== divisor < 0n) {
+        return remainder + divisor;
+    }
+    return remainder;
+}
+//# sourceMappingURL=mod.js.map

package/dist/big-int/mod.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.js","sourceRoot":"","sources":["../../src/big-int/mod.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,SAAS,CAAC,QAAgB,EAAE,OAAe;IAC1D,IAAI,OAAO,KAAK,EAAE,EAAE,CAAC;QACpB,MAAM,IAAI,UAAU,CAAC,kBAAkB,CAAC,CAAC;IAC1C,CAAC;IAED,MAAM,SAAS,GAAG,QAAQ,GAAG,OAAO,CAAC;IAErC,IAAI,SAAS,KAAK,EAAE,IAAI,SAAS,GAAG,EAAE,KAAK,OAAO,GAAG,EAAE,EAAE,CAAC;QACzD,OAAO,SAAS,GAAG,OAAO,CAAC;IAC5B,CAAC;IAED,OAAO,SAAS,CAAC;AAClB,CAAC"}

package/dist/big-int/parse.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Parses `text` as a `bigint` in `radix` — the `bigint` sibling of `parseInt`,
+ * and the radix `BigInt()` never took.
+ *
+ * `BigInt("ff")` throws and there is no `BigInt(text, radix)`, so a `bigint`
+ * cannot be read from anything but decimal or a `0b`/`0o`/`0x` literal without
+ * this. Every radix from 2 to 36 is accepted, digits are case-insensitive, and
+ * surrounding whitespace is ignored.
+ *
+ * Unlike `parseInt` this is **strict**: a character `radix` does not define
+ * throws rather than silently ending the number, so `bigIntParse("12abc")` is
+ * an error and not `12n`. `parseInt` reports that case as `NaN`, which a
+ * `bigint` has no equivalent of.
+ *
+ * A `0b`/`0o`/`0x` prefix is accepted when it agrees with `radix`, and selects
+ * one when `radix` is omitted, matching `BigInt()`. A sign may precede it.
+ *
+ * O(n²/k) for an n-digit input, where k is how many `radix` digits fit in a
+ * safe integer — the accumulator grows as it goes, the same shape as the
+ * engine's own decimal conversion.
+ *
+ * @param text The digits to read, optionally signed and prefixed.
+ * @param radix The base, from 2 to 36. Defaults to the prefix's base, or 10.
+ * @returns The value as a `bigint`.
+ * @throws {RangeError} If `radix` is not an integer in `[2, 36]`, or a prefix
+ *   contradicts it.
+ * @throws {SyntaxError} If `text` holds no digits, or holds one `radix` does
+ *   not define.
+ */
+export declare function bigIntParse(text: string, radix?: number): bigint;
+//# sourceMappingURL=parse.d.ts.map

package/dist/big-int/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../src/big-int/parse.ts"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAwChE"}

package/dist/big-int/parse.js

@@ -0,0 +1,102 @@
+import { DIGIT_NINE, DIGIT_ZERO, LOWERCASE_A, LOWERCASE_Z, UPPERCASE_A, UPPERCASE_Z, } from "../constants/ascii.js";
+const PREFIXES_ = new Map([
+    ["0b", 2],
+    ["0o", 8],
+    ["0x", 16],
+]);
+/**
+ * Parses `text` as a `bigint` in `radix` — the `bigint` sibling of `parseInt`,
+ * and the radix `BigInt()` never took.
+ *
+ * `BigInt("ff")` throws and there is no `BigInt(text, radix)`, so a `bigint`
+ * cannot be read from anything but decimal or a `0b`/`0o`/`0x` literal without
+ * this. Every radix from 2 to 36 is accepted, digits are case-insensitive, and
+ * surrounding whitespace is ignored.
+ *
+ * Unlike `parseInt` this is **strict**: a character `radix` does not define
+ * throws rather than silently ending the number, so `bigIntParse("12abc")` is
+ * an error and not `12n`. `parseInt` reports that case as `NaN`, which a
+ * `bigint` has no equivalent of.
+ *
+ * A `0b`/`0o`/`0x` prefix is accepted when it agrees with `radix`, and selects
+ * one when `radix` is omitted, matching `BigInt()`. A sign may precede it.
+ *
+ * O(n²/k) for an n-digit input, where k is how many `radix` digits fit in a
+ * safe integer — the accumulator grows as it goes, the same shape as the
+ * engine's own decimal conversion.
+ *
+ * @param text The digits to read, optionally signed and prefixed.
+ * @param radix The base, from 2 to 36. Defaults to the prefix's base, or 10.
+ * @returns The value as a `bigint`.
+ * @throws {RangeError} If `radix` is not an integer in `[2, 36]`, or a prefix
+ *   contradicts it.
+ * @throws {SyntaxError} If `text` holds no digits, or holds one `radix` does
+ *   not define.
+ */
+export function bigIntParse(text, radix) {
+    if (radix !== undefined &&
+        (!Number.isInteger(radix) || radix < 2 || radix > 36)) {
+        throw new RangeError(`bigIntParse: radix must be in [2, 36], got ${radix}`);
+    }
+    const trimmed = text.trim();
+    const negative = trimmed.startsWith("-");
+    let digits = negative || trimmed.startsWith("+") ? trimmed.slice(1) : trimmed;
+    const prefixed = PREFIXES_.get(digits.slice(0, 2).toLowerCase());
+    if (prefixed !== undefined) {
+        if (radix !== undefined && radix !== prefixed) {
+            throw new RangeError(`bigIntParse: ${digits.slice(0, 2)} prefix contradicts radix ${radix}`);
+        }
+        digits = digits.slice(2);
+    }
+    const base = radix ?? prefixed ?? 10;
+    if (digits.length === 0) {
+        throw new SyntaxError(`bigIntParse: no digits in ${JSON.stringify(text)}`);
+    }
+    if (!isRadixDigits_(digits, base)) {
+        throw new SyntaxError(`bigIntParse: ${JSON.stringify(text)} is not a base-${base} integer`);
+    }
+    // The engine's decimal conversion is native code; only beat it off that path.
+    const magnitude = base === 10 ? BigInt(digits) : accumulate_(digits, base);
+    return negative ? -magnitude : magnitude;
+}
+function isRadixDigits_(digits, radix) {
+    for (let index = 0; index < digits.length; index++) {
+        const code = digits.charCodeAt(index);
+        let digit;
+        if (code >= DIGIT_ZERO && code <= DIGIT_NINE) {
+            digit = code - DIGIT_ZERO;
+        }
+        else if (code >= LOWERCASE_A && code <= LOWERCASE_Z) {
+            digit = code - LOWERCASE_A + 10;
+        }
+        else if (code >= UPPERCASE_A && code <= UPPERCASE_Z) {
+            digit = code - UPPERCASE_A + 10;
+        }
+        else {
+            return false;
+        }
+        if (digit >= radix) {
+            return false;
+        }
+    }
+    return true;
+}
+function accumulate_(digits, base) {
+    // Widest digit run still worth one `Number.parseInt`, so each bigint
+    // multiply-add absorbs many digits rather than one.
+    let chunkSize = 1;
+    for (let limit = base; limit * base <= Number.MAX_SAFE_INTEGER; limit *= base) {
+        chunkSize++;
+    }
+    const chunkScale = BigInt(base) ** BigInt(chunkSize);
+    // A short leading chunk leaves every later one full width.
+    const lead = digits.length % chunkSize || chunkSize;
+    let magnitude = BigInt(Number.parseInt(digits.slice(0, lead), base));
+    for (let index = lead; index < digits.length; index += chunkSize) {
+        magnitude =
+            magnitude * chunkScale +
+                BigInt(Number.parseInt(digits.slice(index, index + chunkSize), base));
+    }
+    return magnitude;
+}
+//# sourceMappingURL=parse.js.map

package/dist/big-int/parse.js.map

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