functionalscript 0.9.2 → 0.10.0

package/types/asn.1/test.f.js

@@ -0,0 +1,312 @@
+import { empty, length, listToVec, msb, uint, unpack, vec, vec8 } from "../bit_vec/module.f.js";
+import { asBase } from "../nominal/module.f.js";
+import { decodeRaw, decodeInteger, encodeRaw, encodeInteger, integer, encode, decode, constructedSequence, octetString, boolean, constructedSet } from "./module.f.js";
+const { concat, popFront: pop } = msb;
+const cat = listToVec(msb);
+const pop8 = pop(8n);
+const check = (tag, v, rest) => {
+    const s = encodeRaw([tag, v]);
+    const [[t0, v0], r] = decodeRaw(concat(s)(rest));
+    if (t0 !== tag) {
+        throw `t0: ${t0}`;
+    }
+    if (v0 !== v) {
+        throw `v0: ${asBase(v0)}`;
+    }
+    if (r !== rest) {
+        throw `r: ${asBase(r)}`;
+    }
+};
+const integerValueCheck = (i, v) => {
+    const v0 = encodeInteger(i);
+    if (v !== v0) {
+        throw `encode: ${asBase(v)}, ${asBase(v0)}`;
+    }
+    const i0 = decodeInteger(v);
+    if (i !== i0) {
+        throw [i, i0];
+    }
+};
+const ch0 = (r, v, rest) => {
+    const [r0, rest0] = decode(concat(v)(rest));
+    if (rest0 !== rest) {
+        throw `rest: ${asBase(rest0)}`;
+    }
+    const v0 = encode(r);
+    const v1 = encode(r0);
+    if (v !== v0) {
+        throw `encode: ${asBase(v)}, ${asBase(v0)}`;
+    }
+    if (v !== v1) {
+        throw `encode: ${asBase(v)}, ${asBase(v1)}`;
+    }
+};
+const ch = (r, v) => {
+    ch0(r, v, empty);
+    ch0(r, v, vec8(0x23n));
+    ch0(r, v, vec(16n)(0x2345n));
+};
+export default {
+    encodeSmall: () => {
+        const v = vec8(0x13n);
+        const x = encodeRaw([integer, v]);
+        const lx = length(x);
+        if (lx !== 24n) {
+            throw lx;
+        }
+        const [tag, x1] = pop8(x);
+        if (tag !== BigInt(integer)) {
+            throw tag;
+        }
+        const [len, x2] = pop8(x1);
+        if (len !== 1n) {
+            throw len;
+        }
+        const { length: intLen, uint } = unpack(x2);
+        if (intLen !== 8n) {
+            throw intLen;
+        }
+        if (uint !== 0x13n) {
+            throw uint;
+        }
+    },
+    encode7F: () => {
+        const valueLen = 0x7fn << 3n;
+        const value = 0x1234n;
+        const v = vec(valueLen)(value);
+        const x = encodeRaw([integer, v]);
+        const lx = length(x);
+        if (lx !== 0x81n << 3n) {
+            throw lx;
+        }
+        const [tag, x1] = pop8(x);
+        if (tag !== BigInt(integer)) {
+            throw tag;
+        }
+        const [len, x2] = pop8(x1);
+        if (len !== 0x7fn) {
+            throw len;
+        }
+        const { length: intLen, uint } = unpack(x2);
+        if (intLen !== valueLen) {
+            throw intLen;
+        }
+        if (uint !== value) {
+            throw uint;
+        }
+    },
+    encode80: () => {
+        const valueLen = 0x80n << 3n;
+        const value = 0x123456n;
+        const v = vec(valueLen)(value);
+        const x = encodeRaw([integer, v]);
+        const lx = length(x);
+        if (lx !== 0x83n << 3n) {
+            throw lx;
+        }
+        const [tag, x1] = pop8(x);
+        if (tag !== BigInt(integer)) {
+            throw tag;
+        }
+        const [lenLen, x2] = pop8(x1);
+        if (lenLen !== 0x81n) {
+            throw lenLen;
+        }
+        const [len, x3] = pop8(x2);
+        if (len !== 0x80n) {
+            throw len;
+        }
+        const { length: intLen, uint } = unpack(x3);
+        if (intLen !== valueLen) {
+            throw intLen;
+        }
+        if (uint !== value) {
+            throw uint;
+        }
+    },
+    encodeFF: () => {
+        const valueLen = 0xffn << 3n;
+        const value = 0x123456n;
+        const v = vec(valueLen)(value);
+        const x = encodeRaw([integer, v]);
+        const lx = length(x);
+        if (lx !== valueLen + (3n << 3n)) {
+            throw `lx: ${lx}`;
+        }
+        const [tag, x1] = pop8(x);
+        if (tag !== BigInt(integer)) {
+            throw tag;
+        }
+        const [lenLen, x2] = pop8(x1);
+        if (lenLen !== 0x81n) {
+            throw lenLen;
+        }
+        const [len, x3] = pop8(x2);
+        if (len !== 0xffn) {
+            throw len;
+        }
+        const { length: intLen, uint } = unpack(x3);
+        if (intLen !== valueLen) {
+            throw intLen;
+        }
+        if (uint !== value) {
+            throw uint;
+        }
+    },
+    encode103: () => {
+        const valueLen = 0x103n << 3n;
+        const value = 0x123456n;
+        const v = vec(valueLen)(value);
+        const x = encodeRaw([integer, v]);
+        const lx = length(x);
+        if (lx !== valueLen + (4n << 3n)) {
+            throw `lx: ${lx}`;
+        }
+        const [tag, x1] = pop8(x);
+        if (tag !== BigInt(integer)) {
+            throw tag;
+        }
+        const [lenLen, x2] = pop8(x1);
+        if (lenLen !== 0x82n) {
+            throw lenLen;
+        }
+        const [len, x3] = pop(16n)(x2);
+        if (len !== 0x103n) {
+            throw len;
+        }
+        const { length: intLen, uint } = unpack(x3);
+        if (intLen !== valueLen) {
+            throw intLen;
+        }
+        if (uint !== value) {
+            throw uint;
+        }
+    },
+    ed: [
+        () => {
+            const tag = integer;
+            const v = vec(0x10n)(0x8234n);
+            if (asBase(v) !== 0x8234n) {
+                throw asBase(v).toString(16);
+            }
+            check(integer, v, empty);
+        },
+        {
+            x80: () => check(integer, vec(0x80n)(0x8234n), empty),
+            x100: () => check(integer, vec(0x100n)(0x8234n), vec8(0x23n)),
+            x1000: () => check(integer, vec(0x1000n)(0x8234n), vec8(0x23n)),
+            x10000: () => check(integer, vec(0x10000n)(0x8234n), vec8(0x23n)),
+            x20000: () => check(integer, vec(0x20000n)(0x8234n), vec8(0x23n)),
+            x40000: () => check(integer, vec(0x40000n)(0x8234n), empty),
+            x80000: () => check(integer, vec(0x80000n)(0x8234n), empty),
+            xC0000: () => check(integer, vec(0xc0000n)(0x8234n), empty),
+            xE0000: () => check(integer, vec(0xe0000n)(0x8234n), empty),
+            xF0000: () => check(integer, vec(0xf0000n)(0x8234n), empty),
+            xFFF00: () => check(integer, vec(0xfff00n)(0x8234n), empty),
+            xFFF80: () => check(integer, vec(0xfff80n)(0x8234n), empty),
+            xFFFC0: () => check(integer, vec(0xfffc0n)(0x8234n), empty),
+            xFFFD0: () => check(integer, vec(0xfffd0n)(0x8234n), empty),
+            //// fail on Bun because it has a smaller limit for BigInt
+            //xFFFD8: () => check(integer, vec(0xF_FFD8n)(0x8234n), empty),
+            //xFFFE0: () => check(integer, vec(0xF_FFE0n)(0x8234n), empty),
+            //e100000: () => check(integer, vec(0x10_0000n)(0x8234n), empty),
+            //x100000: () => check(integer, vec(0x10_0000n)(0x8234n), vec8(0x23n)),
+            //x1000000: () => check(integer, vec(0x100_0000n)(0x8234n), vec8(0x23n)),
+            //x10000000: () => check(integer, vec(0x1000_0000n)(0x8234n), vec8(0x23n)),
+            //x20000000: () => check(integer, vec(0x2000_0000n)(0x8234n), vec8(0x23n)),
+            //x30000000: () => check(integer, vec(0x3000_0000n)(0x8234n), vec8(0x23n)),
+            //x38000000: () => check(integer, vec(0x3800_0000n)(0x8234n), vec8(0x23n)),
+            //x3C000000: () => check(integer, vec(0x3800_0000n)(0x8234n), vec8(0x23n)),
+            //x3E000000: () => check(integer, vec(0x3E00_0000n)(0x8234n), vec8(0x23n)),
+            //x3F000000: () => check(integer, vec(0x3F00_0000n)(0x8234n), vec8(0x23n)),
+            //x3F800000: () => check(integer, vec(0x3F80_0000n)(0x8234n), vec8(0x23n)),
+            //x3FFFFFC0: () => check(integer, vec(0x3FFF_FFC0n)(0x8234n), vec8(0x23n)),
+            //e3FFFFFC8: () => check(integer, vec(0x3FFF_FFC8n)(0x8234n), empty),
+            //// fail on Node
+            //x3FFFFFC8: () => check(integer, vec(0x3FFF_FFC1n)(0x8234n), vec8(0x23n)),
+            //x40000000: () => check(integer, vec(0x4000_0000n)(0x8234n), vec8(0x23n)),
+            // check(integer, vec(0x1_0000_0000n)(0x8234n), vec8(0x23n))
+        },
+    ],
+    integerValue: {
+        zero: () => integerValueCheck(0n, vec8(0n)),
+        one: () => integerValueCheck(1n, vec8(1n)),
+        minusOne: () => integerValueCheck(-1n, vec8(0xffn)),
+        x7F: () => integerValueCheck(0x7fn, vec8(0x7fn)),
+        x80: () => integerValueCheck(0x80n, vec(16n)(0x80n)),
+        xFF: () => integerValueCheck(0xffn, vec(16n)(0xffn)),
+        nx7F: () => integerValueCheck(-0x7fn, vec8(0x81n)),
+        nx80: () => integerValueCheck(-0x80n, vec8(0x80n)),
+        nx81: () => integerValueCheck(-0x81n, vec(16n)(0xff7fn)),
+        nx7FFF: () => integerValueCheck(-0x7fffn, vec(16n)(0x8001n)),
+        nx8000: () => integerValueCheck(-0x8000n, vec(16n)(0x8000n)),
+        nx8001: () => integerValueCheck(-0x8001n, vec(24n)(0xff7fffn)),
+    },
+    encodeDecode: {
+        integer: () => {
+            ch([integer, 0n], cat([vec8(BigInt(integer)), vec8(1n), vec8(0n)]));
+            ch([integer, 1n], cat([vec8(BigInt(integer)), vec8(1n), vec8(1n)]));
+        },
+        sequence: () => {
+            ch([constructedSequence, []], cat([vec8(BigInt(constructedSequence)), vec8(0n)]));
+            ch([constructedSequence, [[integer, 0n]]], cat([vec8(BigInt(constructedSequence)), vec8(3n), encode([integer, 0n])]));
+            ch([constructedSequence, [[integer, 1n], [integer, 2n]]], cat([
+                vec8(BigInt(constructedSequence)),
+                vec8(6n),
+                encode([integer, 1n]),
+                encode([integer, 2n])
+            ]));
+            ch([constructedSequence, [[octetString, vec8(0x23n)], [boolean, true], [boolean, false]]], cat([
+                vec8(BigInt(constructedSequence)),
+                vec8(9n),
+                encode([octetString, vec8(0x23n)]),
+                encode([boolean, true]),
+                encode([boolean, false]),
+            ]));
+        },
+        set: () => {
+            ch([constructedSet, [[integer, 2n], [integer, 1n]]], cat([
+                vec8(BigInt(constructedSet)),
+                vec8(6n),
+                encode([integer, 1n]),
+                encode([integer, 2n])
+            ]));
+        },
+    },
+    raw: [
+        () => {
+            const e = encodeRaw([0x00n, vec8(0x23n)]);
+            if (e !== cat([vec8(0x00n), vec8(1n), vec8(0x23n)])) {
+                throw `encode: ${length(e)}: ${uint(e).toString(2)}`;
+            }
+            const [[tag, value], rest] = decodeRaw(e);
+            if (rest !== empty) {
+                throw `rest: ${asBase(rest)}`;
+            }
+            if (tag !== 0x00n) {
+                throw `tag: ${tag}`;
+            }
+            if (value !== vec8(0x23n)) {
+                throw `value: ${asBase(value)}`;
+            }
+        },
+        () => {
+            const e = encodeRaw([0x1f20n, vec(16n)(0x1234n)]);
+            if (e !== cat([vec8(0x1fn), vec8(0x20n), vec8(2n), vec(16n)(0x1234n)])) {
+                const l = length(e);
+                const u = uint(e);
+                throw `encode: ${l}: ${u.toString(16)}`;
+            }
+            const [[tag, value], rest] = decodeRaw(e);
+            if (rest !== empty) {
+                throw `rest: ${asBase(rest)}`;
+            }
+            if (tag !== 0x1f20n) {
+                throw `tag: ${tag}`;
+            }
+            if (value !== vec(16n)(0x1234n)) {
+                throw `value: ${asBase(value)}`;
+            }
+        }
+    ]
+};

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

