functionalscript 0.33.0 → 0.35.0

package/fs/bnf/ll1/module.f.js

@@ -0,0 +1,153 @@
+/**
+ * LL(1) dispatch/matcher backend over the BNF data {@link RuleSet}.
+ *
+ * Built from the serializable IR in `fs/bnf/data`, this is one member of the
+ * family of automaton builders that consume a {@link RuleSet}: it compiles the
+ * grammar into a predictive {@link dispatchMap} and matches input into an AST
+ * ({@link MatchResult}). It throws at build time (`can not merge …`) when the
+ * grammar is not LL(1) — a first/first conflict.
+ *
+ * @module
+ */
+import {} from "../../text/utf16/module.f.js";
+import { strictEqual } from "../../types/function/operator/module.f.js";
+import { toArray } from "../../types/list/module.f.js";
+import { rangeMap } from "../../types/range_map/module.f.js";
+import { contains, set } from "../../types/string_set/module.f.js";
+import { rangeDecode } from "../module.f.js";
+import { definedEntries } from "../../types/object/module.f.js";
+import { toData } from "../data/module.f.js";
+import {} from "../module.f.js";
+const dispatchOp = rangeMap({
+    union: a => b => {
+        if (a === null) {
+            return b;
+        }
+        if (b === null) {
+            return a;
+        }
+        throw ['can not merge [', a, '][', b, ']'];
+    },
+    equal: strictEqual,
+    def: null,
+});
+/**
+ * Builds a dispatch map for a {@link RuleSet} to enable predictive parsing.
+ */
+export const dispatchMap = (ruleSet) => {
+    const addRuleToDispatch = (dr, name) => {
+        if (dr === null)
+            return null;
+        return { tag: dr.tag, rules: [...dr.rules, name] };
+    };
+    const addTagToDispatch = (dr, tag) => {
+        if (dr === null)
+            return null;
+        return { tag, rules: dr.rules };
+    };
+    const dispatchRule = (dm, name, current) => {
+        if (name in dm) {
+            return dm;
+        }
+        const newCurrent = set(name)(current);
+        const rule = ruleSet[name];
+        if (typeof rule === 'number') {
+            const range = rangeDecode(rule);
+            const dispatch = dispatchOp.fromRange(range)({ tag: undefined, rules: [] });
+            const dr = { emptyTag: undefined, rangeMap: dispatch };
+            return { ...dm, [name]: dr };
+        }
+        else if (rule instanceof Array) {
+            let emptyTag = true;
+            let result = [];
+            for (const item of rule) {
+                if (contains(item)(newCurrent)) {
+                    result = result.map(x => [addRuleToDispatch(x[0], item), x[1]]);
+                }
+                else {
+                    dm = dispatchRule(dm, item, newCurrent);
+                    const dr = dm[item];
+                    if (emptyTag === true) {
+                        result = result.map(x => [addRuleToDispatch(x[0], item), x[1]]);
+                        result = toArray(dispatchOp.merge(result)(dr.rangeMap));
+                        emptyTag = dr.emptyTag !== undefined ? true : undefined;
+                    }
+                    else {
+                        result = result.map(x => [addRuleToDispatch(x[0], item), x[1]]);
+                    }
+                }
+            }
+            const dr = { emptyTag, rangeMap: result };
+            return { ...dm, [name]: dr };
+        }
+        else {
+            const entries = definedEntries(rule);
+            let result = [];
+            let emptyTag = undefined;
+            for (const [tag, item] of entries) {
+                dm = dispatchRule(dm, item, newCurrent);
+                const dr = dm[item];
+                if (dr.emptyTag !== undefined) {
+                    emptyTag = tag;
+                }
+                else {
+                    const d = dr.rangeMap.map(x => [addTagToDispatch(x[0], tag), x[1]]);
+                    result = toArray(dispatchOp.merge(result)(d));
+                }
+            }
+            const dr = { emptyTag, rangeMap: result };
+            return { ...dm, [name]: dr };
+        }
+    };
+    let result = {};
+    for (const k in ruleSet) {
+        result = dispatchRule(result, k, null);
+    }
+    return result;
+};
+/**
+ * Creates an LL(1) parser from a functional grammar rule.
+ */
+export const parser = (fr) => {
+    const data = toData(fr);
+    return parserRuleSet(data[0]);
+};
+const mrSuccess = (tag, sequence, r) => [{ tag, sequence }, true, r];
+const mrFail = (tag, sequence, r) => [{ tag, sequence }, false, r];
+/**
+ * Creates an LL(1) parser from an already materialized {@link RuleSet}.
+ */
+export const parserRuleSet = (ruleSet) => {
+    const map = dispatchMap(ruleSet);
+    const f = ({ emptyTag, rangeMap }, cp) => {
+        if (cp.length === 0) {
+            return mrSuccess(emptyTag, [], emptyTag === undefined ? null : cp);
+        }
+        const [cp0] = cp;
+        const dr = dispatchOp.get(cp0)(rangeMap);
+        if (dr === null) {
+            return emptyTag === undefined
+                ? mrFail(emptyTag, [], cp)
+                : mrSuccess(emptyTag, [], cp);
+        }
+        let seq = [cp0];
+        const [, ...restCp] = cp;
+        let r = restCp;
+        const { tag, rules } = dr;
+        for (const i of rules) {
+            const rule = typeof i === 'string' ? map[i] : i;
+            const res = f(rule, r);
+            const [astRule, success, newR] = res;
+            if (success === false) {
+                return res;
+            }
+            seq = [...seq, astRule];
+            if (newR === null) {
+                return mrSuccess(tag, seq, null);
+            }
+            r = newR;
+        }
+        return mrSuccess(tag, seq, r);
+    };
+    return (name, cp) => f(map[name], cp);
+};

