functionalscript 0.43.1 → 0.45.0

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

@@ -1,11 +0,0 @@
-type Result = readonly [readonly string[], ToResult];
-type ToResult = (codePoint: number) => Result;
-export declare const terminal = -1;
-export declare const init: ToResult;
-export declare const proof: {
-    throw: {
-        unionConflict: () => void;
-    };
-    defHandler: () => void;
-};
-export {};

package/fjs/fsc/module.f.js

@@ -1,73 +0,0 @@
-/**
- * FunctionalScript command utilities for compile workflows.
- *
- * @module
- */
-import { strictEqual } from '../types/function/operator/module.f.js';
-import { merge as rangeMapMerge, fromRange, get, } from '../types/range_map/module.f.js';
-import { reduce as listReduce, toArray, map } from '../types/list/module.f.js';
-import { range as asciiRange } from '../text/ascii/module.f.js';
-import { flip, fn } from '../types/function/module.f.js';
-import { one } from '../types/range/module.f.js';
-import { assertEq } from '../asserts/module.f.js';
-const fromCharCode = String.fromCharCode;
-const unexpectedSymbol = codePoint => [[`unexpected symbol ${codePoint}`], unexpectedSymbol];
-const def = () => unexpectedSymbol;
-const union = (a) => (b) => {
-    if (a === def || a === b) {
-        return b;
-    }
-    if (b === def) {
-        return a;
-    }
-    throw [a, b];
-};
-const empty = [];
-const reduce = (a) => {
-    const merge = rangeMapMerge({
-        union,
-        equal: strictEqual,
-        def,
-    });
-    return toArray(listReduce(merge)(empty)(a));
-};
-const codePointRange = flip(fromRange(def));
-const range = fn(asciiRange).map(codePointRange).result;
-const rangeSet = (l) => (f) => {
-    const codePointRange = flip(fromRange(def));
-    const g = r => codePointRange(asciiRange(r))(f);
-    return reduce(map(g)(l));
-};
-const create = (a) => {
-    const i = reduce(a);
-    const x = get(def);
-    return v => c => x(i)(c)(v)(c);
-};
-export const terminal = -1;
-const toInit = () => () => [[], init];
-const single = (c) => range(c)(() => () => [[c], unexpectedSymbol]);
-const punctuation = "!\"%&'()*+,-./:;<=>?[]^`{|}~";
-export const init = create([
-    codePointRange(one(terminal))(toInit),
-    rangeSet(['\t', ' ', '\n', '\r'])(toInit),
-    rangeSet(['$', '_', 'AZ', 'az'])(() => c => [[fromCharCode(c)], unexpectedSymbol]),
-    range('09')(() => a => [[fromCharCode(a)], unexpectedSymbol]),
-    ...[...punctuation].map(single),
-])(undefined);
-export const proof = {
-    // union throws when two distinct non-def handlers are merged for the same range;
-    // this path is unreachable through the public API (init has no overlapping ranges),
-    // so we exercise it here where the private union function is in scope.
-    throw: {
-        unionConflict: () => {
-            const a = _s => unexpectedSymbol;
-            const b = _s => unexpectedSymbol;
-            a(undefined);
-            b(undefined);
-            union(a)(b);
-        }
-    },
-    // `def` is the range-map's default handler; the public API never calls it directly
-    // (`init` covers every code point), so exercise it here where it's in scope.
-    defHandler: () => assertEq(def(undefined), unexpectedSymbol)
-};

package/fjs/fsc/proof.f.js

