functionalscript 0.43.1 → 0.44.0

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

@@ -1,23 +0,0 @@
-/**
- * Streaming encoder for the full SUL pipeline.
- * Processes bits one at a time through literal levels L1→L2→L3, then through a dynamic array of hash levels.
- *
- * @module
- */
-import { type PipelineState } from './level/literal/module.f.ts';
-import { type Add } from './level/hash/module.f.ts';
-import { type Id } from './id/module.f.ts';
-import type { InternalState } from '../types/patricia_trie/module.f.ts';
-type HashState = InternalState<Id>;
-export type EncodeState<S> = readonly [
-    PipelineState,
-    S,
-    readonly HashState[]
-];
-export type Encode<S> = {
-    readonly push: (bit: bigint, state: EncodeState<S>) => EncodeState<S>;
-    readonly end: (state: EncodeState<S>) => Id;
-};
-export declare const emptyEncodeState: <S>(storage: S) => EncodeState<S>;
-export declare const encode: <S>(add: Add<S>) => Encode<S>;
-export {};

package/fjs/sul/module.f.js

@@ -1,46 +0,0 @@
-/**
- * Streaming encoder for the full SUL pipeline.
- * Processes bits one at a time through literal levels L1→L2→L3, then through a dynamic array of hash levels.
- *
- * @module
- */
-import { emptyPipelineState, pipelineStep } from './level/literal/module.f.js';
-import { encode as hashEncode } from './level/hash/module.f.js';
-import { level3Id } from './id/module.f.js';
-export const emptyEncodeState = (storage) => [emptyPipelineState, storage, []];
-export const encode = (add) => {
-    const step = hashEncode(add);
-    const cascade = (id0, storage0, stacks0) => {
-        let id = id0, storage = storage0, stacks = stacks0;
-        for (let index = 0;; index++) {
-            if (index >= stacks.length) {
-                const [, [newStorage, newStack]] = step(id, [storage, []]);
-                return [id, newStorage, [...stacks, newStack]];
-            }
-            const [out, [newStorage, newStack]] = step(id, [storage, stacks[index]]);
-            stacks = [...stacks.slice(0, index), newStack, ...stacks.slice(index + 1)];
-            storage = newStorage;
-            if (out === undefined)
-                return [undefined, storage, stacks];
-            id = out;
-        }
-    };
-    const literalStep = (bit, state) => {
-        const [ps, storage, stacks] = state;
-        const [l3Out, newPs] = pipelineStep(bit, ps);
-        if (l3Out === undefined)
-            return [undefined, [newPs, storage, stacks]];
-        const [finalId, newStorage, newStacks] = cascade(level3Id(l3Out), storage, stacks);
-        return [finalId, [newPs, newStorage, newStacks]];
-    };
-    return {
-        push: (bit, state) => literalStep(bit, state)[1],
-        end: state => {
-            let [id, s] = literalStep(1n, state);
-            while (id === undefined) {
-                [id, s] = literalStep(0n, s);
-            }
-            return id;
-        }
-    };
-};

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

@@ -1,9 +0,0 @@
-export declare const proof: {
-    deterministic: () => void;
-    distinct: () => void;
-    order_matters: () => void;
-    length_matters: () => void;
-    has_merges: () => void;
-    compress_correct: () => void;
-    isSymbol_terminal_only: () => void;
-};

package/fjs/sul/proof.f.js

@@ -1,47 +0,0 @@
-import { assert, assertEq } from '../asserts/module.f.js';
-import { compress } from './id/module.f.js';
-import { encode, emptyEncodeState } from './module.f.js';
-const run = (bits) => {
-    const log = [];
-    const add = (l, r, m, isSymbol) => { log.push([l, r, m, isSymbol]); return null; };
-    const enc = encode(add);
-    let s = emptyEncodeState(null);
-    for (const b of bits) {
-        s = enc.push(b, s);
-    }
-    return [enc.end(s), log];
-};
-const id = (bits) => run(bits)[0];
-const zeros = (n) => new Array(n).fill(0n);
-export const proof = {
-    deterministic: () => {
-        assertEq(id(zeros(16)), id(zeros(16)));
-    },
-    distinct: () => {
-        assert(id([0n]) !== id([1n]));
-    },
-    order_matters: () => {
-        assert(id([0n, 1n]) !== id([1n, 0n]));
-    },
-    length_matters: () => {
-        assert(id(zeros(8)) !== id(zeros(16)));
-    },
-    // Enough bits to trigger at least one hash merge
-    has_merges: () => {
-        const [, log] = run(zeros(16));
-        assert(log.length > 0);
-    },
-    // Every recorded merge satisfies merged === compress(left, right)
-    compress_correct: () => {
-        const [, log] = run(zeros(16));
-        for (const [l, r, m] of log) {
-            assertEq(m, compress(l, r));
-        }
-    },
-    // Patricia-trie internal merges are isSymbol=false; terminal merges are isSymbol=true
-    isSymbol_terminal_only: () => {
-        const [, log] = run(zeros(16));
-        assert(log.some(([, , , isSymbol]) => isSymbol));
-        assert(log.every(([l, r, m, isSymbol]) => !isSymbol || m === compress(l, r)));
-    },
-};

