functionalscript 0.43.1 → 0.45.0

package/fjs/asn.1/module.f.js

@@ -1,278 +0,0 @@
-/**
- * ASN.1 BER/DER encoding and decoding over bit vectors. Includes tag/class
- * helpers, length-prefixed payloads, and OID conversion via Base-128.
- *
- * @module
- */
-import { bitLength, divUp8 } from "../types/bigint/module.f.js";
-import { empty, isVec, length, msb, uint, unpack, vec, vec8 } from "../types/bit_vec/module.f.js";
-import { identity } from "../types/function/module.f.js";
-import { max } from "../types/function/compare/module.f.js";
-import { encode as b128encode, decode as b128decode } from "../basen/base128/module.f.js";
-const { popFront: pop, listToVec } = msb;
-const pop8 = pop(8n);
-const classPcMask = 224n;
-const tagNumberMask = 31n;
-const parsedTagEncode = ([classPc, number]) => {
-    const [firstByteNumber, rest] = number < tagNumberMask
-        ? [number, empty]
-        : [tagNumberMask, b128encode(number)];
-    return listToVec([vec8(classPc | firstByteNumber), rest]);
-};
-const parsedTagDecode = (v) => {
-    const [firstByte, rest] = pop8(v);
-    const classPc = (firstByte & classPcMask);
-    const firstByteNumber = firstByte & tagNumberMask;
-    const [number, rest1] = firstByteNumber < tagNumberMask
-        ? [firstByteNumber, rest]
-        : b128decode(rest);
-    return [[classPc, number], rest1];
-};
-const tagEncode = (tag) => vec(max(divUp8(bitLength(tag)))(1n) << 3n)(tag);
-const tagDecode = (v) => {
-    const [parsedTag, rest] = parsedTagDecode(v);
-    return [uint(parsedTagEncode(parsedTag)), rest];
-};
-//
-const eoc = 0x00n;
-/** ASN.1 universal BOOLEAN tag. */
-export const boolean = 0x01n;
-/** ASN.1 universal INTEGER tag. */
-export const integer = 0x02n;
-const bitString = 0x03n;
-/** ASN.1 universal OCTET STRING tag. */
-export const octetString = 0x04n;
-const null_ = 0x05;
-/** ASN.1 universal OBJECT IDENTIFIER tag. */
-export const objectIdentifier = 0x06n;
-const objectDescriptor = 0x07;
-const external = 0x08;
-const real = 0x09;
-const enumerated = 0x0A;
-const embeddedPdv = 0x0B;
-const utf8string = 0x0C;
-const relativeOid = 0x0D;
-const time = 0x0E;
-const sequence = 0x10;
-const set = 0x11;
-const numericString = 0x12;
-const printableString = 0x13;
-const t61String = 0x14;
-const videotexString = 0x15;
-const ia5String = 0x16;
-const utcTime = 0x17;
-const generalizedTime = 0x18;
-const graphicString = 0x19;
-const visibleString = 0x1A;
-const generalString = 0x1B;
-const universalString = 0x1C;
-const characterString = 0x1D;
-const bmpString = 0x1E;
-const date = 0x1F;
-const timeOfDay = 0x20;
-const dateTime = 0x21;
-const duration = 0x22;
-const oidIri = 0x23;
-const relativeOidIri = 0x24;
-const constructed = 0x20;
-export const constructedSequence = 0x30n; // constructed | sequence
-export const constructedSet = 0x31n; // constructed | set
-const round8 = ({ length, uint }) => {
-    const byteLen = divUp8(length);
-    return { byteLen, v: vec(byteLen << 3n)(uint) };
-};
-const lenEncode = (uint) => {
-    if (uint < 0x80n) {
-        return vec8(uint);
-    }
-    const { byteLen, v } = round8({ length: bitLength(uint), uint });
-    return listToVec([vec8(0x80n | byteLen), v]);
-};
-/**
- * Decodes the length field of an ASN.1 TLV and returns the length in bits and the remaining input.
- *
- * @param v - The input bit vector starting with the length field.
- * @returns A tuple containing the length in bits and the remaining input after the length field.
- */
-const lenDecode = (v) => {
-    const firstAndRest = pop8(v);
-    const [first, rest1] = firstAndRest;
-    const [byteLen, rest2] = first < 0x80n ? firstAndRest : pop((first & 0x7fn) << 3n)(rest1);
-    return [byteLen << 3n, rest2];
-};
-/** Encodes a raw ASN.1 TLV tuple into a bit vector. */
-export const encodeRaw = ([tag, value]) => {
-    const tagVec = tagEncode(tag);
-    const { byteLen, v } = round8(unpack(value));
-    return listToVec([tagVec, lenEncode(byteLen), v]);
-};
-/** Decodes a raw ASN.1 TLV tuple and returns the remaining input. */
-export const decodeRaw = (v) => {
-    const [tag, v1] = tagDecode(v);
-    const [len, v2] = lenDecode(v1);
-    const [result, next] = pop(len)(v2);
-    return [[tag, vec(len)(result)], next];
-};
-// boolean
-/** Encodes a JavaScript boolean as an ASN.1 BOOLEAN value. */
-export const encodeBoolean = (b) => vec8(b ? 0xffn : 0x00n);
-/** Decodes an ASN.1 BOOLEAN value. */
-export const decodeBoolean = (v) => uint(v) !== 0n;
-// integer (two's compliment)
-/** Encodes a signed bigint using ASN.1 INTEGER two's complement representation. */
-export const encodeInteger = (uint) => {
-    const offset = uint < 0n ? 1n : 0n;
-    return round8({ length: bitLength(uint + offset) + 1n, uint }).v;
-};
-/** Decodes an ASN.1 INTEGER encoded in two's complement. */
-export const decodeInteger = (v) => {
-    const { length, uint } = unpack(v);
-    const sign = uint >> (length - 1n);
-    return sign === 0n ? uint : uint - (1n << length);
-};
-// octet string
-/** Encodes an OCTET STRING value. */
-export const encodeOctetString = (v) => v;
-/** Decodes an OCTET STRING value. */
-export const decodeOctetString = (v) => v;
-/** Encodes an OBJECT IDENTIFIER value. */
-export const encodeObjectIdentifier = (oid) => {
-    const [first, second, ...rest] = oid;
-    const firstByte = first * 40n + second;
-    return listToVec([vec8(firstByte), ...rest.map(b128encode)]);
-};
-/**
- * Drains a bit vector by repeatedly applying a step until the vector is empty,
- * collecting every decoded item into an array.
- */
-const decodeAll = (step) => (v) => {
-    let result = [];
-    while (length(v) !== 0n) {
-        const [item, rest] = step(v);
-        result = [...result, item];
-        v = rest;
-    }
-    return result;
-};
-/** Decodes an OBJECT IDENTIFIER value. */
-export const decodeObjectIdentifier = (v) => {
-    const [firstByte, rest] = pop8(v);
-    return [firstByte / 40n, firstByte % 40n, ...decodeAll(b128decode)(rest)];
-};
-const genericEncodeSequence = (map) => (...records) => listToVec(map(records.map(encode)));
-/** Encodes a SEQUENCE payload from ordered records. */
-export const encodeSequence = genericEncodeSequence(identity);
-/** Decodes a SEQUENCE payload into records. */
-export const decodeSequence = (v) => decodeAll(decode)(v);
-/** Encodes a SET payload with canonical byte ordering. */
-export const encodeSet = genericEncodeSequence(v => v.toSorted((a, b) => msb.cmp(a)(b)));
-/** Decodes a SET payload. */
-export const decodeSet = decodeSequence;
-// encode
-const recordToRaw = ([tag, value]) => {
-    switch (tag) {
-        case boolean: return encodeBoolean(value);
-        case integer: return encodeInteger(value);
-        case octetString: return encodeOctetString(value);
-        case objectIdentifier: return encodeObjectIdentifier(value);
-        case constructedSequence: return encodeSequence(...value);
-        case constructedSet: return encodeSet(...value);
-    }
-};
-/** Encodes a supported ASN.1 record as TLV. */
-export const encode = (record) => isVec(record) ? record : encodeRaw([record[0], recordToRaw(record)]);
-// decode
-const rawToRecord = (raw) => {
-    const [tag, value] = raw;
-    switch (tag) {
-        case boolean: return [boolean, decodeBoolean(value)];
-        case integer: return [integer, decodeInteger(value)];
-        case octetString: return [octetString, decodeOctetString(value)];
-        case objectIdentifier: return [objectIdentifier, decodeObjectIdentifier(value)];
-        case constructedSequence: return [constructedSequence, decodeSequence(value)];
-        case constructedSet: return [constructedSet, decodeSet(value)];
-        default: return encodeRaw(raw);
-    }
-};
-/** Decodes one supported ASN.1 record and returns the remaining input. */
-export const decode = (v) => {
-    const [raw, rest] = decodeRaw(v);
-    return [rawToRecord(raw), rest];
-};
-/*
-TimeStampReq ::= SEQUENCE {
-    version        INTEGER { v1(1) },               // [x]
-    messageImprint MessageImprint,
-    reqPolicy      TSAPolicyId OPTIONAL,
-    nonce          INTEGER OPTIONAL,                // [X]
-    certReq        BOOLEAN DEFAULT FALSE,           // [X]
-    extensions     [0] IMPLICIT Extensions OPTIONAL // [X]
-}
-
-MessageImprint ::= SEQUENCE {
-    hashAlgorithm  AlgorithmIdentifier,
-    hashedMessage  OCTET STRING         // [X]
-}
-
-TSAPolicyId ::= OBJECT IDENTIFIER // [X]
-*/
-/*
-TimeStampResp ::= SEQUENCE {
-    status          PKIStatusInfo,
-    timeStampToken  TimeStampToken OPTIONAL
-}
-
-PKIStatusInfo ::= SEQUENCE {
-    status        PKIStatus,
-    statusString  PKIFreeText OPTIONAL,
-    failInfo      PKIFailureInfo OPTIONAL
-}
-
-PKIStatus ::= INTEGER {         // [X]
-    granted                (0),
-    grantedWithMods        (1),
-    rejection              (2),
-    waiting                (3),
-    revocationWarning      (4),
-    revocationNotification (5)
-}
-
-TimeStampToken ::= ContentInfo
-
-ContentInfo ::= SEQUENCE {
-    contentType ContentType,
-    content     [0] EXPLICIT ANY DEFINED BY contentType
-}
-
-ContentType ::= OBJECT IDENTIFIER
-
-SignedData ::= SEQUENCE {
-    version          CMSVersion,
-    digestAlgorithms SET OF DigestAlgorithmIdentifier,            // [X]
-    encapContentInfo EncapsulatedContentInfo,
-    certificates     [0] IMPLICIT CertificateSet OPTIONAL,
-    crls             [1] IMPLICIT RevocationInfoChoices OPTIONAL,
-    signerInfos      SET OF SignerInfo                            // [X]
-}
-
-EncapsulatedContentInfo ::= SEQUENCE {
-    eContentType ContentType,
-    eContent     [0] EXPLICIT OCTET STRING OPTIONAL
-}
-
-TSTInfo ::= SEQUENCE  {
-    version        INTEGER  { v1(1) },
-    policy         TSAPolicyId,
-    messageImprint MessageImprint,
-    serialNumber   INTEGER,
-    genTime        GeneralizedTime,
-    accuracy       Accuracy OPTIONAL,
-    ordering       BOOLEAN DEFAULT FALSE,
-    nonce          INTEGER OPTIONAL,
-    tsa            [0] GeneralName OPTIONAL,
-    extensions     [1] IMPLICIT Extensions OPTIONAL
-}
-
-Bits:  8 7   | 6    | 5 4 3 2 1
-       Class | P/C  | Tag number
-*/

