functionalscript 0.43.1 → 0.45.0

package/fjs/media/json/schema/proof.f.d.mts

@@ -0,0 +1,81 @@
+/**
+ * @import { Unknown as JsonValue } from '../types.ts'
+ * @import { Unknown } from './module.f.mjs'
+ * @import { Data } from '../../../types/rtti/data/types.ts'
+ */
+import { number, string } from '../../../types/rtti/module.f.mjs';
+export type _List = () => readonly ['array', _List];
+export type _Tree = () => readonly ['or', typeof number, _Forest];
+export type _Forest = () => readonly ['array', _Tree];
+export type _Lock = () => readonly ['record', () => readonly ['or', typeof string, _Lock]];
+export type _Rec = () => readonly ['record', _Rec];
+export declare const proof: {
+    tag0: {
+        boolean: () => void;
+        number: () => void;
+        string: () => void;
+        bigint: () => void;
+        unknown: () => void;
+    };
+    const: {
+        null: () => void;
+        true: () => void;
+        false: () => void;
+        number: () => void;
+        string: () => void;
+        undefined: () => void;
+        bigint: () => void;
+    };
+    array: () => void;
+    record: () => void;
+    or: () => void;
+    tuple: () => void;
+    struct: {
+        allRequired: () => void;
+        withOptional: () => void;
+        allOptional: () => void;
+        empty: () => void;
+        orOptional: () => void;
+        withConst: () => void;
+        optionalOfEveryKind: () => void;
+    };
+    schemaUnknownTag: () => void;
+    nested: {
+        arrayOfRecords: () => void;
+        orWithConst: () => void;
+        structWithOr: () => void;
+        topInsideTuple: () => void;
+    };
+    normalization: {
+        booleanFromConsts: () => void;
+        unitMembers: () => void;
+        literalAbsorbed: () => void;
+        duplicateLiteral: () => void;
+        never: () => void;
+        emptyTuple: () => void;
+        coverageCollapse: () => void;
+        commutative: () => void;
+    };
+    recursion: {
+        selfList: () => void;
+        mutualEntry: () => void;
+        mutualInline: () => void;
+        recursiveUnion: () => void;
+        recursiveRecord: () => void;
+        optionalRecursiveProperty: () => void;
+        revisionLock: () => void;
+        sharedNonRecursive: () => void;
+    };
+    data: {
+        plain: () => void;
+        tupleWithRest: () => void;
+        structWithRest: () => void;
+        optionalByReference: () => void;
+    };
+    refEncoding: () => void;
+    throw: {
+        missingRootDefinition: () => import("./module.f.mjs")._UnknownConst;
+        missingPrototypeDefinition: () => import("./module.f.mjs")._UnknownConst;
+        missingNestedDefinition: () => import("./module.f.mjs")._UnknownConst;
+    };
+};

package/fjs/media/json/schema/proof.f.mjs