@@ -0,0 +1,20 @@
+/**
+ * Base-128 encoding and decoding utilities over bit vectors.
+ *
+ * @module
+ */
+import { type Vec } from '../bit_vec/module.f.ts';
+/**
+ * Encodes a bigint into an MSB Base128 vector.
+ *
+ * @param uint The bigint to encode.
+ * @returns The encoded MSB Base128 vector.
+ */
+export declare const encode: (uint: bigint) => Vec;
+/**
+ * Decodes an MSB Base128 vector into a bigint.
+ *
+ * @param v The MSB Base128 vector to decode.
+ * @returns A tuple containing the decoded bigint and the remaining vector.
+ */
+export declare const decode: (v: Vec) => readonly [bigint, Vec];

package/types/base128/module.f.js

@@ -0,0 +1,43 @@
+/**
+ * Base-128 encoding and decoding utilities over bit vectors.
+ *
+ * @module
+ */
+import { vec8, msb, empty } from "../bit_vec/module.f.js";
+const { concat, popFront } = msb;
+const pop8 = popFront(8n);
+/**
+ * Encodes a bigint into an MSB Base128 vector.
+ *
+ * @param uint The bigint to encode.
+ * @returns The encoded MSB Base128 vector.
+ */
+export const encode = (uint) => {
+    let result = empty;
+    while (true) {
+        const item = uint & 0x7fn;
+        const flag = result === empty ? 0n : 0x80n;
+        result = concat(vec8(flag | item))(result);
+        uint >>= 7n;
+        if (uint === 0n) {
+            return result;
+        }
+    }
+};
+/**
+ * Decodes an MSB Base128 vector into a bigint.
+ *
+ * @param v The MSB Base128 vector to decode.
+ * @returns A tuple containing the decoded bigint and the remaining vector.
+ */
+export const decode = (v) => {
+    let result = 0n;
+    while (true) {
+        const [byte, rest] = pop8(v);
+        result = (result << 7n) | (byte & 0x7fn);
+        if (byte < 0x80n) {
+            return [result, rest];
+        }
+        v = rest;
+    }
+};

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

