functionalscript 0.43.0 → 0.44.0

package/fjs/media/json/parser/proof.f.js

@@ -1,314 +0,0 @@
-import { parse } from './module.f.js';
-import { tokenize } from '../tokenizer/module.f.js';
-import { toArray } from '../../../types/list/module.f.js';
-import { stringify as jsonStringify } from '../module.f.js';
-import { sort } from '../../../types/object/module.f.js';
-import { stringToList } from '../../../text/utf16/module.f.js';
-import { assertEq } from '../../../asserts/module.f.js';
-const tokenizeString = s => toArray(tokenize(stringToList(s)));
-const stringify = jsonStringify(sort);
-export const proof = {
-    valid: [
-        () => {
-            const tokenList = tokenizeString('null');
-            const obj = parse(tokenList);
-            const result = stringify(obj);
-            assertEq(result, '["ok",null]');
-        },
-        () => {
-            const tokenList = tokenizeString('true');
-            const obj = parse(tokenList);
-            const result = stringify(obj);
-            assertEq(result, '["ok",true]');
-        },
-        () => {
-            const tokenList = tokenizeString('false');
-            const obj = parse(tokenList);
-            const result = stringify(obj);
-            assertEq(result, '["ok",false]');
-        },
-        () => {
-            const tokenList = tokenizeString('0.1');
-            const obj = parse(tokenList);
-            const result = stringify(obj);
-            assertEq(result, '["ok",0.1]');
-        },
-        () => {
-            const tokenList = tokenizeString('1.1e+2');
-            const obj = parse(tokenList);
-            const result = stringify(obj);
-            assertEq(result, '["ok",110]');
-        },
-        () => {
-            const tokenList = tokenizeString('"abc"');
-            const obj = parse(tokenList);
-            const result = stringify(obj);
-            assertEq(result, '["ok","abc"]');
-        },
-        () => {
-            const tokenList = tokenizeString('[]');
-            const obj = parse(tokenList);
-            const result = stringify(obj);
-            assertEq(result, '["ok",[]]');
-        },
-        () => {
-            const tokenList = tokenizeString('[1]');
-            const obj = parse(tokenList);
-            const result = stringify(obj);
-            assertEq(result, '["ok",[1]]');
-        },
-        () => {
-            const tokenList = tokenizeString('[[]]');
-            const obj = parse(tokenList);
-            const result = stringify(obj);
-            assertEq(result, '["ok",[[]]]');
-        },
-        () => {
-            const tokenList = tokenizeString('[0,[1,[2,[]]],3]');
-            const obj = parse(tokenList);
-            const result = stringify(obj);
-            assertEq(result, '["ok",[0,[1,[2,[]]],3]]');
-        },
-        () => {
-            const tokenList = tokenizeString('{}');
-            const obj = parse(tokenList);
-            const result = stringify(obj);
-            if (result !== '["ok",{}]') {
-                throw result;
-            }
-        },
-        () => {
-            const tokenList = tokenizeString('[{}]');
-            const obj = parse(tokenList);
-            const result = stringify(obj);
-            if (result !== '["ok",[{}]]') {
-                throw result;
-            }
-        },
-        () => {
-            const tokenList = tokenizeString('{"a":true,"b":false,"c":null}');
-            const obj = parse(tokenList);
-            const result = stringify(obj);
-            if (result !== '["ok",{"a":true,"b":false,"c":null}]') {
-                throw result;
-            }
-        },
-        () => {
-            const tokenList = tokenizeString('{"a":{"b":{"c":["d"]}}}');
-            const obj = parse(tokenList);
-            const result = stringify(obj);
-            if (result !== '["ok",{"a":{"b":{"c":["d"]}}}]') {
-                throw result;
-            }
-        }
-    ],
-    invalid: [
-        () => {
-            const tokenList = tokenizeString('');
-            const obj = parse(tokenList);
-            const result = stringify(obj);
-            assertEq(result, '["error","unexpected end"]');
-        },
-        // Trailing commas are not valid JSON — strict parser rejects them.
-        () => {
-            const tokenList = tokenizeString('[1,]');
-            const obj = parse(tokenList);
-            const result = stringify(obj);
-            assertEq(result, '["error","unexpected token"]');
-        },
-        () => {
-            const tokenList = tokenizeString('{"a":1,}');
-            const obj = parse(tokenList);
-            const result = stringify(obj);
-            assertEq(result, '["error","unexpected token"]');
-        },
-        () => {
-            const tokenList = tokenizeString('"123');
-            const obj = parse(tokenList);
-            const result = stringify(obj);
-            assertEq(result, '["error","unexpected token"]');
-        },
-        // A literal control character inside a string is not valid JSON (RFC
-        // 8259 §7) even though the shared tokenizer would otherwise accept it.
-        () => {
-            const tokenList = tokenizeString('"\t"');
-            const obj = parse(tokenList);
-            const result = stringify(obj);
-            assertEq(result, '["error","unexpected token"]');
-        },
-        () => {
-            const tokenList = tokenizeString('{"a":"\t"}');
-            const obj = parse(tokenList);
-            const result = stringify(obj);
-            assertEq(result, '["error","unexpected token"]');
-        },
-        () => {
-            const tokenList = tokenizeString('[,]');
-            const obj = parse(tokenList);
-            const result = stringify(obj);
-            assertEq(result, '["error","unexpected token"]');
-        },
-        () => {
-            const tokenList = tokenizeString('[1 2]');
-            const obj = parse(tokenList);
-            const result = stringify(obj);
-            assertEq(result, '["error","unexpected token"]');
-        },
-        () => {
-            const tokenList = tokenizeString('[1,,2]');
-            const obj = parse(tokenList);
-            const result = stringify(obj);
-            assertEq(result, '["error","unexpected token"]');
-        },
-        () => {
-            const tokenList = tokenizeString('[]]');
-            const obj = parse(tokenList);
-            const result = stringify(obj);
-            assertEq(result, '["error","unexpected token"]');
-        },
-        () => {
-            const tokenList = tokenizeString('["a"');
-            const obj = parse(tokenList);
-            const result = stringify(obj);
-            assertEq(result, '["error","unexpected end"]');
-        },
-        () => {
-            const tokenList = tokenizeString('[,1]');
-            const obj = parse(tokenList);
-            const result = stringify(obj);
-            assertEq(result, '["error","unexpected token"]');
-        },
-        () => {
-            const tokenList = tokenizeString('[:]');
-            const obj = parse(tokenList);
-            const result = stringify(obj);
-            assertEq(result, '["error","unexpected token"]');
-        },
-        () => {
-            const tokenList = tokenizeString(']');
-            const obj = parse(tokenList);
-            const result = stringify(obj);
-            assertEq(result, '["error","unexpected token"]');
-        },
-        () => {
-            const tokenList = tokenizeString('{,}');
-            const obj = parse(tokenList);
-            const result = stringify(obj);
-            assertEq(result, '["error","unexpected token"]');
-        },
-        () => {
-            const tokenList = tokenizeString('{1:2}');
-            const obj = parse(tokenList);
-            const result = stringify(obj);
-            assertEq(result, '["error","unexpected token"]');
-        },
-        () => {
-            const tokenList = tokenizeString('{"1"2}');
-            const obj = parse(tokenList);
-            const result = stringify(obj);
-            assertEq(result, '["error","unexpected token"]');
-        },
-        () => {
-            const tokenList = tokenizeString('{"1"::2}');
-            const obj = parse(tokenList);
-            const result = stringify(obj);
-            assertEq(result, '["error","unexpected token"]');
-        },
-        () => {
-            const tokenList = tokenizeString('{"1":2,,"3":4');
-            const obj = parse(tokenList);
-            const result = stringify(obj);
-            assertEq(result, '["error","unexpected token"]');
-        },
-        () => {
-            const tokenList = tokenizeString('{}}');
-            const obj = parse(tokenList);
-            const result = stringify(obj);
-            assertEq(result, '["error","unexpected token"]');
-        },
-        () => {
-            const tokenList = tokenizeString('{"1":2');
-            const obj = parse(tokenList);
-            const result = stringify(obj);
-            assertEq(result, '["error","unexpected end"]');
-        },
-        () => {
-            const tokenList = tokenizeString('{,"1":2}');
-            const obj = parse(tokenList);
-            const result = stringify(obj);
-            assertEq(result, '["error","unexpected token"]');
-        },
-        () => {
-            const tokenList = tokenizeString('}');
-            const obj = parse(tokenList);
-            const result = stringify(obj);
-            assertEq(result, '["error","unexpected token"]');
-        },
-        () => {
-            const tokenList = tokenizeString('{"a":1 "b":2}');
-            const obj = parse(tokenList);
-            const result = stringify(obj);
-            assertEq(result, '["error","unexpected token"]');
-        },
-        () => {
-            const tokenList = tokenizeString('[{]}');
-            const obj = parse(tokenList);
-            const result = stringify(obj);
-            assertEq(result, '["error","unexpected token"]');
-        },
-        () => {
-            const tokenList = tokenizeString('{[}]');
-            const obj = parse(tokenList);
-            const result = stringify(obj);
-            assertEq(result, '["error","unexpected token"]');
-        },
-        () => {
-            const tokenList = tokenizeString('10-5');
-            const obj = parse(tokenList);
-            const result = stringify(obj);
-            assertEq(result, '["error","unexpected token"]');
-        },
-        () => {
-            const tokenList = tokenizeString('undefined');
-            const obj = parse(tokenList);
-            const result = stringify(obj);
-            assertEq(result, '["error","unexpected token"]');
-        },
-    ],
-    // Regression: closing a container used to pop the parser stack lazily
-    // (`drop(1)`, which is `apply(dropStep)` and returns a `Thunk`), leaving one
-    // unforced thunk per closed container. The chain was forced only at the end,
-    // costing a call-stack frame per container and overflowing at roughly 5000 of
-    // them — nested or flat siblings alike — while primitives were unbounded,
-    // since they never push or pop. `popStack` in `module.f.ts` forces the pop
-    // instead, which is why these sizes are safe now.
-    siblingContainers: [
-        () => {
-            const [tag, value] = parse(tokenizeString(`[${Array(6000).fill('{}').join(',')}]`));
-            assertEq(tag, 'ok');
-            assertEq(Array.isArray(value) ? value.length : -1, 6000);
-        },
-        () => {
-            const [tag, value] = parse(tokenizeString(`[${Array(6000).fill('[]').join(',')}]`));
-            assertEq(tag, 'ok');
-            assertEq(Array.isArray(value) ? value.length : -1, 6000);
-        },
-        () => {
-            const keys = Array.from({ length: 6000 }, (_, i) => `"k${i}":{}`);
-            const [tag, value] = parse(tokenizeString(`{${keys.join(',')}}`));
-            assertEq(tag, 'ok');
-            assertEq(typeof value === 'object' && value !== null ? Object.keys(value).length : -1, 6000);
-        },
-        () => {
-            // deep nesting shares the same stack path and overflowed at 5000
-            const [tag] = parse(tokenizeString('['.repeat(5000) + ']'.repeat(5000)));
-            assertEq(tag, 'ok');
-        },
-        () => {
-            // baseline that always worked: primitives never touch the stack
-            const [tag, value] = parse(tokenizeString(`[${Array.from({ length: 12000 }, (_, i) => i).join(',')}]`));
-            assertEq(tag, 'ok');
-            assertEq(Array.isArray(value) ? value.length : -1, 12000);
-        },
-    ],
-};