package/fjs/asn.1/proof.f.d.ts

@@ -1,48 +0,0 @@
-export declare const proof: {
-    encodeSmall: () => void;
-    encode7F: () => void;
-    encode80: () => void;
-    encodeFF: () => void;
-    encode103: () => void;
-    ed: ((() => void) | {
-        x80: () => void;
-        x100: () => void;
-        x1000: () => void;
-        x10000: () => void;
-        x20000: () => void;
-        x40000: () => void;
-        x80000: () => void;
-        xC0000: () => void;
-        xE0000: () => void;
-        xF0000: () => void;
-        xFFF00: () => void;
-        xFFF80: () => void;
-        xFFFC0: () => void;
-        xFFFD0: () => void;
-    })[];
-    integerValue: {
-        zero: () => void;
-        one: () => void;
-        minusOne: () => void;
-        x7F: () => void;
-        x80: () => void;
-        xFF: () => void;
-        nx7F: () => void;
-        nx80: () => void;
-        nx81: () => void;
-        nx7FFF: () => void;
-        nx8000: () => void;
-        nx8001: () => void;
-    };
-    encodeDecode: {
-        integer: () => void;
-        sequence: () => void;
-        set: () => void;
-    };
-    objectIdentifier: {
-        simple: () => void;
-        withArc: () => void;
-    };
-    unknownTag: () => void;
-    raw: (() => void)[];
-};

