functionalscript 0.37.0 → 0.38.0

package/fs/djs/tokenizer-new/module.f.js

@@ -1,155 +0,0 @@
-/**
- * Experimental DJS parser implementation.
- *
- * @module
- */
-import { descentParser } from "../../bnf/descent/module.f.js";
-import { eof, join0Plus, max, none, not, notSet, oneEncode, option, range, remove, repeat, repeat0Plus, repeat1Plus, set, unicodeRange } from "../../bnf/module.f.js";
-import { todo } from "../../asserts/module.f.js";
-export const parse = (input) => {
-    const m = descentParser(jsGrammar());
-    return todo();
-};
-export const jsGrammar = () => {
-    const onenine = range('19');
-    const digit = range('09');
-    const string = [
-        '"',
-        repeat0Plus({
-            ...remove(range(` ${max}`), set('"\\')),
-            escape: [
-                '\\',
-                {
-                    ...set('"\\bfnrt'),
-                    solidus: '/',
-                    u: [
-                        'u',
-                        ...repeat(4)({
-                            digit,
-                            AF: range('AF'),
-                            af: range('af'),
-                        })
-                    ],
-                }
-            ],
-        }),
-        '"'
-    ];
-    const digits0 = repeat0Plus(digit);
-    const digits = [digit, digits0];
-    const number = [
-        {
-            0: '0',
-            onenine: [onenine, digits0],
-        },
-        option({
-            bigint: 'n',
-            frac: [
-                option(['.', digits]),
-                option([set('Ee'), option(set('+-')), digits])
-            ]
-        })
-    ];
-    const ws = set(' \t');
-    const newLine = set('\n\r');
-    const idStart = {
-        smallLetter: range('az'),
-        bigLetter: range('AZ'),
-        lowLine: '_',
-        dollarSign: '$'
-    };
-    const idChar = {
-        ...idStart,
-        digit
-    };
-    const id = [idStart, repeat0Plus(idChar)];
-    const operator = {
-        '.': '.',
-        '=>': '=>',
-        '===': '===',
-        '==': '==',
-        '=': '=',
-        '!==': '!==',
-        '!=': '!=',
-        '!': '!',
-        '>>>=': '>>>=',
-        '>>>': '>>>',
-        '>>=': '>>=',
-        '>>': '>>',
-        '>=': '>=',
-        '>': '>',
-        '<<<<=': '<<<=',
-        '<<<': '<<<',
-        '<<=': '<<=',
-        '<<': '<<',
-        '<=': '<=',
-        '<': '<',
-        '+=': '+=',
-        '++': '++',
-        '+': '+',
-        '-=': '-=',
-        '--': '--',
-        '-': '-',
-        '**=': '**=',
-        '**': '**',
-        '*=': '*=',
-        '*': '*',
-        '/=': '/=',
-        '/': '/',
-        '%=': '%=',
-        '%': '%',
-        '&&=': '&&=',
-        '&&': '&&',
-        '&=': '&=',
-        '&': '&',
-        '||=': '||=',
-        '||': '||',
-        '|=': '|=',
-        '|': '|',
-        '^=': '^=',
-        '^': '^',
-        '~': '~',
-        '??=': '??=',
-        '??': '??',
-        '?.': '?.',
-        '?': '?',
-        '[': '[',
-        ']': ']',
-        '{': '{',
-        '}': '}',
-        '(': '(',
-        ')': ')',
-        ',': ',',
-        ':': ':'
-    };
-    const commentEnd = {
-        ...newLine,
-        eof
-    };
-    const comment = ['/', {
-            // TODO: investigate why `not(commentEnd)` instead of `remove(unicodeRange, newLine)` fail tests.
-            // TODO: should it be `repeat0Plus(not(commentEnd))` instead of `option(remove(unicodeRange, newLine))`.
-            oneline: ['/', option(remove(unicodeRange, newLine)), commentEnd],
-            multiline: [
-                '*',
-                repeat0Plus({
-                    na: notSet('*'),
-                    a: ['*', notSet('/')]
-                }),
-                '*/'
-            ]
-        }
-    ];
-    const token = {
-        number,
-        string,
-        id,
-        comment,
-        operator,
-        ws,
-        newLine,
-        eof
-    };
-    const tokens = repeat0Plus(token);
-    return tokens;
-};

package/fs/media/revision/proof.f.js