package/fs/bnf/ll1/proof.f.d.ts

@@ -0,0 +1,9 @@
+export declare const proof: {
+    dispatch: (() => void)[];
+    parser: (() => void)[];
+    repeat: (() => void)[];
+    repeatParser: (() => void)[];
+    throw: {
+        ambiguousVariantDispatch: () => void;
+    };
+};

package/fs/bnf/ll1/proof.f.js

@@ -0,0 +1,358 @@
+import { stringToCodePointList } from "../../text/utf16/module.f.js";
+import { toArray } from "../../types/list/module.f.js";
+import { commaJoin0Plus, option, range, repeat0Plus, set } from "../module.f.js";
+import { deterministic } from "../testlib.f.js";
+import { toData } from "../data/module.f.js";
+import { dispatchMap, parser, parserRuleSet } from "./module.f.js";
+export const proof = {
+    dispatch: [
+        () => {
+            const terminalRangeRule = range('AF');
+            const data = toData(terminalRangeRule);
+            const dm = dispatchMap(data[0]);
+            const result = JSON.stringify(dm);
+            if (result !== '{"":{"rangeMap":[[null,64],[{"rules":[]},70]]}}') {
+                throw result;
+            }
+        },
+        () => {
+            const stringRule = 'AB';
+            const data = toData(stringRule);
+            const dm = dispatchMap(data[0]);
+            const result = JSON.stringify(dm);
+            if (result !== '{"0":{"rangeMap":[[null,64],[{"rules":[]},65]]},"1":{"rangeMap":[[null,65],[{"rules":[]},66]]},"":{"rangeMap":[[null,64],[{"rules":["1"]},65]]}}') {
+                throw result;
+            }
+        },
+        () => {
+            const a = range('AA');
+            const b = range('BB');
+            const ab = [a, b];
+            const data = toData(ab);
+            const dm = dispatchMap(data[0]);
+            const result = JSON.stringify(dm);
+            if (result !== '{"0":{"rangeMap":[[null,64],[{"rules":[]},65]]},"1":{"rangeMap":[[null,65],[{"rules":[]},66]]},"":{"rangeMap":[[null,64],[{"rules":["1"]},65]]}}') {
+                throw result;
+            }
+        },
+        () => {
+            const emptyRule = '';
+            const data = toData(emptyRule);
+            const dm = dispatchMap(data[0]);
+            const result = JSON.stringify(dm);
+            if (result !== '{"":{"emptyTag":true,"rangeMap":[]}}') {
+                throw result;
+            }
+        },
+        () => {
+            const variantRule = { 'a': range('AA'), 'b': range('BB') };
+            const data = toData(variantRule);
+            const dm = dispatchMap(data[0]);
+            const result = JSON.stringify(dm);
+            if (result !== '{"0":{"rangeMap":[[null,64],[{"rules":[]},65]]},"1":{"rangeMap":[[null,65],[{"rules":[]},66]]},"":{"rangeMap":[[null,64],[{"tag":"a","rules":[]},65],[{"tag":"b","rules":[]},66]]}}') {
+                throw result;
+            }
+        },
+        () => {
+            const emptyRule = '';
+            const variantRule = { 'e': emptyRule, 'a': range('AA') };
+            const data = toData(variantRule);
+            const dm = dispatchMap(data[0]);
+            const result = JSON.stringify(dm);
+            if (result !== '{"0":{"emptyTag":true,"rangeMap":[]},"1":{"rangeMap":[[null,64],[{"rules":[]},65]]},"":{"emptyTag":"e","rangeMap":[[null,64],[{"tag":"a","rules":[]},65]]}}') {
+                throw result;
+            }
+        },
+        () => {
+            const emptyRule = '';
+            const minursRule = range('--');
+            const optionalMinusRule = { 'none': emptyRule, 'minus': minursRule };
+            const digitRule = range('09');
+            const numberRule = [optionalMinusRule, digitRule];
+            const data = toData(numberRule);
+            const dm = dispatchMap(data[0]);
+            const result = JSON.stringify(dm);
+            if (result !== '{"0":{"emptyTag":"none","rangeMap":[[null,44],[{"tag":"minus","rules":[]},45]]},"1":{"emptyTag":true,"rangeMap":[]},"2":{"rangeMap":[[null,44],[{"rules":[]},45]]},"3":{"rangeMap":[[null,47],[{"rules":[]},57]]},"":{"rangeMap":[[null,44],[{"tag":"minus","rules":["3"]},45],[null,47],[{"rules":[]},57]]}}') {
+                throw result;
+            }
+        },
+        () => {
+            const emptyRule = '';
+            const spaceRule = range('  ');
+            const optionalSpaceRule = { 'none': emptyRule, 'space': spaceRule };
+            const minusRule = range('--');
+            const optionalMinusRule = { 'none': emptyRule, 'minus': minusRule };
+            const digitRule = range('09');
+            const numberRule = [optionalSpaceRule, optionalMinusRule, digitRule];
+            const data = toData(numberRule);
+            const dm = dispatchMap(data[0]);
+            const result = JSON.stringify(dm);
+            if (result !== '{"0":{"emptyTag":"none","rangeMap":[[null,31],[{"tag":"space","rules":[]},32]]},"1":{"emptyTag":true,"rangeMap":[]},"2":{"rangeMap":[[null,31],[{"rules":[]},32]]},"3":{"emptyTag":"none","rangeMap":[[null,44],[{"tag":"minus","rules":[]},45]]},"4":{"rangeMap":[[null,44],[{"rules":[]},45]]},"5":{"rangeMap":[[null,47],[{"rules":[]},57]]},"":{"rangeMap":[[null,31],[{"tag":"space","rules":["3","5"]},32],[null,44],[{"tag":"minus","rules":["5"]},45],[null,47],[{"rules":[]},57]]}}') {
+                throw result;
+            }
+        }
+    ],
+    parser: [
+        () => {
+            const emptyRule = '';
+            const m = parser(emptyRule);
+            const mr = m("", []);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"tag":true,"sequence":[]},true,[]]') {
+                throw result;
+            }
+        },
+        () => {
+            const emptyRule = '';
+            const m = parser(emptyRule);
+            const mr = m("", [65, 70]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"tag":true,"sequence":[]},true,[65,70]]') {
+                throw result;
+            }
+        },
+        () => {
+            const terminalRangeRule = range('AF');
+            const m = parser(terminalRangeRule);
+            const mr = m("", [65]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[65]},true,[]]') {
+                throw result;
+            }
+        },
+        () => {
+            const terminalRangeRule = 0x000079_000087;
+            const m = parser(terminalRangeRule);
+            const mr = m("", [64]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[]},false,[64]]') {
+                throw result;
+            }
+        },
+        () => {
+            const terminalRangeRule = 0x000080_000087; //broken range
+            const m = parser(terminalRangeRule);
+            const mr = m("", [64]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[]},false,[64]]') {
+                throw result;
+            }
+        },
+        () => {
+            const variantRule = { 'a': range('AA'), 'b': range('BB') };
+            const m = parser(variantRule);
+            const mr = m("", [65]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"tag":"a","sequence":[65]},true,[]]') {
+                throw result;
+            }
+        },
+        () => {
+            const variantRule = { 'a': range('AA'), 'b': range('BB') };
+            const m = parser(variantRule);
+            const mr = m("", [64]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[]},false,[64]]') {
+                throw result;
+            }
+        },
+        () => {
+            const emptyRule = '';
+            const variantRule = { 'e': emptyRule, 'a': range('AA') };
+            const m = parser(variantRule);
+            const mr = m("", []);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"tag":"e","sequence":[]},true,[]]') {
+                throw result;
+            }
+        },
+        () => {
+            const emptyRule = '';
+            const variantRule = { 'e': emptyRule, 'a': range('AA') };
+            const m = parser(variantRule);
+            const mr = m("", [64]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"tag":"e","sequence":[]},true,[64]]') {
+                throw result;
+            }
+        },
+        () => {
+            const stringRule = 'AB';
+            const m = parser(stringRule);
+            const mr = m("", [65, 66]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[65,{"sequence":[66]}]},true,[]]') {
+                throw result;
+            }
+        },
+        () => {
+            const stringRule = 'AB';
+            const m = parser(stringRule);
+            const mr = m("", [65, 67]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[]},false,[67]]') {
+                throw result;
+            }
+        },
+        () => {
+            const emptyRule = '';
+            const minursRule = range('--');
+            const optionalMinusRule = { 'none': emptyRule, 'minus': minursRule };
+            const digitRule = range('09');
+            const numberRule = [optionalMinusRule, digitRule];
+            const m = parser(numberRule);
+            const mr = m("", [50]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[50]},true,[]]') {
+                throw result;
+            }
+        },
+        () => {
+            const emptyRule = '';
+            const minusRule = range('--');
+            const optionalMinusRule = { 'none': emptyRule, 'minus': minusRule };
+            const digitRule = range('09');
+            const numberRule = [optionalMinusRule, digitRule];
+            const m = parser(numberRule);
+            const mr = m("", [45, 50]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"tag":"minus","sequence":[45,{"sequence":[50]}]},true,[]]') {
+                throw result;
+            }
+        },
+        () => {
+            const emptyRule = '';
+            const minusRule = range('--');
+            const optionalMinusRule = { 'none': emptyRule, 'minus': minusRule };
+            const digitRule = range('09');
+            const numberRule = [optionalMinusRule, digitRule];
+            const m = parser(numberRule);
+            const mr = m("", []);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[]},true,null]') {
+                throw result;
+            } //if remainder is null it means failed
+        },
+        () => {
+            const m = parser(option('a'));
+            const isSuccess = (mr) => mr[1] && mr[2]?.length === 0;
+            const expect = (s, success) => {
+                const mr = m('', toArray(stringToCodePointList(s)));
+                if (isSuccess(mr) !== success) {
+                    throw mr;
+                }
+            };
+            expect('a', true);
+            expect('', true);
+            expect('aa', false);
+            expect('b', false);
+        },
+        () => {
+            const ws = repeat0Plus(set(' \n\r\t'));
+            const cj = commaJoin0Plus(ws);
+            const value = () => ({
+                object: cj('{}', 'a'),
+                array: cj('[]', 'a')
+            });
+            value.name; //bun will fail if no usage of name found
+            const m = parser(value);
+            const isSuccess = (mr) => mr[1] && mr[2]?.length === 0;
+            const expect = (s, success) => {
+                const mr = m('value', toArray(stringToCodePointList(s)));
+                if (isSuccess(mr) !== success) {
+                    throw mr;
+                }
+            };
+            expect('', false);
+            expect('[]', true);
+            expect('[a]', true);
+            expect('[a, a]', true);
+            expect('{a}', true);
+        },
+        () => {
+            const m = parser(deterministic());
+            const isSuccess = (mr) => mr[1] && mr[2]?.length === 0;
+            const expect = (s, success) => {
+                const mr = m('', toArray(stringToCodePointList(s)));
+                if (isSuccess(mr) !== success) {
+                    throw mr;
+                }
+            };
+            expect('   true   ', true);
+            expect('   tr2ue   ', false);
+            expect('   true"   ', false);
+            expect('   "Hello"   ', true);
+            expect('   "Hello   ', false);
+            expect('   "Hello\\n\\r\\""   ', true);
+            expect('   -56.7e+5  ', true);
+            expect('   h-56.7e+5   ', false);
+            expect('   -56.7e+5   3', false);
+            expect('   [] ', true);
+            expect('   {} ', true);
+            expect('   [[[]]] ', true);
+            expect('   [1] ', true);
+            expect('   [ 12, false, "a"]  ', true);
+            expect('   [ 12, false2, "a"]  ', false);
+            expect('   { "q": [ 12, false, [{"b" : "c"}], "a"] }  ', true);
+            expect('   { "q": [ 12, false, [{}], "a"] }  ', true);
+            expect('   { "q": [ 12, false, [}], "a"] }  ', false);
+            expect('   [{ "q": [ 12, false, [{}], "a"] }]  ', true);
+            expect('   [{ "q": [ 12, false, [}], "a"] }]  ', false);
+        }
+    ],
+    repeat: [
+        () => {
+            const repeatData = [{ "": ["ws", "repa"], "ws": [], "repa": ["a", ""], "a": 1090519105 }, ""];
+            const dm = dispatchMap(repeatData[0]);
+            const result = JSON.stringify(dm);
+            if (result !== '{"ws":{"emptyTag":true,"rangeMap":[]},"a":{"rangeMap":[[null,64],[{"rules":[]},65]]},"repa":{"rangeMap":[[null,64],[{"rules":[""]},65]]},"":{"rangeMap":[[null,64],[{"rules":[""]},65]]}}') {
+                throw result;
+            }
+        }
+    ],
+    repeatParser: [
+        () => {
+            const repeatData = [{ "": ["ws", "repa"], "ws": [], "repa": ["a", ""], "a": 1090519105 }, ""];
+            const m = parserRuleSet(repeatData[0]);
+            const mr = m("", []);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[]},true,null]') {
+                throw result;
+            }
+        },
+        () => {
+            const repeatData = [{ "": ["ws", "repa"], "ws": [], "repa": ["a", ""], "a": 1090519105 }, ""];
+            const m = parserRuleSet(repeatData[0]);
+            const mr = m("", [65]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[65,{"sequence":[]}]},true,null]') {
+                throw result;
+            }
+        },
+        () => {
+            const repeatData = [{ "": ["ws", "repa"], "ws": [], "repa": ["a", ""], "a": 1090519105 }, ""];
+            const m = parserRuleSet(repeatData[0]);
+            const mr = m("", [65, 65, 65]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[65,{"sequence":[65,{"sequence":[65,{"sequence":[]}]}]}]},true,null]') {
+                throw result;
+            }
+        },
+        () => {
+            const repeatData = [{ "": ["ws", "repa"], "ws": [], "repa": ["a", ""], "a": 1090519105 }, ""];
+            const m = parserRuleSet(repeatData[0]);
+            const mr = m("", [66]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[]},false,[66]]') {
+                throw result;
+            }
+        }
+    ],
+    throw: {
+        ambiguousVariantDispatch: () => {
+            // Two alternatives covering the same code point — dispatch merge throws.
+            const conflictRule = { 'a': range('AA'), 'b': range('AA') };
+            dispatchMap(toData(conflictRule)[0]);
+        }
+    }
+};

