@ac-kit/core 0.1.0

package/dist/number/bit/popcount32.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Counts the set bits in the low 32 bits of `value` (Hamming weight).
+ *
+ * SWAR (SIMD-within-a-register): sums adjacent bit-pairs, then nibbles, then
+ * bytes, then all four bytes in one multiply — no loop, no lookup table.
+ *
+ * @param value - The value to count; only its low 32 bits are considered.
+ * @returns The number of set bits, from 0 to 32.
+ */
+export declare function popCount32(value: number): number;
+//# sourceMappingURL=popcount32.d.ts.map

package/dist/number/bit/popcount32.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"popcount32.d.ts","sourceRoot":"","sources":["../../../src/number/bit/popcount32.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQhD"}

package/dist/number/bit/popcount32.js

@@ -0,0 +1,17 @@
+/**
+ * Counts the set bits in the low 32 bits of `value` (Hamming weight).
+ *
+ * SWAR (SIMD-within-a-register): sums adjacent bit-pairs, then nibbles, then
+ * bytes, then all four bytes in one multiply — no loop, no lookup table.
+ *
+ * @param value - The value to count; only its low 32 bits are considered.
+ * @returns The number of set bits, from 0 to 32.
+ */
+export function popCount32(value) {
+    let v = value >>> 0;
+    v = v - ((v >>> 1) & 0x55555555);
+    v = (v & 0x33333333) + ((v >>> 2) & 0x33333333);
+    v = (v + (v >>> 4)) & 0x0f0f0f0f;
+    return (v * 0x01010101) >>> 24;
+}
+//# sourceMappingURL=popcount32.js.map

package/dist/number/bit/popcount32.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"popcount32.js","sourceRoot":"","sources":["../../../src/number/bit/popcount32.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,UAAU,UAAU,CAAC,KAAa;IACvC,IAAI,CAAC,GAAG,KAAK,KAAK,CAAC,CAAC;IAEpB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC;IACjC,CAAC,GAAG,CAAC,CAAC,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC;IAChD,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC;IAEjC,OAAO,CAAC,CAAC,GAAG,UAAU,CAAC,KAAK,EAAE,CAAC;AAChC,CAAC"}

package/dist/number/bit/rotl32.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Rotates `value` left within 32 bits.
+ *
+ * JavaScript has no unsigned 32-bit integer type, so bit rotation has to be
+ * emulated with the shift operators, which discard the bits a real rotation
+ * would wrap around.
+ *
+ * @param value - The value to rotate; only its low 32 bits are considered.
+ * @param count - The rotation distance, taken modulo 32.
+ * @returns The rotated value as an unsigned 32-bit integer.
+ */
+export declare function rotl32(value: number, count: number): number;
+//# sourceMappingURL=rotl32.d.ts.map

package/dist/number/bit/rotl32.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rotl32.d.ts","sourceRoot":"","sources":["../../../src/number/bit/rotl32.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAE3D"}

package/dist/number/bit/rotl32.js

@@ -0,0 +1,15 @@
+/**
+ * Rotates `value` left within 32 bits.
+ *
+ * JavaScript has no unsigned 32-bit integer type, so bit rotation has to be
+ * emulated with the shift operators, which discard the bits a real rotation
+ * would wrap around.
+ *
+ * @param value - The value to rotate; only its low 32 bits are considered.
+ * @param count - The rotation distance, taken modulo 32.
+ * @returns The rotated value as an unsigned 32-bit integer.
+ */
+export function rotl32(value, count) {
+    return ((value << count) | (value >>> (32 - count))) >>> 0;
+}
+//# sourceMappingURL=rotl32.js.map

package/dist/number/bit/rotl32.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rotl32.js","sourceRoot":"","sources":["../../../src/number/bit/rotl32.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,UAAU,MAAM,CAAC,KAAa,EAAE,KAAa;IAClD,OAAO,CAAC,CAAC,KAAK,IAAI,KAAK,CAAC,GAAG,CAAC,KAAK,KAAK,CAAC,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;AAC5D,CAAC"}

