functionalscript 0.43.1 → 0.44.0

package/fjs/types/array/module.f.mjs

@@ -0,0 +1,101 @@
+/**
+ * JavaScript immutable arrays.
+ *
+ * @module
+ */
+
+import { fromUndefined, map } from '../nullable/module.f.mjs'
+
+/** @import { Tuple } from './types.ts' */
+
+/**
+ * @type {(value: unknown) => value is readonly unknown[]}
+ */
+export const isArray = value => value instanceof Array
+
+/**
+ * Currently, TypeScript can't narrow the type of `readonly T[]` to `Array2<T>`
+ * only by checking `a.length === 2`, so we need a user-defined type guard.
+ */
+export const isTuple =
+    /**
+     * @template {number} N
+     * @param {N} n
+     */
+    n =>
+    /**
+     * @template T
+     * @param {readonly T[]} a An array of unknown length.
+     * @return {a is Tuple<N, T>} True if `a` has length 2, and `a` is narrowed to `Array2<T>` in that case.
+     */
+    a =>
+        a.length === n
+
+/**
+ * @type {<T>(a: readonly T[]) => readonly T[]}
+ */
+const uncheckTail = a => a.slice(1)
+
+/**
+ * @type {<T>(a: readonly T[]) => readonly T[]}
+ */
+const uncheckHead = a => a.slice(0, -1)
+
+/**
+ * @type {(i: number) => <T>(a: readonly T[]) => T | null}
+ */
+export const at = i => a => fromUndefined(a[i])
+
+export const first = at(0)
+
+/**
+ * @type {<T>(a: readonly T[]) => T | null}
+ */
+export const last = a => at(a.length - 1)(a)
+
+/**
+ * @type {<T>(a: readonly T[]) => readonly T[] | null}
+ */
+export const tail = a => a.length === 0 ? null : uncheckTail(a)
+
+/**
+ * @type {<T>(a: readonly T[]) => readonly [T, readonly T[]] | null}
+ */
+export const splitFirst = a => {
+    /** @typedef {(typeof a)[0]} T */
+    const split = (/** @type {T} */first) =>
+        /** @type {const} */([first, uncheckTail(a)])
+    return map(split)(first(a))
+}
+
+/** @type {<T>(a: readonly T[]) => readonly T[] | null} */
+export const head = a => a.length === 0 ? null : uncheckHead(a)
+
+/** @type {<T>(a: readonly T[]) => readonly [readonly T[], T] | null} */
+export const splitLast = a => {
+    const lastA = last(a)
+    return lastA === null ? null : [uncheckHead(a), lastA]
+}
+
+/**
+ * An empty immutable array.
+ *
+ * Two JavaScript empty arrays are different and has to have two different values.
+ * Usually, it requires memory allocation. If we use the same an empty array everywhere,
+ * we may minimize memory a number of memory allocations.
+ */
+export const empty = /** @type {const} */([])
+
+export const includes =
+    /**
+     * @template I
+     * @template {readonly I[]} T
+     * @param {T} a
+     */
+    a =>
+    /**
+     * @param {I} v
+     * @return {v is T[number]}
+     */
+    v =>
+    a.includes(v)

package/fjs/types/array/proof.f.mjs