package/fs/cas/cli/module.f.d.ts

@@ -0,0 +1,6 @@
+import { type All, type Read, type Write, type WriteFile } from '../../effects/node/module.f.ts';
+import { type Commands } from '../../cli/module.f.ts';
+import { type MemOp } from '../../effects/memory/module.f.ts';
+import { type FileCasOperation } from '../module.f.ts';
+export declare const commands: Commands<FileCasOperation | WriteFile | Write | All | MemOp | Read>;
+export declare const main: (options: import("../../effects/node/module.f.ts").NodeProgramOptions) => import("../../effects/module.f.ts").Effect<All | Read | Write | WriteFile | FileCasOperation | MemOp, number>;

package/fs/cas/cli/module.f.js

@@ -0,0 +1,56 @@
+/**
+ * CAS CLI command handlers.
+ *
+ * @module
+ */
+import { sha256 } from "../../crypto/sha2/module.f.js";
+import { cBase32ToVec, vecToCBase32 } from "../../cbase32/module.f.js";
+import { forEachStep, pure } from "../../effects/module.f.js";
+import { errorExit, log, writeFromStream } from "../../effects/node/module.f.js";
+import { dispatch } from "../../cli/module.f.js";
+import {} from "../../effects/memory/module.f.js";
+import { casAddFile, fileCas } from "../module.f.js";
+export const commands = [
+    {
+        names: ['add'],
+        description: 'Store file content and print its hash',
+        handler: ({ home, args: [path, ...rest] }) => {
+            if (path === undefined || rest.length !== 0) {
+                return errorExit("'cas add' expects one parameter");
+            }
+            const c = fileCas(sha256)(home);
+            return casAddFile(c)(path)
+                .step(hashResult => hashResult[0] === 'error'
+                ? pure(1)
+                : log(vecToCBase32(hashResult[1])).step(() => pure(0)));
+        },
+    },
+    {
+        names: ['get'],
+        description: 'Restore content by hash into a file',
+        handler: ({ home, args: [hashCBase32, path, ...rest] }) => {
+            if (hashCBase32 === undefined || path === undefined || rest.length !== 0) {
+                return errorExit("'cas get' expects two parameters");
+            }
+            const hash = cBase32ToVec(hashCBase32);
+            if (hash === null) {
+                return errorExit(`invalid hash format: ${hashCBase32}`);
+            }
+            const c = fileCas(sha256)(home);
+            const x = c.read(hash);
+            return writeFromStream(path, x)
+                .step(([r, v]) => r === 'error' ? errorExit(`e: ` + String(v)) : pure(0));
+        },
+    },
+    {
+        names: ['list'],
+        description: 'List all stored content hashes',
+        handler: ({ home }) => {
+            const c = fileCas(sha256)(home);
+            return c.list()
+                .step(forEachStep(j => log(vecToCBase32(j))))
+                .step(() => pure(0));
+        },
+    },
+];
+export const main = dispatch(commands);

package/fs/cas/cli/proof.f.d.ts

@@ -0,0 +1,14 @@
+export declare const proof: {
+    mainAdd: () => void;
+    mainAddGetBig: () => void;
+    mainAddWrongArgs: () => void;
+    mainGetFound: () => void;
+    mainGetNotFound: () => void;
+    mainGetWrongArgs: () => void;
+    mainGetInvalidHash: () => void;
+    mainList: () => void;
+    mainListEmptyStore: () => void;
+    mainListCorruptStore: () => void;
+    mainNoCmd: () => void;
+    mainUnknownCmd: () => void;
+};