functionalscript 0.43.0 → 0.44.0

package/fjs/bnf/module.f.js

@@ -1,174 +0,0 @@
-/**
- * Core BNF grammar primitives and helpers for describing parser rules.
- *
- * The module provides terminal-range encoding utilities, rule composition
- * types, and set/range helpers used by FunctionalScript grammar definitions.
- *
- * @module
- */
-import { codePointListToString, stringToCodePointList } from '../text/utf16/module.f.js';
-import { definedValues } from '../types/object/module.f.js';
-import { isArray2 } from '../types/array/module.f.js';
-import { map, toArray, repeat as listRepeat } from '../types/list/module.f.js';
-import { contains } from '../types/range/module.f.js';
-import { assert } from '../asserts/module.f.js';
-/**
- * Full 24-bit symbol range packed into a single {@link TerminalRange}.
- */
-export const fullRange = 0x000000_FFFFFF;
-/**
- * Unicode scalar value range packed into a single {@link TerminalRange}.
- */
-export const unicodeRange = 0x000000_10FFFF;
-/**
- * Maximal Unicode code point encoded as a string value.
- */
-export const unicodeMax = codePointListToString([0x10FFFF]);
-// Internals:
-const { fromEntries } = Object;
-const { fromCodePoint } = String;
-/**
- * Two 24 bit numbers can be fit into one JS number (53 bit).
- */
-const offset = 24;
-const mask = (1 << offset) - 1;
-const isValid = contains(0, mask);
-export const rangeEncode = (a, b) => {
-    assert(isValid(a) && isValid(b) && a <= b);
-    return Number((BigInt(a) << BigInt(offset)) | BigInt(b));
-};
-/**
- * Encodes a single symbol as a {@link TerminalRange}.
- */
-export const oneEncode = (a) => rangeEncode(a, a);
-/**
- * End-of-file marker: `mask`, the single largest value the 24-bit symbol
- * space can hold (the top of `fullRange`). Deliberately outside Unicode
- * (`unicodeRange` tops out at `0x10FFFF`) so it can never collide with a
- * real code point.
- */
-export const eof = oneEncode(mask);
-/**
- * Decodes a packed range into `[start, end]` symbols.
- */
-export const rangeDecode = (r) => [Number(BigInt(r) >> BigInt(offset)), r & mask];
-const mapOneEncode = map(oneEncode);
-export const toSequence = (s) => toArray(mapOneEncode(stringToCodePointList(s)));
-/**
- * Converts the whole string into one rule:
- * - a single {@link TerminalRange} when the string has one symbol,
- * - a sequence of {@link TerminalRange} values when the string has multiple symbols.
- */
-export const str = (s) => {
-    const x = toSequence(s);
-    return x.length === 1 ? x[0] : x;
-};
-const mapEntry = map((v) => [fromCodePoint(v), oneEncode(v)]);
-/**
- * Converts a string into a variant that maps each character to its symbol range.
- */
-export const set = (s) => fromEntries(toArray(mapEntry(stringToCodePointList(s))));
-/**
- * Encodes a two-symbol string into a terminal range.
- *
- * @throws If `ab` does not contain exactly two unicode code points.
- */
-export const range = (ab) => {
-    const a = toArray(stringToCodePointList(ab));
-    if (!isArray2(a)) {
-        throw `Invalid range ${ab}.`;
-    }
-    return rangeEncode(...a);
-};
-const rangeToEntry = (r) => ['0x' + r.toString(16), r];
-const toVariantRangeSet = (r) => fromEntries(r.map(rangeToEntry));
-const removeOne = (list, ab) => {
-    const [a, b] = rangeDecode(ab);
-    let result = [];
-    for (const ab0 of list) {
-        const [a0, b0] = rangeDecode(ab0);
-        if (a0 < a) {
-            // [a0
-            //     ]a
-            result = [...result, rangeEncode(a0, Math.min(b0, a - 1))];
-        }
-        if (b < b0) {
-            //    b0]
-            // b[
-            result = [...result, rangeEncode(Math.max(b + 1, a0), b0)];
-        }
-    }
-    return result;
-};
-export const remove = (range, v) => {
-    let result = [range];
-    for (const r of definedValues(v)) {
-        result = removeOne(result, r);
-    }
-    return toVariantRangeSet(result);
-};
-/**
- * Returns the complement set of the provided ranges over {@link fullRange}.
- */
-export const not = (v) => remove(fullRange, v);
-/**
- * Returns the complement set of a character set over {@link fullRange}.
- */
-export const notSet = (s) => not(set(s));
-/**
- * Shared empty sequence literal.
- */
-export const none = [];
-/**
- * Creates an option value from a required branch.
- */
-export const option = (some) => ({
-    some,
-    none,
-});
-/**
- * Repeat zero or more times.
- *
- * https://english.stackexchange.com/questions/506480/single-word-quantifiers-for-zero-or-more-like-cardinalities
- * - zero or more - any, 0Plus
- * - one or more - several, 1Plus
- *
- * Also see: https://arbs.nzcer.org.nz/types-numbers
- */
-export const repeat0Plus = (some) => {
-    const r = () => option([some, r]);
-    return r;
-};
-/**
- * Repeat one or more times.
- */
-export const repeat1Plus = (some) => [some, repeat0Plus(some)];
-/**
- * Repeats `some` one or more times separated by `separator`.
- */
-export const join1Plus = (some, separator) => [some, repeat0Plus([separator, some])];
-/**
- * Repeats `some` zero or more times separated by `separator`.
- */
-export const join0Plus = (some, separator) => option(join1Plus(some, separator));
-/**
- * A delimited, comma-separated list with whitespace between tokens:
- * `open ws (item ws (',' ws item ws)*)? close`.
- *
- * `ws` is the per-grammar whitespace rule and is curried so callers can
- * partially apply it once (`const cj = commaJoin0Plus(ws)`) before reusing
- * the same combinator at multiple bracket pairs. The two-character string
- * supplies the bracket pair via destructuring (e.g. `'[]'`, `'{}'`).
- */
-export const commaJoin0Plus = (ws) => ([open, close], item) => [open, ws, join0Plus([item, ws], [',', ws]), close];
-/**
- * Repeats a rule a fixed number of times.
- */
-export const repeat = (n) => (some) => toArray(listRepeat(some)(n));
-/**
- * Determines whether the rule is an empty rule.
- */
-export const isEmpty = (rule) => {
-    const d = typeof rule === 'function' ? rule() : rule;
-    return d === '' || (d instanceof Array && d.length === 0);
-};

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