@@ -1,104 +0,0 @@
-import { init, terminal } from './module.f.js';
-import { one } from '../text/ascii/module.f.js';
-import { stringify } from '../media/json/module.f.js';
-import { assertEq } from '../asserts/module.f.js';
-const s = stringify(i => i);
-const f = v => {
-    const n = one(v);
-    return s(init(n)[0]);
-};
-// this doesn't change a name of the function
-const fn = (f, name) => ({ [name]: f }[name]);
-const withName = (name) => 
-// translated into one command: define a `function [name]() { return undefined }`
-Object.getOwnPropertyDescriptor({ [name]: () => undefined }, name).value;
-export const proof = {
-    a: () => {
-        const x = f('1');
-        assertEq(x, '["1"]');
-    },
-    b: () => {
-        // exercises toInit: terminal returns empty output and loops back to init
-        const result = init(terminal);
-        assertEq(result[0].length, 0, result[0]);
-    },
-    c: () => {
-        // exercises unexpectedSymbol: next state after a token returns an error message
-        const next = init(one('1'))[1];
-        const result = next(42);
-        assertEq(result[0][0], 'unexpected symbol 42');
-    },
-    fn: () => {
-        const o = {
-            ["hello world!"]: () => undefined
-        };
-        const f = o["hello world!"];
-        const { name } = f;
-        assertEq(name, "hello world!");
-        //
-        const f1 = { ["boring"]: () => undefined }["boring"];
-        assertEq(f1.name, "boring");
-        //
-        const x = fn(() => undefined, "hello").name;
-        assertEq(x, "");
-        //
-        const m = withName("boring2").name;
-        assertEq(m, "boring2");
-        //
-        const a = function x() { return undefined; };
-        assertEq(a.name, "x");
-    },
-    //
-    f1: () => {
-        const m1 = () => undefined;
-        assertEq(m1.name, "m1");
-    },
-    //
-    f2: () => {
-        const m11 = (() => undefined);
-        assertEq(m11.name, "m11");
-    },
-    //
-    f3: () => {
-        const m2 = true ? () => undefined : () => undefined;
-        // for `bun` it is `m2`:
-        // assertEq(m2.name, "")
-        // see also https://github.com/oven-sh/bun/issues/20398
-    },
-    f4: () => {
-        const id = (i) => i;
-        const f = id(() => undefined);
-        // for `bun` it is `m2`:
-        assertEq(f.name, "");
-    },
-    chars: {
-        whitespace: () => {
-            for (const ch of ['\t', ' ', '\n', '\r']) {
-                const [tokens, next] = init(one(ch));
-                assertEq(tokens.length, 0);
-                assertEq(next, init);
-            }
-        },
-        punctuation: () => {
-            for (const ch of ['!', '"', '%', '&', "'", '(', ')', '*', '+', ',', '-', '.', '/', ':', ';', '<', '=', '>', '?', '[', ']', '^', '`', '{', '|', '}', '~']) {
-                const [tokens] = init(one(ch));
-                assertEq(tokens.length, 1);
-                assertEq(tokens[0], ch);
-            }
-        },
-        identifier_start: () => {
-            for (const ch of ['$', '_', 'A', 'Z', 'a', 'z']) {
-                const [tokens] = init(one(ch));
-                assertEq(tokens.length, 1);
-                assertEq(tokens[0], ch);
-            }
-        },
-        digits: () => {
-            for (const ch of ['0', '5', '9']) {
-                const [tokens] = init(one(ch));
-                assertEq(tokens.length, 1);
-                assertEq(tokens[0], ch);
-            }
-        },
-    },
-};

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

@@ -1,17 +0,0 @@
-/**
- * Finite state machine helpers used by parser and tokenizer logic.
- *
- * @module
- */
-import { type List } from '../types/list/module.f.ts';
-import type { StringMap } from '../types/object/module.f.ts';
-import { type ByteSet } from '../types/byte_set/module.f.ts';
-import { type RangeMapArray } from '../types/range_map/module.f.ts';
-type Rule = readonly [string, ByteSet, string];
-export type Grammar = List<Rule>;
-type Dfa = StringMap<RangeMapArray<string>>;
-export declare const toRange: (s: string) => ByteSet;
-export declare const toUnion: (s: string) => ByteSet;
-export declare const dfa: (grammar: Grammar) => Dfa;
-export declare const run: (dfa: Dfa) => (input: List<number>) => List<string>;
-export {};

