functionalscript 0.43.1 → 0.44.0

package/fjs/text/utf8/module.f.js

@@ -1,247 +0,0 @@
-/**
- * UTF-8 byte-level encoding and decoding utilities for FunctionalScript streams.
- *
- * @module
- */
-import { flatMap, toArray } from '../../types/list/module.f.js';
-import { decoder, errorMask, isValidCodePoint } from '../code_point/module.f.js';
-import { msb, u8List, length } from '../../types/bit_vec/module.f.js';
-import { codePointListToString } from '../utf16/module.f.js';
-/**
- * UTF-8 byte-format constants. Each byte kind is defined by a tag — the fixed
- * high bits identifying the kind — and a payload mask selecting the code-point
- * bits the byte carries. The encoder and the decoder are exact inverses, so
- * both read their bit patterns from this single set of definitions:
- *
- * | byte kind   | pattern      | tag       | payload mask |
- * |-------------|--------------|-----------|--------------|
- * | continuation| `10xx_xxxx`  | `contTag` | `contMask`   |
- * | 2-byte lead | `110x_xxxx`  | `lead2Tag`| `lead2Mask`  |
- * | 3-byte lead | `1110_xxxx`  | `lead3Tag`| `lead3Mask`  |
- * | 4-byte lead | `1111_0xxx`  | `lead4Tag`| `lead4Mask`  |
- */
-const contTag = 0b1000_0000;
-const contMask = 0b0011_1111;
-const lead2Tag = 0b1100_0000;
-const lead2Mask = 0b0001_1111;
-const lead3Tag = 0b1110_0000;
-const lead3Mask = 0b0000_1111;
-const lead4Tag = 0b1111_0000;
-const lead4Mask = 0b0000_0111;
-/**
- * Encodes the low six bits of `x` as a UTF-8 continuation byte.
- */
-const contByte = (x) => x & contMask | contTag;
-/**
- * Reads the six payload bits of a continuation byte.
- */
-const contPayload = (b) => b & contMask;
-/**
- * The valid lead-byte range for 2-, 3-, and 4-byte sequences (RFC 3629);
- * excludes overlong 2-byte leads (`C0`, `C1`) and leads above `U+10FFFF` (`F5`-`F7`).
- */
-const leadMin = 0b1100_0010;
-const leadMax = 0b1111_0100;
-const isLeadByte = (b) => b >= leadMin && b <= leadMax;
-/**
- * Dispatches a fresh-state byte, emitting `prefix` ahead of whatever the byte
- * itself produces. Shared by the `state === null` arm and by error recovery
- * after {@link utf8StateToError}, which differ only in `prefix`.
- */
-const restart = (prefix) => (byte) => byte < contTag ? [[...prefix, byte], null]
-    : isLeadByte(byte) ? [[...prefix], [byte]]
-        : [[...prefix, byte | errorMask], null];
-/**
- * Converts a Unicode code point to a sequence of UTF-8 bytes.
- * @param input The Unicode code point to be converted. Valid range:
- *   - 0x0000 to 0x007F for 1-byte sequences.
- *   - 0x0080 to 0x07FF for 2-byte sequences.
- *   - 0x0800 to 0xFFFF for 3-byte sequences.
- *   - 0x10000 to 0x10FFFF for 4-byte sequences.
- * @returns A readonly array of UTF-8 bytes representing the input code point.
- *   - Returns `[errorMask]` if the input does not match valid UTF-8 encoding rules.
- */
-const codePointToUtf8 = (input) => {
-    if (input >= 0x0000 && input <= 0x007f) {
-        return [input & 0b01111_1111];
-    }
-    if (input >= 0x0080 && input <= 0x07ff) {
-        return [input >> 6 | lead2Tag, contByte(input)];
-    }
-    if (input >= 0x0800 && input <= 0xffff) {
-        return [
-            input >> 12 | lead3Tag,
-            contByte(input >> 6),
-            contByte(input),
-        ];
-    }
-    if (input >= 0x10000 && input <= 0x10ffff) {
-        return [
-            input >> 18 | lead4Tag,
-            contByte(input >> 12),
-            contByte(input >> 6),
-            contByte(input),
-        ];
-    }
-    if ((input & errorMask) !== 0) {
-        if ((input & 0b1000_0000_0000_0000) !== 0) {
-            return [
-                input >> 12 & lead4Mask | lead4Tag,
-                contByte(input >> 6),
-                contByte(input),
-            ];
-        }
-        if ((input & 0b0000_0100_0000_0000) !== 0) {
-            return [
-                input >> 6 & lead3Mask | lead3Tag,
-                contByte(input),
-            ];
-        }
-        if ((input & 0b0000_0010_0000_0000) !== 0) {
-            return [
-                input >> 6 & lead4Mask | lead4Tag,
-                contByte(input),
-            ];
-        }
-        if ((input & 0b0000_0000_1000_0000) !== 0)
-            return [input & 0b1111_1111];
-    }
-    return [errorMask];
-};
-/**
- * Maps a list of Unicode code points to a stream of UTF-8 bytes.
- *
- * @param input - A list of Unicode code points to be converted.
- * @returns A thunk that lazily produces a sequence of UTF-8 bytes.
- */
-export const fromCodePointList = flatMap(codePointToUtf8);
-/**
- * Converts a non-empty UTF-8 decoding state to an error code.
- *
- * @param state - A non-empty UTF-8 decoding state.
- * @returns An I32 error code derived from the invalid UTF-8 state.
- */
-export const utf8StateToError = (state) => {
-    let x;
-    switch (state.length) {
-        case 1: {
-            [x] = state;
-            break;
-        }
-        case 2: {
-            const [s0, s1] = state;
-            x = s0 < lead4Tag
-                ? ((s0 & lead3Mask) << 6) + contPayload(s1) + 0b0000_0100_0000_0000
-                : ((s0 & lead4Mask) << 6) + contPayload(s1) +
-                    0b0000_0010_0000_0000;
-            break;
-        }
-        case 3: {
-            const [s0, s1, s2] = state;
-            x = ((s0 & lead4Mask) << 12) + (contPayload(s1) << 6) +
-                contPayload(s2) + 0b1000_0000_0000_0000;
-            break;
-        }
-        //default:
-        //    throw 'invalid state'
-    }
-    return x | errorMask;
-};
-/**
- * Decodes a byte into a Unicode code point, using a given UTF-8 state.
- *
- * Rejects overlong 3-/4-byte encodings (Unicode Table 3-7): a lead `E0` must
- * be followed by a continuation `>= 0xA0`, and a lead `F0` by a continuation
- * `>= 0x90`. It does not itself reject surrogates (`ED A0..BF`) or code
- * points above `U+10FFFF` (`F4 90..BF`); {@link fromVec}'s
- * `isValidCodePoint` pass filters those out of the raw code-point stream.
- *
- * @param state - The current UTF-8 decoding state.
- * @param byte - A single byte to decode.
- * @returns A tuple containing:
- *   - A list of decoded Unicode code points or error codes.
- *   - The updated UTF-8 state.
- */
-export const utf8ByteToCodePointOp = (byte, state) => {
-    if (byte < 0x00 || byte > 0xff) {
-        return [[errorMask], state];
-    }
-    if (state === null)
-        return restart([])(byte);
-    if (byte >= contTag && byte < lead2Tag) {
-        switch (state.length) {
-            case 1: {
-                const [s0] = state;
-                if (s0 < lead3Tag) {
-                    return [[((s0 & lead2Mask) << 6) + contPayload(byte)], null];
-                }
-                if (s0 < 0b1111_1000) {
-                    // Reject overlong 3-/4-byte encodings: after lead `E0` the
-                    // first continuation must be >= 0xA0, after lead `F0` it
-                    // must be >= 0x90 (Unicode Table 3-7).
-                    const overlong = s0 === lead3Tag && byte < 0b1010_0000 ||
-                        s0 === lead4Tag && byte < 0b1001_0000;
-                    if (!overlong)
-                        return [[], [s0, byte]];
-                }
-                break;
-            }
-            case 2: {
-                const [s0, s1] = state;
-                if (s0 < lead4Tag) {
-                    return [[
-                            ((s0 & lead3Mask) << 12) + (contPayload(s1) << 6) +
-                                contPayload(byte),
-                        ], null];
-                }
-                if (s0 < 0b1111_1000)
-                    return [[], [s0, s1, byte]];
-                break;
-            }
-            case 3: {
-                const [s0, s1, s2] = state;
-                return [[
-                        ((s0 & lead4Mask) << 18) + (contPayload(s1) << 12) +
-                            (contPayload(s2) << 6) + contPayload(byte),
-                    ], null];
-            }
-        }
-    }
-    return restart([utf8StateToError(state)])(byte);
-};
-/**
- * Handles the end-of-file (EOF) case for UTF-8 decoding.
- *
- * @param state - The current UTF-8 decoding state.
- * @returns A tuple containing:
- *   - A list of decoded Unicode code points or error codes.
- *   - The reset UTF-8 state (`null`).
- */
-export const utf8EofToCodePointOp = (state) => [
-    state === null ? null : [utf8StateToError(state)],
-    null,
-];
-/**
- * Converts a list of UTF-8 bytes into a list of Unicode code points.
- *
- * @param input - A list of UTF-8 bytes.
- * @returns A list of Unicode code points or error codes.
- */
-export const toCodePointList = decoder(utf8ByteToCodePointOp, utf8EofToCodePointOp);
-/**
- * Returns the decoded string if `v` is valid UTF-8, or `null` otherwise.
- * Rejects non-octet Vecs, invalid byte sequences, surrogates, and out-of-range
- * code points.
- */
-export const fromVec = (v) => {
-    if ((length(v) & 7n) !== 0n) {
-        return null;
-    }
-    const arr = toArray(toCodePointList(u8List(msb)(v)));
-    for (const cp of arr) {
-        if (!isValidCodePoint(cp)) {
-            return null;
-        }
-    }
-    return codePointListToString(arr);
-};