package/dist/number/bit/rotr32.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Rotates `value` right within 32 bits.
+ *
+ * JavaScript has no unsigned 32-bit integer type, so bit rotation has to be
+ * emulated with the shift operators, which discard the bits a real rotation
+ * would wrap around.
+ *
+ * @param value - The value to rotate; only its low 32 bits are considered.
+ * @param count - The rotation distance, taken modulo 32.
+ * @returns The rotated value as an unsigned 32-bit integer.
+ */
+export declare function rotr32(value: number, count: number): number;
+//# sourceMappingURL=rotr32.d.ts.map

package/dist/number/bit/rotr32.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rotr32.d.ts","sourceRoot":"","sources":["../../../src/number/bit/rotr32.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAE3D"}

package/dist/number/bit/rotr32.js

@@ -0,0 +1,15 @@
+/**
+ * Rotates `value` right within 32 bits.
+ *
+ * JavaScript has no unsigned 32-bit integer type, so bit rotation has to be
+ * emulated with the shift operators, which discard the bits a real rotation
+ * would wrap around.
+ *
+ * @param value - The value to rotate; only its low 32 bits are considered.
+ * @param count - The rotation distance, taken modulo 32.
+ * @returns The rotated value as an unsigned 32-bit integer.
+ */
+export function rotr32(value, count) {
+    return ((value >>> count) | (value << (32 - count))) >>> 0;
+}
+//# sourceMappingURL=rotr32.js.map

package/dist/number/bit/rotr32.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rotr32.js","sourceRoot":"","sources":["../../../src/number/bit/rotr32.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,UAAU,MAAM,CAAC,KAAa,EAAE,KAAa;IAClD,OAAO,CAAC,CAAC,KAAK,KAAK,KAAK,CAAC,GAAG,CAAC,KAAK,IAAI,CAAC,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;AAC5D,CAAC"}

package/dist/number/bit/words-for-bits.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Minimum number of words required to hold `bits` bits, given a word width of
+ * `width` bits.
+ *
+ * @param bits - The number of bits to fit, non-negative.
+ * @param width - The width of a word in bits, positive.
+ * @returns `⌈bits / width⌉`.
+ */
+export declare function wordsForBits(bits: number, width: number): number;
+//# sourceMappingURL=words-for-bits.d.ts.map

package/dist/number/bit/words-for-bits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"words-for-bits.d.ts","sourceRoot":"","sources":["../../../src/number/bit/words-for-bits.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAEhE"}

package/dist/number/bit/words-for-bits.js

@@ -0,0 +1,12 @@
+/**
+ * Minimum number of words required to hold `bits` bits, given a word width of
+ * `width` bits.
+ *
+ * @param bits - The number of bits to fit, non-negative.
+ * @param width - The width of a word in bits, positive.
+ * @returns `⌈bits / width⌉`.
+ */
+export function wordsForBits(bits, width) {
+    return Math.ceil(bits / width);
+}
+//# sourceMappingURL=words-for-bits.js.map

package/dist/number/bit/words-for-bits.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"words-for-bits.js","sourceRoot":"","sources":["../../../src/number/bit/words-for-bits.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,UAAU,YAAY,CAAC,IAAY,EAAE,KAAa;IACvD,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC,CAAC;AAChC,CAAC"}

package/dist/number/clamp.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Clamp a number between a minimum and a maximum value
+ *
+ * @param value The number to clamp
+ * @param min The minimum value
+ * @param max The maximum value
+ * @returns The clamped value
+ */
+export declare function clamp(value: number, min: number, max: number): number;
+//# sourceMappingURL=clamp.d.ts.map

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

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

package/dist/number/clamp.js