@@ -1,12 +0,0 @@
-export declare const proof: {
-    test: () => void;
-    throw: {
-        rangeEncodeInvalid: (() => void)[];
-        rangeInvalid: (() => void)[];
-    };
-    str: (() => void)[];
-    set: () => void;
-    commaJoin0Plus: () => void;
-    isEmpty: (() => void)[];
-    repeat1Plus: (() => void)[];
-};

package/fjs/bnf/proof.f.js

@@ -1,69 +0,0 @@
-import { assert, assertEq } from '../asserts/module.f.js';
-import { classic, deterministic } from './testlib.f.js';
-import { rangeEncode, str, set, range, commaJoin0Plus, isEmpty, oneEncode, repeat1Plus, } from './module.f.js';
-export const proof = {
-    test: () => {
-        classic();
-        deterministic();
-    },
-    throw: {
-        rangeEncodeInvalid: [
-            () => { rangeEncode(-1, 0); },
-            () => { rangeEncode(0, -1); },
-            () => { rangeEncode(5, 3); },
-        ],
-        rangeInvalid: [
-            () => { range('a'); },
-            () => { range('abc'); },
-        ],
-    },
-    str: [
-        () => {
-            const result = str('a');
-            assertEq(typeof result, 'number', result);
-            assertEq(result, oneEncode(0x61));
-        },
-        () => {
-            const result = str('ab');
-            assert(Array.isArray(result), result);
-            assertEq(result.length, 2, result);
-        },
-    ],
-    set: () => {
-        const result = set('abc');
-        assert(!(typeof result !== 'object' || result === null), result);
-        assert('a' in result, result);
-        assert('b' in result, result);
-        assert('c' in result, result);
-    },
-    commaJoin0Plus: () => {
-        const ws = '';
-        const item = 'x';
-        const result = commaJoin0Plus(ws)('[]', item);
-        assert(Array.isArray(result), result);
-        assert(result[0] === '[', result);
-    },
-    isEmpty: [
-        () => { assert(isEmpty(''), 'empty string should be empty'); },
-        () => { assert(isEmpty([]), 'empty array should be empty'); },
-        () => { assert(!(isEmpty('a')), 'non-empty string should not be empty'); },
-        () => {
-            const f = () => '';
-            assert(isEmpty(f), 'function returning empty string should be empty');
-        },
-    ],
-    repeat1Plus: [
-        () => {
-            const result = repeat1Plus('x');
-            assert(result[0] === 'x');
-            assertEq(typeof result[1], 'function', 'expected repeat0Plus function');
-        },
-        () => {
-            const rule = 'ab';
-            const result = repeat1Plus(rule);
-            assertEq(result[0], rule);
-            const inner = result[1]();
-            assert(!(!('some' in inner) || !('none' in inner)), 'expected Option shape');
-        },
-    ],
-};

