functionalscript 0.43.1 → 0.45.0

package/fjs/asserts/proof.f.js

@@ -1,18 +0,0 @@
-import { assert, assertEq, todo } from './module.f.js';
-export const proof = {
-    assertPassesOnTrue: () => {
-        assert(true);
-        assert(true, 'with message');
-    },
-    assertEqPassesOnEqual: () => {
-        assertEq(1, 1);
-        assertEq('x', 'x');
-    },
-    throw: {
-        assertEqThrowsOnUnequal: () => assertEq(1, 2),
-        assertEqThrowsOnUnequal3: () => assertEq(1, 2, "message"),
-        assertThrowsDefaultMsg: () => assert(false),
-        assertThrowsCustomMsg: () => assert(false, 'oops'),
-        todoThrows: () => todo(),
-    },
-};

package/fjs/base_n/module.f.d.ts

@@ -1,45 +0,0 @@
-/**
- * Shared bit-codec factory for alphabet-based encodings such as `base64` and
- * `cbase32`.
- *
- * Each call returns the raw `Vec ↔ string` codec parameterised by the chunk
- * width (`bits`) and the alphabet (and an optional input-character
- * normalisation step on the decode side). Padding strategies — RFC 4648 `=`
- * octet-alignment, Crockford-style stop-bit sentinels, etc. — are deliberately
- * out of scope: they vary per format and are handled by the caller around
- * `vecToString` / `stringToVec`.
- *
- * @module
- */
-import { type Vec } from '../types/bit_vec/module.f.ts';
-import type { Nullable } from '../types/nullable/module.f.ts';
-/**
- * The encode/decode pair returned by {@link baseN}.
- */
-export type BaseN = {
-    /**
-     * Encodes a bit vector by splitting it into `bits`-wide MSB chunks
-     * (`chunkList`, a balanced divide-and-conquer split, not a linear scan)
-     * and indexing each into the alphabet. A trailing partial chunk shorter
-     * than `bits` is left-padded with zeros.
-     */
-    readonly vecToString: (v: Vec) => string;
-    /**
-     * Decodes a string by mapping each character to its alphabet index and
-     * concatenating the resulting `bits`-wide chunks. Returns `null` on the
-     * first character that is not in the alphabet (after `normalize`, when
-     * provided).
-     */
-    readonly stringToVec: (s: string) => Nullable<Vec>;
-};
-/**
- * Builds a {@link BaseN} codec for a fixed chunk width and alphabet.
- *
- * @param bits The chunk width in bits. `alphabet.length` must equal `2 ** bits`.
- * @param alphabet The character used for each unsigned `bits`-bit value, in
- *   ascending order (index `0` → first character).
- * @param normalize Optional pre-lookup transform applied to each input
- *   character on decode — e.g. Crockford base32 lowercases and folds
- *   `i`/`l`→`1`, `o`→`0`.
- */
-export declare const baseN: (bits: bigint, alphabet: string, normalize?: (c: string) => string) => BaseN;

package/fjs/base_n/module.f.js

