functionalscript 0.33.0 → 0.35.0

package/README.md

@@ -11,7 +11,7 @@ FunctionalScript is a safe, purely functional programming language and a strict
   as a subset of JavaScript.
 - [TypeScript](https://en.wikipedia.org/wiki/TypeScript), as a superset of JavaScript.
 
-[A working draft of the FunctionalScript specification](./issues/lang/README.md).
+[A working draft of the FunctionalScript specification](./todo/lang/README.md).
 
 Learn more about
 
@@ -28,22 +28,39 @@ Install FunctionalScript via npm:
 npm install -g functionalscript
 ```
 
-The FunctionalScript compiler command (`fjs compile`) currently supports:
+The `fjs` CLI provides several commands:
 
-* `import` statements
-* `const` declarations
+| Command          | Description                                               |
+|------------------|-----------------------------------------------------------|
+| `fjs test` / `t` | Run the FunctionalScript test suite                       |
+| `fjs compile` / `c` | Compile a `.f.ts` module to JavaScript                 |
+| `fjs run` / `r`  | Run a FunctionalScript module as a Node program           |
+| `fjs cas` / `s`  | Content-addressable storage (`add`, `get`, `list`)        |
+| `fjs mcp` / `m`  | Run an MCP server over stdio exposing the CAS as tools    |
+| `fjs ci` / `i`   | Generate the GitHub Actions CI workflow                   |
 
-It does **not** yet support functions or complex expressions.
+### Content-Addressable Storage (CAS)
 
-Example usage with `fjs`:
+FunctionalScript ships a built-in CAS for storing and retrieving blobs by their cryptographic hash:
 
 ```bash
-fjs compile example.f.js output.json
-# or
-fjs compile example.f.js output.f.js
+fjs cas add myfile.txt   # store a file, print its cBase32 hash
+fjs cas get <hash>       # restore a blob by hash
+fjs cas list             # list all stored hashes
 ```
 
-FunctionalScript code can be compiled directly into either JSON or JavaScript without imports.
+Blobs are stored under `~/.cas/` and addressed by their SHA-256 hash encoded in cBase32.
+
+### MCP Server
+
+The CAS is also exposed as an [MCP](https://modelcontextprotocol.io/) server so LLM agents can read and write blobs without a shell:
+
+```bash
+# register with Claude CLI
+claude mcp add cas -- npx functionalscript m
+```
+
+See [`fs/cas/mcp/README.md`](fs/cas/mcp/README.md) for details on the `cas_add`, `cas_get`, and `cas_list` tools.
 
 ## Vision
 
@@ -67,10 +84,6 @@ In FunctionalScript:
 - A module can depend only on another FunctionalScript module.
 - It also has no standard library. Only a safe subset of standard JavaScript API can be used without referencing other modules.
 
-## Our Next Step
-
-[Re-architecture of NaNVM](https://medium.com/@sergeyshandar/nanvm-re-architecture-8097f766ec1c?sk=d14ec1daf73ac5442f12ce20b2bc037a).
-
 ## Sponsors
 
 - [KirillOsenkov](https://github.com/KirillOsenkov),

package/fs/asserts/module.f.d.ts

@@ -1,4 +1,4 @@
 export declare const todo: () => never;
 export declare const assert: (v: boolean, msg?: unknown) => asserts v;
-export declare const assertEq: <T>(a: T, b: T) => void;
+export declare const assertEq: <T>(...x: readonly [T, T, unknown?]) => void;
 export type Assert<T extends true> = T;

package/fs/asserts/module.f.js

@@ -3,4 +3,7 @@ export const assert = (v, msg = 'assertion failed') => {
     if (!v)
         throw msg;
 };
-export const assertEq = (a, b) => assert(a === b, [a, b]);
+export const assertEq = (...x) => {
+    const [a, b] = x;
+    assert(a === b, x);
+};

package/fs/base64/proof.f.d.ts

@@ -8,4 +8,5 @@ export declare const proof: {
     invalidInput: () => void;
     validPadding: () => void;
     knownVectors: () => void;
+    decodeOverflow: () => void;
 };

package/fs/base64/proof.f.js

@@ -1,14 +1,9 @@
+import { assertEq } from "../asserts/module.f.js";
 import { empty, vec } from "../types/bit_vec/module.f.js";
 import { encode, decode } from "./module.f.js";
 const check = (s, v) => {
-    const sr = encode(v);
-    if (sr !== s) {
-        throw ['encode', sr, s];
-    }
-    const vr = decode(s);
-    if (vr !== v) {
-        throw ['decode', vr, v];
-    }
+    assertEq(encode(v), s);
+    assertEq(decode(s), v);
 };
 export const proof = {
     empty: () => {
@@ -46,62 +41,29 @@ export const proof = {
     },
     nonOctet: () => {
         // encode rejects bit vectors whose length is not a multiple of 8
-        if (encode(vec(1n)(0n)) !== null) {
-            throw '1-bit input should return null';
-        }
-        if (encode(vec(6n)(0n)) !== null) {
-            throw '6-bit input should return null';
-        }
-        if (encode(vec(12n)(0n)) !== null) {
-            throw '12-bit input should return null';
-        }
+        assertEq(encode(vec(1n)(0n)), null);
+        assertEq(encode(vec(6n)(0n)), null);
+        assertEq(encode(vec(12n)(0n)), null);
     },
     invalidInput: () => {
-        if (decode('!') !== null) {
-            throw 'invalid char should return null';
-        }
-        if (decode('A!AA') !== null) {
-            throw 'invalid char mid-string should return null';
-        }
-        if (decode('A===') !== null) {
-            throw 'three equals signs should return null';
-        }
-        if (decode('A') !== null) {
-            throw 'length 1 (not multiple of 4) should return null';
-        }
-        if (decode('AA') !== null) {
-            throw 'length 2 (no padding) should return null';
-        }
-        if (decode('AAA') !== null) {
-            throw 'length 3 (no padding) should return null';
-        }
-        if (decode('=AAA') !== null) {
-            throw 'padding not at end should return null';
-        }
+        assertEq(decode('!'), null);
+        assertEq(decode('A!AA'), null);
+        assertEq(decode('A==='), null);
+        assertEq(decode('A'), null);
+        assertEq(decode('AA'), null);
+        assertEq(decode('AAA'), null);
+        assertEq(decode('=AAA'), null);
         // Non-zero padding bits must be rejected (RFC 4648 §3.5)
-        if (decode('AB==') !== null) {
-            throw 'non-zero 4-pad-bit should return null';
-        }
-        if (decode('AAB=') !== null) {
-            throw 'non-zero 2-pad-bit should return null';
-        }
+        assertEq(decode('AB=='), null);
+        assertEq(decode('AAB='), null);
     },
     validPadding: () => {
         // "==" padding
-        const v2 = decode('AA==');
-        if (v2 !== vec(8n)(0n)) {
-            throw ['AA== should decode to 8-bit zero', v2];
-        }
+        assertEq(decode('AA=='), vec(8n)(0n));
         // "=" padding
-        const v1 = decode('AAA=');
-        if (v1 !== vec(16n)(0n)) {
-            throw ['AAA= should decode to 16-bit zero', v1];
-        }
+        assertEq(decode('AAA='), vec(16n)(0n));
         // No padding
-        const v0 = decode('AAAA');
-        if (v0 !== vec(24n)(0n)) {
-            throw ['AAAA should decode to 24-bit zero', v0];
-        }
+        assertEq(decode('AAAA'), vec(24n)(0n));
     },
     knownVectors: () => {
         // RFC 4648 §10 test vectors (byte-aligned, treating bytes as 8-bit MSB vectors)
@@ -114,4 +76,11 @@ export const proof = {
         // 0x66 0x6f 0x6f ('foo') → Zm9v
         check('Zm9v', vec(24n)(0x666f6fn));
     },
+    decodeOverflow: () => {
+        // 174_764 base64 chars decode to 1_048_584 bits, 8 over `maxLength`;
+        // `decode` should return `null` instead of throwing on (or hanging
+        // while building) an oversized `bigint`.
+        const oversized = 'A'.repeat(174_764);
+        assertEq(decode(oversized), null);
+    },
 };

package/fs/base_n/module.f.js

@@ -11,8 +11,10 @@
  *
  * @module
  */
-import { msb, length, vec, empty } from "../types/bit_vec/module.f.js";
-const { popFront, concat } = msb;
+import { msb, lsb, length, vec } from "../types/bit_vec/module.f.js";
+import {} from "../types/list/module.f.js";
+const { popFront } = msb;
+const { tryListToVec: reversedListToVec } = lsb;
 /**
  * Builds a {@link BaseN} codec for a fixed chunk width and alphabet.
  *
@@ -40,15 +42,19 @@ export const baseN = (bits, alphabet, normalize) => {
             return result;
         },
         stringToVec: s => {
-            let result = empty;
+            // Build a reversed chunk list, bailing out at the first invalid
+            // character so malformed input is rejected in O(prefix) time and
+            // `normalize` is never run past it. `listToVec` then concatenates in
+            // O(n log n).
+            let chunks = null;
             for (const c of s) {
                 const index = toIndex(c);
                 if (index < 0) {
                     return null;
                 }
-                result = concat(result)(vecN(BigInt(index)));
+                chunks = { first: vecN(BigInt(index)), tail: chunks };
             }
-            return result;
+            return reversedListToVec(chunks);
         },
     };
 };

package/fs/base_n/proof.f.d.ts

@@ -7,4 +7,5 @@ export declare const proof: {
     decodeInvalid: () => void;
     normalizeHit: () => void;
     normalizeMiss: () => void;
+    big: () => void;
 };

package/fs/base_n/proof.f.js

@@ -1,4 +1,5 @@
-import { empty, vec } from "../types/bit_vec/module.f.js";
+import { assertEq } from "../asserts/module.f.js";
+import { empty, maxLength, vec, length } from "../types/bit_vec/module.f.js";
 import { baseN } from "./module.f.js";
 const hex = baseN(4n, '0123456789abcdef');
 const cb32 = baseN(5n, '0123456789abcdefghjkmnpqrstvwxyz', c => {
@@ -18,6 +19,9 @@ const cb32 = baseN(5n, '0123456789abcdefghjkmnpqrstvwxyz', c => {
         }
     }
 });
+// Sample input for the `big` proof below: 262 144 `f` characters decode into a
+// 1 Mibit (`maxLength`) vector.
+const bigSampleHex = `f`.repeat(Number(maxLength >> 2n));
 export const proof = {
     encodeEmpty: () => {
         const s = hex.vecToString(empty);
@@ -83,4 +87,11 @@ export const proof = {
             throw 'unknown char should return null';
         }
     },
+    // Decodes a 1 Mibit hex string. With the O(n log n) `listToVec` builder this
+    // runs in well under a second (was ~13 s node / ~43 s bun under the old
+    // per-chunk `concat`).
+    big: () => {
+        const x = hex.stringToVec(bigSampleHex);
+        assertEq(length(x), maxLength);
+    }
 };

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

@@ -1,11 +1,3 @@
-/**
- * Provides grammar-to-data conversion and LL(1) dispatch/matching types and helpers
- * for FunctionalScript BNF rules.
- *
- * @module
- */
-import { type CodePoint } from '../../text/utf16/module.f.ts';
-import { type RangeMapArray } from '../../types/range_map/module.f.ts';
 import { type Rule as FRule } from '../module.f.ts';
 import { type StringMap } from '../../types/object/module.f.ts';
 /**
@@ -31,103 +23,8 @@ export type Variant = StringMap<string, string>;
 export type Rule = Variant | Sequence | TerminalRange;
 /** The full grammar */
 export type RuleSet = Readonly<Record<string, Rule>>;
-type EmptyTag = string | true | undefined;
-type EmptyTagEntry = string | boolean;
-type DispatchRule = {
-    readonly emptyTag: EmptyTag;
-    readonly rangeMap: Dispatch;
-};
-type Dispatch = RangeMapArray<DispatchResult>;
-type DispatchResult = DispatchRuleCollection | null;
-type DispatchRuleOrName = DispatchRule | string;
-type DispatchRuleCollection = {
-    readonly tag: string | undefined;
-    readonly rules: DispatchRuleOrName[];
-};
-type DispatchMap = StringMap<string, DispatchRule>;
-type EmptyTagMap = StringMap<string, EmptyTagEntry>;
-/**
- * Recursive descent matcher for a single named rule.
- */
-export type DescentMatchRule<T> = (name: string, tag: AstTag, s: readonly CodePointMeta<T>[], idx: number) => DescentMatchResult<T>;
-/**
- * Result tuple of a descent match operation: AST node, success flag, and next index.
- */
-export type DescentMatchResult<T> = readonly [AstRuleMeta<T>, boolean, number];
-/**
- * Entry-point recursive descent matcher.
- */
-export type DescentMatch<T> = (name: string, s: readonly CodePointMeta<T>[]) => DescentMatchResult<T>;
-/**
- * Code point value paired with metadata.
- */
-export type CodePointMeta<T> = readonly [CodePoint, T];
-/**
- * AST sequence for the metadata-aware parser.
- */
-export type AstSequenceMeta<T> = readonly (AstRuleMeta<T> | CodePointMeta<T>)[];
-/**
- * Metadata-aware AST node.
- */
-export type AstRuleMeta<T> = {
-    readonly tag: AstTag;
-    readonly sequence: AstSequenceMeta<T>;
-};
-/**
- * Represents a parsed Abstract Syntax Tree (AST) sequence.
- */
-export type AstSequence = readonly (AstRule | CodePoint)[];
-export type AstTag = string | true | undefined;
-/**
- * Represents a parsed AST rule, consisting of a rule name and its parsed sequence.
- */
-type AstRule = {
-    readonly tag: AstTag;
-    readonly sequence: AstSequence;
-};
-/**
- * Represents the remaining input after a match attempt, or `null` if no match is possible.
- */
-export type Remainder = readonly CodePoint[] | null;
-/**
- * Parsing result of {@link parser} and {@link parserRuleSet}.
- *
- * Represents the result of a match operation, including the parsed AST rule and the remainder of the input.
- */
-export type MatchResult = readonly [AstRule, boolean, Remainder];
-/**
- * LL(1) parser function for matching by rule name.
- */
-export type Match = (name: string, s: readonly CodePoint[]) => MatchResult;
-/**
- * Internal match function signature used by compiled dispatch rules.
- */
-export type MatchRule = (dr: DispatchRule, s: readonly CodePoint[]) => MatchResult;
 /**
  * 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];
-/**
- * Builds a dispatch map for a {@link RuleSet} to enable predictive parsing.
- */
-export declare const dispatchMap: (ruleSet: RuleSet) => DispatchMap;
-/**
- * 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>;
-/**
- * Creates an LL(1) parser from a functional grammar rule.
- */
-export declare const parser: (fr: FRule) => Match;
-/**
- * Creates an LL(1) parser from an already materialized {@link RuleSet}.
- */
-export declare const parserRuleSet: (ruleSet: RuleSet) => Match;
-export {};

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

@@ -1,17 +1,19 @@
 /**
- * Provides grammar-to-data conversion and LL(1) dispatch/matching types and helpers
- * for FunctionalScript BNF rules.
+ * The serializable BNF intermediate representation (IR) and the
+ * {@link toData} conversion from the functional grammar.
+ *
+ * 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.
  *
  * @module
  */
 import { stringToCodePointList } from "../../text/utf16/module.f.js";
-import { strictEqual } from "../../types/function/operator/module.f.js";
 import { map, 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 { contains as rangeContains } from "../../types/range/module.f.js";
-import { oneEncode, rangeDecode, } from "../module.f.js";
-import { definedEntries } from "../../types/object/module.f.js";
+import { oneEncode, } from "../module.f.js";
+import {} from "../../types/object/module.f.js";
 const { entries } = Object;
 const find = (map) => (fr) => {
     for (const [k, v] of entries(map)) {
@@ -89,241 +91,3 @@ export const toData = (fr) => {
     const [, ruleSet, id] = toDataAdd({})(fr);
     return [ruleSet, id];
 };
-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;
-};
-const emptyTagMapAdd = (ruleSet) => (map) => (name) => {
-    if (name in map) {
-        return [ruleSet, map, map[name]];
-    }
-    const rule = ruleSet[name];
-    if (typeof rule === 'number') {
-        return [ruleSet, { ...map, [name]: false }, false];
-    }
-    else if (rule instanceof Array) {
-        map = { ...map, [name]: true };
-        let emptyTag = rule.length == 0;
-        for (const item of rule) {
-            const [, newMap, itemEmptyTag] = emptyTagMapAdd(ruleSet)(map)(item);
-            map = newMap;
-            if (emptyTag === false) {
-                emptyTag = itemEmptyTag !== false;
-            }
-        }
-        return [ruleSet, { ...map, [name]: emptyTag }, emptyTag];
-    }
-    else {
-        map = { ...map, [name]: true };
-        const entries = definedEntries(rule);
-        let emptyTag = false;
-        for (const [tag, item] of entries) {
-            const [, newMap, itemEmptyTag] = emptyTagMapAdd(ruleSet)(map)(item);
-            map = newMap;
-            if (itemEmptyTag !== false) {
-                emptyTag = tag;
-            }
-        }
-        return [ruleSet, { ...map, [name]: emptyTag }, emptyTag];
-    }
-};
-/**
- * Creates a map that describes whether each rule can consume empty input and,
- * for tagged variants, which tag represents the empty match.
- */
-export const createEmptyTagMap = (data) => {
-    return emptyTagMapAdd(data[0])({})(data[1])[1];
-};
-/**
- * Creates a recursive descent parser that preserves metadata for each consumed
- * code point.
- */
-export const descentParser = (fr) => {
-    const data = toData(fr);
-    const emptyTagMap = createEmptyTagMap(data);
-    const getEmptyTag = (name) => {
-        const res = emptyTagMap[name];
-        return res === false ? undefined : res;
-    };
-    const f = (name, tag, cp, idx) => {
-        const mrSuccess = (tag, sequence, idx) => [{ tag, sequence }, true, idx];
-        const mrFail = (tag, sequence, idx) => [{ tag, sequence }, false, idx];
-        const rule = data[0][name];
-        if (typeof rule === 'number') {
-            const emptyTag = getEmptyTag(name);
-            if (idx >= cp.length) {
-                return emptyTag === undefined ? mrFail(emptyTag, [], idx) : mrSuccess(emptyTag, [], idx);
-            }
-            const cpi = cp[idx];
-            const range = rangeDecode(rule);
-            if (rangeContains(range)(cpi[0])) {
-                return mrSuccess(tag, [cpi], idx + 1);
-            }
-            return mrFail(emptyTag, [], idx);
-        }
-        else if (rule instanceof Array) {
-            let seq = [];
-            let tidx = idx;
-            for (const item of rule) {
-                const m = f(item, undefined, cp, tidx);
-                const [astRule, success, nidx] = m;
-                tidx = nidx;
-                if (success === false) {
-                    return mrFail(tag, [], idx);
-                }
-                seq = [...seq, astRule];
-            }
-            return mrSuccess(tag, seq, tidx);
-        }
-        else {
-            const entries = definedEntries(rule);
-            const emptyTag = getEmptyTag(name);
-            let emptyResult = mrFail(emptyTag, [], idx);
-            for (const [tag, item] of entries) {
-                const m = f(item, tag, cp, idx);
-                if (m[1]) {
-                    if (idx !== m[2])
-                        return m;
-                    emptyResult = m;
-                }
-            }
-            return emptyResult;
-        }
-    };
-    const match = (name, cp) => {
-        return f(name, undefined, cp, 0);
-    };
-    return match;
-};
-/**
- * Creates an LL(1) parser from a functional grammar rule.
- */
-export const parser = (fr) => {
-    const data = toData(fr);
-    return parserRuleSet(data[0]);
-};
-/**
- * Creates an LL(1) parser from an already materialized {@link RuleSet}.
- */
-export const parserRuleSet = (ruleSet) => {
-    const map = dispatchMap(ruleSet);
-    const f = (rule, cp) => {
-        const mrSuccess = (tag, sequence, r) => [{ tag, sequence }, true, r];
-        const mrFail = (tag, sequence, r) => [{ tag, sequence }, false, r];
-        const { emptyTag, rangeMap } = rule;
-        if (cp.length === 0) {
-            return mrSuccess(emptyTag, [], emptyTag === undefined ? null : cp);
-        }
-        const cp0 = cp[0];
-        const dr = dispatchOp.get(cp0)(rangeMap);
-        if (dr === null) {
-            if (emptyTag === undefined) {
-                return mrFail(emptyTag, [], cp);
-            }
-            return mrSuccess(emptyTag, [], cp);
-        }
-        let seq = [cp0];
-        let r = cp;
-        const [_, ...restCp] = cp;
-        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/data/proof.f.d.ts

@@ -2,16 +2,6 @@ export declare const proof: {
     rangeDecode: () => void;
     rangeEncode: () => void;
     toData: (() => void)[];
-    emptyTags: (() => void)[];
     variantTest: () => void;
-    dispatch: (() => void)[];
-    parser: (() => void)[];
-    descentParser: (() => void)[];
-    descentParserWithMeta: (() => void)[];
-    repeat: (() => void)[];
-    repeatParser: (() => void)[];
     example: () => void;
-    throw: {
-        ambiguousVariantDispatch: () => void;
-    };
 };