package/fjs/bnf/testlib.f.d.ts

@@ -1,3 +0,0 @@
-import { type Rule } from './module.f.ts';
-export declare const classic: () => Rule;
-export declare const deterministic: () => Rule;

package/fjs/bnf/testlib.f.js

@@ -1,138 +0,0 @@
-import { commaJoin0Plus, none, option, range, remove, repeat, repeat0Plus, set, unicodeMax } from './module.f.js';
-export const classic = () => {
-    // https://www.json.org/json-en.html
-    const json = () => [element];
-    const value = () => ({
-        object,
-        array,
-        string,
-        number,
-        true: 'true',
-        false: 'false',
-        null: 'null'
-    });
-    const object = () => ({
-        ws: ['{', ws, '}'],
-        members: ['{', members, '}'],
-    });
-    const members = () => ({
-        member,
-        members: [member, ',', members],
-    });
-    const member = () => [ws, string, ws, ':', element];
-    const array = () => ({
-        ws: ['[', ws, ']'],
-        elements: ['[', elements, ']'],
-    });
-    const elements = () => ({
-        element,
-        elements: [element, ',', elements],
-    });
-    const element = () => [ws, value, ws];
-    const string = () => ['"', characters, '"'];
-    const characters = () => ({
-        none,
-        characters: [character, characters],
-    });
-    const character = () => ({
-        0: 0x20_000021,
-        1: 0x23_00005B,
-        2: 0x5D_10FFFF,
-        escape: ['\\', escape],
-    });
-    const escape = () => ({
-        ...set('"\\/bfnrt'),
-        u: ['u', hex, hex, hex, hex],
-    });
-    const hex = () => ({
-        digit,
-        AF: range('AF'),
-        af: range('af'),
-    });
-    const number = () => [integer, fraction, exponent];
-    const integer = () => ({
-        digit,
-        onenine: [onenine, digits],
-        negDigit: ['-', digit],
-        negOnenine: ['-', onenine, digits],
-    });
-    const digits = () => ({
-        digit,
-        digits: [digit, digits],
-    });
-    const digit = () => ({
-        '0': '0',
-        onenine,
-    });
-    const onenine = range('19');
-    const fraction = () => ({
-        none,
-        digits: ['.', digits],
-    });
-    const exponent = () => ({
-        none,
-        E: ['E', sign, digits],
-        e: ['e', sign, digits],
-    });
-    const sign = {
-        none,
-        ...set('+-'),
-    };
-    const ws = () => ({
-        none,
-        ' ': [' ', ws],
-        '\n': ['\n', ws],
-        '\r': ['\r', ws],
-        '\t': ['\t', ws],
-    });
-    return json;
-};
-export const deterministic = () => {
-    const onenine = range('19');
-    const digit = range('09');
-    const string = [
-        '"',
-        repeat0Plus({
-            ...remove(range(` ${unicodeMax}`), set('"\\')),
-            escape: [
-                '\\',
-                {
-                    ...set('"\\/bfnrt'),
-                    u: [
-                        'u',
-                        ...repeat(4)({
-                            digit,
-                            AF: range('AF'),
-                            af: range('af'),
-                        })
-                    ],
-                }
-            ],
-        }),
-        '"'
-    ];
-    const digits0 = repeat0Plus(digit);
-    const digits = [digit, digits0];
-    const number = [
-        option('-'),
-        {
-            0: '0',
-            onenine: [onenine, digits0],
-        },
-        option(['.', digits]),
-        option([set('Ee'), option(set('+-')), digits])
-    ];
-    const ws = repeat0Plus(set(' \n\r\t'));
-    const cj = commaJoin0Plus(ws);
-    const value = () => ({
-        array: cj('[]', value),
-        object: cj('{}', [string, ws, ':', ws, value]),
-        string,
-        number,
-        true: 'true',
-        false: 'false',
-        null: 'null'
-    });
-    const json = [ws, value, ws];
-    return json;
-};