package/fjs/media/json/proof.f.js

@@ -1,98 +0,0 @@
-import { parse, setProperty, stringify } from './module.f.js';
-import { sort } from '../../types/object/module.f.js';
-import { identity } from '../../types/function/module.f.js';
-import { assertEq } from '../../asserts/module.f.js';
-export const proof = {
-    setProperty: [
-        () => {
-            if (setProperty("Hello")([])({}) !== "Hello") {
-                throw 'error';
-            }
-        },
-        () => {
-            // src === null: should treat as empty object
-            const x = stringify(sort)(setProperty("Hello")(['a'])(null));
-            if (x !== '{"a":"Hello"}') {
-                throw x;
-            }
-        },
-        () => {
-            // typeof src !== 'object': primitive src treated as empty object
-            const x = stringify(sort)(setProperty("Hello")(['a'])(42));
-            if (x !== '{"a":"Hello"}') {
-                throw x;
-            }
-        },
-        () => {
-            // src instanceof Array: array src treated as empty object
-            const x = stringify(sort)(setProperty("Hello")(['a'])([1, 2]));
-            if (x !== '{"a":"Hello"}') {
-                throw x;
-            }
-        },
-    ],
-    stringify: [
-        {
-            sort: () => {
-                const r = setProperty("Hello")(['a'])({});
-                const x = stringify(sort)(r);
-                if (x !== '{"a":"Hello"}') {
-                    throw x;
-                }
-            },
-            identity: () => {
-                const x = stringify(identity)(setProperty("Hello")(['a'])({}));
-                if (x !== '{"a":"Hello"}') {
-                    throw x;
-                }
-            },
-        },
-        {
-            sort: () => {
-                const x = stringify(sort)(setProperty("Hello")(['a'])({ c: [], b: 12 }));
-                if (x !== '{"a":"Hello","b":12,"c":[]}') {
-                    throw x;
-                }
-            },
-            identity: () => {
-                const x = stringify(identity)(setProperty("Hello")(['a'])({ c: [], b: 12 }));
-                if (x !== '{"c":[],"b":12,"a":"Hello"}') {
-                    throw x;
-                }
-            },
-        },
-        {
-            sort: () => {
-                const _0 = { a: { y: [24] }, c: [], b: 12 };
-                const _1 = setProperty("Hello")(['a', 'x'])(_0);
-                const _2 = stringify(sort)(_1);
-                if (_2 !== '{"a":{"x":"Hello","y":[24]},"b":12,"c":[]}') {
-                    throw _2;
-                }
-            },
-            identity: () => {
-                const _0 = { a: { y: [24] }, c: [], b: 12 };
-                const _1 = setProperty("Hello")(['a', 'x'])(_0);
-                const _2 = stringify(identity)(_1);
-                if (_2 !== '{"a":{"y":[24],"x":"Hello"},"c":[],"b":12}') {
-                    throw _2;
-                }
-            }
-        }
-    ],
-    undefined: () => {
-        assertEq(stringify(sort)({ x: undefined }), '{}');
-    },
-    parse: {
-        ok: () => {
-            const [t, v] = parse('{"a":[1,true,null],"b":"x"}');
-            assertEq(t, 'ok');
-            assertEq(stringify(sort)(v), '{"a":[1,true,null],"b":"x"}');
-        },
-        // Malformed input is an error value, not a throw.
-        error: () => {
-            const [t] = parse('{');
-            assertEq(t, 'error');
-        },
-    },
-};