@@ -0,0 +1,98 @@
+import { at, first, last, head, tail, splitFirst, splitLast, empty } from './module.f.mjs'
+import { stringify as jsonStringify } from '../../media/json/module.f.mjs'
+import { sort } from '../object/module.f.mjs'
+import { assertEq, assertNotNullish } from '../../asserts/module.f.mjs'
+
+const stringify = jsonStringify(sort)
+
+export const proof = {
+    stringify: () => {
+        const result = stringify([1, 20, 300])
+        assertEq(result, '[1,20,300]')
+    },
+    at: [
+        () => {
+            const result = at(2)([1, 20, 300])
+            assertEq(result, 300)
+        },
+
+        () => {
+            const result = at(3)([1, 20, 300])
+            assertEq(result, null)
+        }
+    ],
+    first: [
+        () => {
+            const result = first([1, 20, 300])
+            assertEq(result, 1)
+        },
+        () => {
+            const result = first([])
+            assertEq(result, null)
+        }
+    ],
+    last: [
+        () => {
+            const result = last([1, 20, 300])
+            assertEq(result, 300)
+        },
+        () => {
+            const result = last([])
+            assertEq(result, null)
+        }
+    ],
+    head: [
+        () => {
+            const result = assertNotNullish(head([1, 20, 300]))
+            const str = stringify(result)
+            assertEq(str, '[1,20]')
+        },
+        () => {
+            const result = head([])
+            assertEq(result, null)
+        }
+    ],
+    tail: [
+        () => {
+            const result = tail([1, 20, 300])
+            const str = stringify(result)
+            assertEq(str, '[20,300]')
+        },
+        () => {
+            const result = tail([])
+            assertEq(result, null)
+        }
+    ],
+
+    splitFirst: [
+        () => {
+            const result = splitFirst([1, 20, 300])
+            const str = stringify(result)
+            assertEq(str, '[1,[20,300]]')
+        },
+        () => {
+            const result = splitFirst([])
+            assertEq(result, null)
+        },
+    ],
+    splitLast: [
+        () => {
+            const result = splitLast([1, 20, 300])
+            const str = stringify(result)
+            assertEq(str, '[[1,20],300]')
+        },
+        () => {
+            const result = splitLast([])
+            assertEq(result, null)
+        }
+    ],
+    empty: () => {
+        const x = empty
+        /** @type {readonly number[]} */
+        const a = x
+        /** @type {readonly string[]} */
+        const b = x
+        const c = [...a, ...b, ...x]
+        assertEq(c.length, 0, c)
+    }
+}

package/fjs/types/array/types.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Types for JavaScript immutable arrays.
+ *
+ * @module
+ */
+type _Tuple<N extends number, T, R extends readonly T[]> = N extends R['length'] ? R : _Tuple<N, T, readonly [...R, T]>;
+type _Index<N extends number, R extends readonly unknown[]> = R['length'] extends N ? never : R['length'] | _Index<N, readonly [...R, unknown]>;
+export type Index<N extends number> = number extends N ? number : N extends number ? _Index<N, readonly []> : never;
+export type Tuple<N extends number, T> = _Tuple<N, T, readonly []>;
+export type KeyOf<T extends readonly unknown[]> = Index<T['length']>;
+export type Array1_5<T> = Tuple<1, T> | Tuple<2, T> | Tuple<3, T> | Tuple<4, T> | Tuple<5, T>;
+export type Includes<I, T extends readonly I[]> = (v: I) => v is T[number];
+export {};

package/fjs/types/array/types.js

@@ -0,0 +1,6 @@
+/**
+ * Types for JavaScript immutable arrays.
+ *
+ * @module
+ */
+export {};

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

@@ -0,0 +1,14 @@
+/**
+ * Big-float helpers built from bigint mantissa and exponent parts.
+ *
+ * @module
+ */
+import type { BigFloat } from './types.ts';
+export type _BigFloatWithRemainder = readonly [BigFloat, bigint];
+/** @type {(_: BigFloat) => (mul: bigint) => BigFloat} */
+export declare const multiply: (_: BigFloat) => (mul: bigint) => BigFloat;
+/** @type {(dec: BigFloat) => BigFloat} */
+export declare const decToBin: (dec: BigFloat) => BigFloat;
+export declare const proof: {
+    normalizeMantissaZero: () => void;
+};

package/fjs/types/bigfloat/module.f.mjs