package/fjs/bnf/token_symbol/module.f.d.ts

@@ -1,38 +0,0 @@
-import { type Nullable } from '../../types/nullable/module.f.ts';
-/**
- * How many names one encoding holds: every symbol from {@link start} up to but
- * not including `eof` (`0xFFFFFF`, the top of the 24-bit symbol space).
- */
-export declare const capacity: number;
-/**
- * A bidirectional map between a fixed alphabet of token names and the symbol
- * range reserved for them.
- */
-export type Encoding<T extends string> = {
-    /**
-     * The input symbol standing for `name`.
-     *
-     * The result is a bare symbol, the form a tokenizer emits. Wrap it in
-     * `oneEncode` to use it as a terminal of a grammar rule — a symbol and a
-     * `TerminalRange` are both plain numbers, so passing one where the other
-     * belongs is not a type error.
-     */
-    readonly encode: (name: T) => number;
-    /**
-     * The name a symbol stands for, or `null` when the symbol belongs to no
-     * registered name — a code point, `eof`, or a symbol past the end of the
-     * alphabet.
-     */
-    readonly decode: (symbol: number) => Nullable<T>;
-};
-/**
- * Builds an encoding over the complete list of token names.
- *
- * A name takes the symbol at its index in `names`, so the list is append-only:
- * inserting or reordering names changes the symbols of everything after the
- * edit.
- *
- * @throws When `names` holds more than {@link capacity} entries, or when a name
- * repeats — a repeated name has no single symbol to decode back to.
- */
-export declare const encoding: <T extends string>(names: readonly T[]) => Encoding<T>;

package/fjs/bnf/token_symbol/module.f.js