package/fjs/media/json/schema/module.f.d.ts

@@ -1,78 +0,0 @@
-/**
- * Converts an rtti schema to a JSON Schema (draft 2020-12) object.
- *
- * Driven by `fjs/types/rtti/common/module.f.ts`'s `visit`, the same shared
- * `Type`-ADT walker used by `validate` and `parse`.
- *
- * @module
- */
-import { type Type as RttiType } from '../../../types/rtti/module.f.ts';
-import type { Ts } from '../../../types/rtti/ts/module.f.ts';
-import type { Phantom } from '../../../types/phantom/module.f.ts';
-import { unknown as jsonUnknown } from '../module.f.ts';
-declare const unknownThunk: () => readonly ['const', {
-    readonly type: import("../../../types/rtti/module.f.ts").Or<["boolean", "number", "string", "integer", "array", "object", undefined]>;
-    readonly const: import("../../../types/rtti/module.f.ts").Or<readonly [typeof jsonUnknown, undefined]>;
-    readonly not: import("../../../types/rtti/module.f.ts").Or<readonly [Phantom<() => readonly ['const', /*elided*/ any], UnknownConst>, undefined]>;
-    readonly anyOf: import("../../../types/rtti/module.f.ts").Or<readonly [import("../../../types/rtti/module.f.ts").Type1<"array", Phantom<() => readonly ['const', any], UnknownConst>>, undefined]>;
-    readonly items: import("../../../types/rtti/module.f.ts").Or<[Phantom<() => readonly ['const', any], UnknownConst>, false, undefined]>;
-    readonly prefixItems: import("../../../types/rtti/module.f.ts").Or<readonly [import("../../../types/rtti/module.f.ts").Type1<"array", Phantom<() => readonly ['const', any], UnknownConst>>, undefined]>;
-    readonly properties: import("../../../types/rtti/module.f.ts").Or<readonly [import("../../../types/rtti/module.f.ts").Type1<"record", Phantom<() => readonly ['const', any], UnknownConst>>, undefined]>;
-    readonly required: import("../../../types/rtti/module.f.ts").Or<readonly [import("../../../types/rtti/module.f.ts").Type1<"array", import("../../../types/rtti/module.f.ts").String>, undefined]>;
-    readonly additionalProperties: import("../../../types/rtti/module.f.ts").Or<readonly [Phantom<() => readonly ['const', any], UnknownConst>, undefined]>;
-}];
-/** rtti schema for a JSON Schema (draft 2020-12) document. */
-export declare const unknown: Phantom<typeof unknownThunk, UnknownConst>;
-/** A JSON Schema (draft 2020-12) document — the subset of keywords that `toJsonSchema` emits. */
-export type Unknown = Ts<typeof unknown>;
-declare const unknownConst: {
-    readonly type: import("../../../types/rtti/module.f.ts").Or<["boolean", "number", "string", "integer", "array", "object", undefined]>;
-    readonly const: import("../../../types/rtti/module.f.ts").Or<readonly [typeof jsonUnknown, undefined]>;
-    readonly not: import("../../../types/rtti/module.f.ts").Or<readonly [Phantom<typeof unknownThunk, UnknownConst>, undefined]>;
-    readonly anyOf: import("../../../types/rtti/module.f.ts").Or<readonly [import("../../../types/rtti/module.f.ts").Type1<"array", Phantom<typeof unknownThunk, UnknownConst>>, undefined]>;
-    readonly items: import("../../../types/rtti/module.f.ts").Or<[Phantom<typeof unknownThunk, UnknownConst>, false, undefined]>;
-    readonly prefixItems: import("../../../types/rtti/module.f.ts").Or<readonly [import("../../../types/rtti/module.f.ts").Type1<"array", Phantom<typeof unknownThunk, UnknownConst>>, undefined]>;
-    readonly properties: import("../../../types/rtti/module.f.ts").Or<readonly [import("../../../types/rtti/module.f.ts").Type1<"record", Phantom<typeof unknownThunk, UnknownConst>>, undefined]>;
-    readonly required: import("../../../types/rtti/module.f.ts").Or<readonly [import("../../../types/rtti/module.f.ts").Type1<"array", import("../../../types/rtti/module.f.ts").String>, undefined]>;
-    readonly additionalProperties: import("../../../types/rtti/module.f.ts").Or<readonly [Phantom<typeof unknownThunk, UnknownConst>, undefined]>;
-};
-/**
- * Hand-written base type used as the `$out` annotation on `unknown`.
- *
- * The `?` markers are required even though `Ts<>` already includes `undefined`
- * in each field type. Without `?`, `Unknown = UnknownConst` would require all
- * 9 fields to be present in every object literal returned by `toJsonSchema`,
- * because TypeScript distinguishes "field absent" (`?`) from "field present but
- * undefined" (`T | undefined`). JSON Schema objects only include the fields
- * they need, so all fields must be optional.
- */
-type UnknownConst = {
-    readonly type?: Ts<typeof unknownConst.type>;
-    readonly const?: Ts<typeof unknownConst.const>;
-    readonly not?: Ts<typeof unknownConst.not>;
-    readonly anyOf?: Ts<typeof unknownConst.anyOf>;
-    readonly items?: Ts<typeof unknownConst.items>;
-    readonly prefixItems?: Ts<typeof unknownConst.prefixItems>;
-    readonly properties?: Ts<typeof unknownConst.properties>;
-    readonly required?: Ts<typeof unknownConst.required>;
-    readonly additionalProperties?: Ts<typeof unknownConst.additionalProperties>;
-};
-/**
- * Converts an rtti `Type` to a JSON Schema (draft 2020-12) object.
- *
- * | rtti                                          | JSON Schema                                                                         |
- * |-----------------------------------------------|-------------------------------------------------------------------------------------|
- * | `boolean` / `number` / `string`               | `{ "type": "..." }`                                                                 |
- * | `bigint`                                      | `{ "type": "integer" }` (lossy; JSON integers are IEEE-754 doubles)                 |
- * | `unknown`                                     | `{}` (always-true schema)                                                           |
- * | primitive const (`42`, `'x'`, `true`, `null`) | `{ "const": <value> }`                                                              |
- * | `bigint` const                                | `{ "const": Number(value) }` (lossy for \|value\| > MAX_SAFE_INTEGER)               |
- * | `undefined` const                             | `{ "not": {} }` (no JSON value satisfies this)                                      |
- * | struct `{ a: T, … }`                          | `{ "type": "object", "properties": { "a": …T… }, "required": [non-optional keys] }` |
- * | tuple `[A, B]`                                | `{ "type": "array", "prefixItems": […A…, …B…], "items": false }`                    |
- * | `array(T)`                                    | `{ "type": "array", "items": …T… }`                                                 |
- * | `record(T)`                                   | `{ "type": "object", "additionalProperties": …T… }`                                 |
- * | `or(...types)`                                | `{ "anyOf": […each…] }`                                                             |
- */
-export declare const toJsonSchema: (rtti: RttiType) => Unknown;
-export {};