@@ -1,119 +0,0 @@
-import { assert, assertEq } from '../../asserts/module.f.js';
-import { dialect, mediaType, isHash, validate, decodeText } from './module.f.js';
-// Valid cbase32 hashes (round-tripped in fs/basen/cbase32/proof.f.ts): single
-// cbase32 symbols, cheap to write inline here.
-const h1 = '8';
-const h2 = 'r';
-const revisionOf = (extra) => ({
-    dialect,
-    subject: h1,
-    parents: [],
-    ...extra,
-});
-export const proof = {
-    dialectAndMediaType: () => {
-        assertEq(dialect, 'vnd.fjs.revision');
-        assertEq(mediaType, 'application/vnd.fjs.revision+json');
-    },
-    isHash: {
-        validHash: () => assert(isHash(h1)),
-        httpsRejected: () => assert(!isHash('https://example.com/blob/abc')),
-        arbitraryStringRejected: () => assert(!isHash('not-a-hash!')),
-    },
-    validate: {
-        // Zero parents, no `snapshot`: `subject` is the fallback snapshot
-        // reference and must itself be a hash.
-        firstRevisionFallsBackToSubjectHash: () => {
-            const [t] = validate(revisionOf({}));
-            assertEq(t, 'ok');
-        },
-        // Zero parents, no `snapshot`, `subject` is not a hash: invalid.
-        firstRevisionRejectsNonHashSubject: () => {
-            const [t] = validate(revisionOf({ subject: 'my-config' }));
-            assertEq(t, 'error');
-        },
-        // `snapshot` present: `subject` may be an arbitrary string.
-        explicitSnapshotAllowsArbitrarySubject: () => {
-            const [t] = validate(revisionOf({ subject: 'my-config', snapshot: h2 }));
-            assertEq(t, 'ok');
-        },
-        // Exactly one parent, no `snapshot`: the parent's snapshot is inherited,
-        // and `subject` may be an arbitrary string.
-        singleParentInheritsSnapshot: () => {
-            const [t] = validate(revisionOf({ subject: 'my-config', parents: [h2] }));
-            assertEq(t, 'ok');
-        },
-        // More than one parent with no `snapshot`: invalid — no single parent
-        // snapshot to inherit, and falling back to `subject` would silently
-        // lose the merge result.
-        multiParentWithoutSnapshotRejected: () => {
-            const [t] = validate(revisionOf({ subject: 'my-config', parents: [h1, h2] }));
-            assertEq(t, 'error');
-        },
-        // A merge revision with an explicit `snapshot` is valid.
-        multiParentWithSnapshotAccepted: () => {
-            const [t, v] = validate(revisionOf({ subject: 'my-config', parents: [h1, h2], snapshot: h2 }));
-            assertEq(t, 'ok');
-            assertEq(v.snapshot, h2);
-        },
-        // `https://` bridge URLs are rejected wherever a hash is required.
-        httpsRejectedInParents: () => {
-            const [t] = validate(revisionOf({ subject: 'my-config', parents: ['https://example.com/x'], snapshot: h2 }));
-            assertEq(t, 'error');
-        },
-        httpsRejectedInSnapshot: () => {
-            const [t] = validate(revisionOf({ subject: 'my-config', snapshot: 'https://example.com/x' }));
-            assertEq(t, 'error');
-        },
-        httpsRejectedAsFallbackSubject: () => {
-            const [t] = validate(revisionOf({ subject: 'https://example.com/x' }));
-            assertEq(t, 'error');
-        },
-        // `archived` follows the presence-only `option(true)` idiom.
-        archivedAccepted: () => {
-            const [t] = validate(revisionOf({ archived: true }));
-            assertEq(t, 'ok');
-        },
-        // Wrong dialect tag: structural validation rejects it outright.
-        wrongDialectRejected: () => {
-            const [t] = validate({ dialect: 'vnd.fjs.other', subject: h1, parents: [] });
-            assertEq(t, 'error');
-        },
-        // Missing required fields: rejected.
-        missingSubjectRejected: () => {
-            const [t] = validate({ dialect, parents: [] });
-            assertEq(t, 'error');
-        },
-        // rtti structs are open: extra fields don't break validation — the
-        // additive forward-compatibility path the versioning rule relies on.
-        extraFieldsAccepted: () => {
-            const [t] = validate(revisionOf({ future: 'field' }));
-            assertEq(t, 'ok');
-        },
-    },
-    decodeText: {
-        validJson: () => {
-            const [t, v] = decodeText(JSON.stringify(revisionOf({ generation: 0 })));
-            assertEq(t, 'ok');
-            assertEq(v.subject, h1);
-        },
-        // Key order carries no meaning: detection parses the JSON and
-        // validates the parsed value, so `dialect` need not be first.
-        keyOrderIndependent: () => {
-            const text = `{"parents":[],"subject":"${h1}","dialect":"${dialect}"}`;
-            const [t] = decodeText(text);
-            assertEq(t, 'ok');
-        },
-        malformedJsonRejected: () => {
-            const [t] = decodeText('{not json');
-            assertEq(t, 'error');
-        },
-        // Ordinary JSON that isn't a revision at all falls through as an error
-        // here — `fs/media`'s composed detector is what falls back to the
-        // ordinary detector; this module only reports validity.
-        ordinaryJsonRejected: () => {
-            const [t] = decodeText('{"hello":"world"}');
-            assertEq(t, 'error');
-        },
-    },
-};