@@ -0,0 +1,305 @@
+/**
+ * @import { Unknown as JsonValue } from '../types.ts'
+ * @import { Unknown } from './module.f.mjs'
+ * @import { Data } from '../../../types/rtti/data/types.ts'
+ */
+
+import { boolean, number, string, bigint, never, unknown, array, record, or, option } from '../../../types/rtti/module.f.mjs'
+import { stringify } from '../module.f.mjs'
+import { dataToJsonSchema, toJsonSchema, unknown as schemaUnknown } from './module.f.mjs'
+import { unitBit } from '../../../types/rtti/data/module.f.mjs'
+import { assert, assertEq } from '../../../asserts/module.f.mjs'
+
+/** @type {(v: Unknown) => string} */
+const serialize = v => stringify(e => e)(/** @type {JsonValue} */ (/** @type {unknown} */ (v)))
+
+/** @type {(rtti: Parameters<typeof toJsonSchema>[0], expected: Unknown) => () => void} */
+const eq = (rtti, expected) => () => {
+    const result = serialize(toJsonSchema(rtti))
+    const exp = serialize(expected)
+    assertEq(result, exp, [result, exp])
+}
+
+/** @type {(data: Data, expected: Unknown) => () => void} */
+const eqData = (data, expected) => () => {
+    const result = serialize(dataToJsonSchema(data))
+    const exp = serialize(expected)
+    assertEq(result, exp, [result, exp])
+}
+
+/** A recursive list: `type _List = readonly _List[]`. */
+/** @typedef {() => readonly ['array', _List]} _List */
+/** @type {_List} */
+const list = () => ['array', list]
+
+/** Mutual recursion through a container. */
+/** @typedef {() => readonly ['or', typeof number, _Forest]} _Tree */
+/** @typedef {() => readonly ['array', _Tree]} _Forest */
+/** @type {_Tree} */
+const tree = () => ['or', number, forest]
+/** @type {_Forest} */
+const forest = () => ['array', tree]
+
+/** The recursive revision lock schema. Its cycle closes through the
+ * anonymous `or` thunk, which becomes the (empty-string-named) rule. */
+/** @typedef {() => readonly ['record', () => readonly ['or', typeof string, _Lock]]} _Lock */
+/** @type {_Lock} */
+const lock = () => ['record', or(string, lock)]
+
+/** Self-recursive record. */
+/** @typedef {() => readonly ['record', _Rec]} _Rec */
+/** @type {_Rec} */
+const rec = () => ['record', rec]
+
+const listRef = /** @type {const} */ ({ $ref: '#/$defs/list' })
+const treeRef = /** @type {const} */ ({ $ref: '#/$defs/tree' })
+
+/** @type {Unknown} */
+const listDef = { type: 'array', items: listRef }
+
+/** @type {Unknown} */
+const treeDef = { anyOf: [{ type: 'number' }, { type: 'array', items: treeRef }] }
+
+export const proof = {
+    tag0: {
+        boolean: eq(boolean, { type: 'boolean' }),
+        number: eq(number, { type: 'number' }),
+        string: eq(string, { type: 'string' }),
+        bigint: eq(bigint, { type: 'integer' }),
+        unknown: eq(unknown, {}),
+    },
+    const: {
+        null: eq(null, { const: null }),
+        true: eq(true, { const: true }),
+        false: eq(false, { const: false }),
+        number: eq(/** @type {const} */ (42), { const: 42 }),
+        string: eq(/** @type {const} */ ('hello'), { const: 'hello' }),
+        undefined: eq(undefined, { not: {} }),
+        bigint: eq(/** @type {const} */ (7n), { const: 7 }),
+    },
+    array: eq(array(number), { type: 'array', items: { type: 'number' } }),
+    record: eq(record(string), { type: 'object', additionalProperties: { type: 'string' } }),
+    // `anyOf` members follow the canonical kind order, not the operand order
+    or: eq(or(string, number), { anyOf: [{ type: 'number' }, { type: 'string' }] }),
+    tuple: eq(/** @type {const} */ ([number, string]), {
+        type: 'array',
+        prefixItems: [{ type: 'number' }, { type: 'string' }],
+        minItems: 2,
+        items: false,
+    }),
+    struct: {
+        allRequired: eq(/** @type {const} */ ({ x: number, y: string }), {
+            type: 'object',
+            properties: { x: { type: 'number' }, y: { type: 'string' } },
+            required: ['x', 'y'],
+        }),
+        withOptional: eq(/** @type {const} */ ({ x: number, y: option(string) }), {
+            type: 'object',
+            properties: { x: { type: 'number' }, y: { type: 'string' } },
+            required: ['x'],
+        }),
+        allOptional: eq(/** @type {const} */ ({ x: option(number) }), {
+            type: 'object',
+            properties: { x: { type: 'number' } },
+        }),
+        // an unconstrained struct is the whole object kind
+        empty: eq(/** @type {const} */ ({}), { type: 'object' }),
+        orOptional: eq(/** @type {const} */ ({ x: or(string, number, undefined) }), {
+            type: 'object',
+            properties: { x: { anyOf: [{ type: 'number' }, { type: 'string' }] } },
+        }),
+        withConst: eq(/** @type {const} */ ({ x: null, y: string }), {
+            type: 'object',
+            properties: { x: { const: null }, y: { type: 'string' } },
+            required: ['x', 'y'],
+        }),
+        optionalOfEveryKind: eq(/** @type {const} */ ({
+            a: option(number),
+            b: option(string),
+            c: option(bigint),
+            d: option(array(number)),
+            e: option(record(string)),
+            f: or(null, undefined),
+        }), {
+            type: 'object',
+            properties: {
+                a: { type: 'number' },
+                b: { type: 'string' },
+                c: { type: 'integer' },
+                d: { type: 'array', items: { type: 'number' } },
+                e: { type: 'object', additionalProperties: { type: 'string' } },
+                f: { const: null },
+            },
+        }),
+    },
+    schemaUnknownTag: () => {
+        const r = schemaUnknown()
+        assert(r[0] === 'const')
+    },
+    nested: {
+        arrayOfRecords: eq(array(record(boolean)), {
+            type: 'array',
+            items: { type: 'object', additionalProperties: { type: 'boolean' } },
+        }),
+        orWithConst: eq(or(null, string, /** @type {const} */ (42)), {
+            anyOf: [{ const: null }, { const: 42 }, { type: 'string' }],
+        }),
+        structWithOr: eq(/** @type {const} */ ({ id: or(string, number), name: option(string) }), {
+            type: 'object',
+            properties: {
+                id: { anyOf: [{ type: 'number' }, { type: 'string' }] },
+                name: { type: 'string' },
+            },
+            required: ['id'],
+        }),
+        topInsideTuple: eq(/** @type {const} */ ([unknown, number]), {
+            type: 'array',
+            prefixItems: [{}, { type: 'number' }],
+            minItems: 2,
+            items: false,
+        }),
+    },
+    normalization: {
+        booleanFromConsts: eq(or(true, false), { type: 'boolean' }),
+        unitMembers: eq(or(null, undefined, true), {
+            anyOf: [{ const: null }, { not: {} }, { const: true }],
+        }),
+        literalAbsorbed: eq(or(/** @type {const} */ (42), number), { type: 'number' }),
+        duplicateLiteral: eq(or(/** @type {const} */ (1), /** @type {const} */ (1)), { const: 1 }),
+        never: eq(never, { not: {} }),
+        emptyTuple: eq(/** @type {const} */ ([]), { type: 'array', items: false }),
+        // `readonly [number] ⊂ readonly number[]` — the tuple pattern is dropped
+        coverageCollapse: eq(or(/** @type {const} */ ([number]), array(number)), {
+            type: 'array',
+            items: { type: 'number' },
+        }),
+        commutative: () => {
+            const a = serialize(toJsonSchema(or(string, number)))
+            const b = serialize(toJsonSchema(or(number, string)))
+            assertEq(a, b, [a, b])
+        },
+    },
+    recursion: {
+        selfList: eq(list, { ...listRef, $defs: { list: listDef } }),
+        mutualEntry: eq(tree, { ...treeRef, $defs: { tree: treeDef } }),
+        mutualInline: eq(forest, { type: 'array', items: treeRef, $defs: { tree: treeDef } }),
+        recursiveUnion: eq(or(number, list), {
+            anyOf: [{ type: 'number' }, { type: 'array', items: listRef }],
+            $defs: { list: listDef },
+        }),
+        recursiveRecord: eq(rec, {
+            $ref: '#/$defs/rec',
+            $defs: { rec: { type: 'object', additionalProperties: { $ref: '#/$defs/rec' } } },
+        }),
+        optionalRecursiveProperty: eq(/** @type {const} */ ({ p: option(list) }), {
+            type: 'object',
+            properties: { p: { type: 'array', items: listRef } },
+            $defs: { list: listDef },
+        }),
+        revisionLock: eq(lock, {
+            type: 'object',
+            additionalProperties: { $ref: '#/$defs/' },
+            $defs: {
+                '': {
+                    anyOf: [
+                        { type: 'string' },
+                        { type: 'object', additionalProperties: { $ref: '#/$defs/' } },
+                    ],
+                },
+            },
+        }),
+        sharedNonRecursive: () => {
+            // a shared, non-recursive definition is inlined at each use — no `$defs`
+            const person = /** @type {const} */ ({ name: string })
+            /** @type {Unknown} */
+            const personSchema = {
+                type: 'object',
+                properties: { name: { type: 'string' } },
+                required: ['name'],
+            }
+            eq(/** @type {const} */ ([person, person]), {
+                type: 'array',
+                prefixItems: [personSchema, personSchema],
+                minItems: 2,
+                items: false,
+            })()
+        },
+    },
+    data: (() => {
+        /** @type {Data} */
+        const tupleWithRest = [{}, { array: [{ prefix: [{ number: true }], rest: { string: true } }] }]
+        /** @type {Data} */
+        const structWithRest = [{}, {
+            object: [{ props: { a: { number: true } }, rest: { string: true } }],
+        }]
+        /** @type {Data} */
+        const optionalByReference = [
+            { r: { unit: unitBit(null) | unitBit(undefined), number: true } },
+            { object: [{ props: { p: 'r' } }] },
+        ]
+        return {
+            plain: eqData([{}, { number: true }], { type: 'number' }),
+            tupleWithRest: eqData(tupleWithRest, {
+                type: 'array',
+                prefixItems: [{ type: 'number' }],
+                minItems: 1,
+                items: { type: 'string' },
+            }),
+            structWithRest: eqData(structWithRest, {
+                type: 'object',
+                properties: { a: { type: 'number' } },
+                required: ['a'],
+                additionalProperties: { type: 'string' },
+            }),
+            // a referenced definition admitting `undefined` makes the key
+            // optional; the reference itself is kept as the property schema
+            optionalByReference: eqData(optionalByReference, {
+                type: 'object',
+                properties: { p: { $ref: '#/$defs/r' } },
+                $defs: { r: { anyOf: [{ const: null }, { not: {} }, { type: 'number' }] } },
+            }),
+        }
+    })(),
+    refEncoding: (() => {
+        /** @type {Data} */
+        const d = [
+            {
+                'a~b': { number: true },
+                'a/b': { number: true },
+                '%2F': { number: true },
+                'a b': { number: true },
+                'é': { number: true },
+            },
+            { array: [{ prefix: ['a~b', 'a/b', '%2F', 'a b', 'é'] }] },
+        ]
+        return eqData(d, {
+            type: 'array',
+            prefixItems: [
+                { $ref: '#/$defs/a~0b' },
+                { $ref: '#/$defs/a~1b' },
+                { $ref: '#/$defs/%252F' },
+                { $ref: '#/$defs/a%20b' },
+                { $ref: '#/$defs/%C3%A9' },
+            ],
+            minItems: 5,
+            items: false,
+            $defs: {
+                'a~b': { type: 'number' },
+                'a/b': { type: 'number' },
+                '%2F': { type: 'number' },
+                'a b': { type: 'number' },
+                'é': { type: 'number' },
+            },
+        })
+    })(),
+    throw: {
+        missingRootDefinition: () => dataToJsonSchema([{}, 'nope']),
+        // an `Object.prototype` member name is still a missing definition
+        missingPrototypeDefinition: () => dataToJsonSchema([{}, 'toString']),
+        missingNestedDefinition: () => {
+            /** @type {Data} */
+            const d = [{ a: { array: [{ prefix: [], rest: 'missing' }] } }, 'a']
+            return dataToJsonSchema(d)
+        },
+    },
+}