@@ -1,72 +0,0 @@
-/**
- * Shared bit-codec factory for alphabet-based encodings such as `base64` and
- * `cbase32`.
- *
- * Each call returns the raw `Vec ↔ string` codec parameterised by the chunk
- * width (`bits`) and the alphabet (and an optional input-character
- * normalisation step on the decode side). Padding strategies — RFC 4648 `=`
- * octet-alignment, Crockford-style stop-bit sentinels, etc. — are deliberately
- * out of scope: they vary per format and are handled by the caller around
- * `vecToString` / `stringToVec`.
- *
- * @module
- */
-import { msb, lsb, vec, chunkList, unpack } from '../types/bit_vec/module.f.js';
-import { fold } from '../types/list/module.f.js';
-import { compose } from '../types/function/module.f.js';
-const { unpackSplit } = msb;
-const { tryListToVec: reversedListToVec } = lsb;
-// `chunkList(msb)` doesn't depend on `bits` or `v` — shared across every
-// `baseN(...)` codec (base64, cbase32, ...).
-const chunkListMsb = chunkList(msb);
-/**
- * Builds a {@link BaseN} codec for a fixed chunk width and alphabet.
- *
- * @param bits The chunk width in bits. `alphabet.length` must equal `2 ** bits`.
- * @param alphabet The character used for each unsigned `bits`-bit value, in
- *   ascending order (index `0` → first character).
- * @param normalize Optional pre-lookup transform applied to each input
- *   character on decode — e.g. Crockford base32 lowercases and folds
- *   `i`/`l`→`1`, `o`→`0`.
- */
-export const baseN = (bits, alphabet, normalize) => {
-    const vecN = vec(bits);
-    const toIndex = normalize === undefined
-        ? (c) => alphabet.indexOf(c)
-        : (c) => alphabet.indexOf(normalize(c));
-    const unpackSplitBits = unpackSplit(bits);
-    // Converts one `<= bits`-wide chunk (as yielded by `chunkList`, already
-    // masked to its own length) to its alphabet index. A trailing partial
-    // chunk shorter than `bits` is left-padded with zeros: `unpackSplit`'s
-    // shift amount goes negative, which per spec becomes a left shift.
-    const chunkToIndex = (chunk) => {
-        const u = unpack(chunk);
-        return Number(u.length < bits ? unpackSplitBits(u)[0] : u.uint);
-    };
-    // Folds directly over `chunkList`'s lazy list in one pass — faster than
-    // `map` into a second lazy list before joining, since there's no second
-    // list to allocate/traverse.
-    const chunkToString = (chunk) => (acc) => acc + alphabet[chunkToIndex(chunk)];
-    return {
-        // `chunkListMsb(bits)` then `fold(chunkToString)('')` — neither half
-        // depends on `v`, so `compose` builds (and this closure captures)
-        // the composed function once per `baseN(...)` codec; no need to name
-        // the halves separately just to get that one-time build.
-        vecToString: compose(chunkListMsb(bits))(fold(chunkToString)('')),
-        stringToVec: s => {
-            // Build a reversed chunk list, bailing out at the first invalid
-            // character so malformed input is rejected in O(prefix) time and
-            // `normalize` is never run past it. `listToVec` then concatenates in
-            // O(n log n).
-            let chunks = null;
-            for (const c of s) {
-                const index = toIndex(c);
-                if (index < 0) {
-                    return null;
-                }
-                chunks = { first: vecN(BigInt(index)), tail: chunks };
-            }
-            return reversedListToVec(chunks);
-        },
-    };
-};

package/fjs/base_n/proof.f.js