package/fs/text/ascii/proof.f.d.ts

@@ -1,4 +0,0 @@
-export declare const proof: {
-    range: () => void;
-    oneThrowsOnEmpty: () => void;
-};

package/fs/types/bigfloat/proof.f.js

@@ -1,348 +0,0 @@
-import { decToBin } from './module.f.js';
-export const proof = {
-    decToBin: [
-        () => {
-            const result = decToBin([0n, 0]);
-            if (result[0] !== 0n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 0) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([0n, 10]);
-            if (result[0] !== 0n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 0) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([0n, -10]);
-            if (result[0] !== 0n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 0) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([1n, 0]);
-            if (result[0] !== 4503599627370496n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== -52) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([1n, 1]);
-            if (result[0] !== 5629499534213120n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== -49) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([1000n, -2]);
-            if (result[0] !== 5629499534213120n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== -49) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([1n, -1]);
-            if (result[0] !== 7205759403792794n) {
-                throw result[0].toString(2);
-            } //+1
-            if (result[1] !== -56) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([-1n, 0]);
-            if (result[0] !== -4503599627370496n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== -52) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([-1n, 1]);
-            if (result[0] !== -5629499534213120n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== -49) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([-1000n, -2]);
-            if (result[0] !== -5629499534213120n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== -49) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([-1n, -1]);
-            if (result[0] !== -7205759403792794n) {
-                throw result[0].toString(2);
-            } //+1
-            if (result[1] !== -56) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([9007199254740993n, 0]); //54bits (...0.1)
-            if (result[0] !== 4503599627370496n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 1) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([-9007199254740995n, 0]); //54bits (...1.1)
-            if (result[0] !== -4503599627370498n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 1) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([-9007199254740993n, 0]); //54bits (...0.1)
-            if (result[0] !== -4503599627370496n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 1) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([-9007199254740995n, 0]); //54bits (...1.1)
-            if (result[0] !== -4503599627370498n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 1) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([18014398509481985n, 0]); //55bits (...0.01)
-            if (result[0] !== 4503599627370496n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 2) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([18014398509481986n, 0]); //55bits (...0.10)
-            if (result[0] !== 4503599627370496n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 2) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([18014398509481990n, 0]); //55bits (...1.10)
-            if (result[0] !== 4503599627370498n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 2) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([18014398509481987n, 0]); //55bits (0.11)
-            if (result[0] !== 4503599627370497n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 2) {
-                throw result[1];
-            }
-        },
-    ],
-    roundingPositive: [
-        () => {
-            const result = decToBin([288230376151711745n, -1]);
-            // reminder = 0
-            // m = 11001100110011001100110011001100110011001100110011001.101
-            // rounding up
-            if (result[0] !== 7205759403792794n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 2) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([288230376151711760n, -1]);
-            // reminder = 0
-            // m = 11001100110011001100110011001100110011001100110011010.000
-            // rounding down
-            if (result[0] !== 7205759403792794n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 2) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([288230376151711780n, -1]);
-            // reminder = 0
-            // m = 11001100110011001100110011001100110011001100110011010.100
-            // rounding down (to even)
-            if (result[0] !== 7205759403792794n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 2) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([288230376151711781n, -1]);
-            // reminder = 1
-            // m = 11001100110011001100110011001100110011001100110011010.100
-            // rounding up
-            if (result[0] !== 7205759403792795n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 2) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([288230376151711785n, -1]);
-            // reminder = 0
-            // m = 11001100110011001100110011001100110011001100110011010.101
-            // rounding up
-            if (result[0] !== 7205759403792795n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 2) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([288230376151711805n, -1]);
-            // reminder = 0
-            // m = 11001100110011001100110011001100110011001100110011011.001
-            // rounding down
-            if (result[0] !== 7205759403792795n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 2) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([288230376151711820n, -1]);
-            // reminder = 0
-            // m = 11001100110011001100110011001100110011001100110011011.100
-            // rounding up (to even)
-            if (result[0] !== 7205759403792796n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 2) {
-                throw result[1];
-            }
-        }
-    ],
-    roundingNegative: [
-        () => {
-            const result = decToBin([-288230376151711745n, -1]);
-            // reminder = 0
-            // m = -11001100110011001100110011001100110011001100110011001.101
-            // rounding down
-            if (result[0] !== -7205759403792794n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 2) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([-288230376151711760n, -1]);
-            // reminder = 0
-            // m = -11001100110011001100110011001100110011001100110011010.000
-            // rounding up
-            if (result[0] !== -7205759403792794n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 2) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([-288230376151711780n, -1]);
-            // reminder = 0
-            // m = -11001100110011001100110011001100110011001100110011010.100
-            // rounding up (to even)
-            if (result[0] !== -7205759403792794n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 2) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([-288230376151711781n, -1]);
-            // reminder = 1
-            // m = -11001100110011001100110011001100110011001100110011010.100
-            // rounding down
-            if (result[0] !== -7205759403792795n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 2) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([-288230376151711785n, -1]);
-            // reminder = 0
-            // m = -11001100110011001100110011001100110011001100110011010.101
-            // rounding down
-            if (result[0] !== -7205759403792795n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 2) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([-288230376151711805n, -1]);
-            // reminder = 0
-            // m = -11001100110011001100110011001100110011001100110011011.001
-            // rounding up
-            if (result[0] !== -7205759403792795n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 2) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([-288230376151711820n, -1]);
-            // reminder = 0
-            // m = -11001100110011001100110011001100110011001100110011011.100
-            // rounding down (to even)
-            if (result[0] !== -7205759403792796n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 2) {
-                throw result[1];
-            }
-        }
-    ]
-};