package/fjs/fsm/module.f.js

@@ -1,55 +0,0 @@
-/**
- * Finite state machine helpers used by parser and tokenizer logic.
- *
- * @module
- */
-import { equal, isEmpty, fold, toArray, scan, foldScan, empty as emptyList } from '../types/list/module.f.js';
-import { toRangeMap, union as byteSetUnion, one, empty, range } from '../types/byte_set/module.f.js';
-import { intersect, union as sortedSetUnion } from '../types/sorted_set/module.f.js';
-import { merge, get as rangeMapGet } from '../types/range_map/module.f.js';
-import { strictEqual } from '../types/function/operator/module.f.js';
-import { stringify } from '../media/json/module.f.js';
-import { identity } from '../types/function/module.f.js';
-import { stringToList } from '../text/utf16/module.f.js';
-import { cmp } from '../types/string/module.f.js';
-const stringifyIdentity = stringify(identity);
-export const toRange = s => {
-    const [b, e] = toArray(stringToList(s));
-    return range([b, e]);
-};
-const toUnionOp = i => bs => byteSetUnion(bs)(one(i));
-export const toUnion = s => {
-    const codePoints = stringToList(s);
-    return fold(toUnionOp)(empty)(codePoints);
-};
-const mergeOp = { union: sortedSetUnion(cmp), equal: equal(strictEqual), def: [] };
-const hasState = s => set => !isEmpty(intersect(cmp)([s])(set));
-const foldOp = set => ([ruleIn, bs, ruleOut]) => rm => {
-    if (hasState(ruleIn)(set)) {
-        return merge(mergeOp)(rm)(toRangeMap(bs)(ruleOut));
-    }
-    return rm;
-};
-const stringifyOp = ([sortedSet, max]) => [[stringifyIdentity(sortedSet), max], stringifyOp];
-const scanStringify = scan(stringifyOp);
-const fetchOp = ([item, _]) => [item, fetchOp];
-const scanFetch = scan(fetchOp);
-const addEntry = grammar => set => dfa => {
-    const s = stringifyIdentity(set);
-    if (s in dfa) {
-        return dfa;
-    }
-    const setMap = fold(foldOp(set))(emptyList)(grammar);
-    const stringMap = toArray(scanStringify(setMap));
-    const newDfa = { ...dfa, [s]: stringMap };
-    const newStates = scanFetch(setMap);
-    return fold(addEntry(grammar))(newDfa)(newStates);
-};
-const emptyState = [];
-const emptyStateStringify = stringifyIdentity(emptyState);
-const initialState = [''];
-const initialStateStringify = stringifyIdentity(initialState);
-export const dfa = grammar => addEntry(grammar)(initialState)({});
-const get = rangeMapGet(emptyStateStringify);
-const runOp = dfa => input => s => get(dfa[s] ?? [])(input);
-export const run = (dfa) => (input) => foldScan(runOp(dfa))(initialStateStringify)(input);

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

@@ -1,4 +0,0 @@
-export declare const proof: {
-    dfa: () => void;
-    run: (() => void)[];
-};

package/fjs/fsm/proof.f.js