package/fjs/text/ascii/module.f.d.ts

@@ -1,136 +0,0 @@
-/**
- * Provides ASCII code point constants and helpers for creating numeric code points and inclusive ranges.
- *
- * @module
- */
-import type { Range } from '../../types/range/module.f.ts';
-/** Returns the code point value of the first character in a string. */
-export declare const one: (s: string) => number;
-/** Returns an inclusive code point range from the first two characters in a string. */
-export declare const range: (s: string) => Range;
-/** 0x08 */
-export declare const backspace: number;
-/** 0x09 */
-export declare const ht: number;
-/** 0x0A */
-export declare const lf: number;
-/** 0x0C */
-export declare const ff: number;
-/** 0x0D */
-export declare const cr: number;
-/** 0x20 */
-export declare const space: number;
-/** 0x21 */
-export declare const exclamationMark: number;
-/** 0x22 */
-export declare const quotationMark: number;
-/** 0x23 */
-export declare const numberSign: number;
-/** 0x24 */
-export declare const dollarSign: number;
-/** 0x25 */
-export declare const percentSign: number;
-/** 0x26 */
-export declare const ampersand: number;
-/** 0x27 */
-export declare const apostrophe: number;
-/** 0x28 */
-export declare const leftParenthesis: number;
-/** 0x29 */
-export declare const rightParenthesis: number;
-/** 0x2A */
-export declare const asterisk: number;
-/** 0x2B */
-export declare const plusSign: number;
-/** 0x2C */
-export declare const comma: number;
-/** 0x2D */
-export declare const hyphenMinus: number;
-/** 0x2E */
-export declare const fullStop: number;
-/** 0x2F */
-export declare const solidus: number;
-/** 0x30..0x39 */
-export declare const digitRange: Range;
-/** 0x30 */
-export declare const digit0: number;
-/** 0x31 */
-export declare const digit1: number;
-/** 0x32 */
-export declare const digit2: number;
-/** 0x33 */
-export declare const digit3: number;
-/** 0x34 */
-export declare const digit4: number;
-/** 0x35 */
-export declare const digit5: number;
-/** 0x36 */
-export declare const digit6: number;
-/** 0x37 */
-export declare const digit7: number;
-/** 0x38 */
-export declare const digit8: number;
-/** 0x39 */
-export declare const digit9: number;
-/** 0x3A */
-export declare const colon: number;
-/** 0x3B */
-export declare const semicolon: number;
-/** 0x3C */
-export declare const lessThanSign: number;
-/** 0x3D */
-export declare const equalsSign: number;
-/** 0x3E */
-export declare const greaterThanSign: number;
-/** 0x3F */
-export declare const questionMark: number;
-/** 0x40 */
-export declare const commercialAt: number;
-/** 0x41..0x5A */
-export declare const latinCapitalLetterRange: Range;
-/** 0x41 */
-export declare const latinCapitalLetterA: number;
-/** 0x45 */
-export declare const latinCapitalLetterE: number;
-/** 0x46 */
-export declare const latinCapitalLetterF: number;
-/** 0x5B */
-export declare const leftSquareBracket: number;
-/** 0x5C */
-export declare const reverseSolidus: number;
-/** 0x5D */
-export declare const rightSquareBracket: number;
-/** 0x5E */
-export declare const circumflexAccent: number;
-/** 0x5F */
-export declare const lowLine: number;
-/** 0x60 */
-export declare const graveAccent: number;
-/** 0x61..0x7A */
-export declare const latinSmallLetterRange: Range;
-/** 0x61 */
-export declare const latinSmallLetterA: number;
-/** 0x62 */
-export declare const latinSmallLetterB: number;
-/** 0x65 */
-export declare const latinSmallLetterE: number;
-/** 0x66 */
-export declare const latinSmallLetterF: number;
-/** 0x6E */
-export declare const latinSmallLetterN: number;
-/** 0x72 */
-export declare const latinSmallLetterR: number;
-/** 0x74 */
-export declare const latinSmallLetterT: number;
-/** 0x75 */
-export declare const latinSmallLetterU: number;
-/** 0x7A */
-export declare const latinSmallLetterZ: number;
-/** 0x7B */
-export declare const leftCurlyBracket: number;
-/** 0x7C */
-export declare const verticalLine: number;
-/** 0x7D */
-export declare const rightCurlyBracket: number;
-/** 0x7E */
-export declare const tilde: number;

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

