functionalscript 0.30.0 → 0.31.0

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

@@ -4,7 +4,7 @@
  *
  * @module
  */
-import { bitLength } from "../types/bigint/module.f.js";
+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";
@@ -28,7 +28,7 @@ const parsedTagDecode = (v) => {
         : b128decode(rest);
     return [[classPc, number], rest1];
 };
-const tagEncode = (tag) => vec(max((bitLength(tag) + 7n) >> 3n)(1n) << 3n)(tag);
+const tagEncode = (tag) => vec(max(divUp8(bitLength(tag)))(1n) << 3n)(tag);
 const tagDecode = (v) => {
     const [parsedTag, rest] = parsedTagDecode(v);
     return [uint(parsedTagEncode(parsedTag)), rest];
@@ -78,7 +78,7 @@ const constructed = 0x20;
 export const constructedSequence = 0x30n; // constructed | sequence
 export const constructedSet = 0x31n; // constructed | set
 const round8 = ({ length, uint }) => {
-    const byteLen = (length + 7n) >> 3n;
+    const byteLen = divUp8(length);
     return { byteLen, v: vec(byteLen << 3n)(uint) };
 };
 const lenEncode = (uint) => {
@@ -141,33 +141,29 @@ export const encodeObjectIdentifier = (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);
-    const first = firstByte / 40n;
-    const second = firstByte % 40n;
-    let result = [first, second];
-    let tail = rest;
-    while (length(tail) > 0n) {
-        const [value, next] = b128decode(tail);
-        result = [...result, value];
-        tail = next;
-    }
-    return result;
+    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) => {
-    let result = [];
-    while (length(v) !== 0n) {
-        const [record, rest] = decode(v);
-        result = [...result, record];
-        v = rest;
-    }
-    return result;
-};
+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. */

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

@@ -39,5 +39,10 @@ export declare const proof: {
         sequence: () => void;
         set: () => void;
     };
+    objectIdentifier: {
+        simple: () => void;
+        withArc: () => void;
+    };
+    unknownTag: () => void;
     raw: (() => void)[];
 };

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

@@ -1,6 +1,7 @@
-import { empty, length, msb, uint, unpack, vec, vec8 } from "../types/bit_vec/module.f.js";
+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 } from "./module.f.js";
+import { decodeRaw, decodeInteger, encodeRaw, encodeInteger, integer, encode, decode, constructedSequence, octetString, boolean, constructedSet, encodeObjectIdentifier, decodeObjectIdentifier, } from "./module.f.js";
+import { assertEq } from "../asserts/module.f.js";
 const { concat, popFront: pop, listToVec } = msb;
 const pop8 = pop(8n);
 const check = (tag, v, rest) => {
@@ -272,6 +273,41 @@ export const proof = {
             ]));
         },
     },
+    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);
+        if (!isVec(decoded)) {
+            throw 'expected UnsupportedRecord (Vec)';
+        }
+        if (rest !== empty) {
+            throw 'expected empty rest';
+        }
+        // Re-encoding an UnsupportedRecord returns it unchanged (it is already the TLV bytes)
+        if (encode(decoded) !== raw) {
+            throw 'encode should round-trip UnsupportedRecord';
+        }
+    },
     raw: [
         () => {
             const e = encodeRaw([0x00n, vec8(0x23n)]);

package/fs/base64/module.f.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 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/fs/base64/module.f.js

@@ -0,0 +1,60 @@
+/**
+ * Standard Base64 encoding and decoding (RFC 4648).
+ *
+ * @module
+ */
+import { msb, length, vec, empty } from "../types/bit_vec/module.f.js";
+import { baseN } from "../base_n/module.f.js";
+const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const { popFront, concat } = 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;
+    }
+    const rem = len % 24n;
+    const padBits = rem === 0n ? 0n : 6n - rem % 6n;
+    const v = padBits > 0n ? concat(input)(vec(padBits)(0n)) : input;
+    let result = vecToString(v);
+    // 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;
+    }
+    // Decode each character to 6 bits.
+    const result = stringToVec(body);
+    if (result === null) {
+        return null;
+    }
+    // Remove the zero-padding bits introduced during encode.
+    // padChars=1 → 2 padding bits removed, padChars=2 → 4 padding bits removed.
+    const removeBits = BigInt(padChars * 2);
+    const totalBits = length(result);
+    const targetLen = totalBits - removeBits;
+    if (targetLen === 0n) {
+        return empty;
+    }
+    const [kept, padVec] = popFront(targetLen)(result);
+    // Padding bits must be zero (RFC 4648 §3.5).
+    if (removeBits > 0n && padVec !== vec(removeBits)(0n)) {
+        return null;
+    }
+    return vec(targetLen)(kept);
+};