@@ -0,0 +1,2 @@
+declare const _default: () => void;
+export default _default;

package/types/base128/test.f.js

@@ -0,0 +1,26 @@
+import { empty, vec, vec8 } from "../bit_vec/module.f.js";
+import { asBase } from "../nominal/module.f.js";
+import { encode, decode } from "./module.f.js";
+const test = (a, b) => {
+    const encoded = encode(a);
+    if (encoded !== b) {
+        throw `encoded: ${asBase(encoded).toString(16)}, expected: ${asBase(b).toString(16)}`;
+    }
+    const [decoded, rest] = decode(b);
+    if (decoded !== a) {
+        throw `decoded: ${decoded.toString(16)}, expected: ${a.toString(16)}`;
+    }
+    if (rest !== empty) {
+        throw `rest: ${asBase(rest).toString(16)}, expected: ${asBase(empty).toString(16)}`;
+    }
+};
+export default () => {
+    test(0n, vec8(0n));
+    test(1n, vec8(1n));
+    test(0x7fn, vec8(0x7fn));
+    test(0x80n, vec(16n)(0x8100n));
+    test(0x81n, vec(16n)(0x8101n));
+    test(0x82n, vec(16n)(0x8102n));
+    test(0x3fffn, vec(16n)(0xff7fn));
+    test(0x4000n, vec(24n)(0x818000n));
+};

