functionalscript 0.36.0 → 0.38.0

package/{fs → fjs/basen}/cbase32/proof.f.js

@@ -1,26 +1,19 @@
-import { empty, vec } from "../types/bit_vec/module.f.js";
+import { empty, vec } from "../../types/bit_vec/module.f.js";
 import { cBase32ToVec, cBase32ToVec5x, vec5xToCBase32, vecToCBase32 } from "./module.f.js";
+import { assertEq } from '../../asserts/module.f.js';
 const check5x = (s, v) => {
     const sr = vec5xToCBase32(v);
-    if (sr !== s) {
-        throw [sr, s];
-    }
+    assertEq(sr, s, [sr, s]);
     const vr = cBase32ToVec5x(s);
-    if (vr !== v) {
-        throw [vr, v];
-    }
+    assertEq(vr, v, [vr, v]);
     //
     check(`${s}g`, v);
 };
 const check = (s, v) => {
     const sr = vecToCBase32(v);
-    if (sr !== s) {
-        throw [sr, s];
-    }
+    assertEq(sr, s, [sr, s]);
     const vr = cBase32ToVec(s);
-    if (vr !== v) {
-        throw [vr, v];
-    }
+    assertEq(vr, v, [vr, v]);
 };
 export const proof = {
     roundtrip5x: () => {
@@ -50,40 +43,20 @@ export const proof = {
     unalignedBits: () => {
         const v = vec(1n)(1n);
         const cr = vec5xToCBase32(v);
-        if (cr !== "g") {
-            throw ['g', cr];
-        }
+        assertEq(cr, "g", ['g', cr]);
     },
     caseInsensitive: () => {
-        if (cBase32ToVec5x("A") !== cBase32ToVec5x("a")) {
-            throw 'case-insensitive expected';
-        }
-        if (cBase32ToVec5x("I") !== cBase32ToVec5x("1")) {
-            throw 'i maps to 1';
-        }
-        if (cBase32ToVec5x("l") !== cBase32ToVec5x("1")) {
-            throw 'l maps to 1';
-        }
-        if (cBase32ToVec5x("o") !== cBase32ToVec5x("0")) {
-            throw 'o maps to 0';
-        }
-        if (cBase32ToVec5x("u") !== null) {
-            throw 'should error on invalid character';
-        }
+        assertEq(cBase32ToVec5x("A"), cBase32ToVec5x("a"), 'case-insensitive expected');
+        assertEq(cBase32ToVec5x("I"), cBase32ToVec5x("1"), 'i maps to 1');
+        assertEq(cBase32ToVec5x("l"), cBase32ToVec5x("1"), 'l maps to 1');
+        assertEq(cBase32ToVec5x("o"), cBase32ToVec5x("0"), 'o maps to 0');
+        assertEq(cBase32ToVec5x("u"), null, 'should error on invalid character');
     },
     unterminated: () => {
         // No sentinel `1` bit → invalid; must return null, not loop forever.
-        if (cBase32ToVec("") !== null) {
-            throw 'empty must be null';
-        }
-        if (cBase32ToVec("0") !== null) {
-            throw 'single zero symbol must be null';
-        }
-        if (cBase32ToVec("00") !== null) {
-            throw 'all-zero symbols must be null';
-        }
-        if (cBase32ToVec("o") !== null) {
-            throw 'o (maps to 0) must be null';
-        }
+        assertEq(cBase32ToVec(""), null, 'empty must be null');
+        assertEq(cBase32ToVec("0"), null, 'single zero symbol must be null');
+        assertEq(cBase32ToVec("00"), null, 'all-zero symbols must be null');
+        assertEq(cBase32ToVec("o"), null, 'o (maps to 0) must be null');
     }
 };

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

@@ -0,0 +1,52 @@
+import { type Rule as FRule } from '../module.f.ts';
+import { type StringMap } from '../../types/object/module.f.ts';
+/**
+ * Encoded terminal range value used by BNF data rules.
+ *
+ * The same as the functional TerminalRange.
+ */
+export type TerminalRange = number;
+/**
+ * Ordered list of grammar rule names.
+ */
+export type Sequence = readonly string[];
+/** A variant of rule names. */
+export type Variant = StringMap<string, string>;
+/**
+ * Grammar rule definition.
+ *
+ * It can be one of:
+ * - a tagged variant map,
+ * - a sequence of referenced rule names,
+ * - an encoded terminal range.
+ */
+export type Rule = Variant | Sequence | TerminalRange;
+/** The full grammar */
+export type RuleSet = Readonly<Record<string, Rule>>;
+/**
+ * Whether a rule can match empty input: `undefined` if it never can, `true`
+ * if it can with no tag (a nullable sequence), or the tag of the nullable
+ * variant branch.
+ */
+export type EmptyTag = string | true | undefined;
+type EmptyTagMap = StringMap<string, EmptyTag>;
+/**
+ * Computes, for every rule in the set, whether it can match empty input, by
+ * the standard nullable-set fixpoint: a sequence is nullable iff all of its
+ * items are (AND semantics), a variant iff at least one branch is (its tag is
+ * that branch's). Rules may reference each other cyclically (e.g. a `repeat`
+ * rule referring to itself), so this starts every rule as non-nullable and
+ * relaxes every rule, one round at a time, until a full round changes
+ * nothing. A round only ever grows the nullable set or moves a variant's
+ * chosen tag to a later (still-nullable) branch, both bounded, so this always
+ * terminates — but a rule's tag can still change for rounds *after* its own
+ * nullable/non-nullable status has already settled, while a cyclic
+ * dependency's tag catches up, so a fixed round count isn't enough.
+ */
+export declare const emptyTagMap: (ruleSet: RuleSet) => EmptyTagMap;
+/**
+ * Converts a functional grammar rule into serializable BNF data and returns
+ * the generated rule set with the entry rule identifier.
+ */
+export declare const toData: (fr: FRule) => readonly [RuleSet, string];
+export {};

package/{fs → fjs}/bnf/data/module.f.js

@@ -5,15 +5,65 @@
  * This module is the pure, parser-agnostic substrate: it defines the
  * {@link RuleSet} data form (`Rule = Variant | Sequence | TerminalRange`) and
  * converts a functional grammar into it. The automaton builders that consume a
- * {@link RuleSet} live in their own sibling modules (`fs/bnf/ll1`,
- * `fs/bnf/descent`, …), so the IR stays free of any one parser's machinery.
+ * {@link RuleSet} live in their own sibling modules (`fjs/bnf/ll1`,
+ * `fjs/bnf/descent`, …), so the IR stays free of any one parser's machinery.
  *
  * @module
  */
-import { stringToCodePointList } from "../../text/utf16/module.f.js";
-import { map, toArray } from "../../types/list/module.f.js";
-import { oneEncode, } from "../module.f.js";
-import {} from "../../types/object/module.f.js";
+import { stringToCodePointList } from '../../text/utf16/module.f.js';
+import { map, toArray } from '../../types/list/module.f.js';
+import { oneEncode, } from '../module.f.js';
+import { definedEntries } from '../../types/object/module.f.js';
+const emptyTagOf = (map) => (rule) => {
+    if (typeof rule === 'number') {
+        return undefined;
+    }
+    else if (rule instanceof Array) {
+        return rule.every(item => map[item] !== undefined) ? true : undefined;
+    }
+    else {
+        let tag = undefined;
+        for (const [k, item] of definedEntries(rule)) {
+            if (map[item] !== undefined) {
+                tag = k;
+            }
+        }
+        return tag;
+    }
+};
+const emptyTagStep = (ruleSet) => (map) => {
+    let next = map;
+    let changed = false;
+    for (const name in ruleSet) {
+        const tag = emptyTagOf(map)(ruleSet[name]);
+        if (tag !== next[name]) {
+            changed = true;
+        }
+        next = { ...next, [name]: tag };
+    }
+    return [next, changed];
+};
+/**
+ * Computes, for every rule in the set, whether it can match empty input, by
+ * the standard nullable-set fixpoint: a sequence is nullable iff all of its
+ * items are (AND semantics), a variant iff at least one branch is (its tag is
+ * that branch's). Rules may reference each other cyclically (e.g. a `repeat`
+ * rule referring to itself), so this starts every rule as non-nullable and
+ * relaxes every rule, one round at a time, until a full round changes
+ * nothing. A round only ever grows the nullable set or moves a variant's
+ * chosen tag to a later (still-nullable) branch, both bounded, so this always
+ * terminates — but a rule's tag can still change for rounds *after* its own
+ * nullable/non-nullable status has already settled, while a cyclic
+ * dependency's tag catches up, so a fixed round count isn't enough.
+ */
+export const emptyTagMap = (ruleSet) => {
+    const step = emptyTagStep(ruleSet);
+    const relax = (map) => {
+        const [next, changed] = step(map);
+        return changed ? relax(next) : next;
+    };
+    return relax({});
+};
 const { entries } = Object;
 const find = (map) => (fr) => {
     for (const [k, v] of entries(map)) {

package/{fs → fjs}/bnf/data/proof.f.d.ts

@@ -3,5 +3,6 @@ export declare const proof: {
     rangeEncode: () => void;
     toData: (() => void)[];
     variantTest: () => void;
+    emptyTagMap: (() => void)[];
     example: () => void;
 };

package/{fs → fjs}/bnf/data/proof.f.js

@@ -1,23 +1,18 @@
-import { stringify } from "../../json/module.f.js";
-import { identity } from "../../types/function/module.f.js";
-import { sort } from "../../types/object/module.f.js";
-import { oneEncode, option, range, rangeDecode, repeat0Plus, set } from "../module.f.js";
-import { classic, deterministic } from "../testlib.f.js";
-import { toData } from "./module.f.js";
+import { stringify } from '../../media/json/module.f.js';
+import { identity } from '../../types/function/module.f.js';
+import { sort } from '../../types/object/module.f.js';
+import { oneEncode, option, range, rangeDecode, repeat0Plus, set } from '../module.f.js';
+import { classic, deterministic } from '../testlib.f.js';
+import { emptyTagMap, toData } from './module.f.js';
+import { assertEq } from '../../asserts/module.f.js';
 export const proof = {
     rangeDecode: () => {
         const decoded1 = stringify(sort)(rangeDecode(0x000079_000087));
-        if (decoded1 !== '[121,135]') {
-            throw decoded1;
-        }
+        assertEq(decoded1, '[121,135]');
         const decoded2 = stringify(sort)(rangeDecode(0x000080_000087));
-        if (decoded2 !== '[128,135]') {
-            throw decoded2;
-        }
+        assertEq(decoded2, '[128,135]');
         const decoded3 = stringify(sort)(rangeDecode(0x10FFFF_10FFFF));
-        if (decoded3 !== '[1114111,1114111]') {
-            throw decoded3;
-        }
+        assertEq(decoded3, '[1114111,1114111]');
     },
     rangeEncode: () => {
         const encoded1 = oneEncode(0x79);
@@ -70,26 +65,20 @@ export const proof = {
             const varintRule = { true: 'true', false: 'false' };
             const result = stringify(sort)(toData(varintRule));
             const expected = '[{"":{"false":"5","true":"0"},"0":["1","2","3","4"],"1":1946157172,"2":1912602738,"3":1962934389,"4":1694498917,"5":["6","7","8","9","4"],"6":1711276134,"7":1627390049,"8":1811939436,"9":1929379955},""]';
-            if (result !== expected) {
-                throw [result, expected];
-            }
+            assertEq(result, expected, [result, expected]);
         },
         () => {
             const lazyRule = () => 'true';
             const lazyRule0 = () => 'false';
             const result = stringify(sort)(toData([lazyRule, lazyRule0]));
             const expected = '[{"":["lazyRule","lazyRule0"],"0":1946157172,"1":1912602738,"2":1962934389,"3":1694498917,"4":1711276134,"5":1627390049,"6":1811939436,"7":1929379955,"lazyRule":["0","1","2","3"],"lazyRule0":["4","5","6","7","3"]},""]';
-            if (result !== expected) {
-                throw [result, expected];
-            }
+            assertEq(result, expected, [result, expected]);
         },
         () => {
             const emptyRule = '';
             const result = stringify(sort)(toData(emptyRule));
             const expected = '[{"":[]},""]';
-            if (result !== expected) {
-                throw [result, expected];
-            }
+            assertEq(result, expected, [result, expected]);
         },
         () => {
             const optionRule = option('a');
@@ -120,6 +109,52 @@ export const proof = {
             throw result;
         }
     },
+    emptyTagMap: [
+        () => {
+            const stringRule = 'true';
+            const result = JSON.stringify(emptyTagMap(toData(stringRule)[0]));
+            assertEq(result, '{}');
+        },
+        () => {
+            const emptyRule = '';
+            const result = JSON.stringify(emptyTagMap(toData(emptyRule)[0]));
+            assertEq(result, '{"":true}');
+        },
+        () => {
+            const emptyRule = '';
+            const varintRule = { true: 'true', e: emptyRule };
+            const result = JSON.stringify(emptyTagMap(toData(varintRule)[0]));
+            assertEq(result, '{"5":true,"":"e"}');
+        },
+        () => {
+            const repeatRule = repeat0Plus(option('a'));
+            const result = JSON.stringify(emptyTagMap(toData(repeatRule)[0]));
+            assertEq(result, '{"0":"none","3":true,"":true,"r":"none"}');
+        },
+        () => {
+            // Regression for the sequence case: a sequence is nullable iff
+            // *all* of its items are, not just the first one. The old
+            // descent-only implementation pinned the result to nullable as
+            // soon as it saw the leading empty item, and reported this
+            // 2-item sequence as nullable even though its second item is a
+            // mandatory terminal.
+            const data = toData(['', range('AA')]);
+            const emptyTags = emptyTagMap(data[0]);
+            assertEq(emptyTags[data[1]], undefined, emptyTags);
+        },
+        () => {
+            // Regression: a fixed round count (one round per rule) settles
+            // the nullable/non-nullable *set* — a standard result — but a
+            // variant's chosen *tag* can still change for rounds after that,
+            // while a cyclic dependency's own tag catches up. Here A is
+            // nullable via 'x' (A -> E, both settle in 2 rounds), but B (a
+            // 1-item sequence over A) only becomes nullable once A does, and
+            // once B is nullable, A's true winning branch is 'y' (A -> B) —
+            // reachable only by iterating to an actual fixpoint.
+            const rs = { A: { x: 'E', y: 'B' }, B: ['A'], E: [] };
+            assertEq(emptyTagMap(rs).A, 'y');
+        },
+    ],
     example: () => {
         const grammar = {
             space: 0x000020_000020,

package/{fs → fjs}/bnf/descent/module.f.d.ts

@@ -1,20 +1,16 @@
 /**
  * Recursive descent matcher backend over the BNF data {@link RuleSet}.
  *
- * Built from the serializable IR in `fs/bnf/data`, this is a sibling of the
- * LL(1) dispatch builder (`fs/bnf/ll1`). It walks the grammar by recursive
+ * Built from the serializable IR in `fjs/bnf/data`, this is a sibling of the
+ * LL(1) dispatch builder (`fjs/bnf/ll1`). It walks the grammar by recursive
  * descent and preserves per-code-point metadata, producing a metadata-aware
- * AST ({@link AstRuleMeta}). It also exposes {@link createEmptyTagMap}, which
- * records whether each rule can match the empty input.
+ * AST ({@link AstRuleMeta}). Nullability (which rule can match empty input) is
+ * computed once by {@link emptyTagMap} in `fjs/bnf/data`.
  *
  * @module
  */
 import { type CodePoint } from '../../text/utf16/module.f.ts';
-import { type StringMap } from '../../types/object/module.f.ts';
-import { type RuleSet } from '../data/module.f.ts';
 import { type Rule as FRule } from '../module.f.ts';
-type EmptyTagEntry = string | boolean;
-type EmptyTagMap = StringMap<string, EmptyTagEntry>;
 export type AstTag = string | true | undefined;
 /**
  * Recursive descent matcher for a single named rule.
@@ -43,14 +39,8 @@ export type AstRuleMeta<T> = {
     readonly tag: AstTag;
     readonly sequence: AstSequenceMeta<T>;
 };
-/**
- * Creates a map that describes whether each rule can consume empty input and,
- * for tagged variants, which tag represents the empty match.
- */
-export declare const createEmptyTagMap: (data: readonly [RuleSet, string]) => EmptyTagMap;
 /**
  * Creates a recursive descent parser that preserves metadata for each consumed
  * code point.
  */
 export declare const descentParser: <T>(fr: FRule) => DescentMatch<T>;
-export {};

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

@@ -0,0 +1,124 @@
+/**
+ * Recursive descent matcher backend over the BNF data {@link RuleSet}.
+ *
+ * Built from the serializable IR in `fjs/bnf/data`, this is a sibling of the
+ * LL(1) dispatch builder (`fjs/bnf/ll1`). It walks the grammar by recursive
+ * descent and preserves per-code-point metadata, producing a metadata-aware
+ * AST ({@link AstRuleMeta}). Nullability (which rule can match empty input) is
+ * computed once by {@link emptyTagMap} in `fjs/bnf/data`.
+ *
+ * @module
+ */
+import {} from '../../text/utf16/module.f.js';
+import { rangeDecode } from '../module.f.js';
+import { contains as rangeContains } from '../../types/range/module.f.js';
+import { definedEntries } from '../../types/object/module.f.js';
+import { emptyTagMap, toData } from '../data/module.f.js';
+import {} from '../module.f.js';
+/**
+ * Creates a recursive descent parser that preserves metadata for each consumed
+ * code point.
+ */
+export const descentParser = (fr) => {
+    const data = toData(fr);
+    const emptyTags = emptyTagMap(data[0]);
+    // The recursive-descent matcher as an explicit-stack machine: each iteration either
+    // starts the current task (pushing a frame for a sequence/variant and descending into
+    // its first child) or feeds the pending result into the innermost frame. Semantics are
+    // identical to the former recursive `f`, but the JS call stack stays O(1) regardless of
+    // grammar recursion depth — right-recursive rules (e.g. repeat0Plus chains) no longer
+    // overflow on long input (see the longInput proof group).
+    const f = (name, tag, cp, idx) => {
+        const mrSuccess = (tag, sequence, idx) => [{ tag, sequence }, true, idx];
+        const mrFail = (tag, sequence, idx) => [{ tag, sequence }, false, idx];
+        let stack = null;
+        let task = { name, tag, idx };
+        let result = mrFail(undefined, [], idx);
+        while (true) {
+            if (task !== null) {
+                const { name, tag, idx } = task;
+                task = null;
+                // The explicit annotation cuts a control-flow inference cycle (TS7022):
+                // `name`'s narrowed type feeds `rule`, whose type would otherwise feed the
+                // later `task` assignments that `name`'s narrowing depends on.
+                const rule = data[0][name];
+                if (typeof rule === 'number') {
+                    const emptyTag = emptyTags[name];
+                    if (idx >= cp.length) {
+                        result = emptyTag === undefined ? mrFail(emptyTag, [], idx) : mrSuccess(emptyTag, [], idx);
+                    }
+                    else {
+                        const cpi = cp[idx];
+                        const range = rangeDecode(rule);
+                        result = rangeContains(...range)(cpi[0]) ? mrSuccess(tag, [cpi], idx + 1) : mrFail(emptyTag, [], idx);
+                    }
+                }
+                else if (rule instanceof Array) {
+                    if (rule.length === 0) {
+                        result = mrSuccess(tag, [], idx);
+                    }
+                    else {
+                        stack = { top: { kind: 'seq', tag, items: rule, itemIndex: 0, startIdx: idx, seq: [] }, rest: stack };
+                        task = { name: rule[0], tag: undefined, idx };
+                    }
+                }
+                else {
+                    const entries = definedEntries(rule);
+                    const emptyTag = emptyTags[name];
+                    const emptyResult = mrFail(emptyTag, [], idx);
+                    if (entries.length === 0) {
+                        result = emptyResult;
+                    }
+                    else {
+                        stack = { top: { kind: 'variant', entries, entryIndex: 0, idx, emptyResult }, rest: stack };
+                        const [entryTag, entryName] = entries[0];
+                        task = { name: entryName, tag: entryTag, idx };
+                    }
+                }
+                continue;
+            }
+            if (stack === null) {
+                return result;
+            }
+            const frame = stack.top;
+            stack = stack.rest;
+            if (frame.kind === 'seq') {
+                const [astRule, success, nidx] = result;
+                if (success === false) {
+                    result = mrFail(frame.tag, [], frame.startIdx);
+                }
+                else {
+                    const seq = [...frame.seq, astRule];
+                    const itemIndex = frame.itemIndex + 1;
+                    if (itemIndex < frame.items.length) {
+                        stack = { top: { ...frame, itemIndex, seq }, rest: stack };
+                        task = { name: frame.items[itemIndex], tag: undefined, idx: nidx };
+                    }
+                    else {
+                        result = mrSuccess(frame.tag, seq, nidx);
+                    }
+                }
+            }
+            else {
+                // success that consumed input wins immediately: the frame stays popped and
+                // `result` propagates to the frame below, matching the recursive `return m`.
+                if (!(result[1] && frame.idx !== result[2])) {
+                    const emptyResult = result[1] ? result : frame.emptyResult;
+                    const entryIndex = frame.entryIndex + 1;
+                    if (entryIndex < frame.entries.length) {
+                        stack = { top: { ...frame, entryIndex, emptyResult }, rest: stack };
+                        const [entryTag, entryName] = frame.entries[entryIndex];
+                        task = { name: entryName, tag: entryTag, idx: frame.idx };
+                    }
+                    else {
+                        result = emptyResult;
+                    }
+                }
+            }
+        }
+    };
+    const match = (name, cp) => {
+        return f(name, undefined, cp, 0);
+    };
+    return match;
+};

package/{fs → fjs}/bnf/descent/proof.f.d.ts

@@ -1,5 +1,6 @@
 export declare const proof: {
     emptyTags: (() => void)[];
     descentParser: (() => void)[];
+    longInput: (() => void)[];
     descentParserWithMeta: (() => void)[];
 };