functionalscript 0.43.0 → 0.44.0

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

@@ -1,83 +0,0 @@
-import { boolean, number, string, bigint, unknown, array, record, or, option } from '../../../types/rtti/module.f.js';
-import { stringify } from '../module.f.js';
-import { toJsonSchema, unknown as schemaUnknown } from './module.f.js';
-import { assert, assertEq } from '../../../asserts/module.f.js';
-const serialize = (v) => stringify(e => e)(v);
-const eq = (rtti, expected) => () => {
-    const result = serialize(toJsonSchema(rtti));
-    const exp = serialize(expected);
-    assertEq(result, exp, [result, exp]);
-};
-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(42, { const: 42 }),
-        string: eq('hello', { const: 'hello' }),
-        undefined: eq(undefined, { not: {} }),
-        bigint: eq(7n, { const: 7 }),
-    },
-    array: eq(array(number), { type: 'array', items: { type: 'number' } }),
-    record: eq(record(string), { type: 'object', additionalProperties: { type: 'string' } }),
-    or: eq(or(string, number), { anyOf: [{ type: 'string' }, { type: 'number' }] }),
-    tuple: eq([number, string], {
-        type: 'array',
-        prefixItems: [{ type: 'number' }, { type: 'string' }],
-        items: false,
-    }),
-    struct: {
-        allRequired: eq({ x: number, y: string }, {
-            type: 'object',
-            properties: { x: { type: 'number' }, y: { type: 'string' } },
-            required: ['x', 'y'],
-        }),
-        withOptional: eq({ x: number, y: option(string) }, {
-            type: 'object',
-            properties: { x: { type: 'number' }, y: { type: 'string' } },
-            required: ['x'],
-        }),
-        allOptional: eq({ x: option(number) }, {
-            type: 'object',
-            properties: { x: { type: 'number' } },
-        }),
-        empty: eq({}, { type: 'object', properties: {} }),
-        orOptional: eq({ x: or(string, number, undefined) }, {
-            type: 'object',
-            properties: { x: { anyOf: [{ type: 'string' }, { type: 'number' }] } },
-        }),
-        withConst: eq({ x: null, y: string }, {
-            type: 'object',
-            properties: { x: { const: null }, y: { type: 'string' } },
-            required: ['x', 'y'],
-        }),
-    },
-    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, 42), {
-            anyOf: [{ const: null }, { type: 'string' }, { const: 42 }],
-        }),
-        structWithOr: eq({ id: or(string, number), name: option(string) }, {
-            type: 'object',
-            properties: {
-                id: { anyOf: [{ type: 'string' }, { type: 'number' }] },
-                name: { type: 'string' },
-            },
-            required: ['id'],
-        }),
-    },
-};

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

@@ -1,28 +0,0 @@
-/**
- * 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 { type List } from '../../../types/list/module.f.ts';
-/**
- * Serializes a string as a JSON string literal.
- */
-export declare const stringSerialize: (_: string) => List<string>;
-/**
- * Serializes a number as a JSON number literal.
- */
-export declare const numberSerialize: (_: number) => List<string>;
-/**
- * Shared serialized representation for `null`.
- */
-export declare const nullSerialize: string[];
-export declare const boolSerialize: (_: boolean) => List<string>;
-export declare const objectWrap: (input: List<List<string>>) => List<string>;
-/**
- * Wraps serialized entries into a JSON array.
- */
-export declare const arrayWrap: (input: List<List<string>>) => List<string>;

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

