functionalscript 0.43.0 → 0.44.0

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

@@ -1,52 +0,0 @@
-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>;
-/**
- * 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<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/fjs/bnf/data/module.f.js

@@ -1,143 +0,0 @@
-/**
- * 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 (`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 { 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)) {
-        if (v === fr) {
-            return k;
-        }
-    }
-    return undefined;
-};
-const newName = (map, name) => {
-    let i = 0;
-    let result = name;
-    while (result in map) {
-        result = name + i;
-        ++i;
-    }
-    return result;
-};
-const sequence = (list) => map => {
-    let result = [];
-    let set = {};
-    for (const fr of list) {
-        const [map1, set1, id] = toDataAdd(map)(fr);
-        map = map1;
-        set = { ...set, ...set1 };
-        result = [...result, id];
-    }
-    return [map, set, result];
-};
-const variant = (fr) => map => {
-    let set = {};
-    let rule = {};
-    for (const [k, v] of entries(fr)) {
-        const [m1, s, id] = toDataAdd(map)(v);
-        map = m1;
-        set = { ...set, ...s };
-        rule = { ...rule, [k]: id };
-    }
-    return [map, set, rule];
-};
-const mapOneEncode = map(oneEncode);
-const data = (dr) => {
-    switch (typeof dr) {
-        case 'string': {
-            return sequence(toArray(mapOneEncode(stringToCodePointList(dr))));
-        }
-        case 'number':
-            return m => [m, {}, dr];
-        default:
-            if (dr instanceof Array) {
-                return sequence(dr);
-            }
-            return variant(dr);
-    }
-};
-const toDataAdd = (map) => (fr) => {
-    {
-        const id = find(map)(fr);
-        if (id !== undefined) {
-            return [map, {}, id];
-        }
-    }
-    const [dr, tmpId] = typeof fr === 'function' ? [fr(), fr.name] : [fr, ''];
-    const newRule = data(dr);
-    const id = newName(map, tmpId);
-    const map1 = { ...map, [id]: fr };
-    const [map2, set, rule] = newRule(map1);
-    return [map2, { ...set, [id]: rule }, id];
-};
-/**
- * Converts a functional grammar rule into serializable BNF data and returns
- * the generated rule set with the entry rule identifier.
- */
-export const toData = (fr) => {
-    const [, ruleSet, id] = toDataAdd({})(fr);
-    return [ruleSet, id];
-};

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

@@ -1,8 +0,0 @@
-export declare const proof: {
-    rangeDecode: () => void;
-    rangeEncode: () => void;
-    toData: (() => void)[];
-    variantTest: () => void;
-    emptyTagMap: (() => void)[];
-    example: () => void;
-};

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

@@ -1,169 +0,0 @@
-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));
-        assertEq(decoded1, '[121,135]');
-        const decoded2 = stringify(sort)(rangeDecode(0x000080_000087));
-        assertEq(decoded2, '[128,135]');
-        const decoded3 = stringify(sort)(rangeDecode(0x10FFFF_10FFFF));
-        assertEq(decoded3, '[1114111,1114111]');
-    },
-    rangeEncode: () => {
-        const encoded1 = oneEncode(0x79);
-        if (encoded1 !== 0x000079_000079) {
-            throw encoded1;
-        }
-        const encoded2 = oneEncode(0x80);
-        if (encoded2 !== 0x000080_000080) {
-            throw encoded2;
-        }
-        const encoded3 = oneEncode(0x10FFFF);
-        if (encoded3 !== 0x10FFFF_10FFFF) {
-            throw encoded3;
-        }
-    },
-    toData: [
-        () => {
-            const c = toData(classic());
-            const d = toData(deterministic());
-        },
-        () => {
-            const stringRule = 'true';
-            const result = stringify(sort)(toData(stringRule));
-            if (result !== '[{"":["0","1","2","3"],"0":1946157172,"1":1912602738,"2":1962934389,"3":1694498917},""]') {
-                throw result;
-            }
-        },
-        () => {
-            const terminalRangeRule = range('AF');
-            const result = stringify(sort)(toData(terminalRangeRule));
-            if (result !== '[{"":1090519110},""]') {
-                throw result;
-            } //1090519110 = 65 * 2^24 + 70
-        },
-        () => {
-            const sequenceRangeRule = [range('AF'), range('af')];
-            const result = stringify(sort)(toData(sequenceRangeRule));
-            if (result !== '[{"":["0","1"],"0":1090519110,"1":1627390054},""]') {
-                throw result;
-            }
-        },
-        () => {
-            const lazyRule = () => 'true';
-            const result = stringify(sort)(toData(lazyRule));
-            if (result !== '[{"":1946157172,"0":1912602738,"1":1962934389,"2":1694498917,"lazyRule":["","0","1","2"]},"lazyRule"]') {
-                throw result;
-            }
-        },
-        () => {
-            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},""]';
-            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"]},""]';
-            assertEq(result, expected, [result, expected]);
-        },
-        () => {
-            const emptyRule = '';
-            const result = stringify(sort)(toData(emptyRule));
-            const expected = '[{"":[]},""]';
-            assertEq(result, expected, [result, expected]);
-        },
-        () => {
-            const optionRule = option('a');
-            const result = stringify(identity)(toData(optionRule));
-            if (result !== '[{"0":["1"],"1":1627390049,"2":[],"":{"some":"0","none":"2"}},""]') {
-                throw result;
-            }
-        },
-        () => {
-            const repeatRule = repeat0Plus(option('a'));
-            const result = stringify(identity)(toData(repeatRule));
-            if (result !== '[{"0":{"some":"1","none":"3"},"1":["2"],"2":1627390049,"3":[],"":["0","r"],"r":{"some":"","none":"3"}},"r"]') {
-                throw result;
-            }
-        },
-        () => {
-            const repeatRule = repeat0Plus(set(' \n\r\t'));
-            const result = stringify(identity)(toData(repeatRule));
-            if (result !== '[{"0":{" ":"1","\\n":"2","\\r":"3","\\t":"4"},"1":536870944,"2":167772170,"3":218103821,"4":150994953,"5":[],"":["0","r"],"r":{"some":"","none":"5"}},"r"]') {
-                throw result;
-            }
-        }
-    ],
-    variantTest: () => {
-        const varintRule = { a: 'a', b: 'b' };
-        const result = stringify(sort)(toData(varintRule));
-        if (result !== '[{"":{"a":"0","b":"2"},"0":["1"],"1":1627390049,"2":["3"],"3":1644167266},""]') {
-            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,
-            digit: 0x000030_000039,
-            sequence: ['space', 'digit'],
-            spaceOrDigit: {
-                'whiteSpace': 'space',
-                'digit': 'digit',
-            }
-        };
-    },
-};

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