package/fjs/text/utf8/proof.f.js

@@ -1,217 +0,0 @@
-import { toCodePointList, fromCodePointList, fromVec, utf8ByteToCodePointOp } from './module.f.js';
-import { stringify as jsonStringify } from '../../media/json/module.f.js';
-import { sort } from '../../types/object/module.f.js';
-import { toArray } from '../../types/list/module.f.js';
-import { msb, u8ListToVec, vec } from '../../types/bit_vec/module.f.js';
-import { assertEq } from '../../asserts/module.f.js';
-const stringify = jsonStringify(sort);
-export const proof = {
-    toCodePoint: [
-        () => {
-            const result = stringify(toArray(toCodePointList([-1, 256])));
-            assertEq(result, '[2147483648,2147483648]');
-        },
-        () => {
-            const result = stringify(toArray(toCodePointList([128, 193, 245, 255])));
-            assertEq(result, '[-2147483520,-2147483455,-2147483403,-2147483393]');
-        },
-        () => {
-            const result = stringify(toArray(toCodePointList([0, 1, 127])));
-            assertEq(result, '[0,1,127]');
-        },
-        () => {
-            const result = stringify(toArray(toCodePointList([194, 128, 194, 169, 223, 191])));
-            assertEq(result, '[128,169,2047]');
-        },
-        () => {
-            const result = stringify(toArray(toCodePointList([194, 194, 127, 194, 192, 194])));
-            assertEq(result, '[-2147483454,-2147483454,127,-2147483454,-2147483456,-2147483454]');
-        },
-        () => {
-            const result = stringify(toArray(toCodePointList([224, 160, 128, 224, 160, 129, 239, 191, 191])));
-            assertEq(result, '[2048,2049,65535]');
-        },
-        () => {
-            const result = stringify(toArray(toCodePointList([224, 224, 160, 127, 239, 191])));
-            assertEq(result, '[-2147483424,-2147482592,127,-2147481601]');
-        },
-        () => {
-            const result = stringify(toArray(toCodePointList([240, 144, 128, 128, 240, 144, 128, 129, 244, 143, 191, 191])));
-            assertEq(result, '[65536,65537,1114111]');
-        },
-        () => {
-            const result = stringify(toArray(toCodePointList([240, 240, 160, 127, 244, 191])));
-            assertEq(result, '[-2147483408,-2147483104,127,-2147482817]');
-        },
-        () => {
-            const result = stringify(toArray(toCodePointList([240, 160, 160, 244, 160, 160])));
-            assertEq(result, '[-2147448800,-2147432416]');
-        },
-        // Overlong 3-byte encodings (E0 80..9F ..) are rejected, not decoded.
-        () => {
-            const result = stringify(toArray(toCodePointList([224, 128, 128])));
-            assertEq(result, '[-2147483424,-2147483520,-2147483520]');
-        },
-        () => {
-            const result = stringify(toArray(toCodePointList([224, 159, 191])));
-            assertEq(result, '[-2147483424,-2147483489,-2147483457]');
-        },
-        // Overlong 4-byte encodings (F0 80..8F .. ..) are rejected, not decoded.
-        () => {
-            const result = stringify(toArray(toCodePointList([240, 128, 128, 128])));
-            assertEq(result, '[-2147483408,-2147483520,-2147483520,-2147483520]');
-        },
-        () => {
-            const result = stringify(toArray(toCodePointList([240, 143, 191, 191])));
-            assertEq(result, '[-2147483408,-2147483505,-2147483457,-2147483457]');
-        },
-        // Valid boundary cases still decode: E0 A0 80 -> U+0800, F0 90 80 80 -> U+10000.
-        () => {
-            const result = stringify(toArray(toCodePointList([224, 160, 128])));
-            assertEq(result, '[2048]');
-        },
-        () => {
-            const result = stringify(toArray(toCodePointList([240, 144, 128, 128])));
-            assertEq(result, '[65536]');
-        },
-        // A byte stream never accumulates a 2-byte state whose lead is >= F8
-        // (isLeadByte caps leads at F4), so this defensive fallthrough is
-        // only reachable by calling the scan op directly with such a state.
-        () => {
-            const result = stringify(utf8ByteToCodePointOp(0x80, [0xf8, 0x80]));
-            assertEq(result, '[[-2147483136,-2147483520],null]');
-        }
-    ],
-    fromCodePointList: [
-        () => {
-            const result = stringify(toArray(fromCodePointList([0, 1, 0x7F])));
-            assertEq(result, '[0,1,127]');
-        },
-        () => {
-            const result = stringify(toArray(fromCodePointList([0x80])));
-            assertEq(result, '[194,128]');
-        },
-        () => {
-            const result = stringify(toArray(fromCodePointList([0xa9])));
-            assertEq(result, '[194,169]');
-        },
-        () => {
-            const result = stringify(toArray(fromCodePointList([0x7ff])));
-            assertEq(result, '[223,191]');
-        },
-        () => {
-            const result = stringify(toArray(fromCodePointList([0x800])));
-            assertEq(result, '[224,160,128]');
-        },
-        () => {
-            const result = stringify(toArray(fromCodePointList([0x801])));
-            assertEq(result, '[224,160,129]');
-        },
-        () => {
-            const result = stringify(toArray(fromCodePointList([0xffff])));
-            assertEq(result, '[239,191,191]');
-        },
-        () => {
-            const result = stringify(toArray(fromCodePointList([0x10000])));
-            assertEq(result, '[240,144,128,128]');
-        },
-        () => {
-            const result = stringify(toArray(fromCodePointList([0x10001])));
-            assertEq(result, '[240,144,128,129]');
-        },
-        () => {
-            const result = stringify(toArray(fromCodePointList([0x10FFFF])));
-            assertEq(result, '[244,143,191,191]');
-        },
-        () => {
-            const result = stringify(toArray(fromCodePointList([0x110000, 2147483648])));
-            assertEq(result, '[2147483648,2147483648]');
-        }
-    ],
-    toFrom: [
-        () => {
-            const codePointList = toCodePointList([128, 193, 245, 255]);
-            const result = stringify(toArray(fromCodePointList(codePointList)));
-            assertEq(result, '[128,193,245,255]');
-        },
-        () => {
-            const codePointList = toCodePointList([194, 194, 127, 194, 192, 194]);
-            const result = stringify(toArray(fromCodePointList(codePointList)));
-            assertEq(result, '[194,194,127,194,192,194]');
-        },
-        () => {
-            const codePointList = toCodePointList([224, 224, 160, 127, 239, 191]);
-            const result = stringify(toArray(fromCodePointList(codePointList)));
-            assertEq(result, '[224,224,160,127,239,191]');
-        },
-        () => {
-            const codePointList = toCodePointList([240, 240, 160, 127, 244, 191]);
-            const result = stringify(toArray(fromCodePointList(codePointList)));
-            assertEq(result, '[240,240,160,127,244,191]');
-        },
-        () => {
-            const codePointList = toCodePointList([240, 160, 160, 244, 160, 160]);
-            const result = stringify(toArray(fromCodePointList(codePointList)));
-            assertEq(result, '[240,160,160,244,160,160]');
-        }
-    ],
-    fromVec: [
-        // Valid ASCII → decoded string
-        () => {
-            const v = u8ListToVec(msb)([0x68, 0x65, 0x6c, 0x6c, 0x6f]); // "hello"
-            assertEq(fromVec(v), 'hello', 'expected "hello"');
-        },
-        // Valid multi-byte UTF-8 → decoded string (U+00A9 COPYRIGHT SIGN, 2-byte)
-        () => {
-            const v = u8ListToVec(msb)([0xc2, 0xa9]); // "©"
-            assertEq(fromVec(v), '©', 'expected copyright sign');
-        },
-        // Valid 3-byte UTF-8 (U+4E2D CJK)
-        () => {
-            const v = u8ListToVec(msb)([0xe4, 0xb8, 0xad]); // "中"
-            assertEq(fromVec(v), '中', 'expected CJK character');
-        },
-        // Valid 4-byte UTF-8 (U+1F600 GRINNING FACE)
-        () => {
-            const v = u8ListToVec(msb)([0xf0, 0x9f, 0x98, 0x80]);
-            if (fromVec(v) !== '\u{1f600}') {
-                throw 'expected emoji';
-            }
-        },
-        // Invalid byte sequence → null
-        () => {
-            const v = u8ListToVec(msb)([0xff, 0xfe]); // not valid UTF-8
-            assertEq(fromVec(v), null, 'expected null for invalid UTF-8');
-        },
-        // Lone continuation byte → null
-        () => {
-            const v = u8ListToVec(msb)([0x80]);
-            assertEq(fromVec(v), null, 'expected null for lone continuation byte');
-        },
-        // Surrogate half (U+D800, encoded as CESU-8 0xED 0xA0 0x80) → null
-        () => {
-            const v = u8ListToVec(msb)([0xed, 0xa0, 0x80]);
-            assertEq(fromVec(v), null, 'expected null for surrogate');
-        },
-        // Empty Vec → empty string
-        () => {
-            const v = u8ListToVec(msb)([]);
-            assertEq(fromVec(v), '', 'expected empty string');
-        },
-        // Overlong 3-byte encoding (E0 80 80, would decode to U+0000) → null
-        () => {
-            const v = u8ListToVec(msb)([0xe0, 0x80, 0x80]);
-            assertEq(fromVec(v), null, 'expected null for overlong 3-byte encoding');
-        },
-        // Overlong 4-byte encoding (F0 80 80 80, would decode to U+0000) → null
-        () => {
-            const v = u8ListToVec(msb)([0xf0, 0x80, 0x80, 0x80]);
-            assertEq(fromVec(v), null, 'expected null for overlong 4-byte encoding');
-        },
-        // Vec length not a multiple of 8 bits → null
-        () => {
-            const v = vec(4n)(0n);
-            assertEq(fromVec(v), null);
-        },
-    ]
-};

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