package/types/bigfloat/module.f.js

@@ -1,3 +1,8 @@
+/**
+ * Big-float helpers built from bigint mantissa and exponent parts.
+ *
+ * @module
+ */
 import { abs, sign } from "../bigint/module.f.js";
 const twoPow53 = 9007199254740992n;
 const twoPow54 = 18014398509481984n;

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

@@ -1,6 +1,7 @@
-import type { Fold, Reduce as OpReduce } from "../function/operator/module.f.ts";
-import { type List, type Thunk } from "../list/module.f.ts";
-import { type Nominal } from "../nominal/module.f.ts";
+import type { Fold, Reduce as OpReduce } from '../function/operator/module.f.ts';
+import { type List, type Thunk } from '../list/module.f.ts';
+import { type Nominal } from '../nominal/module.f.ts';
+import { type Sign } from '../function/compare/module.f.ts';
 /**
  * A vector of bits represented as a signed `bigint`.
  */
@@ -186,3 +187,13 @@ export declare const listToVec: ({ concat }: BitOrder) => (list: List<Vec>) => V
  */
 export declare const repeat: Fold<bigint, Vec>;
 export declare const isVec: <T>(v: Vec | T) => v is Vec;
+/**
+ * Lexically compares two vectors based on their unsigned integer values,
+ * normalizing them to the same length. If the values are equal,
+ * the shorter vector is considered smaller.
+ *
+ * a < b => -1
+ * a > b => 1
+ * a === b => 0
+ */
+export declare const msbCmp: (av: Vec) => (bv: Vec) => Sign;