@@ -1,154 +0,0 @@
-/**
- * Provides ASCII code point constants and helpers for creating numeric code points and inclusive ranges.
- *
- * @module
- */
-const at = (s) => (i) => {
-    const r = s.codePointAt(i);
-    if (r === void 0) {
-        throw s;
-    }
-    return r;
-};
-/** Returns the code point value of the first character in a string. */
-export const one = (s) => at(s)(0);
-/** Returns an inclusive code point range from the first two characters in a string. */
-export const range = (s) => {
-    const f = at(s);
-    const f0 = f(0);
-    if (s.length === 1) {
-        return [f0, f0];
-    }
-    return [f0, f(1)];
-};
-// 0x00..
-/** 0x08 */
-export const backspace = one('\b');
-/** 0x09 */
-export const ht = one('\t');
-/** 0x0A */
-export const lf = one('\n');
-/** 0x0C */
-export const ff = one('\f');
-/** 0x0D */
-export const cr = one('\r');
-// 0x20..
-/** 0x20 */
-export const space = one(' ');
-/** 0x21 */
-export const exclamationMark = one('!');
-/** 0x22 */
-export const quotationMark = one('"');
-/** 0x23 */
-export const numberSign = one('#');
-/** 0x24 */
-export const dollarSign = one('$');
-/** 0x25 */
-export const percentSign = one('%');
-/** 0x26 */
-export const ampersand = one('&');
-/** 0x27 */
-export const apostrophe = one("'");
-/** 0x28 */
-export const leftParenthesis = one('(');
-/** 0x29 */
-export const rightParenthesis = one(')');
-/** 0x2A */
-export const asterisk = one('*');
-/** 0x2B */
-export const plusSign = one('+');
-/** 0x2C */
-export const comma = one(',');
-/** 0x2D */
-export const hyphenMinus = one('-');
-/** 0x2E */
-export const fullStop = one('.');
-/** 0x2F */
-export const solidus = one('/');
-// 0x30..
-/** 0x30..0x39 */
-export const digitRange = range('09');
-/** 0x30 */
-export const digit0 = one('0');
-/** 0x31 */
-export const digit1 = one('1');
-/** 0x32 */
-export const digit2 = one('2');
-/** 0x33 */
-export const digit3 = one('3');
-/** 0x34 */
-export const digit4 = one('4');
-/** 0x35 */
-export const digit5 = one('5');
-/** 0x36 */
-export const digit6 = one('6');
-/** 0x37 */
-export const digit7 = one('7');
-/** 0x38 */
-export const digit8 = one('8');
-/** 0x39 */
-export const digit9 = one('9');
-/** 0x3A */
-export const colon = one(':');
-/** 0x3B */
-export const semicolon = one(';');
-/** 0x3C */
-export const lessThanSign = one('<');
-/** 0x3D */
-export const equalsSign = one('=');
-/** 0x3E */
-export const greaterThanSign = one('>');
-/** 0x3F */
-export const questionMark = one('?');
-// 0x40..
-/** 0x40 */
-export const commercialAt = one('@');
-/** 0x41..0x5A */
-export const latinCapitalLetterRange = range('AZ');
-/** 0x41 */
-export const latinCapitalLetterA = one('A');
-/** 0x45 */
-export const latinCapitalLetterE = one('E');
-/** 0x46 */
-export const latinCapitalLetterF = one('F');
-/** 0x5B */
-export const leftSquareBracket = one('[');
-/** 0x5C */
-export const reverseSolidus = one('\\');
-/** 0x5D */
-export const rightSquareBracket = one(']');
-/** 0x5E */
-export const circumflexAccent = one('^');
-/** 0x5F */
-export const lowLine = one('_');
-// 0x60..
-/** 0x60 */
-export const graveAccent = one('`');
-/** 0x61..0x7A */
-export const latinSmallLetterRange = range('az');
-/** 0x61 */
-export const latinSmallLetterA = one('a');
-/** 0x62 */
-export const latinSmallLetterB = one('b');
-/** 0x65 */
-export const latinSmallLetterE = one('e');
-/** 0x66 */
-export const latinSmallLetterF = one('f');
-/** 0x6E */
-export const latinSmallLetterN = one('n');
-/** 0x72 */
-export const latinSmallLetterR = one('r');
-/** 0x74 */
-export const latinSmallLetterT = one('t');
-/** 0x75 */
-export const latinSmallLetterU = one('u');
-/** 0x7A */
-export const latinSmallLetterZ = one('z');
-/** 0x7B */
-export const leftCurlyBracket = one('{');
-/** 0x7C */
-export const verticalLine = one('|');
-/** 0x7D */
-export const rightCurlyBracket = one('}');
-/** 0x7E */
-export const tilde = one('~');

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