@@ -0,0 +1,15 @@
+/**
+ * Clamp a number between a minimum and a maximum value
+ *
+ * @param value The number to clamp
+ * @param min The minimum value
+ * @param max The maximum value
+ * @returns The clamped value
+ */
+export function clamp(value, min, max) {
+    if (min > max) {
+        throw new RangeError("min must not be greater than max");
+    }
+    return Math.min(Math.max(value, min), max);
+}
+//# sourceMappingURL=clamp.js.map

package/dist/number/clamp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clamp.js","sourceRoot":"","sources":["../../src/number/clamp.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,UAAU,KAAK,CAAC,KAAa,EAAE,GAAW,EAAE,GAAW;IAC5D,IAAI,GAAG,GAAG,GAAG,EAAE,CAAC;QACf,MAAM,IAAI,UAAU,CAAC,kCAAkC,CAAC,CAAC;IAC1D,CAAC;IAED,OAAO,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC;AAC5C,CAAC"}

package/dist/number/float16-bits.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The IEEE-754 binary16 bit pattern of `value`, as an unsigned 16-bit integer.
+ *
+ * A `number` is a binary64, so `value` is first rounded to binary16 exactly as
+ * `Math.f16round` does — the bits describe that rounded value, not the
+ * original.
+ */
+export declare function float16ToBits(value: number): number;
+/**
+ * The binary16 value whose bit pattern is `bits`, widened to a `number`.
+ *
+ * `bits` is taken modulo 2¹⁶, as the underlying `Uint16Array` does.
+ */
+export declare function bitsToFloat16(bits: number): number;
+//# sourceMappingURL=float16-bits.d.ts.map