@@ -1,73 +0,0 @@
-import { assertEq } from '../asserts/module.f.js';
-import { empty, maxLength, vec, length } from '../types/bit_vec/module.f.js';
-import { baseN } from './module.f.js';
-const hex = baseN(4n, '0123456789abcdef');
-const cb32 = baseN(5n, '0123456789abcdefghjkmnpqrstvwxyz', c => {
-    const lower = c.toLowerCase();
-    switch (lower) {
-        case 'i': {
-            return '1';
-        }
-        case 'l': {
-            return '1';
-        }
-        case 'o': {
-            return '0';
-        }
-        default: {
-            return lower;
-        }
-    }
-});
-// Sample input for the `big` proof below: 262 144 `f` characters decode into a
-// 1 Mibit (`maxLength`) vector.
-const bigSampleHex = `f`.repeat(Number(maxLength >> 2n));
-export const proof = {
-    encodeEmpty: () => {
-        const s = hex.vecToString(empty);
-        assertEq(s, '', [s]);
-    },
-    encodeAligned: () => {
-        // Two 4-bit chunks → two hex digits
-        const s = hex.vecToString(vec(8n)(0xa5n));
-        assertEq(s, 'a5', [s]);
-    },
-    encodeUnaligned: () => {
-        // 6 bits → first 4-bit chunk + a 2-bit tail that popFront pads with
-        // trailing zeros (the standard `popFront` behaviour the codec inherits).
-        const s = hex.vecToString(vec(6n)(41n));
-        assertEq(s, 'a4', [s]);
-    },
-    decodeEmpty: () => {
-        const v = hex.stringToVec('');
-        assertEq(v, empty, [v]);
-    },
-    decodeRoundTrip: () => {
-        const v = hex.stringToVec('ab');
-        assertEq(v, vec(8n)(0xabn), [v]);
-    },
-    decodeInvalid: () => {
-        assertEq(hex.stringToVec('z'), null, 'invalid char should return null');
-        assertEq(hex.stringToVec('aZ'), null, 'mixed invalid char should return null');
-    },
-    normalizeHit: () => {
-        // 'A' lowercases to 'a' — same vector as the lowercase input.
-        const a = cb32.stringToVec('A');
-        const b = cb32.stringToVec('a');
-        assertEq(a, b, [a, b]);
-        // Crockford folds: i,l → 1 and o → 0.
-        assertEq(cb32.stringToVec('I'), cb32.stringToVec('1'), 'I→1');
-        assertEq(cb32.stringToVec('l'), cb32.stringToVec('1'), 'l→1');
-        assertEq(cb32.stringToVec('o'), cb32.stringToVec('0'), 'o→0');
-    },
-    normalizeMiss: () => {
-        assertEq(cb32.stringToVec('u'), null, 'unknown char should return null');
-    },
-    // Decodes a 1 Mibit hex string. With the O(n log n) `listToVec` builder this
-    // runs in well under a second (was ~13 s node / ~43 s bun under the old
-    // per-chunk `concat`).
-    big: () => {
-        const x = hex.stringToVec(bigSampleHex);
-        assertEq(length(x), maxLength);
-    }
-};

package/fjs/basen/base128/module.f.d.ts

@@ -1,20 +0,0 @@
-/**
- * Base-128 encoding and decoding utilities over bit vectors.
- *
- * @module
- */
-import { type Vec } from '../../types/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/fjs/basen/base128/module.f.js

@@ -1,43 +0,0 @@
-/**
- * Base-128 encoding and decoding utilities over bit vectors.
- *
- * @module
- */
-import { vec8, msb, empty } from '../../types/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/fjs/basen/base128/proof.f.js

@@ -1,26 +0,0 @@
-import { empty, vec, vec8 } from '../../types/bit_vec/module.f.js';
-import { asBase } from '../../types/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 const proof = () => {
-    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/fjs/basen/base64/module.f.d.ts

@@ -1,9 +0,0 @@
-/**
- * Standard Base64 encoding and decoding (RFC 4648).
- *
- * @module
- */
-import { type Vec } from "../../types/bit_vec/module.f.ts";
-import type { Nullable } from "../../types/nullable/module.f.ts";
-export declare const encode: (input: Vec) => Nullable<string>;
-export declare const decode: (input: string) => Nullable<Vec>;

package/fjs/basen/base64/module.f.js