@@ -0,0 +1,99 @@
+/**
+ * Big-float helpers built from bigint mantissa and exponent parts.
+ *
+ * @module
+ */
+
+import { abs, sign } from '../bigint/module.f.mjs'
+/** @import { BigFloat } from './types.ts' */
+
+/** @typedef {readonly [BigFloat, bigint]} _BigFloatWithRemainder */
+
+const twoPow53 = 0b0010_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000n
+const twoPow54 = 0b0100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000n
+
+/**
+ * Shifts the mantissa magnitude one bit at a time, compensating the exponent,
+ * until `done(magnitude, bound)` holds; the sign is restored on return.
+ * A zero mantissa is returned unchanged: it can never satisfy a lower bound,
+ * so shifting it would not terminate.
+ *
+ * @param {(m: bigint) => bigint} shift
+ * @param {number} de
+ * @param {(m: bigint, bound: bigint) => boolean} done
+ * @returns {(_: BigFloat) => (bound: bigint) => BigFloat}
+ */
+const normalizeMantissa = (shift, de, done) => ([m, e]) => bound => {
+    if (m === 0n) {
+        return [m, e]
+    }
+    const s = sign(m)
+    m = abs(m)
+    while (true) {
+        if (done(m, bound)) {
+            return [BigInt(s) * m, e]
+        }
+        m = shift(m)
+        e += de
+    }
+}
+
+const increaseMantissa = normalizeMantissa(m => m << 1n, -1, (m, min) => m >= min)
+
+const decreaseMantissa = normalizeMantissa(m => m >> 1n, +1, (m, max) => m < max)
+
+/** @type {(base: bigint) => (exp: number) => bigint} */
+const pow = base => exp => base ** BigInt(exp)
+
+const pow5 = pow(5n)
+
+/** @type {(_: BigFloat) => (mul: bigint) => BigFloat} */
+export const multiply = ([m, e]) => mul => [m * mul, e]
+
+/** @type {(_: BigFloat) => (div: bigint) => _BigFloatWithRemainder} */
+const divide = ([m, e]) => div => [[m / div, e], m % div]
+
+/**
+ * Runs `f` on the magnitude `[abs(m), e]` and restores the sign of `m` on the
+ * result: operations on signed mantissas factor through the magnitude.
+ *
+ * @type {(m: bigint, e: number) => (f: (magnitude: BigFloat) => BigFloat) => BigFloat}
+ */
+const withSign = (m, e) => f => multiply(f([abs(m), e]))(BigInt(sign(m)))
+
+/** @type {(_: _BigFloatWithRemainder) => BigFloat} */
+const round53 = ([[m, e], r]) =>
+    withSign(m, e)(([mAbs]) => {
+        const [m54, e54] = decreaseMantissa([mAbs, e])(twoPow54)
+        const o54 = m54 & 1n
+        const m53 = m54 >> 1n
+        const e53 = e54 + 1
+        if (o54 === 1n && r === 0n && mAbs === m54 >> BigInt(e - e54)) {
+            const odd = m53 & 1n
+            return [m53 + odd, e53]
+        }
+        return [m53 + o54, e53]
+    })
+
+/** @type {(dec: BigFloat) => BigFloat} */
+export const decToBin = dec => {
+    if (dec[0] === 0n) {
+        return [0n, 0]
+    }
+    if (dec[1] >= 0) {
+        /** @type {BigFloat} */
+        const bin = [dec[0] * pow5(dec[1]), dec[1]]
+        const inc = increaseMantissa(bin)(twoPow53)
+        return round53([inc, 0n])
+    }
+    const p = pow5(-dec[1])
+    const [m, e] = increaseMantissa(dec)(p * twoPow53)
+    return withSign(m, e)(magnitude => round53(divide(magnitude)(p)))
+}
+
+export const proof = {
+    // normalizeMantissa guards against zero mantissa to prevent an infinite loop;
+    // this path is unreachable through decToBin (which returns early for 0n),
+    // so we exercise it here where the private helper is in scope.
+    normalizeMantissaZero: () => { increaseMantissa([0n, 5])(1n) }
+}

package/fjs/types/bigfloat/proof.f.mjs