@@ -1,49 +0,0 @@
-/**
- * JavaScript immutable arrays.
- *
- * @module
- */
-export declare const isArray: (value: unknown) => value is readonly unknown[];
-export type Array1<T> = readonly [T];
-export type Index1 = 0;
-export type Array2<T> = readonly [T, T];
-/**
- * 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.
- *
- * @param a An array of unknown length.
- * @returns True if `a` has length 2, and `a` is narrowed to `Array2<T>` in that case.
- */
-export declare const isArray2: <T>(a: readonly T[]) => a is Array2<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 = Index2 | 2;
-export type Array4<T> = readonly [T, T, T, T];
-export type Index4 = Index3 | 3;
-export type Array5<T> = readonly [T, T, T, T, T];
-export type Index5 = Index4 | 4;
-export type Array8<T> = readonly [T, T, T, T, T, T, T, T];
-export type Index8 = Index5 | 5 | 6 | 7;
-export type Array16<T> = readonly [T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T];
-export type Index16 = Index8 | 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 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 Array8<infer _> ? Index8 : T extends Array16<infer _> ? Index16 : T extends readonly (infer _)[] ? number : never;
-export declare const at: (i: number) => <T>(a: readonly T[]) => T | null;
-export declare const first: <T>(_: readonly T[]) => T | null;
-export declare const last: <T>(a: readonly T[]) => T | null;
-export declare const tail: <T>(a: readonly T[]) => readonly T[] | null;
-export declare const splitFirst: <T>(a: readonly T[]) => readonly [T, readonly T[]] | null;
-export declare const head: <T>(a: readonly T[]) => readonly T[] | null;
-export declare const splitLast: <T>(a: readonly T[]) => readonly [readonly T[], T] | null;
-/**
- * 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 declare const empty: readonly [];
-export type Includes<I, T extends readonly I[]> = (v: I) => v is T[number];
-export declare const includes: <I, T extends readonly I[]>(a: T) => (v: I) => v is T[number];

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

@@ -1,42 +0,0 @@
-/**
- * JavaScript immutable arrays.
- *
- * @module
- */
-import { fromUndefined, map } from '../nullable/module.f.js';
-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.
- *
- * @param a An array of unknown length.
- * @returns True if `a` has length 2, and `a` is narrowed to `Array2<T>` in that case.
- */
-export const isArray2 = (a) => a.length === 2;
-const uncheckTail = (a) => a.slice(1);
-const uncheckHead = (a) => a.slice(0, -1);
-export const at = (i) => (a) => fromUndefined(a[i]);
-export const first = at(0);
-export const last = (a) => at(a.length - 1)(a);
-export const tail = (a) => a.length === 0 ? null : uncheckTail(a);
-export const splitFirst = (a) => {
-    const split = (first) => [first, uncheckTail(a)];
-    return map(split)(first(a));
-};
-export const head = (a) => a.length === 0 ? null : uncheckHead(a);
-export const splitLast = (a) => {
-    const lastA = last(a);
-    if (lastA === null) {
-        return null;
-    }
-    return [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 = [];
-export const includes = (a) => (v) => a.includes(v);

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

@@ -1,92 +0,0 @@
-import { at, first, last, head, tail, splitFirst, splitLast, empty } from './module.f.js';
-import { stringify as jsonStringify } from '../../media/json/module.f.js';
-import { sort } from '../object/module.f.js';
-import { assertEq, assertNotNullish } from '../../asserts/module.f.js';
-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;
-        const a = x;
-        const b = x;
-        const c = [...a, ...b, ...x];
-        assertEq(c.length, 0, c);
-    }
-};

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

@@ -1,6 +0,0 @@
-export type BigFloat = readonly [bigint, number];
-export declare const multiply: ([m, e]: BigFloat) => (mul: bigint) => BigFloat;
-export declare const decToBin: (dec: BigFloat) => BigFloat;
-export declare const proof: {
-    normalizeMantissaZero: () => void;
-};