package/fjs/asn.1/proof.f.js

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

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

@@ -1,36 +0,0 @@
-/**
- * Assertion helpers for runtime checks and compile-time type-level tests.
- *
- * @module
- */
-/**
- * Marks a code path as unimplemented. Always throws.
- */
-export declare const todo: () => never;
-/**
- * Throws `msg` (default `'assertion failed'`) if `v` is `false`.
- *
- * Narrows `v` to `true` via `asserts v`, so callers can rely on the
- * condition holding for the rest of the enclosing scope.
- */
-export declare const assert: (v: boolean, msg?: unknown) => asserts v;
-/**
- * Asserts that `a` and `b` are `===`, throwing `x` (the `[a, b]` pair, plus
- * an optional third element used as an extra message) if they differ.
- */
-export declare const assertEq: <T>(...x: readonly [T, T, unknown?]) => void;
-/**
- * Compile-time-only check: a type resolves only if it is exactly `true`.
- * Used to assert type-level properties without any runtime cost, e.g.
- * `type _ = Assert<Equal<A, B>>`.
- */
-export type Assert<T extends true> = T;
-/**
- * Asserts that `a` is neither `null` nor `undefined` and returns it,
- * narrowed to `T`.
- *
- * Use this to chain directly off a call that may return a nullish value,
- * e.g. `const r = assertNotNullish(f(x))`. For a variable that already
- * exists, prefer `assert(a !== null && a !== undefined)` instead.
- */
-export declare const assertNotNullish: <T>(a: T | null | undefined, msg?: unknown) => T;