@@ -0,0 +1,218 @@
+import { decToBin } from './module.f.mjs'
+import { assertEq } from '../../asserts/module.f.mjs'
+
+export const proof = {
+    decToBin: [
+        () => {
+            const result = decToBin([0n, 0])
+            assertEq(result[0], 0b0_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000n, result[0].toString(2))
+            assertEq(result[1], 0)
+        },
+        () => {
+            const result = decToBin([0n, 10])
+            assertEq(result[0], 0b0_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000n, result[0].toString(2))
+            assertEq(result[1], 0)
+        },
+        () => {
+            const result = decToBin([0n, -10])
+            assertEq(result[0], 0b0_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000n, result[0].toString(2))
+            assertEq(result[1], 0)
+        },
+        () => {
+            const result = decToBin([1n, 0])
+            assertEq(result[0], 0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000n, result[0].toString(2))
+            assertEq(result[1], -52)
+        },
+        () => {
+            const result = decToBin([1n, 1])
+            assertEq(result[0], 0b1_0100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000n, result[0].toString(2))
+            assertEq(result[1], -49)
+        },
+        () => {
+            const result = decToBin([1000n, -2])
+            assertEq(result[0], 0b1_0100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000n, result[0].toString(2))
+            assertEq(result[1], -49)
+        },
+        () => {
+            const result = decToBin([1n, -1])
+            assertEq(result[0], 0b1_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1010n, result[0].toString(2)) //+1
+            assertEq(result[1], -56)
+        },
+        () => {
+            const result = decToBin([-1n, 0])
+            assertEq(result[0], -0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000n, result[0].toString(2))
+            assertEq(result[1], -52)
+        },
+        () => {
+            const result = decToBin([-1n, 1])
+            assertEq(result[0], -0b1_0100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000n, result[0].toString(2))
+            assertEq(result[1], -49)
+        },
+        () => {
+            const result = decToBin([-1000n, -2])
+            assertEq(result[0], -0b1_0100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000n, result[0].toString(2))
+            assertEq(result[1], -49)
+        },
+        () => {
+            const result = decToBin([-1n, -1])
+            assertEq(result[0], -0b1_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1010n, result[0].toString(2)) //+1
+            assertEq(result[1], -56)
+        },
+        () => {
+            const result = decToBin([0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0001n, 0]) //54bits (...0.1)
+            assertEq(result[0], 0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000n, result[0].toString(2))
+            assertEq(result[1], 1)
+        },
+        () => {
+            const result = decToBin([-0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0011n, 0]) //54bits (...1.1)
+            assertEq(result[0], -0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0010n, result[0].toString(2))
+            assertEq(result[1], 1)
+        },
+        () => {
+            const result = decToBin([-0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0001n, 0]) //54bits (...0.1)
+            assertEq(result[0], -0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000n, result[0].toString(2))
+            assertEq(result[1], 1)
+        },
+        () => {
+            const result = decToBin([-0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0011n, 0]) //54bits (...1.1)
+            assertEq(result[0], -0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0010n, result[0].toString(2))
+            assertEq(result[1], 1)
+        },
+        () => {
+            const result = decToBin([0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0001n, 0]) //55bits (...0.01)
+            assertEq(result[0], 0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000n, result[0].toString(2))
+            assertEq(result[1], 2)
+        },
+        () => {
+            const result = decToBin([0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0010n, 0]) //55bits (...0.10)
+            assertEq(result[0], 0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000n, result[0].toString(2))
+            assertEq(result[1], 2)
+        },
+        () => {
+            const result = decToBin([0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0110n, 0]) //55bits (...1.10)
+            assertEq(result[0], 0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0010n, result[0].toString(2))
+            assertEq(result[1], 2)
+        },
+        () => {
+            const result = decToBin([0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0011n, 0]) //55bits (0.11)
+            assertEq(result[0], 0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0001n, result[0].toString(2))
+            assertEq(result[1], 2)
+        },
+    ],
+    roundingPositive: [
+        () => {
+            const result = decToBin([0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0001n, -1])
+            // reminder = 0
+            // m = 11001100110011001100110011001100110011001100110011001.101
+            // rounding up
+            assertEq(result[0], 0b1_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1010n, result[0].toString(2))
+            assertEq(result[1], 2)
+        },
+        () => {
+            const result = decToBin([0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0001_0000n, -1])
+            // reminder = 0
+            // m = 11001100110011001100110011001100110011001100110011010.000
+            // rounding down
+            assertEq(result[0], 0b1_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1010n, result[0].toString(2))
+            assertEq(result[1], 2)
+        },
+        () => {
+            const result = decToBin([0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0010_0100n, -1])
+            // reminder = 0
+            // m = 11001100110011001100110011001100110011001100110011010.100
+            // rounding down (to even)
+            assertEq(result[0], 0b1_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1010n, result[0].toString(2))
+            assertEq(result[1], 2)
+        },
+        () => {
+            const result = decToBin([0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0010_0101n, -1])
+            // reminder = 1
+            // m = 11001100110011001100110011001100110011001100110011010.100
+            // rounding up
+            assertEq(result[0], 0b1_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1011n, result[0].toString(2))
+            assertEq(result[1], 2)
+        },
+        () => {
+            const result = decToBin([0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0010_1001n, -1])
+            // reminder = 0
+            // m = 11001100110011001100110011001100110011001100110011010.101
+            // rounding up
+            assertEq(result[0], 0b1_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1011n, result[0].toString(2))
+            assertEq(result[1], 2)
+        },
+        () => {
+            const result = decToBin([0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0011_1101n, -1])
+            // reminder = 0
+            // m = 11001100110011001100110011001100110011001100110011011.001
+            // rounding down
+            assertEq(result[0], 0b1_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1011n, result[0].toString(2))
+            assertEq(result[1], 2)
+        },
+        () => {
+            const result = decToBin([0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0100_1100n, -1])
+            // reminder = 0
+            // m = 11001100110011001100110011001100110011001100110011011.100
+            // rounding up (to even)
+            assertEq(result[0], 0b1_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1100n, result[0].toString(2))
+            assertEq(result[1], 2)
+        }
+    ],
+    roundingNegative: [
+        () => {
+            const result = decToBin([-0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0001n, -1])
+            // reminder = 0
+            // m = -11001100110011001100110011001100110011001100110011001.101
+            // rounding down
+            assertEq(result[0], -0b1_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1010n, result[0].toString(2))
+            assertEq(result[1], 2)
+        },
+        () => {
+            const result = decToBin([-0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0001_0000n, -1])
+            // reminder = 0
+            // m = -11001100110011001100110011001100110011001100110011010.000
+            // rounding up
+            assertEq(result[0], -0b1_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1010n, result[0].toString(2))
+            assertEq(result[1], 2)
+        },
+        () => {
+            const result = decToBin([-0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0010_0100n, -1])
+            // reminder = 0
+            // m = -11001100110011001100110011001100110011001100110011010.100
+            // rounding up (to even)
+            assertEq(result[0], -0b1_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1010n, result[0].toString(2))
+            assertEq(result[1], 2)
+        },
+        () => {
+            const result = decToBin([-0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0010_0101n, -1])
+            // reminder = 1
+            // m = -11001100110011001100110011001100110011001100110011010.100
+            // rounding down
+            assertEq(result[0], -0b1_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1011n, result[0].toString(2))
+            assertEq(result[1], 2)
+        },
+        () => {
+            const result = decToBin([-0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0010_1001n, -1])
+            // reminder = 0
+            // m = -11001100110011001100110011001100110011001100110011010.101
+            // rounding down
+            assertEq(result[0], -0b1_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1011n, result[0].toString(2))
+            assertEq(result[1], 2)
+        },
+        () => {
+            const result = decToBin([-0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0011_1101n, -1])
+            // reminder = 0
+            // m = -11001100110011001100110011001100110011001100110011011.001
+            // rounding up
+            assertEq(result[0], -0b1_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1011n, result[0].toString(2))
+            assertEq(result[1], 2)
+        },
+        () => {
+            const result = decToBin([-0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0100_1100n, -1])
+            // reminder = 0
+            // m = -11001100110011001100110011001100110011001100110011011.100
+            // rounding down (to even)
+            assertEq(result[0], -0b1_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1100n, result[0].toString(2))
+            assertEq(result[1], 2)
+        }
+    ]
+}

package/fjs/types/bigfloat/types.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Types for big-floats built from bigint mantissa and exponent parts.
+ *
+ * @module
+ */
+export type BigFloat = readonly [bigint, number];

package/fjs/types/bigfloat/types.js

@@ -0,0 +1,6 @@
+/**
+ * Types for big-floats built from bigint mantissa and exponent parts.
+ *
+ * @module
+ */
+export {};

package/fjs/types/bigint/benchmark.d.mts

@@ -0,0 +1 @@
+export {};