package/fjs/media/json/serializer/module.f.d.mts

@@ -0,0 +1,40 @@
+/**
+ * JSON serializer for deterministic string output.
+ *
+ * `stringSerialize` is FunctionalScript, not the host's `JSON.stringify`: it
+ * escapes over this repository's own UTF-16 decoder and reproduces the
+ * ECMAScript `QuoteJSONString` result exactly, lone surrogates included.
+ *
+ * @module
+ *
+ * @import { List } from '../../../types/list/types.ts'
+ * @import { Reduce } from '../../../types/function/operator/types.ts'
+ * @import { CodePoint } from '../../../text/utf16/types.ts'
+ */
+import type { List } from '../../../types/list/types.ts';
+/**
+ * Serializes a string as a JSON string literal.
+ *
+ * @type {(_: string) => List<string>}
+ */
+export declare const stringSerialize: (_: string) => List<string>;
+/**
+ * Serializes a number as a JSON number literal.
+ *
+ * @type {(_: number) => List<string>}
+ */
+export declare const numberSerialize: (_: number) => List<string>;
+/**
+ * Shared serialized representation for `null`.
+ */
+export declare const nullSerialize: string[];
+/** @type {(_: boolean) => List<string>} */
+export declare const boolSerialize: (_: boolean) => List<string>;
+/** @type {(input: List<List<string>>) => List<string>} */
+export declare const objectWrap: (input: List<List<string>>) => List<string>;
+/**
+ * Wraps serialized entries into a JSON array.
+ *
+ * @type {(input: List<List<string>>) => List<string>}
+ */
+export declare const arrayWrap: (input: List<List<string>>) => List<string>;