package/fs/base64/proof.f.d.ts

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

package/fs/base64/proof.f.js

@@ -0,0 +1,117 @@
+import { empty, vec } from "../types/bit_vec/module.f.js";
+import { encode, decode } from "./module.f.js";
+const check = (s, v) => {
+    const sr = encode(v);
+    if (sr !== s) {
+        throw ['encode', sr, s];
+    }
+    const vr = decode(s);
+    if (vr !== v) {
+        throw ['decode', vr, 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
+        if (encode(vec(1n)(0n)) !== null) {
+            throw '1-bit input should return null';
+        }
+        if (encode(vec(6n)(0n)) !== null) {
+            throw '6-bit input should return null';
+        }
+        if (encode(vec(12n)(0n)) !== null) {
+            throw '12-bit input should return null';
+        }
+    },
+    invalidInput: () => {
+        if (decode('!') !== null) {
+            throw 'invalid char should return null';
+        }
+        if (decode('A!AA') !== null) {
+            throw 'invalid char mid-string should return null';
+        }
+        if (decode('A===') !== null) {
+            throw 'three equals signs should return null';
+        }
+        if (decode('A') !== null) {
+            throw 'length 1 (not multiple of 4) should return null';
+        }
+        if (decode('AA') !== null) {
+            throw 'length 2 (no padding) should return null';
+        }
+        if (decode('AAA') !== null) {
+            throw 'length 3 (no padding) should return null';
+        }
+        if (decode('=AAA') !== null) {
+            throw 'padding not at end should return null';
+        }
+        // Non-zero padding bits must be rejected (RFC 4648 §3.5)
+        if (decode('AB==') !== null) {
+            throw 'non-zero 4-pad-bit should return null';
+        }
+        if (decode('AAB=') !== null) {
+            throw 'non-zero 2-pad-bit should return null';
+        }
+    },
+    validPadding: () => {
+        // "==" padding
+        const v2 = decode('AA==');
+        if (v2 !== vec(8n)(0n)) {
+            throw ['AA== should decode to 8-bit zero', v2];
+        }
+        // "=" padding
+        const v1 = decode('AAA=');
+        if (v1 !== vec(16n)(0n)) {
+            throw ['AAA= should decode to 16-bit zero', v1];
+        }
+        // No padding
+        const v0 = decode('AAAA');
+        if (v0 !== vec(24n)(0n)) {
+            throw ['AAAA should decode to 24-bit zero', v0];
+        }
+    },
+    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));
+    },
+};

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

@@ -0,0 +1,44 @@
+/**
+ * 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 repeatedly popping `bits`-wide MSB chunks and
+     * indexing them into the alphabet. A trailing partial chunk shorter than
+     * `bits` is left-padded with zeros (the underlying `popFront` semantics).
+     */
+    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/fs/base_n/module.f.js