@@ -1,126 +0,0 @@
-import { dfa, run, toRange, toUnion } from './module.f.js';
-import { union } from '../types/byte_set/module.f.js';
-import { sort, fromEntries } from '../types/object/module.f.js';
-import { stringify } from '../media/json/module.f.js';
-import { identity } from '../types/function/module.f.js';
-import { toArray } from '../types/list/module.f.js';
-import { stringToList } from '../text/utf16/module.f.js';
-import { assertEq } from '../asserts/module.f.js';
-const stringifyIdentity = stringify(identity);
-const buildDfa = () => {
-    const lowercaseAlpha = toRange('az');
-    const uppercaseAlpha = toRange('AZ');
-    const alpha = union(lowercaseAlpha)(uppercaseAlpha);
-    const idSymbol = toUnion('_$');
-    const idBegin = union(alpha)(idSymbol);
-    const digit = toRange('09');
-    const idNext = union(idBegin)(digit);
-    const dot = toUnion('.');
-    const grammar = [
-        ['', digit, 'int'],
-        ['int', digit, 'int'],
-        ['', digit, 'floatBegin'],
-        ['floatBegin', digit, 'floatBegin'],
-        ['floatBegin', dot, 'floatDot'],
-        ['floatDot', digit, 'float'],
-        ['float', digit, 'float'],
-        ['', idBegin, 'id'],
-        ['id', idNext, 'id']
-    ];
-    return dfa(grammar);
-};
-export const proof = {
-    dfa: () => {
-        const dfa = buildDfa();
-        const entries = Object.entries(dfa);
-        const sortedEntries = sort(entries);
-        const obj = fromEntries(sortedEntries);
-        const result = stringifyIdentity(obj);
-        const expectedObj = {
-            '[""]': [
-                ['[]', 35],
-                ['["id"]', 36],
-                ['[]', 47],
-                ['["floatBegin","int"]', 57],
-                ['[]', 64],
-                ['["id"]', 90],
-                ['[]', 94],
-                ['["id"]', 95],
-                ['[]', 96],
-                ['["id"]', 122]
-            ],
-            '["float"]': [['[]', 47], ['["float"]', 57]],
-            '["floatBegin","int"]': [
-                ['[]', 45],
-                ['["floatDot"]', 46],
-                ['[]', 47],
-                ['["floatBegin","int"]', 57]
-            ],
-            '["floatDot"]': [['[]', 47], ['["float"]', 57]],
-            '["id"]': [
-                ['[]', 35],
-                ['["id"]', 36],
-                ['[]', 47],
-                ['["id"]', 57],
-                ['[]', 64],
-                ['["id"]', 90],
-                ['[]', 94],
-                ['["id"]', 95],
-                ['[]', 96],
-                ['["id"]', 122]
-            ],
-            '[]': []
-        };
-        const expectedResult = stringifyIdentity(expectedObj);
-        if (result !== expectedResult) {
-            throw result;
-        }
-    },
-    run: [
-        () => {
-            const dfa = buildDfa();
-            const input = stringToList('a1');
-            const result = stringifyIdentity(toArray(run(dfa)(input)));
-            const expectedOutput = [
-                '["id"]',
-                '["id"]'
-            ];
-            const expectedResult = stringifyIdentity(expectedOutput);
-            assertEq(result, expectedResult);
-        },
-        () => {
-            const dfa = buildDfa();
-            const input = stringToList('0.1');
-            const result = stringifyIdentity(toArray(run(dfa)(input)));
-            const expectedOutput = [
-                '["floatBegin","int"]',
-                '["floatDot"]',
-                '["float"]'
-            ];
-            const expectedResult = stringifyIdentity(expectedOutput);
-            assertEq(result, expectedResult);
-        },
-        () => {
-            const dfa = buildDfa();
-            const input = stringToList('//');
-            const result = stringifyIdentity(toArray(run(dfa)(input)));
-            const expectedOutput = [
-                '[]',
-                '[]'
-            ];
-            const expectedResult = stringifyIdentity(expectedOutput);
-            assertEq(result, expectedResult);
-        },
-        () => {
-            const dfa = buildDfa();
-            const input = stringToList('::');
-            const result = stringifyIdentity(toArray(run(dfa)(input)));
-            const expectedOutput = [
-                '[]',
-                '[]'
-            ];
-            const expectedResult = stringifyIdentity(expectedOutput);
-            assertEq(result, expectedResult);
-        }
-    ]
-};

package/fjs/js/tokenizer/module.f.d.ts