package/fjs/media/json/serializer/module.f.mjs

@@ -0,0 +1,131 @@
+/**
+ * JSON serializer for deterministic string output.
+ *
+ * `stringSerialize` is FunctionalScript, not the host's `JSON.stringify`: it
+ * escapes over this repository's own UTF-16 decoder and reproduces the
+ * ECMAScript `QuoteJSONString` result exactly, lone surrogates included.
+ *
+ * @module
+ *
+ * @import { List } from '../../../types/list/types.ts'
+ * @import { Reduce } from '../../../types/function/operator/types.ts'
+ * @import { CodePoint } from '../../../text/utf16/types.ts'
+ */
+
+import { flat, map, reduce, empty } from '../../../types/list/module.f.mjs'
+import { concat } from '../../../types/string/module.f.mjs'
+import { codePointToString, stringToCodePointList } from '../../../text/utf16/module.f.mjs'
+import { errorMask } from '../../../text/code_point/module.f.mjs'
+import {
+    backspace,
+    cr,
+    ff,
+    hexDigitCodePoint,
+    ht,
+    lf,
+    quotationMark,
+    reverseSolidus,
+    space,
+} from '../../../text/ascii/module.f.mjs'
+
+const jsonStringify = JSON.stringify
+
+const { fromCharCode } = String
+
+/**
+ * The code points JSON gives a two-character escape. Every other code point
+ * below `space` has no short form and goes through `unicodeEscape` instead.
+ */
+const escapeTable = /** @type {const} */ ({
+    [backspace]: '\\b',
+    [ht]: '\\t',
+    [lf]: '\\n',
+    [ff]: '\\f',
+    [cr]: '\\r',
+    [quotationMark]: '\\"',
+    [reverseSolidus]: '\\\\',
+})
+
+/** @type {(value: number) => string} */
+const hexDigit = value => fromCharCode(hexDigitCodePoint(value))
+
+/**
+ * `\uXXXX` with lowercase hex digits, matching ECMAScript's `UnicodeEscape`.
+ *
+ * @type {(unit: number) => string}
+ */
+const unicodeEscape = unit =>
+    `\\u${hexDigit(unit >> 12 & 0xf)}${hexDigit(unit >> 8 & 0xf)}${hexDigit(unit >> 4 & 0xf)}${hexDigit(unit & 0xf)}`
+
+/**
+ * Escapes one decoded code point. A code point tagged with `errorMask` is an
+ * unpaired surrogate, which well-formed JSON stringification (ES2019) emits as
+ * its `\uXXXX` escape rather than as a code unit; everything else is either a
+ * named escape, a `\u00XX` control escape, or the character itself.
+ *
+ * @type {(codePoint: CodePoint) => string}
+ */
+const escapeCodePoint = codePoint =>
+    (codePoint & errorMask) !== 0
+        ? unicodeEscape(codePoint & 0xffff)
+        : escapeTable[/** @type {keyof typeof escapeTable} */ (codePoint)]
+            ?? (codePoint < space ? unicodeEscape(codePoint) : codePointToString(codePoint))
+
+/**
+ * Serializes a string as a JSON string literal.
+ *
+ * @type {(_: string) => List<string>}
+ */
+export const stringSerialize
+    = input => [`"${concat(map(escapeCodePoint)(stringToCodePointList(input)))}"`]
+
+/**
+ * Serializes a number as a JSON number literal.
+ *
+ * @type {(_: number) => List<string>}
+ */
+export const numberSerialize
+    = input => [jsonStringify(input)]
+
+/**
+ * Shared serialized representation for `null`.
+ */
+export const nullSerialize = ['null']
+
+const trueSerialize = ['true']
+
+const falseSerialize = ['false']
+
+/** @type {(_: boolean) => List<string>} */
+export const boolSerialize
+    = value => value ? trueSerialize : falseSerialize
+
+const comma = [',']
+
+/** @type {Reduce<List<string>>} */
+const joinOp
+    = b => prior => flat([prior, comma, b])
+
+/** @type {(input: List<List<string>>) => List<string>} */
+const join
+    = reduce(joinOp)(empty)
+
+/** @type {(open: string) => (close: string) => (input: List<List<string>>) => List<string>} */
+const wrap
+    = open => close => {
+        const seqOpen = [open]
+        const seqClose = [close]
+        return input => flat([seqOpen, join(input), seqClose])
+    }
+
+/** @type {(input: List<List<string>>) => List<string>} */
+export const objectWrap
+    = wrap('{')('}')
+
+/**
+ * Wraps serialized entries into a JSON array.
+ *
+ * @type {(input: List<List<string>>) => List<string>}
+ */
+export const arrayWrap
+    = wrap('[')(']')