package/fjs/media/json/schema/module.f.js

@@ -1,96 +0,0 @@
-/**
- * Converts an rtti schema to a JSON Schema (draft 2020-12) object.
- *
- * Driven by `fjs/types/rtti/common/module.f.ts`'s `visit`, the same shared
- * `Type`-ADT walker used by `validate` and `parse`.
- *
- * @module
- */
-import { array, option, or, record, string } from '../../../types/rtti/module.f.js';
-import { visit } from '../../../types/rtti/common/module.f.js';
-import { unknown as jsonUnknown } from '../module.f.js';
-const unknownThunk = () => ['const', unknownConst];
-/** rtti schema for a JSON Schema (draft 2020-12) document. */
-export const unknown = unknownThunk;
-const unknownConst = {
-    type: or('boolean', 'number', 'string', 'integer', 'array', 'object', undefined),
-    const: option(jsonUnknown),
-    not: option(unknown),
-    anyOf: option(array(unknown)),
-    items: or(unknown, false, undefined),
-    prefixItems: option(array(unknown)),
-    properties: option(record(unknown)),
-    required: option(array(string)),
-    additionalProperties: option(unknown),
-};
-/** Returns true if the rtti schema admits the value `undefined`. */
-const admitsUndefined = (rtti) => {
-    if (rtti === undefined) {
-        return true;
-    }
-    if (typeof rtti !== 'function') {
-        return false;
-    }
-    const [t, ...r] = rtti();
-    return t === 'or' ? r.some(admitsUndefined) : false;
-};
-/** Returns the schema with `undefined` removed from any top-level `or`. */
-const stripUndefined = (rtti) => {
-    if (typeof rtti !== 'function') {
-        return rtti;
-    }
-    const [t, ...r] = rtti();
-    if (t !== 'or') {
-        return rtti;
-    }
-    const rest = r.flatMap(t => t !== undefined ? [t] : []);
-    return rest.length === 1 ? rest[0] : or(...rest);
-};
-// Struct: keys not admitting undefined go into `required`; optional keys have
-// undefined stripped from their property schema. additionalProperties is omitted
-// (lenient), matching rtti's open-struct validation semantics.
-const structSchema = (rtti) => {
-    const ents = Object.entries(rtti);
-    const properties = Object.fromEntries(ents.map(([k, v]) => [k, toJsonSchema(stripUndefined(v))]));
-    const required = ents
-        .filter(([, v]) => !admitsUndefined(v))
-        .map(([k]) => k);
-    return {
-        type: 'object',
-        properties,
-        ...(required.length > 0 ? { required } : {}),
-    };
-};
-const constPrimitiveSchema = (rtti) => rtti === undefined
-    ? { not: {} }
-    // bigint consts are represented as numbers (lossy for |value| > MAX_SAFE_INTEGER)
-    : { const: typeof rtti === 'bigint' ? Number(rtti) : rtti };
-const visitor = {
-    tuple: (t) => ({ type: 'array', prefixItems: t.map(toJsonSchema), items: false }),
-    struct: structSchema,
-    array: item => ({ type: 'array', items: toJsonSchema(item) }),
-    record: item => ({ type: 'object', additionalProperties: toJsonSchema(item) }),
-    or: variants => ({ anyOf: variants.map(toJsonSchema) }),
-    constPrimitive: constPrimitiveSchema,
-    // bigint is not representable in JSON Schema; 'integer' is the closest approximation
-    primitive0: tag => ({ type: tag === 'bigint' ? 'integer' : tag }),
-    unknown: () => ({}),
-};
-/**
- * Converts an rtti `Type` to a JSON Schema (draft 2020-12) object.
- *
- * | rtti                                          | JSON Schema                                                                         |
- * |-----------------------------------------------|-------------------------------------------------------------------------------------|
- * | `boolean` / `number` / `string`               | `{ "type": "..." }`                                                                 |
- * | `bigint`                                      | `{ "type": "integer" }` (lossy; JSON integers are IEEE-754 doubles)                 |
- * | `unknown`                                     | `{}` (always-true schema)                                                           |
- * | primitive const (`42`, `'x'`, `true`, `null`) | `{ "const": <value> }`                                                              |
- * | `bigint` const                                | `{ "const": Number(value) }` (lossy for \|value\| > MAX_SAFE_INTEGER)               |
- * | `undefined` const                             | `{ "not": {} }` (no JSON value satisfies this)                                      |
- * | struct `{ a: T, … }`                          | `{ "type": "object", "properties": { "a": …T… }, "required": [non-optional keys] }` |
- * | tuple `[A, B]`                                | `{ "type": "array", "prefixItems": […A…, …B…], "items": false }`                    |
- * | `array(T)`                                    | `{ "type": "array", "items": …T… }`                                                 |
- * | `record(T)`                                   | `{ "type": "object", "additionalProperties": …T… }`                                 |
- * | `or(...types)`                                | `{ "anyOf": […each…] }`                                                             |
- */
-export const toJsonSchema = visit(visitor);

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

@@ -1,36 +0,0 @@
-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;
-    };
-    schemaUnknownTag: () => void;
-    nested: {
-        arrayOfRecords: () => void;
-        orWithConst: () => void;
-        structWithOr: () => void;
-    };
-};