@@ -1,48 +0,0 @@
-/**
- * Encoding of multi-character token names as single BNF input symbols.
- *
- * A parser built on top of a tokenizer consumes one input symbol per token, so
- * multi-character operators (`>>>=`) and keywords (`instanceof`) each need a
- * symbol of their own. Names are registered as one fixed alphabet and get a
- * symbol from their position in it, above the Unicode range and below `eof`.
- *
- * @module
- */
-import { assert } from '../../asserts/module.f.js';
-import { fromUndefined } from '../../types/nullable/module.f.js';
-import { eof, rangeDecode, unicodeRange } from '../module.f.js';
-const [, unicodeLast] = rangeDecode(unicodeRange);
-const [eofSymbol] = rangeDecode(eof);
-/**
- * The symbol of the first registered name: `0x110000`, one past the last
- * Unicode scalar value, so a token symbol can never be mistaken for a code
- * point of the layer below.
- */
-const start = unicodeLast + 1;
-/**
- * How many names one encoding holds: every symbol from {@link start} up to but
- * not including `eof` (`0xFFFFFF`, the top of the 24-bit symbol space).
- */
-export const capacity = eofSymbol - start;
-/**
- * Builds an encoding over the complete list of token names.
- *
- * A name takes the symbol at its index in `names`, so the list is append-only:
- * inserting or reordering names changes the symbols of everything after the
- * edit.
- *
- * @throws When `names` holds more than {@link capacity} entries, or when a name
- * repeats — a repeated name has no single symbol to decode back to.
- */
-export const encoding = (names) => {
-    assert(names.length <= capacity, ['too many token names', names.length]);
-    assert(new Set(names).size === names.length, ['duplicate token name', names]);
-    return {
-        encode: name => {
-            const index = names.indexOf(name);
-            assert(index !== -1, ['unregistered token name', name]);
-            return start + index;
-        },
-        decode: symbol => fromUndefined(names[symbol - start]),
-    };
-};

package/fjs/bnf/token_symbol/proof.f.js

@@ -1,37 +0,0 @@
-import { assertEq } from '../../asserts/module.f.js';
-import { capacity, encoding } from './module.f.js';
-const names = ['>>', '>>>=', 'instanceof'];
-export const proof = {
-    encode: () => {
-        const { encode } = encoding(names);
-        assertEq(encode('>>'), 0x110000);
-        assertEq(encode('instanceof'), 0x110002);
-    },
-    decode: [
-        () => {
-            const { decode } = encoding(names);
-            assertEq(decode(0x110000), '>>');
-            assertEq(decode(0x110002), 'instanceof');
-        },
-        () => {
-            const { decode } = encoding(names);
-            // past the end of the alphabet, a code point, and `eof`
-            assertEq(decode(0x110003), null);
-            assertEq(decode(0x10FFFF), null);
-            assertEq(decode(0xFFFFFF), null);
-        },
-    ],
-    roundTrip: () => {
-        const { encode, decode } = encoding(names);
-        for (const name of names) {
-            assertEq(decode(encode(name)), name);
-        }
-    },
-    throw: {
-        duplicateName: () => { encoding(['a', 'b', 'a']); },
-        unregisteredName: () => { encoding(['a']).encode('b'); },
-        // `capacity` names fit, so one more is the smallest list that doesn't.
-        // The array is sparse, so this costs a length, not the strings.
-        tooManyNames: () => { encoding(new Array(capacity + 1)); },
-    },
-};

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

@@ -1,6 +0,0 @@
-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/fjs/cas/cli/module.f.js

@@ -1,53 +0,0 @@
-/**
- * CAS CLI command handlers.
- *
- * @module
- */
-import { sha256 } from '../../crypto/sha2/module.f.js';
-import { cBase32ToVec, vecToCBase32 } from '../../basen/cbase32/module.f.js';
-import { forEachStep, pure, step } 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 step(casAddFile(c)(path), hashResult => hashResult[0] === 'error'
-                ? pure(1)
-                : step(log(vecToCBase32(hashResult[1])), () => 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 step(writeFromStream(path, x), ([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);
-            const x0 = forEachStep(c.list(), j => log(vecToCBase32(j)));
-            return step(x0, () => pure(0));
-        },
-    },
-];
-export const main = dispatch(commands);

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

@@ -1,17 +0,0 @@
-export declare const proof: {
-    mainAdd: () => void;
-    mainAddGetBig: () => void;
-    mainAddWrongArgs: () => void;
-    mainAddMissingFile: () => void;
-    mainGetFound: () => void;
-    mainGetNotFound: () => void;
-    mainGetWrongArgs: () => void;
-    mainGetInvalidHash: () => void;
-    mainList: () => void;
-    mainListEmptyStore: () => void;
-    mainNoCmd: () => void;
-    mainUnknownCmd: () => void;
-    throw: {
-        mainListCorruptStore: () => readonly [import("../../effects/node/virtual/module.f.ts").State, number];
-    };
-};