package/dist/number/float16-bits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"float16-bits.d.ts","sourceRoot":"","sources":["../../src/number/float16-bits.ts"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAInD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAIlD"}

package/dist/number/float16-bits.js

@@ -0,0 +1,24 @@
+const BUFFER_ = new ArrayBuffer(2);
+const FLOAT_ = new Float16Array(BUFFER_);
+const BITS_ = new Uint16Array(BUFFER_);
+/**
+ * The IEEE-754 binary16 bit pattern of `value`, as an unsigned 16-bit integer.
+ *
+ * A `number` is a binary64, so `value` is first rounded to binary16 exactly as
+ * `Math.f16round` does — the bits describe that rounded value, not the
+ * original.
+ */
+export function float16ToBits(value) {
+    FLOAT_[0] = value;
+    return BITS_[0];
+}
+/**
+ * The binary16 value whose bit pattern is `bits`, widened to a `number`.
+ *
+ * `bits` is taken modulo 2¹⁶, as the underlying `Uint16Array` does.
+ */
+export function bitsToFloat16(bits) {
+    BITS_[0] = bits;
+    return FLOAT_[0];
+}
+//# sourceMappingURL=float16-bits.js.map

package/dist/number/float16-bits.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"float16-bits.js","sourceRoot":"","sources":["../../src/number/float16-bits.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG,IAAI,WAAW,CAAC,CAAC,CAAC,CAAC;AACnC,MAAM,MAAM,GAAG,IAAI,YAAY,CAAC,OAAO,CAAC,CAAC;AACzC,MAAM,KAAK,GAAG,IAAI,WAAW,CAAC,OAAO,CAAC,CAAC;AAEvC;;;;;;GAMG;AACH,MAAM,UAAU,aAAa,CAAC,KAAa;IAC1C,MAAM,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC;IAElB,OAAO,KAAK,CAAC,CAAC,CAAE,CAAC;AAClB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,aAAa,CAAC,IAAY;IACzC,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAEhB,OAAO,MAAM,CAAC,CAAC,CAAE,CAAC;AACnB,CAAC"}

package/dist/number/float32-bits.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The IEEE-754 binary32 bit pattern of `value`, as an unsigned 32-bit integer.
+ *
+ * A `number` is a binary64, so `value` is first rounded to binary32 exactly as
+ * `Math.fround` does — the bits describe that rounded value, not the original.
+ */
+export declare function float32ToBits(value: number): number;
+/**
+ * The binary32 value whose bit pattern is `bits`, widened to a `number`.
+ *
+ * `bits` is taken modulo 2³², as the underlying `Uint32Array` does.
+ */
+export declare function bitsToFloat32(bits: number): number;
+//# sourceMappingURL=float32-bits.d.ts.map

package/dist/number/float32-bits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"float32-bits.d.ts","sourceRoot":"","sources":["../../src/number/float32-bits.ts"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAInD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAIlD"}

package/dist/number/float32-bits.js

@@ -0,0 +1,23 @@
+const BUFFER_ = new ArrayBuffer(4);
+const FLOAT_ = new Float32Array(BUFFER_);
+const BITS_ = new Uint32Array(BUFFER_);
+/**
+ * The IEEE-754 binary32 bit pattern of `value`, as an unsigned 32-bit integer.
+ *
+ * A `number` is a binary64, so `value` is first rounded to binary32 exactly as
+ * `Math.fround` does — the bits describe that rounded value, not the original.
+ */
+export function float32ToBits(value) {
+    FLOAT_[0] = value;
+    return BITS_[0];
+}
+/**
+ * The binary32 value whose bit pattern is `bits`, widened to a `number`.
+ *
+ * `bits` is taken modulo 2³², as the underlying `Uint32Array` does.
+ */
+export function bitsToFloat32(bits) {
+    BITS_[0] = bits;
+    return FLOAT_[0];
+}
+//# sourceMappingURL=float32-bits.js.map

package/dist/number/float32-bits.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"float32-bits.js","sourceRoot":"","sources":["../../src/number/float32-bits.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG,IAAI,WAAW,CAAC,CAAC,CAAC,CAAC;AACnC,MAAM,MAAM,GAAG,IAAI,YAAY,CAAC,OAAO,CAAC,CAAC;AACzC,MAAM,KAAK,GAAG,IAAI,WAAW,CAAC,OAAO,CAAC,CAAC;AAEvC;;;;;GAKG;AACH,MAAM,UAAU,aAAa,CAAC,KAAa;IAC1C,MAAM,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC;IAElB,OAAO,KAAK,CAAC,CAAC,CAAE,CAAC;AAClB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,aAAa,CAAC,IAAY;IACzC,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAEhB,OAAO,MAAM,CAAC,CAAC,CAAE,CAAC;AACnB,CAAC"}

package/dist/number/float64-bits.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The IEEE-754 binary64 bit pattern of `value`.
+ *
+ * A JS `number` _is_ a binary64, so this is exact for every input, `NaN` and
+ * the infinities included. The `NaN` payload is whatever the runtime produced;
+ * it is not canonicalised.
+ */
+export declare function float64ToBits(value: number): bigint;
+/**
+ * The binary64 value whose bit pattern is `bits`.
+ *
+ * `bits` is taken modulo 2⁶⁴, as the underlying `BigUint64Array` does.
+ */
+export declare function bitsToFloat64(bits: bigint): number;
+//# sourceMappingURL=float64-bits.d.ts.map

package/dist/number/float64-bits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"float64-bits.d.ts","sourceRoot":"","sources":["../../src/number/float64-bits.ts"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAInD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAIlD"}

package/dist/number/float64-bits.js

@@ -0,0 +1,24 @@
+const BUFFER_ = new ArrayBuffer(8);
+const FLOAT_ = new Float64Array(BUFFER_);
+const BITS_ = new BigUint64Array(BUFFER_);
+/**
+ * The IEEE-754 binary64 bit pattern of `value`.
+ *
+ * A JS `number` _is_ a binary64, so this is exact for every input, `NaN` and
+ * the infinities included. The `NaN` payload is whatever the runtime produced;
+ * it is not canonicalised.
+ */
+export function float64ToBits(value) {
+    FLOAT_[0] = value;
+    return BITS_[0];
+}
+/**
+ * The binary64 value whose bit pattern is `bits`.
+ *
+ * `bits` is taken modulo 2⁶⁴, as the underlying `BigUint64Array` does.
+ */
+export function bitsToFloat64(bits) {
+    BITS_[0] = bits;
+    return FLOAT_[0];
+}
+//# sourceMappingURL=float64-bits.js.map

package/dist/number/float64-bits.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"float64-bits.js","sourceRoot":"","sources":["../../src/number/float64-bits.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG,IAAI,WAAW,CAAC,CAAC,CAAC,CAAC;AACnC,MAAM,MAAM,GAAG,IAAI,YAAY,CAAC,OAAO,CAAC,CAAC;AACzC,MAAM,KAAK,GAAG,IAAI,cAAc,CAAC,OAAO,CAAC,CAAC;AAE1C;;;;;;GAMG;AACH,MAAM,UAAU,aAAa,CAAC,KAAa;IAC1C,MAAM,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC;IAElB,OAAO,KAAK,CAAC,CAAC,CAAE,CAAC;AAClB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,aAAa,CAAC,IAAY;IACzC,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAEhB,OAAO,MAAM,CAAC,CAAC,CAAE,CAAC;AACnB,CAAC"}

package/dist/number/integer/_powers-of-ten.d.ts

@@ -0,0 +1,2 @@
+export declare const POWERS_OF_TEN: readonly number[];
+//# sourceMappingURL=_powers-of-ten.d.ts.map

package/dist/number/integer/_powers-of-ten.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_powers-of-ten.d.ts","sourceRoot":"","sources":["../../../src/number/integer/_powers-of-ten.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,aAAa,EAAE,SAAS,MAAM,EAKjC,CAAC"}

package/dist/number/integer/_powers-of-ten.js

@@ -0,0 +1,11 @@
+// ---------------------------------------------------------------------------
+// Pre-built integer table: 10^0 … 10^18
+// 10^18 < 2^63 < 10^19, so all 19 entries fit in a JS `number` exactly.
+// ---------------------------------------------------------------------------
+export const POWERS_OF_TEN = [
+    1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000,
+    1000000000, 10000000000, 100000000000, 1000000000000,
+    10000000000000, 100000000000000, 1000000000000000,
+    10000000000000000, 100000000000000000, 1000000000000000000,
+];
+//# sourceMappingURL=_powers-of-ten.js.map

package/dist/number/integer/_powers-of-ten.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_powers-of-ten.js","sourceRoot":"","sources":["../../../src/number/integer/_powers-of-ten.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,wCAAwC;AACxC,wEAAwE;AACxE,8EAA8E;AAC9E,MAAM,CAAC,MAAM,aAAa,GAAsB;IAC/C,CAAC,EAAE,EAAE,EAAE,GAAG,EAAE,IAAK,EAAE,KAAM,EAAE,MAAO,EAAE,OAAS,EAAE,QAAU,EAAE,SAAW;IACtE,UAAa,EAAE,WAAc,EAAE,YAAe,EAAE,aAAiB;IACjE,cAAkB,EAAE,eAAmB,EAAE,gBAAqB;IAC9D,iBAAsB,EAAE,kBAAuB,EAAE,mBAAyB;CACjE,CAAC"}

package/dist/number/integer/bit-length.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Number of bits in `|value|`, which is `⌊log₂|value|⌋ + 1`. Zero for `0`.
+ *
+ * The `number` sibling of {@link bigIntBitLength}. `Math.clz32` settles the low
+ * 32 bits directly; above that the value is split into two halves, since a safe
+ * integer needs at most 53 bits.
+ *
+ * @param value - A safe integer; the fractional part of a non-integer is
+ *   ignored.
+ * @returns The bit length, from 0 to 53.
+ */
+export declare function bitLength(value: number): number;
+//# sourceMappingURL=bit-length.d.ts.map

package/dist/number/integer/bit-length.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bit-length.d.ts","sourceRoot":"","sources":["../../../src/number/integer/bit-length.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAY/C"}

package/dist/number/integer/bit-length.js

@@ -0,0 +1,22 @@
+/**
+ * Number of bits in `|value|`, which is `⌊log₂|value|⌋ + 1`. Zero for `0`.
+ *
+ * The `number` sibling of {@link bigIntBitLength}. `Math.clz32` settles the low
+ * 32 bits directly; above that the value is split into two halves, since a safe
+ * integer needs at most 53 bits.
+ *
+ * @param value - A safe integer; the fractional part of a non-integer is
+ *   ignored.
+ * @returns The bit length, from 0 to 53.
+ */
+export function bitLength(value) {
+    const magnitude = Math.floor(Math.abs(value));
+    if (magnitude < 1) {
+        return 0;
+    }
+    if (magnitude <= 0xffffffff) {
+        return 32 - Math.clz32(magnitude);
+    }
+    return 64 - Math.clz32(Math.floor(magnitude / 0x100000000));
+}
+//# sourceMappingURL=bit-length.js.map

package/dist/number/integer/bit-length.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bit-length.js","sourceRoot":"","sources":["../../../src/number/integer/bit-length.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,UAAU,SAAS,CAAC,KAAa;IACtC,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;IAE9C,IAAI,SAAS,GAAG,CAAC,EAAE,CAAC;QACnB,OAAO,CAAC,CAAC;IACV,CAAC;IAED,IAAI,SAAS,IAAI,UAAU,EAAE,CAAC;QAC7B,OAAO,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;IACnC,CAAC;IAED,OAAO,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,GAAG,WAAW,CAAC,CAAC,CAAC;AAC7D,CAAC"}

package/dist/number/integer/clamp-to-integer.d.ts

@@ -0,0 +1,14 @@
+import { RoundingMethod } from "../round.js";
+/**
+ * Clamp a number between a minimum and a maximum value and return an integer in
+ * range.
+ *
+ * Min is rounding up and max is rounded down prior to clamping.
+ *
+ * @param value The number to clamp
+ * @param min The minimum value
+ * @param max The maximum value
+ * @returns The clamped integer
+ */
+export declare function clampToInteger(value: number, min: number, max: number, roundingMethod?: RoundingMethod): number;
+//# sourceMappingURL=clamp-to-integer.d.ts.map

package/dist/number/integer/clamp-to-integer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clamp-to-integer.d.ts","sourceRoot":"","sources":["../../../src/number/integer/clamp-to-integer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAS,MAAM,aAAa,CAAC;AAEpD;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAC7B,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,cAAc,GAAE,cAAwB,GACtC,MAAM,CAMR"}

package/dist/number/integer/clamp-to-integer.js

@@ -0,0 +1,20 @@
+import { clamp } from "../clamp.js";
+import { round } from "../round.js";
+/**
+ * Clamp a number between a minimum and a maximum value and return an integer in
+ * range.
+ *
+ * Min is rounding up and max is rounded down prior to clamping.
+ *
+ * @param value The number to clamp
+ * @param min The minimum value
+ * @param max The maximum value
+ * @returns The clamped integer
+ */
+export function clampToInteger(value, min, max, roundingMethod = "round") {
+    min = Math.ceil(min);
+    max = Math.floor(max);
+    value = round(value, { roundingMethod });
+    return clamp(value, min, max);
+}
+//# sourceMappingURL=clamp-to-integer.js.map

package/dist/number/integer/clamp-to-integer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clamp-to-integer.js","sourceRoot":"","sources":["../../../src/number/integer/clamp-to-integer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAkB,KAAK,EAAE,MAAM,aAAa,CAAC;AAEpD;;;;;;;;;;GAUG;AACH,MAAM,UAAU,cAAc,CAC7B,KAAa,EACb,GAAW,EACX,GAAW,EACX,cAAc,GAAmB,OAAO;IAExC,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACrB,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IACtB,KAAK,GAAG,KAAK,CAAC,KAAK,EAAE,EAAE,cAAc,EAAE,CAAC,CAAC;IAEzC,OAAO,KAAK,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;AAC/B,CAAC"}

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

@@ -0,0 +1,11 @@
+/**
+ * Euclidean division — the quotient whose remainder is {@link modEuclid}, so `a
+ * === divEuclid(a, b) * b + modEuclid(a, b)`.
+ *
+ * Agrees with {@link divFloor} for a positive divisor and rounds the other way
+ * for a negative one: `divEuclid(7, -2) === -3`, `divFloor(7, -2) === -4`.
+ *
+ * @throws {RangeError} When `divisor` is zero.
+ */
+export declare function divEuclid(dividend: number, divisor: number): number;
+//# sourceMappingURL=div-euclid.d.ts.map

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

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

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

@@ -0,0 +1,14 @@
+import { modEuclid } from "./mod-euclid.js";
+/**
+ * Euclidean division — the quotient whose remainder is {@link modEuclid}, so `a
+ * === divEuclid(a, b) * b + modEuclid(a, b)`.
+ *
+ * Agrees with {@link divFloor} for a positive divisor and rounds the other way
+ * for a negative one: `divEuclid(7, -2) === -3`, `divFloor(7, -2) === -4`.
+ *
+ * @throws {RangeError} When `divisor` is zero.
+ */
+export function divEuclid(dividend, divisor) {
+    return (dividend - modEuclid(dividend, divisor)) / divisor;
+}
+//# sourceMappingURL=div-euclid.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"div-euclid.js","sourceRoot":"","sources":["../../../src/number/integer/div-euclid.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C;;;;;;;;GAQG;AACH,MAAM,UAAU,SAAS,CAAC,QAAgB,EAAE,OAAe;IAC1D,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC,GAAG,OAAO,CAAC;AAC5D,CAAC"}

package/dist/number/integer/div-floor.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Flooring division — rounds toward negative infinity, and pairs with
+ * {@link mod}.
+ *
+ * `divFloor(-7, 2) === -4`, where {@link divTrunc} gives `-3`.
+ *
+ * @throws {RangeError} When `divisor` is zero.
+ */
+export declare function divFloor(dividend: number, divisor: number): number;
+//# sourceMappingURL=div-floor.d.ts.map

package/dist/number/integer/div-floor.d.ts.map

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

package/dist/number/integer/div-floor.js

@@ -0,0 +1,13 @@
+import { mod } from "./mod.js";
+/**
+ * Flooring division — rounds toward negative infinity, and pairs with
+ * {@link mod}.
+ *
+ * `divFloor(-7, 2) === -4`, where {@link divTrunc} gives `-3`.
+ *
+ * @throws {RangeError} When `divisor` is zero.
+ */
+export function divFloor(dividend, divisor) {
+    return (dividend - mod(dividend, divisor)) / divisor;
+}
+//# sourceMappingURL=div-floor.js.map

package/dist/number/integer/div-floor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"div-floor.js","sourceRoot":"","sources":["../../../src/number/integer/div-floor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAE/B;;;;;;;GAOG;AACH,MAAM,UAAU,QAAQ,CAAC,QAAgB,EAAE,OAAe;IACzD,OAAO,CAAC,QAAQ,GAAG,GAAG,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC,GAAG,OAAO,CAAC;AACtD,CAAC"}

package/dist/number/integer/div-trunc.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Truncating division — rounds toward zero, as `Math.trunc(a / b)` does.
+ *
+ * Computed from the remainder rather than by truncating a float quotient, so
+ * the result is the exact integer whenever both operands are safe integers.
+ *
+ * `divTrunc(-7, 2) === -3`.
+ *
+ * @throws {RangeError} When `divisor` is zero.
+ */
+export declare function divTrunc(dividend: number, divisor: number): number;
+//# sourceMappingURL=div-trunc.d.ts.map

package/dist/number/integer/div-trunc.d.ts.map

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

package/dist/number/integer/div-trunc.js

@@ -0,0 +1,17 @@
+/**
+ * Truncating division — rounds toward zero, as `Math.trunc(a / b)` does.
+ *
+ * Computed from the remainder rather than by truncating a float quotient, so
+ * the result is the exact integer whenever both operands are safe integers.
+ *
+ * `divTrunc(-7, 2) === -3`.
+ *
+ * @throws {RangeError} When `divisor` is zero.
+ */
+export function divTrunc(dividend, divisor) {
+    if (divisor === 0) {
+        throw new RangeError("Division by zero");
+    }
+    return (dividend - (dividend % divisor)) / divisor;
+}
+//# sourceMappingURL=div-trunc.js.map

package/dist/number/integer/div-trunc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"div-trunc.js","sourceRoot":"","sources":["../../../src/number/integer/div-trunc.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,UAAU,QAAQ,CAAC,QAAgB,EAAE,OAAe;IACzD,IAAI,OAAO,KAAK,CAAC,EAAE,CAAC;QACnB,MAAM,IAAI,UAAU,CAAC,kBAAkB,CAAC,CAAC;IAC1C,CAAC;IAED,OAAO,CAAC,QAAQ,GAAG,CAAC,QAAQ,GAAG,OAAO,CAAC,CAAC,GAAG,OAAO,CAAC;AACpD,CAAC"}

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

@@ -0,0 +1,20 @@
+/**
+ * Floor of log₁₀ for a **positive integer** `number` value.
+ *
+ * Backward-scans the powers of ten below `Number.MAX_SAFE_INTEGER` — O(19) =
+ * O(1).
+ *
+ * @example
+ * 	```ts
+ * 	ilog10(1); // → 0
+ * 	ilog10(9); // → 0
+ * 	ilog10(10); // → 1
+ * 	ilog10(999); // → 2
+ * 	```;
+ *
+ * @param n - Must satisfy `n >= 1`; negative / zero / non-integer input is
+ *   undefined behaviour.
+ * @returns Floor of log₁₀(n), i.e. the number of decimal digits minus one.
+ */
+export declare function ilog10(n: number): number;
+//# sourceMappingURL=ilog10.d.ts.map

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

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

package/dist/number/integer/ilog10.js

@@ -0,0 +1,30 @@
+import { ipow10 } from "./ipow10.js";
+/**
+ * Floor of log₁₀ for a **positive integer** `number` value.
+ *
+ * Backward-scans the powers of ten below `Number.MAX_SAFE_INTEGER` — O(19) =
+ * O(1).
+ *
+ * @example
+ * 	```ts
+ * 	ilog10(1); // → 0
+ * 	ilog10(9); // → 0
+ * 	ilog10(10); // → 1
+ * 	ilog10(999); // → 2
+ * 	```;
+ *
+ * @param n - Must satisfy `n >= 1`; negative / zero / non-integer input is
+ *   undefined behaviour.
+ * @returns Floor of log₁₀(n), i.e. the number of decimal digits minus one.
+ */
+export function ilog10(n) {
+    // Scan backward so the common case (small numbers) exits early for large n
+    // and the scan terminates as soon as we find floor(log10).
+    for (let i = 18; i >= 1; i--) {
+        const threshold = ipow10(i);
+        if (threshold !== null && n >= threshold)
+            return i;
+    }
+    return 0;
+}
+//# sourceMappingURL=ilog10.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ilog10.js","sourceRoot":"","sources":["../../../src/number/integer/ilog10.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,MAAM,CAAC,CAAS;IAC/B,2EAA2E;IAC3E,2DAA2D;IAC3D,KAAK,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAC9B,MAAM,SAAS,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;QAC5B,IAAI,SAAS,KAAK,IAAI,IAAI,CAAC,IAAI,SAAS;YAAE,OAAO,CAAC,CAAC;IACpD,CAAC;IACD,OAAO,CAAC,CAAC;AACV,CAAC"}

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

@@ -0,0 +1,8 @@
+/**
+ * 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 declare function ilog2(value: number): number;
+//# sourceMappingURL=ilog2.d.ts.map