@@ -1,71 +0,0 @@
-/**
- * Standard Base64 encoding and decoding (RFC 4648).
- *
- * @module
- */
-import { msb, length, vec, maxLength } from "../../types/bit_vec/module.f.js";
-import { baseN } from "../../base_n/module.f.js";
-const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-const { popFront } = msb;
-const { vecToString, stringToVec } = baseN(6n, alphabet);
-export const encode = (input) => {
-    const len = length(input);
-    // Base64 is a byte codec; reject non-octet-aligned inputs.
-    if (len % 8n !== 0n) {
-        return null;
-    }
-    // `vecToString` (via `baseN`'s `chunkList`) already left-pads a trailing
-    // partial 6-bit chunk with zeros, so `input` needs no explicit padding —
-    // building one would risk pushing an intermediate `Vec` past `maxLength`
-    // for input already at or near that limit, for no benefit.
-    let result = vecToString(input);
-    // Append `=` padding to make total length a multiple of 4.
-    while (result.length % 4 !== 0) {
-        result += '=';
-    }
-    return result;
-};
-export const decode = (input) => {
-    // Count and strip trailing `=` padding (0, 1, or 2).
-    let padChars = 0;
-    for (let i = input.length - 1; i >= 0 && input[i] === '='; i--) {
-        padChars++;
-    }
-    if (padChars > 2) {
-        return null;
-    }
-    const body = input.slice(0, input.length - padChars);
-    // Total chars must make a multiple of 4 with the padding.
-    if ((body.length + padChars) % 4 !== 0) {
-        return null;
-    }
-    if (padChars === 0) {
-        return stringToVec(body);
-    }
-    // `encode`'s zero-padding bits (added to reach a 6-bit boundary) live
-    // entirely inside the *last* character's chunk — RFC 4648 padding never
-    // spans more than one base64 character. Decode every character but the
-    // last through `stringToVec` as usual, then decode and trim the last
-    // character on its own, so no intermediate `Vec` built here is ever
-    // wider than the final, post-trim result — even for input whose decoded
-    // payload lands exactly at `maxLength`.
-    const removeBits = BigInt(padChars * 2);
-    const realBits = 6n - removeBits;
-    const head = stringToVec(body.slice(0, body.length - 1));
-    if (head === null) {
-        return null;
-    }
-    const lastChunk = stringToVec(body.slice(body.length - 1));
-    if (lastChunk === null) {
-        return null;
-    }
-    if (length(head) + realBits > maxLength) {
-        return null;
-    }
-    const [kept, pad] = popFront(realBits)(lastChunk);
-    // Padding bits must be zero (RFC 4648 §3.5).
-    if (pad !== vec(removeBits)(0n)) {
-        return null;
-    }
-    return msb.concat(head)(vec(realBits)(kept));
-};

package/fjs/basen/base64/proof.f.d.ts

@@ -1,16 +0,0 @@
-export declare const proof: {
-    empty: () => void;
-    oneByte: () => void;
-    twoBytes: () => void;
-    threeBytes: () => void;
-    roundtrip: () => void;
-    nonOctet: () => void;
-    invalidInput: () => void;
-    validPadding: () => void;
-    knownVectors: () => void;
-    decodeOverflow: () => void;
-    decodePaddedTailRejections: () => void;
-    encodeAtMaxLengthSucceeds: () => void;
-    decodeAtMaxLengthSucceeds: () => void;
-    encodeLargeVecIsSlow: () => void;
-};

package/fjs/basen/base64/proof.f.js