@@ -1,104 +0,0 @@
-import { type List } from '../../types/list/module.f.ts';
-import type { BigFloat } from '../../types/bigfloat/module.f.ts';
-export type StringToken = {
-    readonly kind: 'string';
-    readonly value: string;
-};
-export type NumberToken = {
-    readonly kind: 'number';
-    readonly value: string;
-    readonly bf: BigFloat;
-};
-export type BigIntToken = {
-    readonly kind: 'bigint';
-    readonly value: bigint;
-};
-export type ErrorToken = {
-    readonly kind: 'error';
-    message: ErrorMessage;
-};
-export type WhitespaceToken = {
-    readonly kind: 'ws';
-};
-export type NewLineToken = {
-    readonly kind: 'nl';
-};
-type TrueToken = {
-    readonly kind: 'true';
-};
-type FalseToken = {
-    readonly kind: 'false';
-};
-type NullToken = {
-    readonly kind: 'null';
-};
-type UndefinedToken = {
-    readonly kind: 'undefined';
-};
-type KeywordToken = {
-    readonly kind: 'arguments' | 'await' | 'break' | 'case' | 'catch' | 'class' | 'const' | 'continue';
-} | {
-    readonly kind: 'debugger' | 'default' | 'delete' | 'do' | 'else' | 'enum' | 'eval' | 'export';
-} | {
-    readonly kind: 'extends' | 'finally' | 'for' | 'function' | 'if' | 'implements' | 'import' | 'in';
-} | {
-    readonly kind: 'instanceof' | 'interface' | 'let' | 'new' | 'package' | 'private' | 'protected' | 'public';
-} | {
-    readonly kind: 'return' | 'static' | 'super' | 'switch' | 'this' | 'throw' | 'try' | 'typeof';
-} | {
-    readonly kind: 'var' | 'void' | 'while' | 'with' | 'yield';
-};
-export type IdToken = {
-    readonly kind: 'id';
-    readonly value: string;
-};
-type OperatorToken = {
-    readonly kind: '{' | '}' | ':' | ',' | '[' | ']';
-} | {
-    readonly kind: '.' | '=';
-} | {
-    readonly kind: '(' | ')';
-} | {
-    readonly kind: '==' | '!=' | '===' | '!==' | '>' | '>=' | '<' | '<=';
-} | {
-    readonly kind: '+' | '-' | '*' | '/' | '%' | '++' | '--' | '**';
-} | {
-    readonly kind: '+=' | '-=' | '*=' | '/=' | '%=' | '**=';
-} | {
-    readonly kind: '&' | '|' | '^' | '~' | '<<' | '>>' | '>>>';
-} | {
-    readonly kind: '&=' | '|=' | '^=' | '<<=' | '>>=' | '>>>=';
-} | {
-    readonly kind: '&&' | '||' | '!' | '??';
-} | {
-    readonly kind: '&&=' | '||=' | '??=';
-} | {
-    readonly kind: '?' | '?.' | '=>';
-};
-export type CommentToken = {
-    readonly kind: '//' | '/*';
-    readonly value: string;
-};
-export type EofToken = {
-    readonly kind: 'eof';
-};
-export type JsToken = KeywordToken | TrueToken | FalseToken | NullToken | WhitespaceToken | NewLineToken | StringToken | NumberToken | ErrorToken | IdToken | BigIntToken | UndefinedToken | OperatorToken | CommentToken | EofToken;
-export type TokenMetadata = {
-    readonly path: string;
-    readonly line: number;
-    readonly column: number;
-};
-export type JsTokenWithMetadata = {
-    readonly token: JsToken;
-    readonly metadata: TokenMetadata;
-};
-type ErrorMessage = '" are missing' | 'unescaped character' | 'invalid hex value' | 'unexpected character' | 'invalid number' | 'invalid token' | '*\/ expected' | 'unterminated string literal' | 'unescaped control character in string' | 'eof';
-export declare const isKeywordToken: (token: JsToken) => boolean;
-export declare const tokenize: (input: List<number>) => (path: string) => List<JsTokenWithMetadata>;
-export declare const proof: {
-    getOperatorTokenInvalid: () => void;
-    throw: {
-        unionConflict: () => void;
-    };
-};
-export {};