@@ -0,0 +1,54 @@
+/**
+ * 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, length, vec, empty } from "../types/bit_vec/module.f.js";
+const { popFront, concat } = 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 popFrontN = popFront(bits);
+    const vecN = vec(bits);
+    const toIndex = normalize === undefined
+        ? (c) => alphabet.indexOf(c)
+        : (c) => alphabet.indexOf(normalize(c));
+    return {
+        vecToString: v => {
+            let result = '';
+            while (length(v) > 0n) {
+                const [r, rest] = popFrontN(v);
+                result += alphabet[Number(r)];
+                v = rest;
+            }
+            return result;
+        },
+        stringToVec: s => {
+            let result = empty;
+            for (const c of s) {
+                const index = toIndex(c);
+                if (index < 0) {
+                    return null;
+                }
+                result = concat(result)(vecN(BigInt(index)));
+            }
+            return result;
+        },
+    };
+};

package/fs/base_n/proof.f.d.ts

@@ -0,0 +1,10 @@
+export declare const proof: {
+    encodeEmpty: () => void;
+    encodeAligned: () => void;
+    encodeUnaligned: () => void;
+    decodeEmpty: () => void;
+    decodeRoundTrip: () => void;
+    decodeInvalid: () => void;
+    normalizeHit: () => void;
+    normalizeMiss: () => void;
+};

package/fs/base_n/proof.f.js

@@ -0,0 +1,86 @@
+import { empty, vec } 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;
+        }
+    }
+});
+export const proof = {
+    encodeEmpty: () => {
+        const s = hex.vecToString(empty);
+        if (s !== '') {
+            throw [s];
+        }
+    },
+    encodeAligned: () => {
+        // Two 4-bit chunks → two hex digits
+        const s = hex.vecToString(vec(8n)(0xa5n));
+        if (s !== 'a5') {
+            throw [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));
+        if (s !== 'a4') {
+            throw [s];
+        }
+    },
+    decodeEmpty: () => {
+        const v = hex.stringToVec('');
+        if (v !== empty) {
+            throw [v];
+        }
+    },
+    decodeRoundTrip: () => {
+        const v = hex.stringToVec('ab');
+        if (v !== vec(8n)(0xabn)) {
+            throw [v];
+        }
+    },
+    decodeInvalid: () => {
+        if (hex.stringToVec('z') !== null) {
+            throw 'invalid char should return null';
+        }
+        if (hex.stringToVec('aZ') !== null) {
+            throw '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');
+        if (a !== b) {
+            throw [a, b];
+        }
+        // Crockford folds: i,l → 1 and o → 0.
+        if (cb32.stringToVec('I') !== cb32.stringToVec('1')) {
+            throw 'I→1';
+        }
+        if (cb32.stringToVec('l') !== cb32.stringToVec('1')) {
+            throw 'l→1';
+        }
+        if (cb32.stringToVec('o') !== cb32.stringToVec('0')) {
+            throw 'o→0';
+        }
+    },
+    normalizeMiss: () => {
+        if (cb32.stringToVec('u') !== null) {
+            throw 'unknown char should return null';
+        }
+    },
+};

package/fs/bnf/data/module.f.d.ts

@@ -7,6 +7,7 @@
 import { type CodePoint } from '../../text/utf16/module.f.ts';
 import { type RangeMapArray } from '../../types/range_map/module.f.ts';
 import { type Rule as FRule } from '../module.f.ts';
+import { type StringMap } from '../../types/object/module.f.ts';
 /**
  * Encoded terminal range value used by BNF data rules.
  *
@@ -18,9 +19,7 @@ export type TerminalRange = number;
  */
 export type Sequence = readonly string[];
 /** A variant of rule names. */
-export type Variant = {
-    readonly [k in string]: string;
-};
+export type Variant = StringMap<string, string>;
 /**
  * Grammar rule definition.
  *
@@ -45,12 +44,8 @@ type DispatchRuleCollection = {
     readonly tag: string | undefined;
     readonly rules: DispatchRuleOrName[];
 };
-type DispatchMap = {
-    readonly [id in string]: DispatchRule;
-};
-type EmptyTagMap = {
-    readonly [id in string]: EmptyTagEntry;
-};
+type DispatchMap = StringMap<string, DispatchRule>;
+type EmptyTagMap = StringMap<string, EmptyTagEntry>;
 /**
  * Recursive descent matcher for a single named rule.
  */

package/fs/bnf/data/module.f.js

@@ -11,6 +11,7 @@ import { rangeMap } from "../../types/range_map/module.f.js";
 import { contains, set } from "../../types/string_set/module.f.js";
 import { contains as rangeContains } from "../../types/range/module.f.js";
 import { oneEncode, rangeDecode, } from "../module.f.js";