@@ -1,14 +0,0 @@
-import { one, range } from './module.f.js';
-import { stringify as jsonStringify } from '../../media/json/module.f.js';
-import { sort } from '../../types/object/module.f.js';
-import { assertEq } from '../../asserts/module.f.js';
-const stringify = jsonStringify(sort);
-export const proof = {
-    range: () => {
-        const r = stringify(range("A"));
-        assertEq(r, '[65,65]');
-    },
-    throw: {
-        oneThrowsOnEmpty: () => one(''),
-    },
-};

package/fjs/text/code_point/module.f.d.ts

@@ -1,65 +0,0 @@
-/**
- * Shared Unicode code-point contract for the UTF-8 and UTF-16 decoders: the
- * error-tag mask used to flag invalid sequences, the streaming `decoder`
- * factory that wraps a per-unit step and an end-of-input step into a single
- * `List`-to-`List` conversion, and the code-point classification predicates
- * (BMP / surrogate / supplementary-plane / overall validity) that both codecs
- * share.
- *
- * @module
- */
-import { type List } from '../../types/list/module.f.ts';
-import type { StateScan } from '../../types/function/operator/module.f.ts';
-/**
- * Error mask used to tag invalid code points or encoding errors. A decoded
- * value with this bit set represents a malformed unit rather than a valid
- * code point.
- */
-export declare const errorMask = 2147483648;
-/**
- * Builds a streaming decoder from the two direction-specific steps.
- *
- * Decoding starts from the empty (`null`) state. The input is processed unit by
- * unit through `byteOp`, then a trailing end-of-input marker drives `eofOp` to
- * flush any leftover decoding state.
- *
- * @param byteOp - The per-unit decoding step.
- * @param eofOp - The end-of-input step that flushes the remaining state.
- * @returns A function converting a list of code units into a list of code points.
- */
-export declare const decoder: <Unit, S, Cp>(byteOp: StateScan<Unit, S | null, List<Cp>>, eofOp: (state: S | null) => readonly [List<Cp>, S | null]) => (input: List<Unit>) => List<Cp>;
-/**
- * Checks whether the 16-bit word (U16) is a high surrogate.
- * Range: 0xD800 - 0xDBFF.
- */
-export declare const isHighSurrogate: (i: number) => boolean;
-/**
- * Checks whether the 16-bit word (U16) is a low surrogate.
- * Range: 0xDC00 - 0xDFFF.
- */
-export declare const isLowSurrogate: (i: number) => boolean;
-/**
- * Checks whether the code point is in the BMP range.
- * BMP is the main Unicode plane that covers code points 0x0000 - 0xFFFF, except
- * for the range of surrogates.
- */
-export declare const isBmpCodePoint: (codePoint: number) => boolean;
-/**
- * Checks whether the code point belongs to a supplementary (additional) Unicode
- * plane. Supplementary planes cover code points from 0x010000 to 0x10FFFF.
- */
-export declare const isSupplementaryPlane: (i: number) => boolean;
-/**
- * Checks whether the code point is a valid scalar value: within the assignable
- * Unicode range (0x0000 - 0x10FFFF) and not a surrogate.
- */
-export declare const isValidCodePoint: (c: number) => boolean;
-/**
- * Checks whether the code point is a *text* code point — distinct from
- * {@link isValidCodePoint}, which gates well-formedness for decoding. A code
- * point is text unless it is a control character: the controls are 0x0000 -
- * 0x001F, 0x007F (DEL), and 0x0080 - 0x009F (C1), minus the whitespace block
- * 0x0009 - 0x000D (TAB, LF, VT, FF, CR), which is legitimate in text. Every
- * code point at or above 0x0020 that is not DEL or a C1 control is text.
- */
-export declare const isTextCodePoint: (c: number) => boolean;

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

