functionalscript 0.43.0 → 0.44.0

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

@@ -1,375 +0,0 @@
-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';
-import { assertEq } from '../../asserts/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)));
-                assertEq(isSuccess(mr), success, 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)));
-                assertEq(isSuccess(mr), success, 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)));
-                assertEq(isSuccess(mr), success, 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]);
-        }
-    },
-    // Regression: `emptyTagMap` must stay correct for cyclic rule references.
-    // A naive single-pass, memoized derivation that marks a rule nullable as
-    // a placeholder *before* recursing into its own children (to break the
-    // cycle) over-approximates nullability here, and made `dispatchMap`
-    // falsely report a first/first conflict for this grammar even though it
-    // has none — `value` only ever nests inside brackets or is the literal
-    // `a`, and `ws` is genuinely optional on both sides of it.
-    cyclicNullability: () => {
-        const ws = option(' ');
-        const value = () => ({ array: ['[', value, ']'], leaf: 'a' });
-        const m = parser([ws, value, ws]); // must not throw 'can not merge'
-        const expect = (s, success) => {
-            const mr = m('', toArray(stringToCodePointList(s)));
-            assertEq(mr[1] && mr[2]?.length === 0, success, mr);
-        };
-        expect('a', true);
-        expect(' a ', true);
-        expect('[a]', true);
-        expect('[[a]]', true);
-        expect(' [[a]] ', true);
-        expect('b', false);
-    },
-};

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

@@ -1,165 +0,0 @@
-import { type StringMap } from '../types/object/module.f.ts';
-import { type Array2 } from '../types/array/module.f.ts';
-/**
- * A range of symbols. Two 24-bit numbers are stored in one JS number (48 bits).
- *
- * For example: 0xBBBBBB_EEEEEE
- * - 0xBBBBBB is the first symbol (24 bits)
- * - 0xEEEEEE is the last symbol (24 bits)
- *
- * 24 bits per half, not 26 (the most `float64`'s 52-bit safe-integer mantissa
- * could fit two of): 24 is divisible by 4, so each half is exactly 6 hex
- * digits, and the packed pair reads as a plain `0xYYYYYY_ZZZZZZ` literal with
- * no partial hex digit at either boundary. 26 bits would still be safe to
- * store but wouldn't align to hex nibbles, making the packed literal harder
- * to read and split by eye.
- *
- * Not 16 bits (32 bits total) either, even though a 32-bit pair would fit in
- * a JS bitwise operator's native 32-bit range (JS `|`/`&`/`<<`/etc. operate on
- * 32-bit ints, whereas the 48-bit pair used here, and even a 52-bit one,
- * would need converting to `BigInt` for bitwise operations). 16 bits per
- * symbol can't hold a full Unicode code point: the max scalar value `0x10FFFF`
- * needs 21 bits, well past `0xFFFF`. So the bitwise-op convenience of 16 loses
- * to the requirement of representing every Unicode code point in one half.
- */
-export type TerminalRange = number;
-/**
- * Full 24-bit symbol range packed into a single {@link TerminalRange}.
- */
-export declare const fullRange: TerminalRange;
-/**
- * Unicode scalar value range packed into a single {@link TerminalRange}.
- */
-export declare const unicodeRange: TerminalRange;
-/**
- * Maximal Unicode code point encoded as a string value.
- */
-export declare const unicodeMax: string;
-/** A sequence of rules. */
-export type Sequence = readonly Rule[];
-/** A variant */
-export type Variant = {
-    readonly [k in string]?: Rule;
-};
-/**
- * Data-only grammar rule.
- */
-export type DataRule = Variant | Sequence | TerminalRange | string;
-/**
- * Lazily evaluated grammar rule.
- */
-export type LazyRule = () => DataRule;
-/**
- * Grammar rule, either immediate data or lazy rule factory.
- */
-export type Rule = DataRule | LazyRule;
-export declare const rangeEncode: (a: number, b: number) => TerminalRange;
-/**
- * Encodes a single symbol as a {@link TerminalRange}.
- */
-export declare const oneEncode: (a: number) => TerminalRange;
-/**
- * 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 declare const eof: TerminalRange;
-/**
- * Decodes a packed range into `[start, end]` symbols.
- */
-export declare const rangeDecode: (r: number) => Array2<number>;
-export declare const toSequence: (s: string) => readonly TerminalRange[];
-/**
- * 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 declare const str: (s: string) => readonly TerminalRange[] | TerminalRange;
-/**
- * Converts a string into a variant that maps each character to its symbol range.
- */
-export declare const set: (s: string) => RangeVariant;
-/**
- * Encodes a two-symbol string into a terminal range.
- *
- * @throws If `ab` does not contain exactly two unicode code points.
- */
-export declare const range: (ab: string) => TerminalRange;
-/**
- * A set of terminal ranges compatible with the `Variant` rule.
- */
-export type RangeVariant = StringMap<TerminalRange>;
-export declare const remove: (range: TerminalRange, v: RangeVariant) => RangeVariant;
-/**
- * Returns the complement set of the provided ranges over {@link fullRange}.
- */
-export declare const not: (v: RangeVariant) => RangeVariant;
-/**
- * Returns the complement set of a character set over {@link fullRange}.
- */
-export declare const notSet: (s: string) => RangeVariant;
-/**
- * Empty sequence type for optional grammar branches.
- */
-export type None = readonly [];
-/**
- * Shared empty sequence literal.
- */
-export declare const none: None;
-/**
- * Optional grammar branch.
- */
-export type Option<S> = {
-    some: S;
-    none: None;
-};
-/**
- * Creates an option value from a required branch.
- */
-export declare const option: <S extends Rule>(some: S) => Option<S>;
-export type Repeat0Plus<T> = () => Option<readonly [T, Repeat0Plus<T>]>;
-/**
- * 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 declare const repeat0Plus: <T extends Rule>(some: T) => Repeat0Plus<T>;
-export type Repeat1Plus<T> = readonly [T, Repeat0Plus<T>];
-/**
- * Repeat one or more times.
- */
-export declare const repeat1Plus: <T extends Rule>(some: T) => Repeat1Plus<T>;
-export type Join1Plus<T, S> = readonly [T, Repeat0Plus<readonly [S, T]>];
-/**
- * Repeats `some` one or more times separated by `separator`.
- */
-export declare const join1Plus: <T extends Rule, S extends Rule>(some: T, separator: S) => Join1Plus<T, S>;
-export type Join0Plus<T, S> = Option<readonly [T, Repeat0Plus<readonly [S, T]>]>;
-/**
- * Repeats `some` zero or more times separated by `separator`.
- */
-export declare const join0Plus: <T extends Rule, S extends Rule>(some: T, separator: S) => Rule;
-/**
- * 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 declare const commaJoin0Plus: (ws: Rule) => ([open, close]: string, item: Rule) => Sequence;
-export type Repeat<T> = readonly T[];
-/**
- * Repeats a rule a fixed number of times.
- */
-export declare const repeat: (n: number) => <T extends Rule>(some: T) => Repeat<T>;
-/**
- * Determines whether the rule is an empty rule.
- */
-export declare const isEmpty: (rule: Rule) => boolean;