package/types/bit_vec/module.f.js

@@ -21,11 +21,12 @@
  *
  * @module
  */
-import { abs, bitLength, mask, max, xor } from "../bigint/module.f.js";
+import { bitLength, mask, max, min, xor } from "../bigint/module.f.js";
 import { flip } from "../function/module.f.js";
 import { fold } from "../list/module.f.js";
 import { asBase, asNominal } from "../nominal/module.f.js";
 import { repeat as mRepeat } from "../monoid/module.f.js";
+import { cmp } from "../function/compare/module.f.js";
 /**
  * An empty vector of bits.
  */
@@ -55,7 +56,7 @@ export const vec = (len) => {
     const lastBit = 1n << last;
     return ui => {
         // normalize `u`
-        const u = m & abs(ui);
+        const u = m & ui;
         //
         const sign = u >> last;
         const x = sign !== 0n ? u : -(u ^ lastBit);
@@ -203,3 +204,21 @@ export const listToVec = ({ concat }) => fold(flip(concat))(empty);
  */
 export const repeat = mRepeat({ identity: empty, operation: lsb.concat });
 export const isVec = (v) => typeof v === 'bigint';
+/**
+ * Lexically compares two vectors based on their unsigned integer values,
+ * normalizing them to the same length. If the values are equal,
+ * the shorter vector is considered smaller.
+ *
+ * a < b => -1
+ * a > b => 1
+ * a === b => 0
+ */
+export const msbCmp = (av) => (bv) => {
+    const au = unpack(av);
+    const bu = unpack(bv);
+    const al = au.length;
+    const bl = bu.length;
+    const { a, b } = msbNorm(au)(bu)(min(al)(bl));
+    const result = cmp(a)(b);
+    return result !== 0 ? result : cmp(al)(bl);
+};

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

@@ -37,5 +37,6 @@ declare const _default: {
     lsbXor: () => void;
     msbXor: () => void;
     repeat: () => void;
+    msbCmp: () => void;
 };
 export default _default;

package/types/bit_vec/test.f.js

@@ -1,6 +1,6 @@
-import { abs, mask } from "../bigint/module.f.js";
+import { mask } from "../bigint/module.f.js";
 import { asBase, asNominal } from "../nominal/module.f.js";
-import { length, empty, uint, vec, lsb, msb, repeat, vec8 } from "./module.f.js";
+import { length, empty, uint, vec, lsb, msb, repeat, vec8, msbCmp } from "./module.f.js";
 const unsafeVec = (a) => asNominal(a);
 // 0x8 = 0b1000 = 0 + 8
 // 0x9 = 0b1001 = 1 + 8
@@ -347,16 +347,16 @@ export default {
             const v = vec(len)(ui);
             const x = asBase(v);
             if (x !== raw) {
-                throw x;
+                throw `x: ${x}, raw: ${raw}`;
             }
             const len2 = length(v);
             if (len2 !== len) {
                 throw len2;
             }
             const u = uint(v);
-            const mui = mask(len) & abs(ui);
+            const mui = mask(len) & ui;
             if (u !== mui) {
-                throw u;
+                throw [u, mui];
             }
         };
         // 0n
@@ -373,7 +373,15 @@ export default {
             () => c(2n)(1n)(-3n),
             () => c(2n)(2n)(2n),
             () => c(2n)(3n)(3n),
-            () => c(2n)(-7n)(3n), //< overflow
+            // -1 is 0b.....1
+            // -2 is 0b....10
+            // -3 is 0b...101
+            // -4 is 0b...100
+            // -5 is 0b..1011
+            // -6 is 0b..1010
+            // -7 is 0b..1011, cut 0b11, vec: -0b11
+            // -8 is 0b..1100 = ~(8-1) = ~7
+            () => c(2n)(-7n)(-3n), //< overflow.
         ];
     },
     concat2: () => {
@@ -420,5 +428,19 @@ export default {
         if (repeat(7n)(vec(5n)(0x13n)) !== vec(35n)(21059194483n)) {
             throw 'repeat failed';
         }
+    },
+    msbCmp: () => {
+        const c = (a) => (b) => (r) => {
+            const result = msbCmp(a)(b);
+            if (result !== r) {
+                throw `result: ${result}, expected: ${r}`;
+            }
+        };
+        c(vec(4n)(0x5n))(vec(4n)(0x5n))(0); // 0b0101 == 0b0101
+        c(vec(4n)(0x5n))(vec(4n)(0x6n))(-1); // 0b0101 < 0b0110
+        c(vec(4n)(0x6n))(vec(4n)(0x5n))(1); // 0b0110 > 0b0101
+        c(vec(4n)(0x5n))(vec(5n)(0x5n))(1); // 0b0101_ < 0b00101
+        c(vec(5n)(0x5n))(vec(4n)(0x5n))(-1); // 0b00101 < 0b0101_
+        c(vec(4n)(0x5n))(vec(5n)(0xan))(-1); // 0b0101_ < 0b01010
     }
 };

package/types/btree/find/module.f.d.ts

@@ -1,3 +1,8 @@
+/**
+ * Lookup operations for persistent B-tree structures.
+ *
+ * @module
+ */
 import type { Leaf1, Leaf2, Branch3, Branch5, TNode } from '../types/module.f.ts';
 import type { List } from '../../list/module.f.ts';
 import { type Compare } from '../../function/compare/module.f.ts';

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

@@ -1,3 +1,8 @@
+/**
+ * Core persistent B-tree construction and traversal helpers.
+ *
+ * @module
+ */
 import { type List } from '../list/module.f.ts';
 import type { Tree } from './types/module.f.ts';
 export declare const empty: null;

package/types/btree/module.f.js

@@ -1,3 +1,8 @@
+/**
+ * Core persistent B-tree construction and traversal helpers.
+ *
+ * @module
+ */
 import { flat } from "../list/module.f.js";
 import { map } from "../nullable/module.f.js";
 const nodeValues = node => () => {

package/types/btree/remove/module.f.d.ts

@@ -1,3 +1,8 @@
+/**
+ * Removal operations for persistent B-tree structures.
+ *
+ * @module
+ */
 import type { TNode, Tree } from '../types/module.f.ts';
 import type { Compare } from '../../function/compare/module.f.ts';
 export declare const nodeRemove: <T>(c: Compare<T>) => (node: TNode<T>) => Tree<T>;

package/types/btree/set/module.f.d.ts

@@ -1,3 +1,8 @@
+/**
+ * Insertion and update operations for persistent B-tree structures.
+ *
+ * @module
+ */
 import type { TNode, Tree } from '../types/module.f.ts';
 import type { Compare } from '../../function/compare/module.f.ts';
 export declare const set: <T>(c: Compare<T>) => (f: (value: T | null) => T) => (tree: Tree<T>) => TNode<T>;

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

@@ -1,3 +1,8 @@
+/**
+ * Shared type definitions for persistent B-tree modules.
+ *
+ * @module
+ */
 import type { Array1, Array2 } from '../../array/module.f.ts';
 export type Leaf1<T> = Array1<T>;
 export type Leaf2<T> = Array2<T>;

package/types/byte_set/module.f.js

@@ -1,3 +1,8 @@
+/**
+ * Compact byte-set operations and predicates.
+ *
+ * @module
+ */
 import { compose } from "../function/module.f.js";
 import { reverse, countdown, flat, map } from "../list/module.f.js";
 export const has = n => s => ((s >> BigInt(n)) & 1n) === 1n;

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

@@ -1,3 +1,8 @@
+/**
+ * Content-addressable Base32 encoding and decoding helpers.
+ *
+ * @module
+ */
 import { type Vec } from "../bit_vec/module.f.ts";
 import type { Nullable } from "../nullable/module.f.ts";
 export declare const vec5xToCBase32: (v: Vec) => string;

package/types/cbase32/module.f.js

@@ -1,3 +1,8 @@
+/**
+ * Content-addressable Base32 encoding and decoding helpers.
+ *
+ * @module
+ */
 import { msb, lsb, length, vec, empty } from "../bit_vec/module.f.js";
 //                         0123456789abcdef
 const m = '0123456789abcdefghjkmnpqrstvwxyz';

package/types/effect/mock/module.f.d.ts

@@ -1,3 +1,8 @@
+/**
+ * Mock effect runtimes for testing effectful programs.
+ *
+ * @module
+ */
 import type { Effect, Operations } from "../module.f.ts";
 export type MemOperationMap<O extends Operations, S> = {
     readonly [K in keyof O]: (state: S, payload: O[K][0]) => readonly [S, O[K][1]];

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

@@ -1,3 +1,8 @@
+/**
+ * Core effect type constructors and combinators.
+ *
+ * @module
+ */
 export type Operations = {
     readonly [command in string]: readonly [input: unknown, output: unknown];
 };