package/fjs/media/json/serializer/proof.f.mjs

@@ -0,0 +1,92 @@
+import { arrayWrap, boolSerialize, numberSerialize, objectWrap, stringSerialize } from './module.f.mjs'
+import * as list from '../../../types/list/module.f.mjs'
+import { concat } from '../../../types/string/module.f.mjs'
+import { assertEq } from '../../../asserts/module.f.mjs'
+
+const { toArray } = list
+
+// The expected literals below are what the host's `JSON.stringify` produces for
+// the same input; `stringSerialize` has to reproduce them exactly, so any
+// divergence in the FunctionalScript escaping shows up here as a failure.
+/** @type {(input: string) => string} */
+const serialized = input => concat(stringSerialize(input))
+
+export const proof = {
+    arrayWrap: [
+        () => {
+            const result = JSON.stringify(toArray(arrayWrap(null)))
+            assertEq(result, '["[","]"]')
+        },
+        () => {
+            const result = JSON.stringify(toArray(arrayWrap([['a','b']])))
+            assertEq(result, '["[","a","b","]"]')
+        },
+        () => {
+            const result = JSON.stringify(toArray(arrayWrap([['a'],['b']])))
+            assertEq(result, '["[","a",",","b","]"]')
+        }
+    ],
+    objectWrap: [
+        () => {
+            const result = JSON.stringify(toArray(objectWrap(null)))
+            if (result !== '["{","}"]') { throw result }
+        },
+        () => {
+            const result = JSON.stringify(toArray(objectWrap([['a','b']])))
+            if (result !== '["{","a","b","}"]') { throw result }
+        },
+        () => {
+            const result = JSON.stringify(toArray(objectWrap([['a'],['b']])))
+            if (result !== '["{","a",",","b","}"]') { throw result }
+        }
+    ],
+    stringSerialize: [
+        () => { assertEq(serialized('abc'), '"abc"') },
+        () => { assertEq(serialized('123'), '"123"') },
+        () => { assertEq(serialized(''), '""') },
+        // one chunk, like every other leaf serializer in this module
+        () => { assertEq(toArray(stringSerialize('a"')).length, 1) },
+        // the two escapes JSON requires outside the control block
+        () => { assertEq(serialized('a"b'), '"a\\"b"') },
+        () => { assertEq(serialized('a\\b'), '"a\\\\b"') },
+        // every named control escape
+        () => { assertEq(serialized('\b\f\n\r\t'), '"\\b\\f\\n\\r\\t"') },
+        // control code points without a named escape, covering both hex-digit
+        // halves: '0'-'9' and 'a'-'f'
+        () => { assertEq(serialized('\u0000'), '"\\u0000"') },
+        () => { assertEq(serialized('\u000b'), '"\\u000b"') },
+        () => { assertEq(serialized('\u001f'), '"\\u001f"') },
+        // `space` is the first code point copied through unescaped, and DEL is
+        // not a JSON escape at all
+        () => { assertEq(serialized(' \u007f'), '" \u007f"') },
+        // a surrogate pair decodes to one code point and survives unchanged
+        () => { assertEq(serialized('😀'), '"😀"') },
+        // unpaired surrogates, well-formed-stringify escaped: leading, trailing,
+        // in the middle, doubled, and left over at end of input
+        () => { assertEq(serialized('\ud800'), '"\\ud800"') },
+        () => { assertEq(serialized('\udfff'), '"\\udfff"') },
+        () => { assertEq(serialized('a\udc00b'), '"a\\udc00b"') },
+        () => { assertEq(serialized('\ud800\ud800'), '"\\ud800\\ud800"') },
+        () => { assertEq(serialized('a\ud83d'), '"a\\ud83d"') },
+    ],
+    numberSerialize: [
+        () => {
+            const result = JSON.stringify(toArray(numberSerialize(123)))
+            assertEq(result, '["123"]')
+        },
+        () => {
+            const result = JSON.stringify(toArray(numberSerialize(10e20)))
+            assertEq(result, '["1e+21"]')
+        }
+    ],
+    boolSerialize: [
+        () => {
+            const result = JSON.stringify(toArray(boolSerialize(false)))
+            assertEq(result, '["false"]')
+        },
+        () => {
+            const result = JSON.stringify(toArray(boolSerialize(true)))
+            assertEq(result, '["true"]')
+        }
+    ]
+}

package/fjs/media/json/tokenizer/module.f.d.mts

@@ -0,0 +1,25 @@
+/**
+ * Tokenizer for JSON lexical analysis.
+ *
+ * @module
+ *
+ * @import { StateScan } from '../../../types/function/operator/types.ts'
+ * @import { List } from '../../../types/list/types.ts'
+ * @import { JsToken } from '../../../js/tokenizer/types.ts'
+ * @import { JsonToken, _ScanState, _ScanInput } from './types.ts'
+ */
+import type { List } from '../../../types/list/types.ts';
+import type { JsonToken } from './types.ts';
+/**
+ * Converts a stream of UTF-8 bytes into JSON tokens.
+ *
+ * The tokenizer accepts only JSON-compatible JavaScript tokens, ignores
+ * whitespace/newline tokens, and reports invalid token sequences as
+ * `{ kind: 'error' }` tokens.
+ *
+ * @type {(input: List<number>) => List<JsonToken>}
+ */
+export declare const tokenize: (input: List<number>) => List<JsonToken>;
+export declare const proof: {
+    parseMinusStateEof: () => void;
+};