+import { definedEntries } from "../../types/object/module.f.js";
 const { entries } = Object;
 const find = (map) => (fr) => {
     for (const [k, v] of entries(map)) {
@@ -151,7 +152,7 @@ export const dispatchMap = (ruleSet) => {
             return { ...dm, [name]: dr };
         }
         else {
-            const entries = Object.entries(rule);
+            const entries = definedEntries(rule);
             let result = [];
             let emptyTag = undefined;
             for (const [tag, item] of entries) {
@@ -197,7 +198,7 @@ const emptyTagMapAdd = (ruleSet) => (map) => (name) => {
     }
     else {
         map = { ...map, [name]: true };
-        const entries = Object.entries(rule);
+        const entries = definedEntries(rule);
         let emptyTag = false;
         for (const [tag, item] of entries) {
             const [, newMap, itemEmptyTag] = emptyTagMapAdd(ruleSet)(map)(item);
@@ -258,7 +259,7 @@ export const descentParser = (fr) => {
             return mrSuccess(tag, seq, tidx);
         }
         else {
-            const entries = Object.entries(rule);
+            const entries = definedEntries(rule);
             const emptyTag = getEmptyTag(name);
             let emptyResult = mrFail(emptyTag, [], idx);
             for (const [tag, item] of entries) {

package/fs/bnf/module.f.d.ts

@@ -1,3 +1,4 @@
+import { type StringMap } from '../types/object/module.f.ts';
 import { type Array2 } from '../types/array/module.f.ts';
 /**
  * A range of symbols. Two 24-bit numbers are stored in one JS number (48 bits).
@@ -27,7 +28,7 @@ export declare const unicodeMax: string;
 export type Sequence = readonly Rule[];
 /** A variant */
 export type Variant = {
-    readonly [k in string]: Rule;
+    readonly [k in string]?: Rule;
 };
 /**
  * Data-only grammar rule.
@@ -74,9 +75,7 @@ export declare const range: (ab: string) => TerminalRange;
 /**
  * A set of terminal ranges compatible with the `Variant` rule.
  */
-export type RangeVariant = {
-    readonly [k in string]: TerminalRange;
-};
+export type RangeVariant = StringMap<string, TerminalRange>;
 export declare const remove: (range: TerminalRange, v: RangeVariant) => RangeVariant;
 /**
  * Returns the complement set of the provided ranges over {@link fullRange}.

package/fs/bnf/module.f.js

@@ -7,6 +7,7 @@
  * @module
  */
 import { codePointListToString, stringToCodePointList } from "../text/utf16/module.f.js";
+import { definedValues } from "../types/object/module.f.js";
 import { isArray2 } from "../types/array/module.f.js";
 import { map, toArray, repeat as listRepeat } from "../types/list/module.f.js";
 /**
@@ -26,7 +27,7 @@ export const max = codePointListToString([0xFFFFFF]);
  */
 export const unicodeMax = codePointListToString([0x10FFFF]);
 // Internals:
-const { fromEntries, values } = Object;
+const { fromEntries } = Object;
 const { fromCodePoint } = String;
 /**
  * Two 24 bit numbers can be fit into one JS number (53 bit).
@@ -102,7 +103,7 @@ const removeOne = (list, ab) => {
 };
 export const remove = (range, v) => {
     let result = [range];
-    for (const r of values(v)) {
+    for (const r of definedValues(v)) {
         result = removeOne(result, r);
     }
     return toVariantRangeSet(result);

package/fs/bnf/proof.f.d.ts

@@ -1,3 +1,12 @@
 export declare const proof: {
     test: () => void;
+    throw: {
+        rangeEncodeInvalid: (() => void)[];
+        rangeInvalid: (() => void)[];
+    };
+    str: (() => void)[];
+    set: () => void;
+    commaJoin0Plus: () => void;
+    isEmpty: (() => void)[];
+    repeat1Plus: (() => void)[];
 };