@@ -1,139 +0,0 @@
-import { assertEq } from '../../asserts/module.f.js';
-import { empty, vec, repeat, vec8, maxLength } from "../../types/bit_vec/module.f.js";
-import { encode, decode } from "./module.f.js";
-const check = (s, v) => {
-    assertEq(encode(v), s);
-    assertEq(decode(s), v);
-};
-export const proof = {
-    empty: () => {
-        check('', empty);
-    },
-    oneByte: () => {
-        // 0x00 → 0b00000000, padded to 12 bits → AA==
-        check('AA==', vec(8n)(0n));
-        // 0x48 'H' → 0b01001000 → SA==
-        check('SA==', vec(8n)(72n));
-        // 0xFF → 0b11111111, padded 12: 111111110000 → /w==
-        check('/w==', vec(8n)(255n));
-    },
-    twoBytes: () => {
-        // 0x0000 → AAAA with == stripped → 16 bits: AA==? No: 16 bits → 18 bits with 2 pad → 3 chars + =
-        // 0b0000000000000000 padded 2 bits → 18 bits: 000000 000000 000000 → AAA=
-        check('AAA=', vec(16n)(0n));
-        // 0xFFFF → 0b1111111111111111 padded 2 bits → 111111 111111 111100 → //8=
-        check('//8=', vec(16n)(65535n));
-    },
-    threeBytes: () => {
-        // 24 bits, no padding
-        check('AAAA', vec(24n)(0n));
-        check('////', vec(24n)(16777215n));
-    },
-    roundtrip: () => {
-        // Various bit lengths
-        check('AA==', vec(8n)(0n));
-        check('AAA=', vec(16n)(0n));
-        check('AAAA', vec(24n)(0n));
-        // 32 bits
-        check('AAAAAA==', vec(32n)(0n));
-        // 40 bits (5 bytes: AAAA + AAA=)
-        check('AAAAAAA=', vec(40n)(0n));
-    },
-    nonOctet: () => {
-        // encode rejects bit vectors whose length is not a multiple of 8
-        assertEq(encode(vec(1n)(0n)), null);
-        assertEq(encode(vec(6n)(0n)), null);
-        assertEq(encode(vec(12n)(0n)), null);
-    },
-    invalidInput: () => {
-        assertEq(decode('!'), null);
-        assertEq(decode('A!AA'), null);
-        assertEq(decode('A==='), null);
-        assertEq(decode('A'), null);
-        assertEq(decode('AA'), null);
-        assertEq(decode('AAA'), null);
-        assertEq(decode('=AAA'), null);
-        // Non-zero padding bits must be rejected (RFC 4648 §3.5)
-        assertEq(decode('AB=='), null);
-        assertEq(decode('AAB='), null);
-    },
-    validPadding: () => {
-        // "==" padding
-        assertEq(decode('AA=='), vec(8n)(0n));
-        // "=" padding
-        assertEq(decode('AAA='), vec(16n)(0n));
-        // No padding
-        assertEq(decode('AAAA'), vec(24n)(0n));
-    },
-    knownVectors: () => {
-        // RFC 4648 §10 test vectors (byte-aligned, treating bytes as 8-bit MSB vectors)
-        // '' → ''
-        check('', empty);
-        // 0x66 ('f') → Zg==
-        check('Zg==', vec(8n)(0x66n));
-        // 0x66 0x6f ('fo') → Zm8=
-        check('Zm8=', vec(16n)(0x666fn));
-        // 0x66 0x6f 0x6f ('foo') → Zm9v
-        check('Zm9v', vec(24n)(0x666f6fn));
-    },
-    decodeOverflow: () => {
-        // 174_764 base64 chars decode to 1_048_584 bits, 8 over `maxLength`;
-        // `decode` should return `null` instead of throwing on (or hanging
-        // while building) an oversized `bigint`.
-        const oversized = 'A'.repeat(174_764);
-        assertEq(decode(oversized), null);
-    },
-    decodePaddedTailRejections: () => {
-        // These all take the padded branch of `decode` (`padChars > 0`,
-        // i.e. the `head`/`lastChunk` split), unlike `decodeOverflow` above
-        // which takes the unpadded fast path. An invalid character before
-        // the final char must be rejected via the `head` decode...
-        assertEq(decode('!A=='), null);
-        // ...and an invalid final character (the one holding the padding
-        // bits) must be rejected via the last-character decode.
-        assertEq(decode('A!=='), null);
-        // Same as `decodeOverflow`, but with a padded tail so it's the
-        // padded branch that measures the result against `maxLength` and
-        // rejects it.
-        assertEq(decode('A'.repeat(174_764) + '='), null);
-    },
-    encodeAtMaxLengthSucceeds: () => {
-        // A `maxLength`-sized vector's trailing partial 6-bit chunk is
-        // left-padded by `vecToString` itself (see `baseN`), so `encode`
-        // never needs to build an over-`maxLength` intermediate and must not
-        // reject this boundary input.
-        assertEq(encode(vec(maxLength)(0n)), 'A'.repeat(174_763) + '=');
-    },
-    decodeAtMaxLengthSucceeds: () => {
-        // Companion to `encodeAtMaxLengthSucceeds`: the encoded string's raw,
-        // pre-trim bit count (1_048_578) is 2 over `maxLength` even though
-        // the payload it decodes to is exactly `maxLength`. `decode` must
-        // trim the last character's 2 zero-padding bits before — not after —
-        // measuring the result against `maxLength`.
-        check('A'.repeat(174_763) + '=', vec(maxLength)(0n));
-    },
-    // Regression guard: `encode` used to be quadratic in the input size, not
-    // linear. `baseN`'s `vecToString` (`fjs/base_n/module.f.ts`) popped one
-    // 6-bit chunk off the front at a time via `popFront`, and each `popFront`
-    // re-masked the entire remaining bigint through `vec()`'s `m & ui` —
-    // O(remaining length) — so encoding a vector of `n` bits cost O(n²). A
-    // 90,000-byte input took ~5.6s on Node and ~18.4s on Bun (Bun's `bigint`
-    // has a much higher per-operation constant, see PR #1190), reliably
-    // blowing `bun test`'s 5s per-test timeout — the same class of failure
-    // that hit `cas_get content:true` on a comparably-sized binary blob in CI
-    // (PR #1201).
-    //
-    // Fixed by rewriting `vecToString` as a balanced recursive split
-    // (`unpackToString`), mirroring the `chunkList`/`unpackChunkList`
-    // divide-and-conquer already used by `u8List` and by concatenation
-    // (`msb.concat` / `unpackListToVec`, PR #1192) — true O(n log n) now,
-    // since each half is masked to its own length before recursing. The same
-    // call now takes ~50ms on Node and ~225ms on Bun. No timing assertion
-    // (duration varies by engine/machine) — this just exercises the call and
-    // relies on the test runner's own per-test timing to catch a regression.
-    encodeLargeVecIsSlow: () => {
-        const big = repeat(90000n)(vec8(0xffn));
-        const result = encode(big);
-        assertEq(result?.length, 120_000);
-    },
-};

