functionalscript 0.4.1 → 0.4.3

package/crypto/hmac/module.f.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Provides an implementation of HMAC (Hash-based Message Authentication Code).
+ *
+ * https://en.wikipedia.org/wiki/HMAC
+ *
+ * @module
+ *
+ * @example
+ *
+ * ```ts
+ * import { vec } from '../../types/bit_vec/module.f.ts'
+ * import { msbUtf8 } from '../../text/module.f.ts'
+ * import { sha256 } from '../sha2/module.f.ts'
+ *
+ * const r = hmac(sha256)(msbUtf8('key'))(msbUtf8('The quick brown fox jumps over the lazy dog'))
+ * if (r !== vec(256n)(0xf7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8n)) { throw r }
+ * ```
+ */
+import { type Vec } from '../../types/bit_vec/module.f.ts';
+import { type Sha2 } from '../sha2/module.f.ts';
+/**
+ * Generates an HMAC (Hash-based Message Authentication Code) using the specified SHA-2 hash function.
+ *
+ * @param sha2 - The SHA-2 hash function implementation to use.
+ * @returns - A function that takes a key and returns another function
+ * that takes a message and computes the HMAC.
+ */
+export declare const hmac: (sha2: Sha2) => (k: Vec) => (m: Vec) => Vec;

package/crypto/hmac/module.f.js

@@ -0,0 +1,60 @@
+/**
+ * Provides an implementation of HMAC (Hash-based Message Authentication Code).
+ *
+ * https://en.wikipedia.org/wiki/HMAC
+ *
+ * @module
+ *
+ * @example
+ *
+ * ```ts
+ * import { vec } from '../../types/bit_vec/module.f.ts'
+ * import { msbUtf8 } from '../../text/module.f.ts'
+ * import { sha256 } from '../sha2/module.f.ts'
+ *
+ * const r = hmac(sha256)(msbUtf8('key'))(msbUtf8('The quick brown fox jumps over the lazy dog'))
+ * if (r !== vec(256n)(0xf7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8n)) { throw r }
+ * ```
+ */
+import { length } from "../../types/bit_vec/module.f.js";
+import { empty, msb, vec, vec8 } from "../../types/bit_vec/module.f.js";
+import { flip } from "../../types/function/module.f.js";
+import { repeat } from "../../types/monoid/module.f.js";
+import { computeSync } from "../sha2/module.f.js";
+const { concat } = msb;
+/**
+ * Outer padding.
+ */
+const oPad = vec8(0x5cn);
+/**
+ * Inner padding.
+ */
+const iPad = vec8(0x36n);
+/**
+ * Repeats a vector to create a padded block of the desired length.
+ */
+const padRepeat = repeat({ identity: empty, operation: concat });
+/**
+ * Generates an HMAC (Hash-based Message Authentication Code) using the specified SHA-2 hash function.
+ *
+ * @param sha2 - The SHA-2 hash function implementation to use.
+ * @returns - A function that takes a key and returns another function
+ * that takes a message and computes the HMAC.
+ */
+export const hmac = (sha2) => {
+    const { blockLength } = sha2;
+    const p = flip(padRepeat)(blockLength >> 3n);
+    const ip = p(iPad);
+    const op = p(oPad);
+    const c = computeSync(sha2);
+    const vbl = vec(blockLength);
+    const xor = (a) => (b) => vbl(a ^ b);
+    return k => m => {
+        const k1 = length(k) > blockLength ? c([k]) : k;
+        const k2 = concat(k1)(vec(blockLength - length(k1))(0n));
+        const xk2 = xor(k2);
+        const f = (p, msg) => c([xk2(p), msg]);
+        const m1 = f(ip, m);
+        return f(op, m1);
+    };
+};

package/crypto/hmac/test.f.d.ts

@@ -0,0 +1,6 @@
+declare const _default: {
+    example: () => void;
+    sha256: () => void;
+    sha512: () => void;
+};
+export default _default;

package/crypto/hmac/test.f.js