@@ -1,87 +0,0 @@
-/**
- * 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`.
- *
- * A failed result also carries a {@link DescentFailure}: the furthest position a
- * terminal was rejected at, which — unlike the result's own index — never
- * rewinds and is what diagnostics should be built from.
- *
- * @module
- */
-import { type CodePoint } from '../../text/utf16/module.f.ts';
-import { type TerminalRange } from '../module.f.ts';
-import { type Rule as FRule } from '../module.f.ts';
-export type AstTag = string | true | undefined;
-/**
- * Recursive descent matcher for a single named rule.
- */
-export type DescentMatchRule<T> = (name: string, tag: AstTag, s: readonly CodePointMeta<T>[], idx: number) => DescentMatchResult<T>;
-/**
- * Where a match ran out of road, for diagnostics.
- *
- * `idx` is the furthest position any terminal was tried at and rejected, and
- * `expected` holds the terminals that would have allowed progress there, in the
- * order the grammar tried them and without repeats.
- *
- * Unlike a failed result's own index, this never rewinds: a failing sequence
- * item rewinds the result to the sequence's start, while the furthest failure is
- * a high-water mark over the whole match — including branches the grammar
- * backtracked out of. That is what makes "expected X or Y at N" possible.
- *
- * `idx` is `0` with an empty `expected` when the match failed without ever
- * rejecting a terminal, as an empty variant does.
- */
-export type DescentFailure = {
-    readonly idx: number;
-    readonly expected: readonly TerminalRange[];
-};
-/**
- * Result of a descent match operation.
- *
- * `failure` is present exactly when `success` is `false`: a successful match has
- * nothing to diagnose, and its `idx` already says where matching stopped. Note
- * the consequence for a match that succeeds *without consuming all input* —
- * `idx` still locates the position it stopped at, but the terminals that would
- * have let it continue are not reported.
- *
- * On failure `idx` has rewound to the start of the enclosing sequence and
- * locates nothing; read `failure.idx` instead.
- *
- * The same type describes a match in progress, where `failure` is likewise
- * absent until the match ends.
- */
-export type DescentMatchResult<T> = {
-    readonly ast: AstRuleMeta<T>;
-    readonly success: boolean;
-    readonly idx: number;
-    readonly failure?: DescentFailure;
-};
-/**
- * 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>;
-};
-/**
- * Creates a recursive descent parser that preserves metadata for each consumed
- * code point.
- */
-export declare const descentParser: <T>(fr: FRule) => DescentMatch<T>;

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

@@ -1,149 +0,0 @@
-/**
- * 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`.
- *
- * A failed result also carries a {@link DescentFailure}: the furthest position a
- * terminal was rejected at, which — unlike the result's own index — never
- * rewinds and is what diagnostics should be built from.
- *
- * @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';
-/**
- * Folds one rejected terminal into the furthest-failure record: further along
- * replaces, the same position accumulates (ignoring repeats), earlier is
- * discarded.
- */
-const recordFailure = (failure, idx, terminal) => {
-    if (idx > failure.idx) {
-        return { idx, expected: [terminal] };
-    }
-    if (idx < failure.idx || failure.expected.includes(terminal)) {
-        return failure;
-    }
-    return { idx, expected: [...failure.expected, terminal] };
-};
-/**
- * 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) => ({ ast: { tag, sequence }, success: true, idx });
-        const mrFail = (tag, sequence, idx) => ({ ast: { tag, sequence }, success: false, idx });
-        let stack = null;
-        let task = { name, tag, idx };
-        let result = mrFail(undefined, [], idx);
-        // High-water mark across the whole match, so it survives the rewinds a
-        // failing sequence item does to `result`.
-        let furthest = { idx: 0, expected: [] };
-        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') {
-                    // No nullable case: `emptyTagOf` in `bnf/data` returns `undefined`
-                    // for every terminal, so `emptyTags[name]` here is always
-                    // `undefined` and a terminal either consumes one symbol or fails.
-                    if (idx < cp.length && rangeContains(...rangeDecode(rule))(cp[idx][0])) {
-                        result = mrSuccess(tag, [cp[idx]], idx + 1);
-                    }
-                    else {
-                        // The only place a terminal is rejected, so the only place
-                        // the furthest failure can advance.
-                        furthest = recordFailure(furthest, idx, rule);
-                        result = mrFail(undefined, [], 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) {
-                // A success has nothing to diagnose; only a failure carries it.
-                return result.success ? result : { ...result, failure: furthest };
-            }
-            const frame = stack.top;
-            stack = stack.rest;
-            if (frame.kind === 'seq') {
-                const { ast: astRule, success, idx: 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.success && frame.idx !== result.idx)) {
-                    const emptyResult = result.success ? 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/fjs/bnf/descent/proof.f.d.ts

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