package/fjs/asserts/module.f.js

@@ -1,39 +0,0 @@
-/**
- * Assertion helpers for runtime checks and compile-time type-level tests.
- *
- * @module
- */
-/**
- * Marks a code path as unimplemented. Always throws.
- */
-export const todo = () => { throw 'not implemented'; };
-/**
- * Throws `msg` (default `'assertion failed'`) if `v` is `false`.
- *
- * Narrows `v` to `true` via `asserts v`, so callers can rely on the
- * condition holding for the rest of the enclosing scope.
- */
-export const assert = (v, msg = 'assertion failed') => {
-    if (!v)
-        throw msg;
-};
-/**
- * Asserts that `a` and `b` are `===`, throwing `x` (the `[a, b]` pair, plus
- * an optional third element used as an extra message) if they differ.
- */
-export const assertEq = (...x) => {
-    const [a, b] = x;
-    assert(a === b, x);
-};
-/**
- * Asserts that `a` is neither `null` nor `undefined` and returns it,
- * narrowed to `T`.
- *
- * Use this to chain directly off a call that may return a nullish value,
- * e.g. `const r = assertNotNullish(f(x))`. For a variable that already
- * exists, prefer `assert(a !== null && a !== undefined)` instead.
- */
-export const assertNotNullish = (a, msg) => {
-    assert(a !== null && a !== undefined, msg);
-    return a;
-};

package/fjs/asserts/proof.f.d.ts

@@ -1,11 +0,0 @@
-export declare const proof: {
-    assertPassesOnTrue: () => void;
-    assertEqPassesOnEqual: () => void;
-    throw: {
-        assertEqThrowsOnUnequal: () => void;
-        assertEqThrowsOnUnequal3: () => void;
-        assertThrowsDefaultMsg: () => void;
-        assertThrowsCustomMsg: () => void;
-        todoThrows: () => never;
-    };
-};