functionalscript 0.1.594 → 0.1.597

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "functionalscript",
-  "version": "0.1.594",
+  "version": "0.1.597",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "index.f.mjs",
   "scripts": {
+    "tscp": "tsc --declaration --emitDeclarationOnly --noEmit false",
     "tsc": "tsc",
     "test": "tsc && npm run test-only",
     "index": "node ./dev/index.mjs",

package/prime_field/module.f.d.mts

@@ -0,0 +1,44 @@
+declare namespace _default {
+    export { prime_field };
+    export let sqrt: (f: PrimeField) => (a: bigint) => bigint | null;
+}
+export default _default;
+export type Reduce = Operator.Reduce<bigint>;
+export type Unary = Operator.Unary<bigint, bigint>;
+export type PrimeField = {
+    readonly p: bigint;
+    readonly middle: bigint;
+    readonly max: bigint;
+    readonly neg: Unary;
+    readonly sub: Reduce;
+    readonly add: Reduce;
+    readonly abs: Unary;
+    readonly mul: Reduce;
+    readonly reciprocal: Unary;
+    readonly div: Reduce;
+    readonly pow: Reduce;
+    readonly pow2: Unary;
+    readonly pow3: Unary;
+};
+/** @typedef {Operator.Reduce<bigint>} Reduce */
+/** @typedef {Operator.Unary<bigint, bigint>} Unary*/
+/**
+ * @typedef {{
+ *  readonly p: bigint
+ *  readonly middle: bigint
+ *  readonly max: bigint
+ *  readonly neg: Unary
+ *  readonly sub: Reduce
+ *  readonly add: Reduce
+ *  readonly abs: Unary
+ *  readonly mul: Reduce
+ *  readonly reciprocal: Unary
+ *  readonly div: Reduce
+ *  readonly pow: Reduce
+ *  readonly pow2: Unary
+ *  readonly pow3: Unary
+ * }} PrimeField
+ */
+/** @type {(p: bigint) => PrimeField} */
+declare const prime_field: (p: bigint) => PrimeField;
+import * as Operator from '../types/function/operator/module.f.mjs';

package/prime_field/test.f.d.mts

@@ -0,0 +1,12 @@
+declare namespace _default {
+    function prime_field_test(): {
+        neg: () => void;
+        sub: () => void;
+        add: () => void;
+        mul: () => void;
+        reciprocal: () => void;
+        pow: () => void;
+        sqrt: () => void;
+    };
+}
+export default _default;

package/secp/module.f.d.mts

@@ -0,0 +1,49 @@
+declare namespace _default {
+    export { curve };
+    export let eq: (a: Point) => (b: Point) => boolean;
+    export let secp256k1: Init;
+    export let secp192r1: Init;
+}
+export default _default;
+export type Point2D = readonly [bigint, bigint];
+export type Point = Point2D | null;
+export type Init = {
+    readonly p: bigint;
+    readonly a: readonly [bigint, bigint];
+    readonly g: readonly [bigint, bigint];
+    readonly n: bigint;
+};
+export type Curve = {
+    readonly pf: Pf.PrimeField;
+    readonly nf: Pf.PrimeField;
+    readonly y2: (x: bigint) => bigint;
+    readonly y: (x: bigint) => bigint | null;
+    readonly neg: (a: Point) => Point;
+    readonly add: Operator.Reduce<Point>;
+    readonly mul: (a: Point) => (n: bigint) => Point;
+};
+/** @typedef {readonly[bigint, bigint]} Point2D */
+/** @typedef {Point2D|null} Point */
+/**
+ * @typedef {{
+ *  readonly p: bigint
+ *  readonly a: readonly[bigint, bigint]
+ *  readonly g: readonly[bigint, bigint]
+ *  readonly n: bigint
+ * }} Init
+ */
+/**
+ * @typedef {{
+ *  readonly pf: Pf.PrimeField
+ *  readonly nf: Pf.PrimeField
+ *  readonly y2: (x: bigint) => bigint
+ *  readonly y: (x: bigint) => bigint|null
+ *  readonly neg: (a: Point) => Point
+ *  readonly add: Operator.Reduce<Point>
+ *  readonly mul: (a: Point) => (n: bigint) => Point
+ * }} Curve
+ */
+/** @type {(i: Init) => Curve} */
+declare const curve: (i: Init) => Curve;
+import * as Pf from '../prime_field/module.f.mjs';
+import * as Operator from '../types/function/operator/module.f.mjs';

package/secp/module.f.mjs

@@ -1,5 +1,5 @@
-import * as op from '../types/function/operator/module.f.mjs'
-import pf, * as pfT from '../prime_field/module.f.mjs'
+import * as Operator from '../types/function/operator/module.f.mjs'
+import pf, * as Pf from '../prime_field/module.f.mjs'
 import bi from '../types/bigint/module.f.mjs'
 const { scalar_mul } = bi
 const { prime_field, sqrt } = pf
@@ -19,12 +19,12 @@ const { prime_field, sqrt } = pf
 
 /**
  * @typedef {{
- *  readonly pf: pfT.PrimeField
- *  readonly nf: pfT.PrimeField
+ *  readonly pf: Pf.PrimeField
+ *  readonly nf: Pf.PrimeField
  *  readonly y2: (x: bigint) => bigint
  *  readonly y: (x: bigint) => bigint|null
  *  readonly neg: (a: Point) => Point
- *  readonly add: op.Reduce<Point>
+ *  readonly add: Operator.Reduce<Point>
  *  readonly mul: (a: Point) => (n: bigint) => Point
  * }} Curve
  */
@@ -41,7 +41,7 @@ const curve = ({ p, a: [a0, a1], n }) => {
     // y**2 = a1*x**3 + a0
     /** @type {(x: bigint) => bigint} */
     const y2 = x => addA0(add(pow3(x))(mulA1(x)))
-    /** @type {op.Reduce<Point>} */
+    /** @type {Operator.Reduce<Point>} */
     const addPoint = p => q => {
         if (p === null) {
             return q

package/secp/test.f.d.mts

@@ -0,0 +1,4 @@
+declare namespace _default {
+    function test(): void;
+}
+export default _default;

package/secp/test.f.mjs

@@ -1,13 +1,13 @@
-import mt, * as mT from './module.f.mjs'
-const { curve, secp256k1, secp192r1, eq } = mt
+import _, * as T from './module.f.mjs'
+const { curve, secp256k1, secp192r1, eq } = _
 
 export default {
     test: () => {
-        /** @type {(c: mT.Init) => void} */
+        /** @type {(c: T.Init) => void} */
         const test_curve = c => {
             const { g } = c
             const { mul, neg, pf: { abs }, y: yf, nf: { p: n } } = curve(c)
-            /** @type {(p: mT.Point) => void} */
+            /** @type {(p: T.Point) => void} */
             const point_check = p => {
                 if (p === null) { throw 'null' }
                 const [x, y] = p
@@ -17,7 +17,7 @@ export default {
             }
             point_check(g)
             point_check(neg(g))
-            /** @type {(p: mT.Point) => void} */
+            /** @type {(p: T.Point) => void} */
             const test_mul = p => {
                 if (mul(p)(0n) !== null) { throw 'O' }
                 if (mul(p)(1n) !== p) { throw 'p' }

package/sha2/module.f.d.mts

@@ -0,0 +1,23 @@
+declare namespace _default {
+    export { padding };
+    export { computeSha256 };
+    export { computeSha224 };
+    export { compress256 };
+    export { compress224 };
+}
+export default _default;
+export type HashInput = {
+    readonly f: (i: number) => number;
+    readonly length: number;
+};
+export type Hash8 = arrayT.Array8<number>;
+export type Array16 = arrayT.Array16<number>;
+/** @type  {(input: readonly number[]) => (bits: number) => HashInput} */
+declare const padding: (input: readonly number[]) => (bits: number) => HashInput;
+/** @type {(input: readonly number[]) => (bitsCount: number) => Hash8} */
+declare const computeSha256: (input: readonly number[]) => (bitsCount: number) => Hash8;
+/** @type {(input: readonly number[]) => (bitsCount: number) => Hash8} */
+declare const computeSha224: (input: readonly number[]) => (bitsCount: number) => Hash8;
+declare const compress256: (data: Array16) => Hash8;
+declare const compress224: (data: Array16) => Hash8;
+import * as arrayT from '../types/array/module.f.mjs';

package/sha2/module.f.mjs

@@ -1,4 +1,4 @@
-import array, * as arrayT from '../types/array/module.f.mjs'
+import * as arrayT from '../types/array/module.f.mjs'
 
 /**
  * @typedef {{

package/sha2/test.f.d.mts

@@ -0,0 +1,10 @@
+declare namespace _default {
+    export namespace empty {
+        function sha256(): void;
+        function sha224(): void;
+    }
+    export let sha224compress: (() => void)[];
+    let sha256_1: (() => void)[];
+    export { sha256_1 as sha256 };
+}
+export default _default;

package/sha2/test.f.mjs

@@ -2,7 +2,6 @@ import _ from './module.f.mjs'
 import json, * as jsonT from '../json/module.f.mjs'
 import o from '../types/object/module.f.mjs'
 const { sort } = o
-import list from '../types/list/module.f.mjs'
 
 /** @type {(a: number) => number} */
 const toU32 = x => (x + 0x1_0000_0000) % 0x1_0000_0000

package/text/ascii/module.f.d.mts

@@ -0,0 +1,73 @@
+declare namespace _default {
+    export { one };
+    export { range };
+    export let backspace: number;
+    export let ht: number;
+    export let lf: number;
+    export let ff: number;
+    export let cr: number;
+    export let space: number;
+    export let exclamationMark: number;
+    export let quotationMark: number;
+    export let numberSign: number;
+    export let dollarSign: number;
+    export let percentSign: number;
+    export let ampersand: number;
+    export let apostrophe: number;
+    export let leftParenthesis: number;
+    export let rightParenthesis: number;
+    export let asterisk: number;
+    export let plusSign: number;
+    export let comma: number;
+    export let hyphenMinus: number;
+    export let fullStop: number;
+    export let solidus: number;
+    export let digitRange: Range.Range;
+    export let digit0: number;
+    export let digit1: number;
+    export let digit2: number;
+    export let digit3: number;
+    export let digit4: number;
+    export let digit5: number;
+    export let digit6: number;
+    export let digit7: number;
+    export let digit8: number;
+    export let digit9: number;
+    export let colon: number;
+    export let semicolon: number;
+    export let lessThanSign: number;
+    export let equalsSign: number;
+    export let greaterThanSign: number;
+    export let questionMark: number;
+    export let commercialAt: number;
+    export let latinCapitalLetterRange: Range.Range;
+    export let latinCapitalLetterA: number;
+    export let latinCapitalLetterE: number;
+    export let latinCapitalLetterF: number;
+    export let leftSquareBracket: number;
+    export let reverseSolidus: number;
+    export let rightSquareBracket: number;
+    export let circumflexAccent: number;
+    export let lowLine: number;
+    export let graveAccent: number;
+    export let latinSmallLetterRange: Range.Range;
+    export let latinSmallLetterA: number;
+    export let latinSmallLetterB: number;
+    export let latinSmallLetterE: number;
+    export let latinSmallLetterF: number;
+    export let latinSmallLetterN: number;
+    export let latinSmallLetterR: number;
+    export let latinSmallLetterT: number;
+    export let latinSmallLetterU: number;
+    export let latinSmallLetterZ: number;
+    export let leftCurlyBracket: number;
+    export let verticalLine: number;
+    export let rightCurlyBracket: number;
+    export let tilde: number;
+}
+export default _default;
+/** @type {(s: string) => number} */
+declare const one: (s: string) => number;
+/** @type {(s: string) => Range.Range} */
+declare const range: (s: string) => Range.Range;
+import * as Range from '../../types/range/module.f.mjs';

package/text/ascii/test.f.d.mts

@@ -0,0 +1,4 @@
+declare namespace _default {
+    function range(): void;
+}
+export default _default;

package/text/module.f.d.mts

@@ -0,0 +1,18 @@
+declare namespace _default {
+    export { flat };
+    export { curly };
+}
+export default _default;
+export type Block = ItemThunk | ItemArray;
+export type ItemArray = readonly Item[];
+export type ItemThunk = () => List.List<Item>;
+export type Item = string | ItemArray | ItemThunk;
+/** @typedef {ItemThunk|ItemArray} Block */
+/** @typedef {readonly Item[]} ItemArray */
+/** @typedef {() => List.List<Item>} ItemThunk */
+/** @typedef {string|ItemArray|ItemThunk} Item */
+/** @type {(indent: string) => (text: Block) => List.List<string>} */
+declare const flat: (indent: string) => (text: Block) => List.List<string>;
+/** @type {(type: string) => (name: string) => (body: Block) => Block} */
+declare const curly: (type: string) => (name: string) => (body: Block) => Block;
+import * as List from '../types/list/module.f.mjs';

package/text/sgr/module.f.d.mts

@@ -0,0 +1,14 @@
+declare namespace _default {
+    export { sgr };
+    export let reset: string;
+    export let bold: string;
+    export let fgRed: string;
+    export let fgGreen: string;
+}
+export default _default;
+/**
+ * https://en.wikipedia.org/wiki/ANSI_escape_code#SGR
+ *
+ * @type {(c: number) => string}
+ */
+declare const sgr: (c: number) => string;

package/text/test.f.d.mts

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

package/text/utf16/module.f.d.mts

@@ -0,0 +1,19 @@
+declare namespace _default {
+    export { fromCodePointList };
+    export { toCodePointList };
+    export { stringToList };
+    export { listToString };
+}
+export default _default;
+export type WordOrEof = u16 | null;
+export type Utf16State = number | null;
+export type u16 = number;
+export type i32 = number;
+declare const fromCodePointList: (input: List.List<number>) => List.Thunk<number>;
+/** @type {(input: List.List<u16>) => List.List<i32>} */
+declare const toCodePointList: (input: List.List<u16>) => List.List<i32>;
+/** @type {(s: string) => List.List<u16>} */
+declare const stringToList: (s: string) => List.List<u16>;
+/** @type {(input: List.List<u16>) => string} */
+declare const listToString: (input: List.List<u16>) => string;
+import * as List from '../../types/list/module.f.mjs';

package/text/utf16/test.f.d.mts

@@ -0,0 +1,6 @@
+declare namespace _default {
+    let toCodePointList: (() => void)[];
+    let fromCodePointList: (() => void)[];
+    let string: (() => void)[];
+}
+export default _default;

package/text/utf16/test.f.mjs

@@ -1,10 +1,10 @@
 import encoding from './module.f.mjs'
-import json, * as jsonT from '../../json/module.f.mjs'
+import json, * as Json from '../../json/module.f.mjs'
 import o from '../../types/object/module.f.mjs'
 const { sort } = o
 import list from '../../types/list/module.f.mjs'
 
-/** @type {(a: readonly jsonT.Unknown[]) => string} */
+/** @type {(a: readonly Json.Unknown[]) => string} */
 const stringify = a => json.stringify(sort)(a)
 
 export default {

package/text/utf8/module.f.d.mts

@@ -0,0 +1,15 @@
+declare namespace _default {
+    export { fromCodePointList };
+    export { toCodePointList };
+}
+export default _default;
+export type ByteOrEof = u8 | null;
+export type Utf8NonEmptyState = Array.Array1<number> | Array.Array2<number> | Array.Array3<number>;
+export type Utf8State = null | Utf8NonEmptyState;
+export type u8 = number;
+export type i32 = number;
+declare const fromCodePointList: (input: List.List<number>) => List.Thunk<number>;
+/** @type {(input: List.List<u8>) => List.List<i32>} */
+declare const toCodePointList: (input: List.List<u8>) => List.List<i32>;
+import * as Array from '../../types/array/module.f.mjs';
+import * as List from '../../types/list/module.f.mjs';

package/text/utf8/module.f.mjs

@@ -1,11 +1,11 @@
 import list, * as List from '../../types/list/module.f.mjs'
 import * as operator from '../../types/function/operator/module.f.mjs'
-import * as arrayT from '../../types/array/module.f.mjs'
+import * as Array from '../../types/array/module.f.mjs'
 const { flatMap, flat, stateScan } = list
 
 /** @typedef {u8|null} ByteOrEof */
 
-/** @typedef {arrayT.Array1<number>|arrayT.Array2<number>|arrayT.Array3<number>} Utf8NonEmptyState */
+/** @typedef {Array.Array1<number>|Array.Array2<number>|Array.Array3<number>} Utf8NonEmptyState */
 
 /** @typedef {null|Utf8NonEmptyState} Utf8State */
 

package/text/utf8/test.f.d.mts

@@ -0,0 +1,6 @@
+declare namespace _default {
+    let toCodePoint: (() => void)[];
+    let fromCodePointList: (() => void)[];
+    let toFrom: (() => void)[];
+}
+export default _default;

package/types/array/module.f.d.mts

@@ -0,0 +1,41 @@
+declare namespace _default {
+    export { at };
+    export { first };
+    export { last };
+    export { head };
+    export { tail };
+    export { splitFirst };
+    export { splitLast };
+}
+export default _default;
+export type Array1<T> = readonly [T];
+export type Index1 = 0;
+export type Array2<T> = readonly [T, T];
+export type Tuple2<T0, T1> = readonly [T0, T1];
+export type Index2 = 0 | 1;
+export type Array3<T> = readonly [T, T, T];
+export type Tuple3<T0, T1, T2> = readonly [T0, T1, T2];
+export type Index3 = 0 | 1 | 2;
+export type Array4<T> = readonly [T, T, T, T];
+export type Index4 = 0 | 1 | 2 | 3;
+export type Array5<T> = readonly [T, T, T, T, T];
+export type Array8<T> = readonly [T, T, T, T, T, T, T, T];
+export type Array16<T> = readonly [T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T];
+export type Index16 = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15;
+export type Array1_5<T> = Array1<T> | Array2<T> | Array3<T> | Array4<T> | Array5<T>;
+export type Index5 = 0 | 1 | 2 | 3 | 4;
+export type KeyOf<T> = T extends Array1<infer _> ? Index1 : T extends Array2<infer _> ? Index2 : T extends Array3<infer _> ? Index3 : T extends Array4<infer _> ? Index4 : T extends Array5<infer _> ? Index5 : T extends readonly (infer _)[] ? number : never;
+/** @type {(index: number) => <T>(a: readonly T[]) => T|null} */
+declare const at: (index: number) => <T>(a: readonly T[]) => T | null;
+/** @type {<T>(_: readonly T[]) => T|null} */
+declare const first: <T>(_: readonly T[]) => T | null;
+/** @type {<T>(_: readonly T[]) => T|null} */
+declare const last: <T>(_: readonly T[]) => T | null;
+/** @type {<T>(_: readonly T[]) => readonly T[]|null} */
+declare const head: <T>(_: readonly T[]) => readonly T[] | null;
+/** @type {<T>(_: readonly T[]) => readonly T[] | null} */
+declare const tail: <T>(_: readonly T[]) => readonly T[] | null;
+/** @type {<T>(_: readonly T[]) => readonly[T, readonly T[]]|null} */
+declare const splitFirst: <T>(_: readonly T[]) => readonly [T, readonly T[]] | null;
+/** @type {<T>(_: readonly T[]) => readonly[readonly T[], T]|null} */
+declare const splitLast: <T>(_: readonly T[]) => readonly [readonly T[], T] | null;

package/types/array/test.f.d.mts

@@ -0,0 +1,10 @@
+declare namespace _default {
+    function stringify(): void;
+    let at: (() => void)[];
+    let first: (() => void)[];
+    let last: (() => void)[];
+    let head: (() => void)[];
+    let tail: (() => void)[];
+    let splitFirst: (() => void)[];
+}
+export default _default;

package/types/bigfloat/module.f.d.mts

@@ -0,0 +1,11 @@
+declare namespace _default {
+    export { decToBin };
+    export { multiply };
+}
+export default _default;
+export type BigFloat = readonly [bigint, number];
+export type BigFloatWithRemainder = readonly [BigFloat, bigint];
+/** @type {(dec: BigFloat) => BigFloat} */
+declare const decToBin: (dec: BigFloat) => BigFloat;
+/** @type {(b: BigFloat) => (mul: bigint) => BigFloat} */
+declare const multiply: (b: BigFloat) => (mul: bigint) => BigFloat;

package/types/bigfloat/test.f.d.mts

@@ -0,0 +1,6 @@
+declare namespace _default {
+    let decToBin: (() => void)[];
+    let roundingPositive: (() => void)[];
+    let roundingNegative: (() => void)[];
+}
+export default _default;

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

@@ -0,0 +1,77 @@
+declare namespace _default {
+    export { addition };
+    export { sum };
+    export { abs };
+    export { sign };
+    export { serialize };
+    export { scalar_mul };
+    export { log2 };
+    export { bitLength };
+}
+export default _default;
+export type Unary = Operator.Unary<bigint, bigint>;
+export type Additive<T> = {
+    readonly 0: T;
+    readonly add: Operator.Reduce<T>;
+};
+/** @typedef {Operator.Unary<bigint, bigint>} Unary*/
+/** @type {(a: bigint) => (b: bigint) => bigint} */
+declare const addition: (a: bigint) => (b: bigint) => bigint;
+declare const sum: (input: import("../list/module.f.mjs").List<bigint>) => bigint;
+/** @type {(a: bigint) => bigint} */
+declare const abs: (a: bigint) => bigint;
+/** @type {(a: bigint) => Compare.Sign} */
+declare const sign: (a: bigint) => Compare.Sign;
+/** @type {(a: bigint) => string} */
+declare const serialize: (a: bigint) => string;
+/**
+ * @template T
+ * @typedef {{
+ *  readonly 0: T
+ *  readonly add: Operator.Reduce<T>
+ * }} Additive
+ */
+/** @type {<T>(a: Additive<T>) => (a: T) => (n: bigint) => T} */
+declare const scalar_mul: <T>(a: Additive<T>) => (a: T) => (n: bigint) => T;
+/**
+ * Calculates the base-2 logarithm (floor).
+ *
+ * This function returns the integer part of the logarithm. For example:
+ * - `log2(1n)` returns `0n`,
+ * - `log2(2n)` returns `1n`,
+ * - `log2(15n)` returns `3n`.
+ *
+ * @param {bigint} v - The input BigInt.
+ * @returns {bigint} The base-2 logarithm (floor) of the input BigInt, or `-1n` if the input is less than or equal to 0.
+ *
+ * @remarks
+ * The function operates in two phases:
+ * 1. **Fast Doubling Phase:** Uses exponential steps to quickly narrow down the range
+ *    of the most significant bit.
+ * 2. **Binary Search Phase:** Refines the result by halving the step size and incrementally
+ *    determining the exact value of the logarithm.
+ */
+declare function log2(v: bigint): bigint;
+/**
+ * Calculates the bit length of a given BigInt.
+ *
+ * The bit length of a number is the number of bits required to represent its absolute value in binary,
+ * excluding leading zeros. For example:
+ * - `0n` has a bit length of 0 (it has no bits).
+ * - `1n` (binary `1`) has a bit length of 1.
+ * - `255n` (binary `11111111`) has a bit length of 8.
+ * - `-255n` (absolute value `255`, binary `11111111`) also has a bit length of 8.
+ *
+ * The function handles both positive and negative numbers. For negative inputs, the bit length is calculated
+ * based on the absolute value of the number. Zero has a bit length of 0.
+ *
+ * @param {bigint} v - The input BigInt.
+ * @returns {bigint} The bit length of the input BigInt.
+ *
+ * @remark
+ * The function uses the `log2` function to calculate the position of the most significant bit(MSB)
+ * and adds `1n` to account for the MSB itself.For negative numbers, the absolute value is used.
+ */
+declare function bitLength(v: bigint): bigint;
+import * as Operator from '../function/operator/module.f.mjs';
+import * as Compare from '../function/compare/module.f.mjs';

package/types/bigint/module.f.mjs

@@ -1,10 +1,10 @@
-import compare, * as compareT from '../function/compare/module.f.mjs'
-import op, * as Op from '../function/operator/module.f.mjs'
+import compare, * as Compare from '../function/compare/module.f.mjs'
+import * as Operator from '../function/operator/module.f.mjs'
 const { unsafeCmp } = compare
 import list from '../list/module.f.mjs'
 const { reduce } = list
 
-/** @typedef {Op.Unary<bigint, bigint>} Unary*/
+/** @typedef {Operator.Unary<bigint, bigint>} Unary*/
 
 /** @type {(a: bigint) => (b: bigint) => bigint} */
 const addition = a => b => a + b
@@ -14,7 +14,7 @@ const sum = reduce(addition)(0n)
 /** @type {(a: bigint) => bigint} */
 const abs = a => a >= 0 ? a : -a
 
-/** @type {(a: bigint) => compareT.Sign} */
+/** @type {(a: bigint) => Compare.Sign} */
 const sign = a => unsafeCmp(a)(0n)
 
 /** @type {(a: bigint) => string} */
@@ -24,7 +24,7 @@ const serialize = a => `${a}n`
  * @template T
  * @typedef {{
  *  readonly 0: T
- *  readonly add: Op.Reduce<T>
+ *  readonly add: Operator.Reduce<T>
  * }} Additive
  */
 

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

@@ -0,0 +1,16 @@
+declare namespace _default {
+    function sum(): void;
+    let abs: (() => void)[];
+    let serialize: (() => void)[];
+    let log2: (() => void)[];
+    function toString2(): void;
+    function minus(): void;
+    function not(): void;
+    let bitLen: {
+        0: () => void;
+        m: () => void;
+        big: () => void;
+        neg: (() => void)[];
+    };
+}
+export default _default;