package/fs/types/nullable/proof.f.js

@@ -1,50 +0,0 @@
-import { fromUndefined, map, match, toOption } from './module.f.js';
-export const proof = [
-    () => {
-        const optionSq = map((v) => v * v);
-        const sq3 = optionSq(3);
-        if (sq3 !== 9) {
-            throw sq3;
-        }
-        const sqNull = optionSq(null);
-        if (sqNull !== null) {
-            throw sqNull;
-        }
-    },
-    () => {
-        const opt1 = toOption(5);
-        if (opt1.length !== 1 || opt1[0] !== 5) {
-            throw opt1;
-        }
-        const opt2 = toOption(null);
-        if (opt2.length !== 0) {
-            throw opt2;
-        }
-    },
-    () => {
-        const double = match((v) => v * 2)(() => -1);
-        if (double(3) !== 6) {
-            throw double(3);
-        }
-        if (double(null) !== -1) {
-            throw double(null);
-        }
-    },
-    () => {
-        if (fromUndefined(undefined) !== null) {
-            throw 0;
-        }
-        if (fromUndefined(5) !== 5) {
-            throw 1;
-        }
-        if (fromUndefined(0) !== 0) {
-            throw 2;
-        }
-        if (fromUndefined(null) !== null) {
-            throw 3;
-        }
-        if (fromUndefined('') !== '') {
-            throw 4;
-        }
-    },
-];

package/fs/types/range/module.f.js

@@ -1,2 +0,0 @@
-export const contains = ([b, e]) => i => b <= i && i <= e;
-export const one = a => [a, a];

package/fs/types/range/proof.f.js

@@ -1,18 +0,0 @@
-import { contains } from './module.f.js';
-export const proof = () => {
-    if (!contains([0, 5])(1)) {
-        throw 1;
-    }
-    if (!contains([0, 5])(0)) {
-        throw 0;
-    }
-    if (!contains([0, 5])(5)) {
-        throw 5;
-    }
-    if (contains([0, 5])(-1)) {
-        throw -1;
-    }
-    if (contains([0, 5])(6)) {
-        throw 6;
-    }
-};