@@ -1,103 +0,0 @@
-/**
- * Shared Unicode code-point contract for the UTF-8 and UTF-16 decoders: the
- * error-tag mask used to flag invalid sequences, the streaming `decoder`
- * factory that wraps a per-unit step and an end-of-input step into a single
- * `List`-to-`List` conversion, and the code-point classification predicates
- * (BMP / surrogate / supplementary-plane / overall validity) that both codecs
- * share.
- *
- * @module
- */
-import { flat, stateScan } from '../../types/list/module.f.js';
-import { contains } from '../../types/range/module.f.js';
-/**
- * Error mask used to tag invalid code points or encoding errors. A decoded
- * value with this bit set represents a malformed unit rather than a valid
- * code point.
- */
-export const errorMask = 0b1000_0000_0000_0000_0000_0000_0000_0000;
-/**
- * Builds a streaming decoder from the two direction-specific steps.
- *
- * Decoding starts from the empty (`null`) state. The input is processed unit by
- * unit through `byteOp`, then a trailing end-of-input marker drives `eofOp` to
- * flush any leftover decoding state.
- *
- * @param byteOp - The per-unit decoding step.
- * @param eofOp - The end-of-input step that flushes the remaining state.
- * @returns A function converting a list of code units into a list of code points.
- */
-export const decoder = (byteOp, eofOp) => {
-    const op = (input, state) => input === null ? eofOp(state) : byteOp(input, state);
-    const run = stateScan(op)(null);
-    return input => flat(run(flat([input, [null]])));
-};
-/**
- * Unicode code-point classification boundaries. The surrogate block
- * (`0xD800`–`0xDFFF`) splits into a high half (`0xD800`–`0xDBFF`) and a low half
- * (`0xDC00`–`0xDFFF`); the BMP ends at `0xFFFF` and `maxCodePoint` (`0x10FFFF`)
- * is the largest assignable code point. Every predicate below is derived from
- * these constants so the surrogate bounds and the maximum appear exactly once.
- */
-const surrogateMin = 0xd800;
-const lowSurrogateMin = 0xdc00;
-const surrogateMax = 0xdfff;
-const bmpMax = 0xffff;
-const maxCodePoint = 0x10_ffff;
-/**
- * Checks whether the 16-bit word (U16) is a high surrogate.
- * Range: 0xD800 - 0xDBFF.
- */
-export const isHighSurrogate = contains(surrogateMin, lowSurrogateMin - 1);
-/**
- * Checks whether the 16-bit word (U16) is a low surrogate.
- * Range: 0xDC00 - 0xDFFF.
- */
-export const isLowSurrogate = contains(lowSurrogateMin, surrogateMax);
-/**
- * Ranges of code points for the lower (Low) and higher (High) parts of the BMP
- * (Basic Multilingual Plane), i.e. the BMP with the surrogate block removed.
- */
-const lowBmp = contains(0x0000, surrogateMin - 1);
-const highBmp = contains(surrogateMax + 1, bmpMax);
-/**
- * Checks whether the code point is in the BMP range.
- * BMP is the main Unicode plane that covers code points 0x0000 - 0xFFFF, except
- * for the range of surrogates.
- */
-export const isBmpCodePoint = (codePoint) => lowBmp(codePoint) || highBmp(codePoint);
-/**
- * Checks whether the code point belongs to a supplementary (additional) Unicode
- * plane. Supplementary planes cover code points from 0x010000 to 0x10FFFF.
- */
-export const isSupplementaryPlane = contains(bmpMax + 1, maxCodePoint);
-/**
- * The full assignable code-point range and the surrogate block, used to gate
- * overall validity below.
- */
-const validRange = contains(0, maxCodePoint);
-const isSurrogate = contains(surrogateMin, surrogateMax);
-/**
- * Checks whether the code point is a valid scalar value: within the assignable
- * Unicode range (0x0000 - 0x10FFFF) and not a surrogate.
- */
-export const isValidCodePoint = (c) => validRange(c) && !isSurrogate(c);
-/**
- * The control-character blocks and the whitespace exception used to separate
- * *text* code points from binary control bytes. C0 controls span 0x0000 -
- * 0x001F; 0x007F (DEL) and the C1 controls (0x0080 - 0x009F) form one
- * contiguous run; the whitespace block 0x0009 - 0x000D (TAB, LF, VT, FF, CR) is
- * the only control range legitimate in text.
- */
-const c0Control = contains(0x00, 0x1f);
-const delAndC1Control = contains(0x7f, 0x9f);
-const textWhitespace = contains(0x09, 0x0d);
-/**
- * Checks whether the code point is a *text* code point — distinct from
- * {@link isValidCodePoint}, which gates well-formedness for decoding. A code
- * point is text unless it is a control character: the controls are 0x0000 -
- * 0x001F, 0x007F (DEL), and 0x0080 - 0x009F (C1), minus the whitespace block
- * 0x0009 - 0x000D (TAB, LF, VT, FF, CR), which is legitimate in text. Every
- * code point at or above 0x0020 that is not DEL or a C1 control is text.
- */
-export const isTextCodePoint = (c) => textWhitespace(c) || !(c0Control(c) || delAndC1Control(c));

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