@@ -1,73 +0,0 @@
-/**
- * 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 { flat, map, reduce, empty } from '../../../types/list/module.f.js';
-import {} from '../../../types/function/operator/module.f.js';
-import { concat } from '../../../types/string/module.f.js';
-import { codePointToString, stringToCodePointList, } from '../../../text/utf16/module.f.js';
-import { errorMask } from '../../../text/code_point/module.f.js';
-import { backspace, cr, digit0, ff, ht, latinSmallLetterA, lf, quotationMark, reverseSolidus, space, } from '../../../text/ascii/module.f.js';
-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 = {
-    [backspace]: '\\b',
-    [ht]: '\\t',
-    [lf]: '\\n',
-    [ff]: '\\f',
-    [cr]: '\\r',
-    [quotationMark]: '\\"',
-    [reverseSolidus]: '\\\\',
-};
-const hexDigit = (value) => fromCharCode(value < 10 ? digit0 + value : latinSmallLetterA + value - 10);
-/**
- * `\uXXXX` with lowercase hex digits, matching ECMAScript's `UnicodeEscape`.
- */
-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.
- */
-const escapeCodePoint = (codePoint) => (codePoint & errorMask) !== 0
-    ? unicodeEscape(codePoint & 0xffff)
-    : escapeTable[codePoint]
-        ?? (codePoint < space ? unicodeEscape(codePoint) : codePointToString(codePoint));
-/**
- * Serializes a string as a JSON string literal.
- */
-export const stringSerialize = input => [`"${concat(map(escapeCodePoint)(stringToCodePointList(input)))}"`];
-/**
- * Serializes a number as a JSON number literal.
- */
-export const numberSerialize = input => [jsonStringify(input)];
-/**
- * Shared serialized representation for `null`.
- */
-export const nullSerialize = ['null'];
-const trueSerialize = ['true'];
-const falseSerialize = ['false'];
-export const boolSerialize = value => value ? trueSerialize : falseSerialize;
-const comma = [','];
-const joinOp = b => prior => flat([prior, comma, b]);
-const join = reduce(joinOp)(empty);
-const wrap = open => close => {
-    const seqOpen = [open];
-    const seqClose = [close];
-    return input => flat([seqOpen, join(input), seqClose]);
-};
-export const objectWrap = wrap('{')('}');
-/**
- * Wraps serialized entries into a JSON array.
- */
-export const arrayWrap = wrap('[')(']');

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

@@ -1,94 +0,0 @@
-import { arrayWrap, boolSerialize, numberSerialize, objectWrap, stringSerialize } from './module.f.js';
-import * as list from '../../../types/list/module.f.js';
-import { concat } from '../../../types/string/module.f.js';
-import { assertEq } from '../../../asserts/module.f.js';
-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.
-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.ts

@@ -1,15 +0,0 @@
-import { type List } from '../../../types/list/module.f.ts';
-import { type EofToken, type ErrorToken, type NumberToken, type StringToken } from '../../../js/tokenizer/module.f.ts';
-export type JsonToken = {
-    readonly kind: 'true' | 'false' | 'null';
-} | {
-    readonly kind: '{' | '}' | ':' | ',' | '[' | ']';
-} | StringToken | NumberToken | ErrorToken | EofToken;
-/**
- * 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.
- */
-export declare const tokenize: (input: List<number>) => List<JsonToken>;

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

@@ -1,63 +0,0 @@
-/**
- * Tokenizer for JSON lexical analysis.
- *
- * @module
- */
-import {} from '../../../types/function/operator/module.f.js';
-import { concat, empty, flat, stateScan } from '../../../types/list/module.f.js';
-import { multiply } from '../../../types/bigfloat/module.f.js';
-import { tokenize as jsTokenize } from '../../../js/tokenizer/module.f.js';
-const mapToken = input => {
-    switch (input.kind) {
-        case '{':
-        case '}':
-        case ':':
-        case ',':
-        case '[':
-        case ']':
-        case 'true':
-        case 'false':
-        case 'null':
-        case 'string':
-        case 'number':
-        case 'eof':
-        case 'error': return [input];
-        case 'ws':
-        case 'nl': return empty;
-        default: return [{ kind: 'error', message: 'invalid token' }];
-    }
-};
-const parseDefaultState = input => {
-    if (input === null)
-        return [empty, { kind: 'def' }];
-    switch (input.token.kind) {
-        case '-': return [empty, { kind: '-' }];
-        default: return [mapToken(input.token), { kind: 'def' }];
-    }
-};
-const parseMinusState = input => {
-    if (input === null)
-        return [[{ kind: 'error', message: 'invalid token' }], { kind: 'def' }];
-    switch (input.token.kind) {
-        case '-': return [[{ kind: 'error', message: 'invalid token' }], { kind: '-' }];
-        case 'number': return [[{ kind: 'number', bf: multiply(input.token.bf)(-1n), value: `-${input.token.value}` }], { kind: 'def' }];
-        default: return [{ first: { kind: 'error', message: 'invalid token' }, tail: mapToken(input.token) }, { kind: 'def' }];
-    }
-};
-const scanToken = (input, state) => {
-    switch (state.kind) {
-        case '-': return parseMinusState(input);
-        default: return parseDefaultState(input);
-    }
-};
-/**
- * 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.
- */
-export const tokenize = (input) => {
-    const jsTokens = jsTokenize(input)('');
-    return flat(stateScan(scanToken)({ kind: 'def' })(concat(jsTokens)([null])));
-};

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

@@ -1,5 +0,0 @@
-export declare const proof: {
-    json: (() => void)[];
-    id: (() => void)[];
-    keywords: (() => void)[];
-};