@@ -0,0 +1,24 @@
+import { msbUtf8 } from "../../text/module.f.js";
+import { vec } from "../../types/bit_vec/module.f.js";
+import { sha256, sha512 } from "../sha2/module.f.js";
+import { hmac } from "./module.f.js";
+export default {
+    example: () => {
+        const r = hmac(sha256)(msbUtf8('key'))(msbUtf8('The quick brown fox jumps over the lazy dog'));
+        if (r !== vec(256n)(0xf7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8n)) {
+            throw r;
+        }
+    },
+    sha256: () => {
+        const r = hmac(sha256)(msbUtf8('key'))(msbUtf8('The quick brown fox jumps over the lazy dog'));
+        if (r !== 0x1f7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8n) {
+            throw r;
+        }
+    },
+    sha512: () => {
+        const r = hmac(sha512)(msbUtf8('key'))(msbUtf8('The quick brown fox jumps over the lazy dog'));
+        if (r !== 0x1b42af09057bac1e2d41708e48a902e09b5ff7f12ab428a4fe86653c73dd248fb82f948a549f7b791a5b41915ee4d1ec3935357e4e2317250d0372afa2ebeeb3an) {
+            throw r;
+        }
+    }
+};

package/crypto/sha2/module.f.d.ts

@@ -1,5 +1,6 @@
 import type { Array16, Array8 } from '../../types/array/module.f.ts';
 import { type Vec } from '../../types/bit_vec/module.f.ts';
+import { type List } from '../../types/list/module.f.ts';
 export type V8 = Array8<bigint>;
 export type V16 = Array16<bigint>;
 /**
@@ -40,6 +41,14 @@ export type Base = {
  * ```
  */
 export type Sha2 = {
+    /**
+     * A hash length.
+     */
+    readonly hashLength: bigint;
+    /**
+     * An internal block length.
+     */
+    readonly blockLength: bigint;
     /**
      * Initial state of the SHA-2 algorithm.
      */
@@ -60,6 +69,7 @@ export type Sha2 = {
      */
     readonly end: (state: State) => bigint;
 };
+export declare const computeSync: ({ append, init, end }: Sha2) => (list: List<Vec>) => Vec;
 export declare const base32: Base;
 export declare const base64: Base;
 /** SHA-256 */

package/crypto/sha2/module.f.js

@@ -1,5 +1,7 @@
 import { mask } from "../../types/bigint/module.f.js";
 import { vec, length, empty, msb } from "../../types/bit_vec/module.f.js";
+import { flip } from "../../types/function/module.f.js";
+import { fold } from "../../types/list/module.f.js";
 const { concat, popFront, front } = msb;
 const lastOne = vec(1n)(1n);
 const base = ({ logBitLen, k, bs0, bs1, ss0, ss1 }) => {
@@ -138,6 +140,7 @@ const base = ({ logBitLen, k, bs0, bs1, ss0, ss1 }) => {
         },
         end: (hashLength) => {
             const offset = (bitLength << 3n) - hashLength;
+            const result = vec(hashLength);
             return (state) => {
                 const { len, remainder } = state;
                 let { hash } = state;
@@ -148,12 +151,14 @@ const base = ({ logBitLen, k, bs0, bs1, ss0, ss1 }) => {
                     hash = compress(hash)(u);
                     u = 0n;
                 }
-                return fromV8(compress(hash)(u | (len + rLen))) >> offset;
+                return result(fromV8(compress(hash)(u | (len + rLen))) >> offset);
             };
         }
     };
 };