@@ -1,72 +0,0 @@
-import { isBmpCodePoint, isHighSurrogate, isLowSurrogate, isSupplementaryPlane, isTextCodePoint, isValidCodePoint, } from './module.f.js';
-const check = (actual, expected) => {
-    if (actual !== expected) {
-        throw `${actual} !== ${expected}`;
-    }
-};
-export const proof = {
-    isHighSurrogate: [
-        () => check(isHighSurrogate(0xd800), true),
-        () => check(isHighSurrogate(0xdbff), true),
-        () => check(isHighSurrogate(0xd7ff), false),
-        () => check(isHighSurrogate(0xdc00), false),
-    ],
-    isLowSurrogate: [
-        () => check(isLowSurrogate(0xdc00), true),
-        () => check(isLowSurrogate(0xdfff), true),
-        () => check(isLowSurrogate(0xdbff), false),
-        () => check(isLowSurrogate(0xe000), false),
-    ],
-    isBmpCodePoint: [
-        // lowBmp branch true
-        () => check(isBmpCodePoint(0x0000), true),
-        () => check(isBmpCodePoint(0xd7ff), true),
-        // lowBmp false, highBmp true
-        () => check(isBmpCodePoint(0xe000), true),
-        () => check(isBmpCodePoint(0xffff), true),
-        // both false: surrogate and supplementary
-        () => check(isBmpCodePoint(0xd800), false),
-        () => check(isBmpCodePoint(0x10000), false),
-    ],
-    isSupplementaryPlane: [
-        () => check(isSupplementaryPlane(0x10000), true),
-        () => check(isSupplementaryPlane(0x10ffff), true),
-        () => check(isSupplementaryPlane(0xffff), false),
-        () => check(isSupplementaryPlane(0x110000), false),
-    ],
-    isValidCodePoint: [
-        // in range, not surrogate
-        () => check(isValidCodePoint(0x0000), true),
-        () => check(isValidCodePoint(0x10ffff), true),
-        // in range, surrogate -> invalid
-        () => check(isValidCodePoint(0xd800), false),
-        () => check(isValidCodePoint(0xdfff), false),
-        // out of range -> validRange short-circuits false
-        () => check(isValidCodePoint(-1), false),
-        () => check(isValidCodePoint(0x110000), false),
-    ],
-    isTextCodePoint: [
-        // C0 controls are binary...
-        () => check(isTextCodePoint(0x00), false), // NUL
-        () => check(isTextCodePoint(0x08), false), // BS
-        () => check(isTextCodePoint(0x1b), false), // ESC
-        () => check(isTextCodePoint(0x1f), false), // US
-        // ...except the whitespace block 0x09 - 0x0D
-        () => check(isTextCodePoint(0x09), true), // TAB
-        () => check(isTextCodePoint(0x0a), true), // LF
-        () => check(isTextCodePoint(0x0b), true), // VT
-        () => check(isTextCodePoint(0x0c), true), // FF
-        () => check(isTextCodePoint(0x0d), true), // CR
-        // printable ASCII is text
-        () => check(isTextCodePoint(0x20), true), // space
-        () => check(isTextCodePoint(0x41), true), // 'A'
-        () => check(isTextCodePoint(0x7e), true), // '~'
-        // DEL and the C1 controls are binary
-        () => check(isTextCodePoint(0x7f), false), // DEL
-        () => check(isTextCodePoint(0x80), false), // C1 start
-        () => check(isTextCodePoint(0x9f), false), // C1 end
-        // above C1 is text again
-        () => check(isTextCodePoint(0xa0), true), // NBSP
-        () => check(isTextCodePoint(0x10ffff), true),
-    ],
-};