functionalscript 0.43.1 → 0.45.0

package/fjs/bnf/descent/proof.f.mjs

@@ -0,0 +1,427 @@
+/**
+ * @module
+ *
+ * @import { CodePoint } from '../../text/utf16/types.ts'
+ * @import { DescentMatch, CodePointMeta, DescentMatchResult } from './types.ts'
+ */
+
+import { stringToCodePointList } from '../../text/utf16/module.f.mjs'
+import { map, toArray } from '../../types/list/module.f.mjs'
+import { commaJoin0Plus, eof, option, range, repeat0Plus, set } from '../module.f.mjs'
+import { emptyTagMap, toData } from '../data/module.f.mjs'
+import { descentParser } from './module.f.mjs'
+import { assertEq, assertNotNullish } from '../../asserts/module.f.mjs'
+import { deterministic } from '../testlib.f.mjs'
+
+/** @type {(cp: CodePoint) => CodePointMeta<unknown>} */
+const mapCodePoint = cp => [cp, undefined]
+
+/**
+ * The code point of a one-character string, for expectations that would
+ * otherwise spell it as a bare number. Goes through the module's own
+ * conversion, the same one that builds the parser's input.
+ *
+ * @type {(s: string) => CodePoint}
+ */
+const cp1 = s => toArray(stringToCodePointList(s))[0]
+
+/** @type {(m: DescentMatch<unknown>, name: string, cp: readonly CodePoint[]) => DescentMatchResult<unknown>} */
+const descentParserCpOnly = (m, name, cp) => {
+    const cpm = toArray(map(mapCodePoint)(cp))
+    return m(name, cpm)
+}
+
+export const proof = {
+    emptyTags: [
+        () => {
+            const stringRule = 'true'
+            const data = toData(stringRule)
+            const emptyTags = emptyTagMap(data[0])
+            const result = JSON.stringify(emptyTags)
+            if (result !== '{}') { throw result }
+        },
+        () => {
+            const terminalRangeRule = range('AF')
+            const data = toData(terminalRangeRule)
+            const emptyTags = emptyTagMap(data[0])
+            const result = JSON.stringify(emptyTags)
+            if (result !== '{}') { throw result }
+        },
+        () => {
+            const varintRule = { true: 'true', false: 'false'}
+            const data = toData(varintRule)
+            const emptyTags = emptyTagMap(data[0])
+            const result = JSON.stringify(emptyTags)
+            if (result !== '{}') { throw result }
+        },
+        () => {
+            const emptyRule = ''
+            const data = toData(emptyRule)
+            const emptyTags = emptyTagMap(data[0])
+            const result = JSON.stringify(emptyTags)
+            if (result !== '{"":true}') { throw result }
+        },
+        () => {
+            const emptyRule = ''
+            const varintRule = { true: 'true', e: emptyRule}
+            const data = toData(varintRule)
+            const emptyTags = emptyTagMap(data[0])
+            const result = JSON.stringify(emptyTags)
+            if (result !== '{"5":true,"":"e"}') { throw result }
+        },
+        () => {
+            const repeatRule = repeat0Plus(option('a'))
+            const data = toData(repeatRule)
+            const emptyTags = emptyTagMap(data[0])
+            const result = JSON.stringify(emptyTags)
+            if (result !== '{"0":"none","3":true,"":true,"r":"none"}') { throw result }
+        },
+        () => {
+            const repeatRule = repeat0Plus(set(' \n\r\t'))
+            const data = toData(repeatRule)
+            const emptyTags = emptyTagMap(data[0])
+            const result = JSON.stringify(emptyTags)
+            if (result !== '{"5":true,"r":"none"}') { throw result }
+        }
+    ],
+    descentParser: [
+        () => {
+            const emptyRule = ''
+            const m = descentParser(emptyRule)
+            const mr = m("", [])
+            const result = JSON.stringify(mr)
+            if (result !== '{"ast":{"sequence":[]},"success":true,"idx":0}') { throw result }
+        },
+        () => {
+            const emptyRule = ''
+            const m = descentParser(emptyRule)
+            const mr = descentParserCpOnly(m, "", toArray(stringToCodePointList('AF')))
+            const result = JSON.stringify(mr)
+            if (result !== '{"ast":{"sequence":[]},"success":true,"idx":0}') { throw result }
+        },
+        () => {
+            // Literal code point on purpose. Elsewhere both sides of the
+            // assertion come from `stringToCodePointList` — the input is built
+            // with it and the expectation interpolates `cp1`, which calls it
+            // too — so a change to the conversion would move both sides
+            // together and the test would still pass. Pinning `A` to 65 here
+            // covers the conversion itself.
+            const terminalRangeRule = range('AF')
+            const m = descentParser(terminalRangeRule)
+            const mr = descentParserCpOnly(m, "", toArray(stringToCodePointList('A')))
+            const result = JSON.stringify(mr)
+            if (result !== '{"ast":{"sequence":[[65,null]]},"success":true,"idx":1}') { throw result }
+        },
+        () => {
+            const terminalRangeRule = range('AF')
+            const m = descentParser(terminalRangeRule)
+            const mr =descentParserCpOnly(m, "", toArray(stringToCodePointList('@')))
+            const result = JSON.stringify(mr)
+            if (result !== `{"ast":{"sequence":[]},"success":false,"idx":0,"failure":{"idx":0,"expected":[${range('AF')}]}}`) { throw result }
+        },
+        () => {
+            const variantRule = { 'a': range('AA'), 'b': range('BB')}
+            const m = descentParser(variantRule)
+            const mr = descentParserCpOnly(m, "", toArray(stringToCodePointList('A')))
+            const result = JSON.stringify(mr)
+            if (result !== `{"ast":{"tag":"a","sequence":[[${cp1('A')},null]]},"success":true,"idx":1}`) { throw result }
+        },
+        () => {
+            const variantRule = { 'a': range('AA'), 'b': range('BB')}
+            const m = descentParser(variantRule)
+            const mr = descentParserCpOnly(m, "", toArray(stringToCodePointList('@')))
+            const result = JSON.stringify(mr)
+            // Both branches were rejected at 0, so both terminals are expected there.
+            if (result !== `{"ast":{"sequence":[]},"success":false,"idx":0,"failure":{"idx":0,"expected":[${range('AA')},${range('BB')}]}}`) { throw result }
+        },
+        () => {
+            const emptyRule = ''
+            const variantRule = { 'e': emptyRule, 'a': range('AA')}
+             const m = descentParser(variantRule)
+            const mr = m("", [])
+            const result = JSON.stringify(mr)
+            if (result !== '{"ast":{"tag":"e","sequence":[]},"success":true,"idx":0}') { throw result }
+        },
+        () => {
+            const emptyRule = ''
+            const variantRule = { 'e': emptyRule, 'a': range('AA')}
+            const m = descentParser(variantRule)
+            const mr = descentParserCpOnly(m, "", toArray(stringToCodePointList('@')))
+            const result = JSON.stringify(mr)
+            if (result !== '{"ast":{"tag":"e","sequence":[]},"success":true,"idx":0}') { throw result }
+        },
+        () => {
+            const emptyVariantRule = {}
+            const m = descentParser(emptyVariantRule)
+            const mr = m("", [])
+            const result = JSON.stringify(mr)
+            // A variant with no branches fails without ever trying a terminal,
+            // so there is nothing to expect.
+            if (result !== '{"ast":{"sequence":[]},"success":false,"idx":0,"failure":{"idx":0,"expected":[]}}') { throw result }
+        },
+        () => {
+            const stringRule = 'AB'
+            const m = descentParser(stringRule)
+            const mr = descentParserCpOnly(m, "", toArray(stringToCodePointList('AB')))
+            const result = JSON.stringify(mr)
+            if (result !== `{"ast":{"sequence":[{"sequence":[[${cp1('A')},null]]},{"sequence":[[${cp1('B')},null]]}]},"success":true,"idx":2}`) { throw result }
+        },
+        () => {
+            const stringRule = 'AB'
+            const m = descentParser(stringRule)
+            const mr = descentParserCpOnly(m, "", toArray(stringToCodePointList('AC')))
+            const result = JSON.stringify(mr)
+            // The result index rewound to the sequence's start, but the furthest
+            // failure kept the position where 'B' was actually rejected.
+            if (result !== `{"ast":{"sequence":[]},"success":false,"idx":0,"failure":{"idx":1,"expected":[${range('BB')}]}}`) { throw result }
+        },
+        () => {
+            const emptyRule = ''
+            const minursRule = range('--')
+            const optionalMinusRule = { 'none': emptyRule, 'minus': minursRule}
+            const digitRule = range('09')
+            const numberRule = [optionalMinusRule, digitRule]
+            const m = descentParser(numberRule)
+            const mr = descentParserCpOnly(m, "", toArray(stringToCodePointList('2')))
+            const result = JSON.stringify(mr)
+            if (result !== `{"ast":{"sequence":[{"tag":"none","sequence":[]},{"sequence":[[${cp1('2')},null]]}]},"success":true,"idx":1}`) { throw result }
+        },
+        () => {
+            const emptyRule = ''
+            const minusRule = range('--')
+            const optionalMinusRule = { 'none': emptyRule, 'minus': minusRule}
+            const digitRule = range('09')
+            const numberRule = [optionalMinusRule, digitRule]
+            const m = descentParser(numberRule)
+            const mr = descentParserCpOnly(m, "", toArray(stringToCodePointList('-2')))
+            const result = JSON.stringify(mr)
+            if (result !== `{"ast":{"sequence":[{"tag":"minus","sequence":[[${cp1('-')},null]]},{"sequence":[[${cp1('2')},null]]}]},"success":true,"idx":2}`) { throw result }
+        },
+        () => {
+            const emptyRule = ''
+            const minursRule = range('--')
+            const optionalMinusRule = { 'none': emptyRule, 'minus': minursRule}
+            const digitRule = range('09')
+            const numberRule = [optionalMinusRule, digitRule]
+            const m = descentParser(numberRule)
+            const mr = m("", [])
+            const result = JSON.stringify(mr)
+            // Past the end: '-' and then the digit range were both rejected at 0.
+            if (result !== `{"ast":{"sequence":[]},"success":false,"idx":0,"failure":{"idx":0,"expected":[${range('--')},${range('09')}]}}`) { throw result }
+        },
+        () => {
+            const m = descentParser(option('a'))
+
+            const expect = (/** @type {string} */s, /** @type {Boolean} */expected) => {
+                const cp = toArray(stringToCodePointList(s))
+                const mr = descentParserCpOnly(m, '', cp)
+                const success = mr.success && mr.idx === cp.length
+                assertEq(success, expected, 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 = descentParser(value)
+
+            const expect = (/** @type {string} */s, /** @type {boolean} */expected) => {
+                const cp = toArray(stringToCodePointList(s))
+                const mr = descentParserCpOnly(m, 'value', cp)
+                const success = mr.success && mr.idx === cp.length
+                assertEq(success, expected, mr)
+            }
+
+            expect('', false)
+            expect('[]', true)
+            expect('[a]', true)
+            expect('[a, a]', true)
+            expect('{a}', true)
+        },
+        () => {
+            const m = descentParser(deterministic())
+
+            const expect = (/** @type {string} */s, /** @type {boolean} */expected) => {
+                const cp = toArray(stringToCodePointList(s))
+                const mr = descentParserCpOnly(m, '', cp)
+                const success = mr.success && mr.idx === cp.length
+                assertEq(success, expected, 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)
+        }
+    ],
+    // Regression for the stack-recursive matcher bug: the matcher used to recurse
+    // natively once per grammar step, so match depth grew with input length and these
+    // inputs threw "RangeError: Maximum call stack size exceeded" at a few thousand
+    // code points. The explicit-frame-stack matcher handles them in O(1) JS call stack.
+    longInput: [
+        () => {
+            // long right-recursive repetition: one repeat0Plus chain across the whole input
+            const rule = repeat0Plus(set(' \n\r\t'))
+            const name = toData(rule)[1]
+            const m = descentParser(rule)
+            const cp = toArray(stringToCodePointList(' '.repeat(10000)))
+            const { success: ok, idx } = descentParserCpOnly(m, name, cp)
+            assertEq(ok, true)
+            assertEq(idx, 10000)
+        },
+        () => {
+            // deep non-repetition nesting: 5000 bracket levels in the JSON-like test
+            // grammar — a shape that repetition-specific fixes (a `repeat` primitive)
+            // would not cover
+            const m = descentParser(deterministic())
+            const n = 5000
+            const cp = toArray(stringToCodePointList('['.repeat(n) + ']'.repeat(n)))
+            const { success: ok, idx } = descentParserCpOnly(m, '', cp)
+            assertEq(ok, true)
+            assertEq(idx, n * 2)
+        },
+    ],
+    descentParserWithMeta: [
+        () => {
+            const emptyRule = ''
+            const minusRule = range('--')
+            const optionalMinusRule = { 'none': emptyRule, 'minus': minusRule}
+            const digitRule = range('09')
+            const numberRule = [optionalMinusRule, digitRule]
+            const m = descentParser(numberRule)
+            const mr = m("", [[cp1('-'), 'minus'], [cp1('2'), 'two']])
+            const result = JSON.stringify(mr)
+            if (result !== `{"ast":{"sequence":[{"tag":"minus","sequence":[[${cp1('-')},"minus"]]},{"sequence":[[${cp1('2')},"two"]]}]},"success":true,"idx":2}`) { throw result }
+        },
+    ],
+    logicalEof: [
+        () => {
+            // The matcher synthesizes one EOF after the physical input, so the
+            // `eof` terminal matches empty input. It contributes no AST leaf,
+            // and the public index stays physical.
+            const m = descentParser(eof)
+            const mr = m('', [])
+            assertEq(JSON.stringify(mr), '{"ast":{"sequence":[]},"success":true,"idx":0}')
+        },
+        () => {
+            // Callers pass physical symbols only, so EOF is not available
+            // before the end of the input.
+            const m = descentParser(eof)
+            const mr = descentParserCpOnly(m, '', toArray(stringToCodePointList('A')))
+            assertEq(mr.success, false)
+            const f = assertNotNullish(mr.failure)
+            assertEq(f.idx, 0)
+            assertEq(f.expected.length, 1)
+            assertEq(f.expected[0], eof)
+        },
+        () => {
+            // Non-empty input: the terminal consumes the synthesized EOF after
+            // the last code point, and `idx` still reports `input.length`.
+            const m = descentParser([range('AA'), eof])
+            const cp = toArray(stringToCodePointList('A'))
+            const mr = descentParserCpOnly(m, '', cp)
+            assertEq(mr.success, true)
+            assertEq(mr.idx, cp.length)
+            assertEq(JSON.stringify(mr.ast), `{"sequence":[{"sequence":[[${cp1('A')},null]]},{"sequence":[]}]}`)
+        },
+        () => {
+            // Exactly one EOF is synthesized: a second `eof` terminal has
+            // nothing left to consume, and its failure points at `input.length`.
+            const m = descentParser([eof, eof])
+            const mr = m('', [])
+            assertEq(mr.success, false)
+            const f = assertNotNullish(mr.failure)
+            assertEq(f.idx, 0)
+            assertEq(f.expected.length, 1)
+            assertEq(f.expected[0], eof)
+        },
+        () => {
+            // EOF as one alternative among ordinary terminals.
+            const m = descentParser({ a: range('AA'), e: eof })
+            assertEq(JSON.stringify(m('', [])), '{"ast":{"tag":"e","sequence":[]},"success":true,"idx":0}')
+            const mr = descentParserCpOnly(m, '', toArray(stringToCodePointList('A')))
+            assertEq(mr.success, true)
+            assertEq(mr.idx, 1)
+        },
+        () => {
+            // Repetition terminates on EOF: consuming it moves the complete
+            // cursor, so the repeat makes exactly one round and then takes its
+            // empty branch — with `idx` alone this would never stop.
+            const m = descentParser(repeat0Plus(eof))
+            const mr = m('', [])
+            assertEq(JSON.stringify(mr), '{"ast":{"sequence":[{"sequence":[]},{"tag":"none","sequence":[]}]},"success":true,"idx":0}')
+        },
+        () => {
+            // Backtracking restores the complete cursor: `x` consumes EOF and
+            // then fails, so `y` must still find EOF available.
+            const m = descentParser({ x: [eof, range('AA')], y: eof })
+            assertEq(JSON.stringify(m('', [])), '{"ast":{"tag":"y","sequence":[]},"success":true,"idx":0}')
+        },
+        () => {
+            // Diagnostic ordering by the complete cursor: `y` got further than
+            // `x` — the same physical index, but past the EOF it consumed — so
+            // only its expectation is reported, and at the physical end.
+            const m = descentParser({ x: range('AA'), y: [eof, range('BB')] })
+            const mr = m('', [])
+            assertEq(mr.success, false)
+            const f = assertNotNullish(mr.failure)
+            assertEq(f.idx, 0)
+            assertEq(f.expected.length, 1)
+            assertEq(f.expected[0], range('BB'))
+        },
+    ],
+    furthestFailure: [
+        () => {
+            // A branch rejected *before* the high-water mark must not pull it back:
+            // `x` gets to index 1 before failing, then `y` fails at 0.
+            const m = descentParser({ x: ['A', 'B'], y: 'B' })
+            const { success: ok, idx, failure } = descentParserCpOnly(m, '', toArray(stringToCodePointList('AC')))
+            assertEq(ok, false)
+            assertEq(idx, 0)
+            // A failed match always carries a failure; that is the contract.
+            const f = assertNotNullish(failure)
+            assertEq(f.idx, 1)
+            assertEq(f.expected.length, 1)
+            assertEq(f.expected[0], range('BB'))
+        },
+        () => {
+            // The same terminal rejected at the same index by two branches is
+            // expected once, not twice.
+            const m = descentParser({ x: ['A', 'B'], y: ['A', 'B', 'C'] })
+            const { failure } = descentParserCpOnly(m, '', toArray(stringToCodePointList('AC')))
+            const f = assertNotNullish(failure)
+            assertEq(f.idx, 1)
+            assertEq(f.expected.length, 1)
+            assertEq(f.expected[0], range('BB'))
+        },
+    ],
+}

package/fjs/bnf/descent/types.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Types for the recursive descent matcher backend.
+ *
+ * @module
+ */
+import type { CodePoint } from '../../text/utf16/types.ts';
+import type { TerminalRange } from '../types.ts';
+export type AstTag = string | true | undefined;
+/**
+ * Recursive descent matcher for a single named rule, starting from `startPos` —
+ * a position that counts the synthesized end-of-input symbol, unlike the public
+ * `idx` of the result.
+ */
+export type DescentMatchRule<T> = (name: string, tag: AstTag, s: readonly CodePointMeta<T>[], startPos: 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.
+ *
+ * `idx` is physical, so a terminal rejected at — or past — the synthesized
+ * end-of-input symbol reports `input.length`. The high-water mark itself is
+ * kept on the complete cursor, so those two are still ordered against each
+ * other and their expected terminals do not merge.
+ */
+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.
+ *
+ * `idx` is physical — `0 <= idx <= input.length` — so a match that consumed the
+ * synthesized end-of-input symbol reports `input.length`, the same as one that
+ * stopped just before it.
+ */
+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>;
+};

package/fjs/bnf/ll1/module.f.d.mts

@@ -0,0 +1,67 @@
+/**
+ * LL(1) dispatch/matcher backend over the BNF data {@link RuleSet}.
+ *
+ * Built from the serializable IR in `fjs/bnf/data`, this is one member of the
+ * family of automaton builders that consume a {@link RuleSet}: it compiles the
+ * grammar into a predictive {@link dispatchMap} and matches input into an AST
+ * ({@link MatchResult}). It throws at build time (`can not merge …`) when the
+ * grammar is not LL(1) — a first/first conflict. Nullability is looked up from
+ * {@link emptyTagMap} in `fjs/bnf/data` rather than re-derived here.
+ *
+ * The caller passes physical symbols only; the matcher synthesizes the one
+ * logical EOF ({@link eofSymbol}) after them, so a grammar can dispatch on the
+ * end of input with the `eof` terminal.
+ *
+ * See `./types.ts` for the type-level API.
+ *
+ * @module
+ *
+ * @import { CodePoint } from '../../text/utf16/types.ts'
+ * @import { Properties } from '../../types/range_map/types.ts'
+ * @import { StringSet } from '../../types/string_set/types.ts'
+ * @import { EmptyTag, RuleSet } from '../data/types.ts'
+ * @import { Rule as FRule } from '../types.ts'
+ * @import { AstSequence, AstTag, Match, MatchResult, Remainder, _AstRule, _Dispatch, _DispatchMap, _DispatchResult, _DispatchRule } from './types.ts'
+ */
+import type { RuleSet } from '../data/types.ts';
+import type { Rule as FRule } from '../types.ts';
+import type { AstSequence, AstTag, Match, _AstRule, _DispatchMap, _DispatchRule } from './types.ts';
+/**
+ * Builds a dispatch map for a {@link RuleSet} to enable predictive parsing.
+ *
+ * @type {(ruleSet: RuleSet) => _DispatchMap}
+ */
+export declare const dispatchMap: (ruleSet: RuleSet) => _DispatchMap;
+/**
+ * Creates an LL(1) parser from a functional grammar rule.
+ *
+ * @type {(fr: FRule) => Match}
+ */
+export declare const parser: (fr: FRule) => Match;
+export type _Cursor = number;
+export type _Position = _Cursor | null;
+export type _Result = {
+    readonly ast: _AstRule;
+    readonly success: boolean;
+    readonly pos: _Position;
+};
+export type _Frame = {
+    readonly tag: AstTag;
+    readonly rules: readonly string[];
+    readonly ruleIndex: number;
+    readonly seq: AstSequence;
+};
+export type _Stack = null | {
+    readonly top: _Frame;
+    readonly rest: _Stack;
+};
+export type _Task = {
+    readonly rule: _DispatchRule;
+    readonly pos: _Cursor;
+};
+/**
+ * Creates an LL(1) parser from an already materialized {@link RuleSet}.
+ *
+ * @type {(ruleSet: RuleSet) => Match}
+ */
+export declare const parserRuleSet: (ruleSet: RuleSet) => Match;