-const sha2 = ({ append, end }, hash, hashLength) => ({
+const sha2 = ({ append, end, chunkLength }, hash, hashLength) => ({
+    hashLength,
+    blockLength: chunkLength,
     init: {
         hash,
         len: 0n,
@@ -162,6 +167,10 @@ const sha2 = ({ append, end }, hash, hashLength) => ({
     append,
     end: end(hashLength),
 });
+export const computeSync = ({ append, init, end }) => {
+    const f = fold(flip(append))(init);
+    return (list) => end(f(list));
+};
 export const base32 = base({
     logBitLen: 5n,
     k: [

package/crypto/sha2/test.f.js

@@ -1,7 +1,8 @@
 import { msbUtf8 } from "../../text/module.f.js";
 import { empty, msb, vec } from "../../types/bit_vec/module.f.js";
+import { map } from "../../types/list/module.f.js";
 import { repeat } from "../../types/monoid/module.f.js";
-import { base32, base64, sha224, sha256, sha384, sha512, sha512x224, sha512x256, } from "./module.f.js";
+import { base32, base64, computeSync, sha224, sha256, sha384, sha512, sha512x224, sha512x256, } from "./module.f.js";
 const { concat: beConcat } = msb;
 const checkEmpty = ({ init, end }) => (x) => {
     const result = end(init);
@@ -22,7 +23,7 @@ export default {
                     const result = fromV8(compress(sha256.init.hash)(e));
                     const x = 0xe3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855n;
                     if (result !== x) {
-                        throw [result, x];
+                        throw [result.toString(16), x.toString(16)];
                     }
                 },
                 s224: () => {
@@ -70,29 +71,35 @@ export default {
         }
     },
     sha2: {
-        sha256: () => checkEmpty(sha256)(0xe3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855n),
-        sha224: () => checkEmpty(sha224)(0xd14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42fn),
-        sha512: () => checkEmpty(sha512)(0xcf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3en),
-        sha384: () => checkEmpty(sha384)(0x38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95bn),
-        sha512x256: () => checkEmpty(sha512x256)(0xc672b8d1ef56ed28ab87c3622c5114069bdd3ad7b8f9737498d0c01ecef0967an),
-        sha512x224: () => checkEmpty(sha512x224)(0x6ed0dd02806fa89e25de060c19d3ac86cabb87d6a0ddd05c333b84f4n),
+        sha256: () => checkEmpty(sha256)(0x1e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855n),
+        sha224: () => checkEmpty(sha224)(0x1d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42fn),
+        sha512: () => checkEmpty(sha512)(0x1cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3en),
+        sha384: () => checkEmpty(sha384)(0x138b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95bn),
+        sha512x256: () => checkEmpty(sha512x256)(0x1c672b8d1ef56ed28ab87c3622c5114069bdd3ad7b8f9737498d0c01ecef0967an),
+        sha512x224: () => checkEmpty(sha512x224)(0x16ed0dd02806fa89e25de060c19d3ac86cabb87d6a0ddd05c333b84f4n),
     },
     utf8: [
         () => {
-            const s = msbUtf8("The quick brown fox jumps over the lazy dog");
-            let state = sha224.init;
-            state = sha224.append(state)(s);
-            const h = sha224.end(state);
-            if (h !== 0x730e109bd7a8a32b1cb9d9a09aa2325d2430587ddbc0c38bad911525n) {
-                throw h;
+            const e = 0x1730e109bd7a8a32b1cb9d9a09aa2325d2430587ddbc0c38bad911525n;
+            {
+                const s = msbUtf8("The quick brown fox jumps over the lazy dog");
+                const h = computeSync(sha224)([s]);
+                if (h !== e) {
+                    throw h;
+                }
+            }
+            {
+                const s = ['The', ' quick', ' brown', ' fox', ' jumps', ' over', ' the', ' lazy', ' dog'];
+                const h = computeSync(sha224)(map(msbUtf8)(s));
+                if (h !== e) {
+                    throw h;
+                }
             }
         },
         () => {
             const s = msbUtf8("The quick brown fox jumps over the lazy dog.");
-            let state = sha224.init;
-            state = sha224.append(state)(s);
-            const h = sha224.end(state);
-            if (h !== 0x619cba8e8e05826e9b8c519c0a5c68f4fb653e8a3d8aa04bb2c8cd4cn) {
+            const h = computeSync(sha224)([s]);
+            if (h !== 0x1619cba8e8e05826e9b8c519c0a5c68f4fb653e8a3d8aa04bb2c8cd4cn) {
                 throw h;
             }
         },
@@ -104,7 +111,7 @@ export default {
             let state = sha256.init;
             state = sha256.append(state)(s);
             const h = sha256.end(state);
-            if (h !== 0xb94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9n) {
+            if (h !== 0x1b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9n) {
                 throw h;
             }
         }
@@ -117,7 +124,7 @@ export default {
                 let state = sha256.init;
                 state = sha256.append(state)(r);
                 const h = sha256.end(state);
-                if (h >> 224n !== 0x8a83665fn) {
+                if (h >> 224n !== 0x18a83665fn) {
                     throw h;
                 }
             },
@@ -126,7 +133,7 @@ export default {
                 let state = sha256.init;
                 state = sha256.append(state)(r);
                 const h = sha256.end(state);
-                if (h !== 0x3138bb9bc78df27c473ecfd1410f7bd45ebac1f59cf3ff9cfe4db77aab7aedd3n) {
+                if (h !== 0x13138bb9bc78df27c473ecfd1410f7bd45ebac1f59cf3ff9cfe4db77aab7aedd3n) {
                     throw h;
                 }
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "type": "module",
   "files": [
     "**/*.f.d.ts",

package/types/bigint/module.f.d.ts

@@ -1,5 +1,5 @@
 /**
- * A collection of utility functions for working with `bigint` values.
+ * Utility functions for working with `bigint` values.
  *
  * @module
  *
@@ -14,17 +14,67 @@
  * const bitCount = bitLength(255n) // 8n
  * const bitmask = mask(5n) // 31n
  * const m = min(3n)(13n) // 3n
+ * const c = combination([3n, 2n, 1n]) // 60n
  * ```
  */
 import { type Sign } from '../function/compare/module.f.ts';
 import type * as Operator from '../function/operator/module.f.ts';
 import { type List } from '../list/module.f.ts';
+/**
+ * Type representing a unary operation on `bigint`.
+ */
 export type Unary = Operator.Unary<bigint, bigint>;
+/**
+ * Type representing a reduction operation on `bigint` values.
+ */
 export type Reduce = Operator.Reduce<bigint>;
+/**
+ * Adds two `bigint` values.
+ *
+ * @param a - The first bigint value.
+ * @returns A function that takes the second bigint value and returns the sum.
+ */
 export declare const addition: Reduce;
+/**
+ * Calculates the sum of a list of `bigint` values.
+ *
+ * @param input - A list of bigint values.
+ * @returns The sum of all values in the list.
+ */
 export declare const sum: (input: List<bigint>) => bigint;
+/**
+ * Multiplies two `bigint` values.
+ *
+ * @param a - The first bigint value.
+ * @returns A function that takes the second bigint value and returns the product.
+ */
+export declare const multiple: Reduce;
+/**
+ * Calculates the product of a list of `bigint` values.
+ *
+ * @param input - A list of bigint values.
+ * @returns The product of all values in the list.
+ */
+export declare const product: (input: List<bigint>) => bigint;
+/**
+ * Calculates the absolute value of a `bigint`.
+ *
+ * @param a - The bigint value.
+ * @returns The absolute value of the input bigint.
+ */
 export declare const abs: Unary;
+/**
+ * Determines the sign of a `bigint`.
+ * @param a - The bigint value.
+ * @returns `1` if positive, `-1` if negative, and `0` if zero.
+ */
 export declare const sign: (a: bigint) => Sign;
+/**
+ * Serializes a `bigint` to a string representation.
+ *
+ * @param a - The bigint value.
+ * @returns A string representation of the bigint (e.g., '123n').
+ */
 export declare const serialize: (a: bigint) => string;
 /**
  * Calculates the base-2 logarithm (floor).
@@ -81,6 +131,37 @@ export declare const bitLength: (v: bigint) => bigint;
  */
 export declare const mask: (len: bigint) => bigint;
 /**
- * A minimal value.
+ * Returns the smaller of two `bigint` values.
+ *
+ * @param a - The first bigint.
+ * @returns A function that takes the second bigint and returns the smaller value.
  */
 export declare const min: (a: bigint) => (b: bigint) => bigint;
+/**
+ * Returns the larger of two `bigint` values.
+ *
+ * @param a - The first bigint.
+ * @returns A function that takes the second bigint and returns the larger value.
+ */
+export declare const max: (a: bigint) => (b: bigint) => bigint;
+/**
+ * Calculates the partial factorial `b!/a!`.
+ *
+ * @param a - The starting bigint value.
+ * @returns A function that takes `b` and computes `b!/a!`.
+ */
+export declare const partialFactorial: (a: bigint) => (b: bigint) => bigint;
+/**
+ * Calculates the factorial of a `bigint`.
+ *
+ * @param b - The bigint value.
+ * @returns The factorial of the input.
+ */
+export declare const factorial: (b: bigint) => bigint;
+/**
+ * Calculates the number of combinations for a list of `bigint` values.
+ *
+ * @param k - A list of bigint values.
+ * @returns The number of combinations.
+ */
+export declare const combination: (...k: readonly bigint[]) => bigint;

package/types/bigint/module.f.js

@@ -1,5 +1,5 @@
 /**
- * A collection of utility functions for working with `bigint` values.
+ * Utility functions for working with `bigint` values.
  *
  * @module
  *
@@ -14,15 +14,61 @@
  * const bitCount = bitLength(255n) // 8n
  * const bitmask = mask(5n) // 31n
  * const m = min(3n)(13n) // 3n
+ * const c = combination([3n, 2n, 1n]) // 60n
  * ```
  */
 import { unsafeCmp } from "../function/compare/module.f.js";
 import { reduce } from "../list/module.f.js";
+/**
+ * Adds two `bigint` values.
+ *
+ * @param a - The first bigint value.
+ * @returns A function that takes the second bigint value and returns the sum.
+ */
 export const addition = a => b => a + b;
+/**
+ * Calculates the sum of a list of `bigint` values.
+ *
+ * @param input - A list of bigint values.
+ * @returns The sum of all values in the list.
+ */
 export const sum = reduce(addition)(0n);
+/**
+ * Multiplies two `bigint` values.
+ *
+ * @param a - The first bigint value.
+ * @returns A function that takes the second bigint value and returns the product.
+ */
+export const multiple = a => b => a * b;
+/**
+ * Calculates the product of a list of `bigint` values.
+ *
+ * @param input - A list of bigint values.
+ * @returns The product of all values in the list.
+ */
+export const product = reduce(multiple)(1n);
+/**
+ * Calculates the absolute value of a `bigint`.
+ *
+ * @param a - The bigint value.
+ * @returns The absolute value of the input bigint.
+ */
 export const abs = a => a >= 0 ? a : -a;
+/**
+ * Determines the sign of a `bigint`.
+ * @param a - The bigint value.
+ * @returns `1` if positive, `-1` if negative, and `0` if zero.
+ */
 export const sign = (a) => unsafeCmp(a)(0n);
+/**
+ * Serializes a `bigint` to a string representation.
+ *
+ * @param a - The bigint value.
+ * @returns A string representation of the bigint (e.g., '123n').
+ */
 export const serialize = (a) => `${a}n`;
+const { isFinite } = Number;
+const { log2: mathLog2 } = Math;
 /**
  * Calculates the base-2 logarithm (floor).
  *
@@ -52,7 +98,7 @@ export const log2 = (v) => {
     let result = -1n;
     // `bigints` higher than 2**1023 may lead to `Inf` during conversion to `number`.
     // For example: `Number((1n << 1024n) - (1n << 970n)) === Inf`.
-    let i = 1023n;
+    let i = 0x400n;
     while (true) {
         const n = v >> i;
         if (n === 0n) {
@@ -68,7 +114,7 @@ export const log2 = (v) => {
     //
     // We know that `v` is not 0 so it doesn't make sense to check `n` when `i` is 0.
     // Because of this, We check if `i` is greater than 1023 before we divide it by 2.
-    while (i !== 1023n) {
+    while (i !== 0x400n) {
         i >>= 1n;
         const n = v >> i;
         if (n !== 0n) {
@@ -79,12 +125,20 @@ export const log2 = (v) => {
     //
     // 3. Remainder Phase.
     //
-    // We know that `v` is less than `1n << 1023` so we can calculate a remainder using
+    // We know that `v` is less than `1n << 1024` so we can calculate a remainder using
     // `Math.log2`.
-    const rem = BigInt(Math.log2(Number(v)) | 0);
-    // (v >> rem) is either `0` or `1`, and it's used as a correction for
-    // Math.log2 rounding.
-    return result + rem + (v >> rem);
+    const nl = mathLog2(Number(v));
+    if (isFinite(nl)) {
+        const rem = BigInt(nl | 0);
+        // (v >> rem) is either `0` or `1`, and it's used as a correction for
+        // Math.log2 rounding.
+        return result + rem + (v >> rem);
+    }
+    else {
+        // nl is Inf, it means log2(v) === 0x3FF and we add +1 to compensate for initial
+        // `result = -1n`.
+        return result + 0x400n;
+    }
 };
 /**
  * Calculates the bit length of a given BigInt.
@@ -129,6 +183,58 @@ export const bitLength = (v) => {
  */
 export const mask = (len) => (1n << len) - 1n;
 /**
- * A minimal value.
+ * Returns the smaller of two `bigint` values.
+ *
+ * @param a - The first bigint.
+ * @returns A function that takes the second bigint and returns the smaller value.
  */
 export const min = (a) => (b) => a < b ? a : b;
+/**
+ * Returns the larger of two `bigint` values.
+ *
+ * @param a - The first bigint.
+ * @returns A function that takes the second bigint and returns the larger value.
+ */
+export const max = (a) => (b) => a < b ? b : a;
+/**
+ * Calculates the partial factorial `b!/a!`.
+ *
+ * @param a - The starting bigint value.
+ * @returns A function that takes `b` and computes `b!/a!`.
+ */
+export const partialFactorial = (a) => (b) => {
+    let result = b;
+    while (true) {
+        --b;
+        if (b <= a) {
+            return result;
+        }
+        result *= b;
+    }
+};
+/**
+ * Calculates the factorial of a `bigint`.
+ *
+ * @param b - The bigint value.
+ * @returns The factorial of the input.
+ */
+export const factorial = partialFactorial(1n);
+/**
+ * Calculates the number of combinations for a list of `bigint` values.
+ *
+ * @param k - A list of bigint values.
+ * @returns The number of combinations.
+ */
+export const combination = (...k) => {
+    let s = 0n;
+    let m = 1n;
+    let p = 1n;
+    for (let i of k) {
+        s += i;
+        if (i >= m) {
+            [i, m] = [m, i];
+        }
+        p *= factorial(i);
+    }
+    return partialFactorial(m)(s) / p;
+};

package/types/bigint/test.f.d.ts

@@ -23,5 +23,9 @@ declare const _default: {
         big: () => void;
         neg: (() => void)[];
     };
+    factorial: () => void;
+    combination: () => void;
+    combination50x50: () => void;
+    combination3: () => void;
 };
 export default _default;

package/types/bigint/test.f.js

@@ -1,4 +1,4 @@
-import { sum, abs, serialize, log2, bitLength, mask, min } from "./module.f.js";
+import { sum, abs, serialize, log2, bitLength, mask, min, combination, factorial } from "./module.f.js";
 const oldLog2 = (v) => {
     if (v <= 0n) {
         return -1n;
@@ -64,6 +64,50 @@ export const clz32Log2 = (v) => {
     }
     return result - BigInt(Math.clz32(Number(v)));
 };
+const m1023log2 = (v) => {
+    if (v <= 0n) {
+        return -1n;
+    }
+    //
+    // 1. Fast Doubling.
+    //
+    let result = -1n;
+    // `bigints` higher than 2**1023 may lead to `Inf` during conversion to `number`.
+    // For example: `Number((1n << 1024n) - (1n << 970n)) === Inf`.
+    let i = 1023n;
+    while (true) {
+        const n = v >> i;
+        if (n === 0n) {
+            // overshot
+            break;
+        }
+        v = n;
+        result += i;
+        i <<= 1n;
+    }
+    //
+    // 2. Binary Search.
+    //
+    // We know that `v` is not 0 so it doesn't make sense to check `n` when `i` is 0.
+    // Because of this, We check if `i` is greater than 1023 before we divide it by 2.
+    while (i !== 1023n) {
+        i >>= 1n;
+        const n = v >> i;
+        if (n !== 0n) {
+            result += i;
+            v = n;
+        }
+    }
+    //
+    // 3. Remainder Phase.
+    //
+    // We know that `v` is less than `1n << 1023` so we can calculate a remainder using
+    // `Math.log2`.
+    const rem = BigInt(Math.log2(Number(v)) | 0);
+    // (v >> rem) is either `0` or `1`, and it's used as a correction for
+    // Math.log2 rounding.
+    return result + rem + (v >> rem);
+};
 const benchmark = f => () => {
     let e = 1048575n;
     let c = 1n << e;
@@ -130,14 +174,19 @@ export default {
         if (m !== 3n) {
             throw m;
         }
+        const c = combination(3n, 2n, 1n); // 60n
+        if (c !== 60n) {
+            throw c;
+        }
     },
     benchmark: () => {
         const list = {
-            strBinLog2,
-            strHexLog2,
+            // strBinLog2,
+            // strHexLog2,
             str32Log2,
-            oldLog2,
-            clz32Log2,
+            // oldLog2,
+            // clz32Log2,
+            // m1023log2,
             log2,
         };
         const transform = (b) => Object.fromEntries(Object.entries(list).map(([k, f]) => [k, b(f)]));
@@ -346,5 +395,61 @@ export default {
                 }
             },
         ]
+    },
+    factorial: () => {
+        {
+            const r = factorial(3n);
+            if (r !== 6n) {
+                throw r;
+            }
+        }
+        {
+            const r = factorial(5n);
+            if (r !== 120n) {
+                throw r;
+            }
+        }
+    },
+    combination: () => {
+        const r = combination(2n, 3n);
+        if (r != 120n / (2n * 6n)) {
+            throw r;
+        }
+    },
+    combination50x50: () => {
+        {
+            const r = combination(1n, 1n);
+            if (r !== 2n) {
+                throw r;
+            }
+        }
+        {
+            const r = combination(2n, 2n);
+            if (r !== 6n) {
+                throw r;
+            }
+        }
+        {
+            const r = combination(3n, 3n);
+            if (r !== 20n) {
+                throw r;
+            }
+        }
+        {
+            const r = combination(4n, 4n);
+            if (r !== 70n) {
+                throw r;
+            }
+        }
+    },
+    combination3: () => {
+        const r = combination(2n, 3n, 4n, 2n);
+        // 2! * 3! * 4! * 2! : 2! * 2! * 3!
+        // 2+3+4+2 = 5*6*7*8*9*10*11
+        // e = 5 * 6 * 7 * 8 * 9 * 10 * 11 / (2n * 2n * 6n) =
+        // e = 5     * 7 * 2 * 9 * 10 * 11 = 69300
+        if (r !== 69300n) {
+            throw r;
+        }
     }
 };

package/types/bit_vec/module.f.d.ts

@@ -6,7 +6,7 @@ export type Vec = bigint;
 /**
  * An empty vector of bits.
  */
-export declare const empty = 1n;
+export declare const empty: Vec;
 /**
  * Calculates the length of the given vector of bits.
  */

package/types/number/module.f.d.ts

@@ -4,3 +4,7 @@ export declare const sum: (input: List<number>) => number;
 export declare const min: (input: List<number>) => number | null;
 export declare const max: (input: List<number>) => number | null;
 export declare const cmp: (a: number) => (b: number) => Sign;
+/**
+ * Count a number of ones in 32 bit number
+ */
+export declare const countOnes: (n: number) => number;

package/types/number/module.f.js

@@ -5,3 +5,19 @@ export const sum = reduce(addition)(0);
 export const min = reduce(minOp)(null);
 export const max = reduce(maxOp)(null);
 export const cmp = unsafeCmp;
+const mo = [
+    [0x5555_5555, 1],
+    [0x3333_3333, 2],
+    [0x0F0F_0F0F, 4],
+    [0x00FF_00FF, 8],
+    [0x0000_FFFF, 16],
+];
+/**
+ * Count a number of ones in 32 bit number
+ */
+export const countOnes = (n) => {
+    for (const [mask, offset] of mo) {
+        n = (n & mask) + ((n >> offset) & mask);
+    }
+    return n;
+};

package/types/number/test.f.d.ts

@@ -7,5 +7,6 @@ declare const _default: {
     max: () => void;
     cmp: () => void;
     standard: () => void;
+    countOnes: (() => void)[];
 };
 export default _default;

package/types/number/test.f.js

@@ -1,4 +1,4 @@
-import { sum, min, max, cmp } from "./module.f.js";
+import { sum, min, max, cmp, countOnes } from "./module.f.js";
 export default {
     sum: () => {
         const result = sum([2, 3, 4, 5]);
@@ -34,7 +34,7 @@ export default {
     },
     standard: () => {
         const check = a => b => {
-            if (BigInt(Number(a)) != b) {
+            if (BigInt(Number(a)) !== b) {
                 throw [a, b];
             }
         };
@@ -119,5 +119,21 @@ export default {
         //      4_3210_FEDC_BA98_7654_3210_FEDC_BA98_7654_3210_FEDC_BA98_7654_3210_1234
         check(104002482718319358n)(104002482718319360n);
         check(142693895881191444n)(142693895881191440n);
-    }
+    },
+    countOnes: [
+        () => {
+            //                    1121 2231 = 5 + 8 = 13
+            const r = countOnes(0x1234_5678);
+            if (r !== 13) {
+                throw r;
+            }
+        },
+        () => {
+            //                    2232 3340 = 9 + 10 = 19
+            const r = countOnes(0x9ABC_DEF0);
+            if (r !== 19) {
+                throw r;
+            }
+        }
+    ]
 };