package/fjs/basen/cbase32/module.f.d.ts

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

package/fjs/basen/cbase32/module.f.js

@@ -1,55 +0,0 @@
-/**
- * Content-addressable Base32 encoding and decoding helpers.
- *
- * @module
- */
-import { msb, lsb, length, vec, empty } from "../../types/bit_vec/module.f.js";
-import { baseN } from "../../base_n/module.f.js";
-//                         0123456789abcdef
-const m = '0123456789abcdefghjkmnpqrstvwxyz';
-const { concat } = msb;
-const popBack1 = lsb.popFront(1n);
-const normalizeChar = (c) => {
-    const lower = c.toLowerCase();
-    switch (lower) {
-        case 'i': {
-            return '1';
-        }
-        case 'l': {
-            return '1';
-        }
-        case 'o': {
-            return '0';
-        }
-        default: {
-            return lower;
-        }
-    }
-};
-const codec = baseN(5n, m, normalizeChar);
-export const vec5xToCBase32 = codec.vecToString;
-export const cBase32ToVec5x = codec.stringToVec;
-export const vecToCBase32 = (v) => {
-    const len = length(v);
-    const extraLen = 5n - len % 5n;
-    const last = 1n << (extraLen - 1n);
-    const padded = concat(v)(vec(extraLen)(last));
-    return vec5xToCBase32(padded);
-};
-export const cBase32ToVec = (s) => {
-    let v = cBase32ToVec5x(s);
-    if (v === null) {
-        return null;
-    }
-    // Strip the padding: trailing zeros up to and including the sentinel `1` bit.
-    // A string with no sentinel — only zero symbols (`0`/`o`), or empty — exhausts
-    // to `empty` and is rejected as `null` rather than looping forever.
-    while (v !== empty) {
-        const [last, rest] = popBack1(v);
-        v = rest;
-        if (last === 1n) {
-            return v;
-        }
-    }
-    return null;
-};

package/fjs/basen/cbase32/proof.f.d.ts

@@ -1,7 +0,0 @@
-export declare const proof: {
-    roundtrip5x: () => void;
-    roundtrip: () => void;
-    unalignedBits: () => void;
-    caseInsensitive: () => void;
-    unterminated: () => void;
-};