@plumile/ui 0.1.113 → 0.1.114

package/lib/esm/node_modules/chevrotain/lib/src/parse/grammar/interpreter.js

@@ -1,269 +0,0 @@
-import { Alternation as e, Alternative as t, NonTerminal as n, Option as r, Repetition as i, RepetitionMandatory as a, RepetitionMandatoryWithSeparator as o, RepetitionWithSeparator as s, Rule as c, Terminal as l } from "../../../../../@chevrotain/gast/lib/src/model.js";
-import { RestWalker as u } from "./rest.js";
-import { first as d } from "./first.js";
-//#region ../../node_modules/chevrotain/lib/src/parse/grammar/interpreter.js
-var f = class extends u {
-	constructor(e, t) {
-		super(), this.topProd = e, this.path = t, this.possibleTokTypes = [], this.nextProductionName = "", this.nextProductionOccurrence = 0, this.found = !1, this.isAtEndOfPath = !1;
-	}
-	startWalking() {
-		if (this.found = !1, this.path.ruleStack[0] !== this.topProd.name) throw Error("The path does not start with the walker's top Rule!");
-		return this.ruleStack = [...this.path.ruleStack].reverse(), this.occurrenceStack = [...this.path.occurrenceStack].reverse(), this.ruleStack.pop(), this.occurrenceStack.pop(), this.updateExpectedNext(), this.walk(this.topProd), this.possibleTokTypes;
-	}
-	walk(e, t = []) {
-		this.found || super.walk(e, t);
-	}
-	walkProdRef(e, t, n) {
-		if (e.referencedRule.name === this.nextProductionName && e.idx === this.nextProductionOccurrence) {
-			let r = t.concat(n);
-			this.updateExpectedNext(), this.walk(e.referencedRule, r);
-		}
-	}
-	updateExpectedNext() {
-		this.ruleStack.length === 0 ? (this.nextProductionName = "", this.nextProductionOccurrence = 0, this.isAtEndOfPath = !0) : (this.nextProductionName = this.ruleStack.pop(), this.nextProductionOccurrence = this.occurrenceStack.pop());
-	}
-}, p = class extends f {
-	constructor(e, t) {
-		super(e, t), this.path = t, this.nextTerminalName = "", this.nextTerminalOccurrence = 0, this.nextTerminalName = this.path.lastTok.name, this.nextTerminalOccurrence = this.path.lastTokOccurrence;
-	}
-	walkTerminal(e, n, r) {
-		if (this.isAtEndOfPath && e.terminalType.name === this.nextTerminalName && e.idx === this.nextTerminalOccurrence && !this.found) {
-			let e = new t({ definition: n.concat(r) });
-			this.possibleTokTypes = d(e), this.found = !0;
-		}
-	}
-}, m = class extends u {
-	constructor(e, t) {
-		super(), this.topRule = e, this.occurrence = t, this.result = {
-			token: void 0,
-			occurrence: void 0,
-			isEndOfRule: void 0
-		};
-	}
-	startWalking() {
-		return this.walk(this.topRule), this.result;
-	}
-}, h = class extends m {
-	walkMany(e, t, n) {
-		if (e.idx === this.occurrence) {
-			let e = t.concat(n)[0];
-			this.result.isEndOfRule = e === void 0, e instanceof l && (this.result.token = e.terminalType, this.result.occurrence = e.idx);
-		} else super.walkMany(e, t, n);
-	}
-}, g = class extends m {
-	walkManySep(e, t, n) {
-		if (e.idx === this.occurrence) {
-			let e = t.concat(n)[0];
-			this.result.isEndOfRule = e === void 0, e instanceof l && (this.result.token = e.terminalType, this.result.occurrence = e.idx);
-		} else super.walkManySep(e, t, n);
-	}
-}, _ = class extends m {
-	walkAtLeastOne(e, t, n) {
-		if (e.idx === this.occurrence) {
-			let e = t.concat(n)[0];
-			this.result.isEndOfRule = e === void 0, e instanceof l && (this.result.token = e.terminalType, this.result.occurrence = e.idx);
-		} else super.walkAtLeastOne(e, t, n);
-	}
-}, v = class extends m {
-	walkAtLeastOneSep(e, t, n) {
-		if (e.idx === this.occurrence) {
-			let e = t.concat(n)[0];
-			this.result.isEndOfRule = e === void 0, e instanceof l && (this.result.token = e.terminalType, this.result.occurrence = e.idx);
-		} else super.walkAtLeastOneSep(e, t, n);
-	}
-};
-function y(c, u, d = []) {
-	d = [...d];
-	let f = [], p = 0;
-	function m(e) {
-		return e.concat(c.slice(p + 1));
-	}
-	function h(e) {
-		let t = y(m(e), u, d);
-		return f.concat(t);
-	}
-	for (; d.length < u && p < c.length;) {
-		let u = c[p];
-		if (u instanceof t || u instanceof n) return h(u.definition);
-		if (u instanceof r) f = h(u.definition);
-		else if (u instanceof a) return h(u.definition.concat([new i({ definition: u.definition })]));
-		else if (u instanceof o) return h([new t({ definition: u.definition }), new i({ definition: [new l({ terminalType: u.separator })].concat(u.definition) })]);
-		else if (u instanceof s) f = h(u.definition.concat([new i({ definition: [new l({ terminalType: u.separator })].concat(u.definition) })]));
-		else if (u instanceof i) f = h(u.definition.concat([new i({ definition: u.definition })]));
-		else if (u instanceof e) return u.definition.forEach((e) => {
-			e.definition.length !== 0 && (f = h(e.definition));
-		}), f;
-		else if (u instanceof l) d.push(u.terminalType);
-		else throw Error("non exhaustive match");
-		p++;
-	}
-	return f.push({
-		partialPath: d,
-		suffixDef: c.slice(p)
-	}), f;
-}
-function b(u, d, f, p) {
-	let m = "EXIT_NONE_TERMINAL", h = [m], g = "EXIT_ALTERNATIVE", _ = !1, v = d.length, y = v - p - 1, b = [], S = [];
-	for (S.push({
-		idx: -1,
-		def: u,
-		ruleStack: [],
-		occurrenceStack: []
-	}); S.length !== 0;) {
-		let u = S.pop();
-		if (u === g) {
-			_ && S.at(-1).idx <= y && S.pop();
-			continue;
-		}
-		let p = u.def, C = u.idx, w = u.ruleStack, T = u.occurrenceStack;
-		if (p.length === 0) continue;
-		let E = p[0];
-		/* istanbul ignore else */
-		if (E === m) {
-			let e = {
-				idx: C,
-				def: p.slice(1),
-				ruleStack: w.slice(0, -1),
-				occurrenceStack: T.slice(0, -1)
-			};
-			S.push(e);
-		} else if (E instanceof l)
- /* istanbul ignore else */
-		if (C < v - 1) {
-			let e = C + 1, t = d[e];
-			if (f(t, E.terminalType)) {
-				let t = {
-					idx: e,
-					def: p.slice(1),
-					ruleStack: w,
-					occurrenceStack: T
-				};
-				S.push(t);
-			}
-		} else if (C === v - 1) b.push({
-			nextTokenType: E.terminalType,
-			nextTokenOccurrence: E.idx,
-			ruleStack: w,
-			occurrenceStack: T
-		}), _ = !0;
-		else throw Error("non exhaustive match");
-		else if (E instanceof n) {
-			let e = [...w];
-			e.push(E.nonTerminalName);
-			let t = [...T];
-			t.push(E.idx);
-			let n = {
-				idx: C,
-				def: E.definition.concat(h, p.slice(1)),
-				ruleStack: e,
-				occurrenceStack: t
-			};
-			S.push(n);
-		} else if (E instanceof r) {
-			let e = {
-				idx: C,
-				def: p.slice(1),
-				ruleStack: w,
-				occurrenceStack: T
-			};
-			S.push(e), S.push(g);
-			let t = {
-				idx: C,
-				def: E.definition.concat(p.slice(1)),
-				ruleStack: w,
-				occurrenceStack: T
-			};
-			S.push(t);
-		} else if (E instanceof a) {
-			let e = new i({
-				definition: E.definition,
-				idx: E.idx
-			}), t = {
-				idx: C,
-				def: E.definition.concat([e], p.slice(1)),
-				ruleStack: w,
-				occurrenceStack: T
-			};
-			S.push(t);
-		} else if (E instanceof o) {
-			let e = new i({
-				definition: [new l({ terminalType: E.separator })].concat(E.definition),
-				idx: E.idx
-			}), t = {
-				idx: C,
-				def: E.definition.concat([e], p.slice(1)),
-				ruleStack: w,
-				occurrenceStack: T
-			};
-			S.push(t);
-		} else if (E instanceof s) {
-			let e = {
-				idx: C,
-				def: p.slice(1),
-				ruleStack: w,
-				occurrenceStack: T
-			};
-			S.push(e), S.push(g);
-			let t = new i({
-				definition: [new l({ terminalType: E.separator })].concat(E.definition),
-				idx: E.idx
-			}), n = {
-				idx: C,
-				def: E.definition.concat([t], p.slice(1)),
-				ruleStack: w,
-				occurrenceStack: T
-			};
-			S.push(n);
-		} else if (E instanceof i) {
-			let e = {
-				idx: C,
-				def: p.slice(1),
-				ruleStack: w,
-				occurrenceStack: T
-			};
-			S.push(e), S.push(g);
-			let t = new i({
-				definition: E.definition,
-				idx: E.idx
-			}), n = {
-				idx: C,
-				def: E.definition.concat([t], p.slice(1)),
-				ruleStack: w,
-				occurrenceStack: T
-			};
-			S.push(n);
-		} else if (E instanceof e) for (let e = E.definition.length - 1; e >= 0; e--) {
-			let t = {
-				idx: C,
-				def: E.definition[e].definition.concat(p.slice(1)),
-				ruleStack: w,
-				occurrenceStack: T
-			};
-			S.push(t), S.push(g);
-		}
-		else if (E instanceof t) S.push({
-			idx: C,
-			def: E.definition.concat(p.slice(1)),
-			ruleStack: w,
-			occurrenceStack: T
-		});
-		else if (E instanceof c) S.push(x(E, C, w, T));
-		else throw Error("non exhaustive match");
-	}
-	return b;
-}
-function x(e, t, n, r) {
-	let i = [...n];
-	i.push(e.name);
-	let a = [...r];
-	return a.push(1), {
-		idx: t,
-		def: e.definition,
-		ruleStack: i,
-		occurrenceStack: a
-	};
-}
-//#endregion
-export { p as NextAfterTokenWalker, v as NextTerminalAfterAtLeastOneSepWalker, _ as NextTerminalAfterAtLeastOneWalker, g as NextTerminalAfterManySepWalker, h as NextTerminalAfterManyWalker, b as nextPossibleTokensAfter, y as possiblePathsFrom };
-
-//# sourceMappingURL=interpreter.js.map

package/lib/esm/node_modules/chevrotain/lib/src/parse/grammar/interpreter.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"interpreter.js","names":[],"sources":["../../../../../../../../../../node_modules/chevrotain/lib/src/parse/grammar/interpreter.js"],"sourcesContent":["import { first } from \"./first.js\";\nimport { RestWalker } from \"./rest.js\";\nimport { Alternation, Alternative, NonTerminal, Option, Repetition, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Rule, Terminal, } from \"@chevrotain/gast\";\nexport class AbstractNextPossibleTokensWalker extends RestWalker {\n    constructor(topProd, path) {\n        super();\n        this.topProd = topProd;\n        this.path = path;\n        this.possibleTokTypes = [];\n        this.nextProductionName = \"\";\n        this.nextProductionOccurrence = 0;\n        this.found = false;\n        this.isAtEndOfPath = false;\n    }\n    startWalking() {\n        this.found = false;\n        if (this.path.ruleStack[0] !== this.topProd.name) {\n            throw Error(\"The path does not start with the walker's top Rule!\");\n        }\n        // immutable for the win\n        this.ruleStack = [...this.path.ruleStack].reverse(); // intelij bug requires assertion\n        this.occurrenceStack = [...this.path.occurrenceStack].reverse(); // intelij bug requires assertion\n        // already verified that the first production is valid, we now seek the 2nd production\n        this.ruleStack.pop();\n        this.occurrenceStack.pop();\n        this.updateExpectedNext();\n        this.walk(this.topProd);\n        return this.possibleTokTypes;\n    }\n    walk(prod, prevRest = []) {\n        // stop scanning once we found the path\n        if (!this.found) {\n            super.walk(prod, prevRest);\n        }\n    }\n    walkProdRef(refProd, currRest, prevRest) {\n        // found the next production, need to keep walking in it\n        if (refProd.referencedRule.name === this.nextProductionName &&\n            refProd.idx === this.nextProductionOccurrence) {\n            const fullRest = currRest.concat(prevRest);\n            this.updateExpectedNext();\n            this.walk(refProd.referencedRule, fullRest);\n        }\n    }\n    updateExpectedNext() {\n        // need to consume the Terminal\n        if (this.ruleStack.length === 0) {\n            // must reset nextProductionXXX to avoid walking down another Top Level production while what we are\n            // really seeking is the last Terminal...\n            this.nextProductionName = \"\";\n            this.nextProductionOccurrence = 0;\n            this.isAtEndOfPath = true;\n        }\n        else {\n            this.nextProductionName = this.ruleStack.pop();\n            this.nextProductionOccurrence = this.occurrenceStack.pop();\n        }\n    }\n}\nexport class NextAfterTokenWalker extends AbstractNextPossibleTokensWalker {\n    constructor(topProd, path) {\n        super(topProd, path);\n        this.path = path;\n        this.nextTerminalName = \"\";\n        this.nextTerminalOccurrence = 0;\n        this.nextTerminalName = this.path.lastTok.name;\n        this.nextTerminalOccurrence = this.path.lastTokOccurrence;\n    }\n    walkTerminal(terminal, currRest, prevRest) {\n        if (this.isAtEndOfPath &&\n            terminal.terminalType.name === this.nextTerminalName &&\n            terminal.idx === this.nextTerminalOccurrence &&\n            !this.found) {\n            const fullRest = currRest.concat(prevRest);\n            const restProd = new Alternative({ definition: fullRest });\n            this.possibleTokTypes = first(restProd);\n            this.found = true;\n        }\n    }\n}\n/**\n * This walker only \"walks\" a single \"TOP\" level in the Grammar Ast, this means\n * it never \"follows\" production refs\n */\nexport class AbstractNextTerminalAfterProductionWalker extends RestWalker {\n    constructor(topRule, occurrence) {\n        super();\n        this.topRule = topRule;\n        this.occurrence = occurrence;\n        this.result = {\n            token: undefined,\n            occurrence: undefined,\n            isEndOfRule: undefined,\n        };\n    }\n    startWalking() {\n        this.walk(this.topRule);\n        return this.result;\n    }\n}\nexport class NextTerminalAfterManyWalker extends AbstractNextTerminalAfterProductionWalker {\n    walkMany(manyProd, currRest, prevRest) {\n        if (manyProd.idx === this.occurrence) {\n            const firstAfterMany = currRest.concat(prevRest)[0];\n            this.result.isEndOfRule = firstAfterMany === undefined;\n            if (firstAfterMany instanceof Terminal) {\n                this.result.token = firstAfterMany.terminalType;\n                this.result.occurrence = firstAfterMany.idx;\n            }\n        }\n        else {\n            super.walkMany(manyProd, currRest, prevRest);\n        }\n    }\n}\nexport class NextTerminalAfterManySepWalker extends AbstractNextTerminalAfterProductionWalker {\n    walkManySep(manySepProd, currRest, prevRest) {\n        if (manySepProd.idx === this.occurrence) {\n            const firstAfterManySep = currRest.concat(prevRest)[0];\n            this.result.isEndOfRule = firstAfterManySep === undefined;\n            if (firstAfterManySep instanceof Terminal) {\n                this.result.token = firstAfterManySep.terminalType;\n                this.result.occurrence = firstAfterManySep.idx;\n            }\n        }\n        else {\n            super.walkManySep(manySepProd, currRest, prevRest);\n        }\n    }\n}\nexport class NextTerminalAfterAtLeastOneWalker extends AbstractNextTerminalAfterProductionWalker {\n    walkAtLeastOne(atLeastOneProd, currRest, prevRest) {\n        if (atLeastOneProd.idx === this.occurrence) {\n            const firstAfterAtLeastOne = currRest.concat(prevRest)[0];\n            this.result.isEndOfRule = firstAfterAtLeastOne === undefined;\n            if (firstAfterAtLeastOne instanceof Terminal) {\n                this.result.token = firstAfterAtLeastOne.terminalType;\n                this.result.occurrence = firstAfterAtLeastOne.idx;\n            }\n        }\n        else {\n            super.walkAtLeastOne(atLeastOneProd, currRest, prevRest);\n        }\n    }\n}\n// TODO: reduce code duplication in the AfterWalkers\nexport class NextTerminalAfterAtLeastOneSepWalker extends AbstractNextTerminalAfterProductionWalker {\n    walkAtLeastOneSep(atleastOneSepProd, currRest, prevRest) {\n        if (atleastOneSepProd.idx === this.occurrence) {\n            const firstAfterfirstAfterAtLeastOneSep = currRest.concat(prevRest)[0];\n            this.result.isEndOfRule = firstAfterfirstAfterAtLeastOneSep === undefined;\n            if (firstAfterfirstAfterAtLeastOneSep instanceof Terminal) {\n                this.result.token = firstAfterfirstAfterAtLeastOneSep.terminalType;\n                this.result.occurrence = firstAfterfirstAfterAtLeastOneSep.idx;\n            }\n        }\n        else {\n            super.walkAtLeastOneSep(atleastOneSepProd, currRest, prevRest);\n        }\n    }\n}\nexport function possiblePathsFrom(targetDef, maxLength, currPath = []) {\n    // avoid side effects\n    currPath = [...currPath];\n    let result = [];\n    let i = 0;\n    // TODO: avoid inner funcs\n    function remainingPathWith(nextDef) {\n        return nextDef.concat(targetDef.slice(i + 1));\n    }\n    // TODO: avoid inner funcs\n    function getAlternativesForProd(definition) {\n        const alternatives = possiblePathsFrom(remainingPathWith(definition), maxLength, currPath);\n        return result.concat(alternatives);\n    }\n    /**\n     * Mandatory productions will halt the loop as the paths computed from their recursive calls will already contain the\n     * following (rest) of the targetDef.\n     *\n     * For optional productions (Option/Repetition/...) the loop will continue to represent the paths that do not include the\n     * the optional production.\n     */\n    while (currPath.length < maxLength && i < targetDef.length) {\n        const prod = targetDef[i];\n        /* istanbul ignore else */\n        if (prod instanceof Alternative) {\n            return getAlternativesForProd(prod.definition);\n        }\n        else if (prod instanceof NonTerminal) {\n            return getAlternativesForProd(prod.definition);\n        }\n        else if (prod instanceof Option) {\n            result = getAlternativesForProd(prod.definition);\n        }\n        else if (prod instanceof RepetitionMandatory) {\n            const newDef = prod.definition.concat([\n                new Repetition({\n                    definition: prod.definition,\n                }),\n            ]);\n            return getAlternativesForProd(newDef);\n        }\n        else if (prod instanceof RepetitionMandatoryWithSeparator) {\n            const newDef = [\n                new Alternative({ definition: prod.definition }),\n                new Repetition({\n                    definition: [new Terminal({ terminalType: prod.separator })].concat(prod.definition),\n                }),\n            ];\n            return getAlternativesForProd(newDef);\n        }\n        else if (prod instanceof RepetitionWithSeparator) {\n            const newDef = prod.definition.concat([\n                new Repetition({\n                    definition: [new Terminal({ terminalType: prod.separator })].concat(prod.definition),\n                }),\n            ]);\n            result = getAlternativesForProd(newDef);\n        }\n        else if (prod instanceof Repetition) {\n            const newDef = prod.definition.concat([\n                new Repetition({\n                    definition: prod.definition,\n                }),\n            ]);\n            result = getAlternativesForProd(newDef);\n        }\n        else if (prod instanceof Alternation) {\n            prod.definition.forEach((currAlt) => {\n                // TODO: this is a limited check for empty alternatives\n                //   It would prevent a common case of infinite loops during parser initialization.\n                //   However **in-directly** empty alternatives may still cause issues.\n                if (currAlt.definition.length !== 0) {\n                    result = getAlternativesForProd(currAlt.definition);\n                }\n            });\n            return result;\n        }\n        else if (prod instanceof Terminal) {\n            currPath.push(prod.terminalType);\n        }\n        else {\n            throw Error(\"non exhaustive match\");\n        }\n        i++;\n    }\n    result.push({\n        partialPath: currPath,\n        suffixDef: targetDef.slice(i),\n    });\n    return result;\n}\nexport function nextPossibleTokensAfter(initialDef, tokenVector, tokMatcher, maxLookAhead) {\n    const EXIT_NON_TERMINAL = \"EXIT_NONE_TERMINAL\";\n    // to avoid creating a new Array each time.\n    const EXIT_NON_TERMINAL_ARR = [EXIT_NON_TERMINAL];\n    const EXIT_ALTERNATIVE = \"EXIT_ALTERNATIVE\";\n    let foundCompletePath = false;\n    const tokenVectorLength = tokenVector.length;\n    const minimalAlternativesIndex = tokenVectorLength - maxLookAhead - 1;\n    const result = [];\n    const possiblePaths = [];\n    possiblePaths.push({\n        idx: -1,\n        def: initialDef,\n        ruleStack: [],\n        occurrenceStack: [],\n    });\n    while (possiblePaths.length !== 0) {\n        const currPath = possiblePaths.pop();\n        // skip alternatives if no more results can be found (assuming deterministic grammar with fixed lookahead)\n        if (currPath === EXIT_ALTERNATIVE) {\n            if (foundCompletePath &&\n                possiblePaths.at(-1).idx <= minimalAlternativesIndex) {\n                // remove irrelevant alternative\n                possiblePaths.pop();\n            }\n            continue;\n        }\n        const currDef = currPath.def;\n        const currIdx = currPath.idx;\n        const currRuleStack = currPath.ruleStack;\n        const currOccurrenceStack = currPath.occurrenceStack;\n        // For Example: an empty path could exist in a valid grammar in the case of an EMPTY_ALT\n        if (currDef.length === 0) {\n            continue;\n        }\n        const prod = currDef[0];\n        /* istanbul ignore else */\n        if (prod === EXIT_NON_TERMINAL) {\n            const nextPath = {\n                idx: currIdx,\n                def: currDef.slice(1),\n                ruleStack: currRuleStack.slice(0, -1),\n                occurrenceStack: currOccurrenceStack.slice(0, -1),\n            };\n            possiblePaths.push(nextPath);\n        }\n        else if (prod instanceof Terminal) {\n            /* istanbul ignore else */\n            if (currIdx < tokenVectorLength - 1) {\n                const nextIdx = currIdx + 1;\n                const actualToken = tokenVector[nextIdx];\n                if (tokMatcher(actualToken, prod.terminalType)) {\n                    const nextPath = {\n                        idx: nextIdx,\n                        def: currDef.slice(1),\n                        ruleStack: currRuleStack,\n                        occurrenceStack: currOccurrenceStack,\n                    };\n                    possiblePaths.push(nextPath);\n                }\n                // end of the line\n            }\n            else if (currIdx === tokenVectorLength - 1) {\n                // IGNORE ABOVE ELSE\n                result.push({\n                    nextTokenType: prod.terminalType,\n                    nextTokenOccurrence: prod.idx,\n                    ruleStack: currRuleStack,\n                    occurrenceStack: currOccurrenceStack,\n                });\n                foundCompletePath = true;\n            }\n            else {\n                throw Error(\"non exhaustive match\");\n            }\n        }\n        else if (prod instanceof NonTerminal) {\n            const newRuleStack = [...currRuleStack];\n            newRuleStack.push(prod.nonTerminalName);\n            const newOccurrenceStack = [...currOccurrenceStack];\n            newOccurrenceStack.push(prod.idx);\n            const nextPath = {\n                idx: currIdx,\n                def: prod.definition.concat(EXIT_NON_TERMINAL_ARR, currDef.slice(1)),\n                ruleStack: newRuleStack,\n                occurrenceStack: newOccurrenceStack,\n            };\n            possiblePaths.push(nextPath);\n        }\n        else if (prod instanceof Option) {\n            // the order of alternatives is meaningful, FILO (Last path will be traversed first).\n            const nextPathWithout = {\n                idx: currIdx,\n                def: currDef.slice(1),\n                ruleStack: currRuleStack,\n                occurrenceStack: currOccurrenceStack,\n            };\n            possiblePaths.push(nextPathWithout);\n            // required marker to avoid backtracking paths whose higher priority alternatives already matched\n            possiblePaths.push(EXIT_ALTERNATIVE);\n            const nextPathWith = {\n                idx: currIdx,\n                def: prod.definition.concat(currDef.slice(1)),\n                ruleStack: currRuleStack,\n                occurrenceStack: currOccurrenceStack,\n            };\n            possiblePaths.push(nextPathWith);\n        }\n        else if (prod instanceof RepetitionMandatory) {\n            // TODO:(THE NEW operators here take a while...) (convert once?)\n            const secondIteration = new Repetition({\n                definition: prod.definition,\n                idx: prod.idx,\n            });\n            const nextDef = prod.definition.concat([secondIteration], currDef.slice(1));\n            const nextPath = {\n                idx: currIdx,\n                def: nextDef,\n                ruleStack: currRuleStack,\n                occurrenceStack: currOccurrenceStack,\n            };\n            possiblePaths.push(nextPath);\n        }\n        else if (prod instanceof RepetitionMandatoryWithSeparator) {\n            // TODO:(THE NEW operators here take a while...) (convert once?)\n            const separatorGast = new Terminal({\n                terminalType: prod.separator,\n            });\n            const secondIteration = new Repetition({\n                definition: [separatorGast].concat(prod.definition),\n                idx: prod.idx,\n            });\n            const nextDef = prod.definition.concat([secondIteration], currDef.slice(1));\n            const nextPath = {\n                idx: currIdx,\n                def: nextDef,\n                ruleStack: currRuleStack,\n                occurrenceStack: currOccurrenceStack,\n            };\n            possiblePaths.push(nextPath);\n        }\n        else if (prod instanceof RepetitionWithSeparator) {\n            // the order of alternatives is meaningful, FILO (Last path will be traversed first).\n            const nextPathWithout = {\n                idx: currIdx,\n                def: currDef.slice(1),\n                ruleStack: currRuleStack,\n                occurrenceStack: currOccurrenceStack,\n            };\n            possiblePaths.push(nextPathWithout);\n            // required marker to avoid backtracking paths whose higher priority alternatives already matched\n            possiblePaths.push(EXIT_ALTERNATIVE);\n            const separatorGast = new Terminal({\n                terminalType: prod.separator,\n            });\n            const nthRepetition = new Repetition({\n                definition: [separatorGast].concat(prod.definition),\n                idx: prod.idx,\n            });\n            const nextDef = prod.definition.concat([nthRepetition], currDef.slice(1));\n            const nextPathWith = {\n                idx: currIdx,\n                def: nextDef,\n                ruleStack: currRuleStack,\n                occurrenceStack: currOccurrenceStack,\n            };\n            possiblePaths.push(nextPathWith);\n        }\n        else if (prod instanceof Repetition) {\n            // the order of alternatives is meaningful, FILO (Last path will be traversed first).\n            const nextPathWithout = {\n                idx: currIdx,\n                def: currDef.slice(1),\n                ruleStack: currRuleStack,\n                occurrenceStack: currOccurrenceStack,\n            };\n            possiblePaths.push(nextPathWithout);\n            // required marker to avoid backtracking paths whose higher priority alternatives already matched\n            possiblePaths.push(EXIT_ALTERNATIVE);\n            // TODO: an empty repetition will cause infinite loops here, will the parser detect this in selfAnalysis?\n            const nthRepetition = new Repetition({\n                definition: prod.definition,\n                idx: prod.idx,\n            });\n            const nextDef = prod.definition.concat([nthRepetition], currDef.slice(1));\n            const nextPathWith = {\n                idx: currIdx,\n                def: nextDef,\n                ruleStack: currRuleStack,\n                occurrenceStack: currOccurrenceStack,\n            };\n            possiblePaths.push(nextPathWith);\n        }\n        else if (prod instanceof Alternation) {\n            // the order of alternatives is meaningful, FILO (Last path will be traversed first).\n            for (let i = prod.definition.length - 1; i >= 0; i--) {\n                const currAlt = prod.definition[i];\n                const currAltPath = {\n                    idx: currIdx,\n                    def: currAlt.definition.concat(currDef.slice(1)),\n                    ruleStack: currRuleStack,\n                    occurrenceStack: currOccurrenceStack,\n                };\n                possiblePaths.push(currAltPath);\n                possiblePaths.push(EXIT_ALTERNATIVE);\n            }\n        }\n        else if (prod instanceof Alternative) {\n            possiblePaths.push({\n                idx: currIdx,\n                def: prod.definition.concat(currDef.slice(1)),\n                ruleStack: currRuleStack,\n                occurrenceStack: currOccurrenceStack,\n            });\n        }\n        else if (prod instanceof Rule) {\n            // last because we should only encounter at most a single one of these per invocation.\n            possiblePaths.push(expandTopLevelRule(prod, currIdx, currRuleStack, currOccurrenceStack));\n        }\n        else {\n            throw Error(\"non exhaustive match\");\n        }\n    }\n    return result;\n}\nfunction expandTopLevelRule(topRule, currIdx, currRuleStack, currOccurrenceStack) {\n    const newRuleStack = [...currRuleStack];\n    newRuleStack.push(topRule.name);\n    const newCurrOccurrenceStack = [...currOccurrenceStack];\n    // top rule is always assumed to have been called with occurrence index 1\n    newCurrOccurrenceStack.push(1);\n    return {\n        idx: currIdx,\n        def: topRule.definition,\n        ruleStack: newRuleStack,\n        occurrenceStack: newCurrOccurrenceStack,\n    };\n}\n//# sourceMappingURL=interpreter.js.map"],"x_google_ignoreList":[0],"mappings":"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"}

package/lib/esm/node_modules/chevrotain/lib/src/parse/grammar/keys.js

@@ -1,8 +0,0 @@
-var e = 1024, t = 1280, n = 1536;
-function r(e, t, n) {
-	return n | t | e;
-}
-//#endregion
-export { e as AT_LEAST_ONE_IDX, n as AT_LEAST_ONE_SEP_IDX, t as MANY_SEP_IDX, r as getKeyForAutomaticLookahead };
-
-//# sourceMappingURL=keys.js.map

package/lib/esm/node_modules/chevrotain/lib/src/parse/grammar/keys.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"keys.js","names":[],"sources":["../../../../../../../../../../node_modules/chevrotain/lib/src/parse/grammar/keys.js"],"sourcesContent":["// Lookahead keys are 32Bit integers in the form\n// TTTTTTTT-ZZZZZZZZZZZZ-YYYY-XXXXXXXX\n// XXXX -> Occurrence Index bitmap.\n// YYYY -> DSL Method Type bitmap.\n// ZZZZZZZZZZZZZZZ -> Rule short Index bitmap.\n// TTTTTTTTT -> alternation alternative index bitmap\nexport const BITS_FOR_METHOD_TYPE = 4;\nexport const BITS_FOR_OCCURRENCE_IDX = 8;\nexport const BITS_FOR_RULE_IDX = 12;\n// TODO: validation, this means that there may at most 2^8 --> 256 alternatives for an alternation.\nexport const BITS_FOR_ALT_IDX = 8;\n// short string used as part of mapping keys.\n// being short improves the performance when composing KEYS for maps out of these\n// The 5 - 8 bits (16 possible values, are reserved for the DSL method indices)\nexport const OR_IDX = 1 << BITS_FOR_OCCURRENCE_IDX;\nexport const OPTION_IDX = 2 << BITS_FOR_OCCURRENCE_IDX;\nexport const MANY_IDX = 3 << BITS_FOR_OCCURRENCE_IDX;\nexport const AT_LEAST_ONE_IDX = 4 << BITS_FOR_OCCURRENCE_IDX;\nexport const MANY_SEP_IDX = 5 << BITS_FOR_OCCURRENCE_IDX;\nexport const AT_LEAST_ONE_SEP_IDX = 6 << BITS_FOR_OCCURRENCE_IDX;\n// this actually returns a number, but it is always used as a string (object prop key)\nexport function getKeyForAutomaticLookahead(ruleIdx, dslMethodIdx, occurrence) {\n    return occurrence | dslMethodIdx | ruleIdx;\n}\nconst BITS_START_FOR_ALT_IDX = 32 - BITS_FOR_ALT_IDX;\n//# sourceMappingURL=keys.js.map"],"x_google_ignoreList":[0],"mappings":"AAiBA,IAAa,IAAmB,MACnB,IAAe,MACf,IAAuB;AAEpC,SAAgB,EAA4B,GAAS,GAAc,GAAY;CAC3E,OAAO,IAAa,IAAe"}

package/lib/esm/node_modules/chevrotain/lib/src/parse/grammar/llk_lookahead.js

@@ -1,45 +0,0 @@
-import { defaultGrammarValidatorErrorProvider as e } from "../errors_public.js";
-import { buildAlternativesLookAheadFunc as t, buildLookaheadFuncForOptionalProd as n, buildLookaheadFuncForOr as r, buildSingleAlternativeLookaheadFunction as i, getProdType as a } from "./lookahead.js";
-import { validateAmbiguousAlternationAlternatives as o, validateEmptyOrAlternative as s, validateNoLeftRecursion as c, validateSomeNonEmptyLookaheadPath as l } from "./checks.js";
-import { DEFAULT_PARSER_CONFIG as u } from "../parser/parser.js";
-//#region ../../node_modules/chevrotain/lib/src/parse/grammar/llk_lookahead.js
-var d = class {
-	constructor(e) {
-		this.maxLookahead = e?.maxLookahead ?? u.maxLookahead;
-	}
-	validate(e) {
-		let t = this.validateNoLeftRecursion(e.rules);
-		if (t.length === 0) {
-			let n = this.validateEmptyOrAlternatives(e.rules), r = this.validateAmbiguousAlternationAlternatives(e.rules, this.maxLookahead), i = this.validateSomeNonEmptyLookaheadPath(e.rules, this.maxLookahead);
-			return [
-				...t,
-				...n,
-				...r,
-				...i
-			];
-		}
-		return t;
-	}
-	validateNoLeftRecursion(t) {
-		return t.flatMap((t) => c(t, t, e));
-	}
-	validateEmptyOrAlternatives(t) {
-		return t.flatMap((t) => s(t, e));
-	}
-	validateAmbiguousAlternationAlternatives(t, n) {
-		return t.flatMap((t) => o(t, n, e));
-	}
-	validateSomeNonEmptyLookaheadPath(t, n) {
-		return l(t, n, e);
-	}
-	buildLookaheadForAlternation(e) {
-		return r(e.prodOccurrence, e.rule, e.maxLookahead, e.hasPredicates, e.dynamicTokensEnabled, t);
-	}
-	buildLookaheadForOptional(e) {
-		return n(e.prodOccurrence, e.rule, e.maxLookahead, e.dynamicTokensEnabled, a(e.prodType), i);
-	}
-};
-//#endregion
-export { d as LLkLookaheadStrategy };
-
-//# sourceMappingURL=llk_lookahead.js.map

package/lib/esm/node_modules/chevrotain/lib/src/parse/grammar/llk_lookahead.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"llk_lookahead.js","names":[],"sources":["../../../../../../../../../../node_modules/chevrotain/lib/src/parse/grammar/llk_lookahead.js"],"sourcesContent":["import { defaultGrammarValidatorErrorProvider } from \"../errors_public.js\";\nimport { DEFAULT_PARSER_CONFIG } from \"../parser/parser.js\";\nimport { validateAmbiguousAlternationAlternatives, validateEmptyOrAlternative, validateNoLeftRecursion, validateSomeNonEmptyLookaheadPath, } from \"./checks.js\";\nimport { buildAlternativesLookAheadFunc, buildLookaheadFuncForOptionalProd, buildLookaheadFuncForOr, buildSingleAlternativeLookaheadFunction, getProdType, } from \"./lookahead.js\";\nexport class LLkLookaheadStrategy {\n    constructor(options) {\n        var _a;\n        this.maxLookahead =\n            (_a = options === null || options === void 0 ? void 0 : options.maxLookahead) !== null && _a !== void 0 ? _a : DEFAULT_PARSER_CONFIG.maxLookahead;\n    }\n    validate(options) {\n        const leftRecursionErrors = this.validateNoLeftRecursion(options.rules);\n        if (leftRecursionErrors.length === 0) {\n            const emptyAltErrors = this.validateEmptyOrAlternatives(options.rules);\n            const ambiguousAltsErrors = this.validateAmbiguousAlternationAlternatives(options.rules, this.maxLookahead);\n            const emptyRepetitionErrors = this.validateSomeNonEmptyLookaheadPath(options.rules, this.maxLookahead);\n            const allErrors = [\n                ...leftRecursionErrors,\n                ...emptyAltErrors,\n                ...ambiguousAltsErrors,\n                ...emptyRepetitionErrors,\n            ];\n            return allErrors;\n        }\n        return leftRecursionErrors;\n    }\n    validateNoLeftRecursion(rules) {\n        return rules.flatMap((currTopRule) => validateNoLeftRecursion(currTopRule, currTopRule, defaultGrammarValidatorErrorProvider));\n    }\n    validateEmptyOrAlternatives(rules) {\n        return rules.flatMap((currTopRule) => validateEmptyOrAlternative(currTopRule, defaultGrammarValidatorErrorProvider));\n    }\n    validateAmbiguousAlternationAlternatives(rules, maxLookahead) {\n        return rules.flatMap((currTopRule) => validateAmbiguousAlternationAlternatives(currTopRule, maxLookahead, defaultGrammarValidatorErrorProvider));\n    }\n    validateSomeNonEmptyLookaheadPath(rules, maxLookahead) {\n        return validateSomeNonEmptyLookaheadPath(rules, maxLookahead, defaultGrammarValidatorErrorProvider);\n    }\n    buildLookaheadForAlternation(options) {\n        return buildLookaheadFuncForOr(options.prodOccurrence, options.rule, options.maxLookahead, options.hasPredicates, options.dynamicTokensEnabled, buildAlternativesLookAheadFunc);\n    }\n    buildLookaheadForOptional(options) {\n        return buildLookaheadFuncForOptionalProd(options.prodOccurrence, options.rule, options.maxLookahead, options.dynamicTokensEnabled, getProdType(options.prodType), buildSingleAlternativeLookaheadFunction);\n    }\n}\n//# sourceMappingURL=llk_lookahead.js.map"],"x_google_ignoreList":[0],"mappings":";;;;;AAIA,IAAa,IAAb,MAAkC;CAC9B,YAAY,GAAS;EAEjB,KAAK,eACK,GAA0D,gBAA+C,EAAsB;;CAE7I,SAAS,GAAS;EACd,IAAM,IAAsB,KAAK,wBAAwB,EAAQ,MAAM;EACvE,IAAI,EAAoB,WAAW,GAAG;GAClC,IAAM,IAAiB,KAAK,4BAA4B,EAAQ,MAAM,EAChE,IAAsB,KAAK,yCAAyC,EAAQ,OAAO,KAAK,aAAa,EACrG,IAAwB,KAAK,kCAAkC,EAAQ,OAAO,KAAK,aAAa;GAOtG,OAAO;IALH,GAAG;IACH,GAAG;IACH,GAAG;IACH,GAAG;IAES;;EAEpB,OAAO;;CAEX,wBAAwB,GAAO;EAC3B,OAAO,EAAM,SAAS,MAAgB,EAAwB,GAAa,GAAa,EAAqC,CAAC;;CAElI,4BAA4B,GAAO;EAC/B,OAAO,EAAM,SAAS,MAAgB,EAA2B,GAAa,EAAqC,CAAC;;CAExH,yCAAyC,GAAO,GAAc;EAC1D,OAAO,EAAM,SAAS,MAAgB,EAAyC,GAAa,GAAc,EAAqC,CAAC;;CAEpJ,kCAAkC,GAAO,GAAc;EACnD,OAAO,EAAkC,GAAO,GAAc,EAAqC;;CAEvG,6BAA6B,GAAS;EAClC,OAAO,EAAwB,EAAQ,gBAAgB,EAAQ,MAAM,EAAQ,cAAc,EAAQ,eAAe,EAAQ,sBAAsB,EAA+B;;CAEnL,0BAA0B,GAAS;EAC/B,OAAO,EAAkC,EAAQ,gBAAgB,EAAQ,MAAM,EAAQ,cAAc,EAAQ,sBAAsB,EAAY,EAAQ,SAAS,EAAE,EAAwC"}

package/lib/esm/node_modules/chevrotain/lib/src/parse/grammar/lookahead.js

@@ -1,245 +0,0 @@
-import { Alternation as e, Alternative as t, Option as n, Repetition as r, RepetitionMandatory as i, RepetitionMandatoryWithSeparator as a, RepetitionWithSeparator as o } from "../../../../../@chevrotain/gast/lib/src/model.js";
-import { GAstVisitor as s } from "../../../../../@chevrotain/gast/lib/src/visitor.js";
-import { RestWalker as c } from "./rest.js";
-import { tokenStructuredMatcher as l, tokenStructuredMatcherNoCategories as u } from "../../scan/tokens.js";
-import { possiblePathsFrom as d } from "./interpreter.js";
-//#region ../../node_modules/chevrotain/lib/src/parse/grammar/lookahead.js
-var f;
-(function(e) {
-	e[e.OPTION = 0] = "OPTION", e[e.REPETITION = 1] = "REPETITION", e[e.REPETITION_MANDATORY = 2] = "REPETITION_MANDATORY", e[e.REPETITION_MANDATORY_WITH_SEPARATOR = 3] = "REPETITION_MANDATORY_WITH_SEPARATOR", e[e.REPETITION_WITH_SEPARATOR = 4] = "REPETITION_WITH_SEPARATOR", e[e.ALTERNATION = 5] = "ALTERNATION";
-})(f ||= {});
-function p(t) {
-	/* istanbul ignore else */
-	if (t instanceof n || t === "Option") return f.OPTION;
-	if (t instanceof r || t === "Repetition") return f.REPETITION;
-	if (t instanceof i || t === "RepetitionMandatory") return f.REPETITION_MANDATORY;
-	if (t instanceof a || t === "RepetitionMandatoryWithSeparator") return f.REPETITION_MANDATORY_WITH_SEPARATOR;
-	if (t instanceof o || t === "RepetitionWithSeparator") return f.REPETITION_WITH_SEPARATOR;
-	if (t instanceof e || t === "Alternation") return f.ALTERNATION;
-	throw Error("non exhaustive match");
-}
-function m(e) {
-	let { occurrence: t, rule: n, prodType: r, maxLookahead: i } = e, a = p(r);
-	return a === f.ALTERNATION ? T(t, n, i) : E(t, n, a, i);
-}
-function h(e, t, n, r, i, a) {
-	let o = T(e, t, n);
-	return a(o, r, k(o) ? u : l, i);
-}
-function g(e, t, n, r, i, a) {
-	let o = E(e, t, i, n), s = k(o) ? u : l;
-	return a(o[0], s, r);
-}
-function _(e, t, n, r) {
-	let i = e.length, a = e.every((e) => e.every((e) => e.length === 1));
-	if (t) return function(t) {
-		let r = t.map((e) => e.GATE);
-		for (let t = 0; t < i; t++) {
-			let i = e[t], a = i.length, o = r[t];
-			if (!(o !== void 0 && o.call(this) === !1)) nextPath: for (let e = 0; e < a; e++) {
-				let r = i[e], a = r.length;
-				for (let e = 0; e < a; e++) if (n(this.LA_FAST(e + 1), r[e]) === !1) continue nextPath;
-				return t;
-			}
-		}
-	};
-	if (a && !r) {
-		let t = e.map((e) => e.flat()).reduce((e, t, n) => (t.forEach((t) => {
-			t.tokenTypeIdx in e || (e[t.tokenTypeIdx] = n), t.categoryMatches.forEach((t) => {
-				Object.hasOwn(e, t) || (e[t] = n);
-			});
-		}), e), {});
-		return function() {
-			return t[this.LA_FAST(1).tokenTypeIdx];
-		};
-	} else return function() {
-		for (let t = 0; t < i; t++) {
-			let r = e[t], i = r.length;
-			nextPath: for (let e = 0; e < i; e++) {
-				let i = r[e], a = i.length;
-				for (let e = 0; e < a; e++) if (n(this.LA_FAST(e + 1), i[e]) === !1) continue nextPath;
-				return t;
-			}
-		}
-	};
-}
-function v(e, t, n) {
-	let r = e.every((e) => e.length === 1), i = e.length;
-	if (r && !n) {
-		let t = e.flat();
-		if (t.length === 1 && t[0].categoryMatches.length === 0) {
-			let e = t[0].tokenTypeIdx;
-			return function() {
-				return this.LA_FAST(1).tokenTypeIdx === e;
-			};
-		} else {
-			let e = t.reduce((e, t, n) => (e[t.tokenTypeIdx] = !0, t.categoryMatches.forEach((t) => {
-				e[t] = !0;
-			}), e), []);
-			return function() {
-				return e[this.LA_FAST(1).tokenTypeIdx] === !0;
-			};
-		}
-	} else return function() {
-		nextPath: for (let n = 0; n < i; n++) {
-			let r = e[n], i = r.length;
-			for (let e = 0; e < i; e++) if (t(this.LA_FAST(e + 1), r[e]) === !1) continue nextPath;
-			return !0;
-		}
-		return !1;
-	};
-}
-var y = class extends c {
-	constructor(e, t, n) {
-		super(), this.topProd = e, this.targetOccurrence = t, this.targetProdType = n;
-	}
-	startWalking() {
-		return this.walk(this.topProd), this.restDef;
-	}
-	checkIsTarget(e, t, n, r) {
-		return e.idx === this.targetOccurrence && this.targetProdType === t ? (this.restDef = n.concat(r), !0) : !1;
-	}
-	walkOption(e, t, n) {
-		this.checkIsTarget(e, f.OPTION, t, n) || super.walkOption(e, t, n);
-	}
-	walkAtLeastOne(e, t, n) {
-		this.checkIsTarget(e, f.REPETITION_MANDATORY, t, n) || super.walkOption(e, t, n);
-	}
-	walkAtLeastOneSep(e, t, n) {
-		this.checkIsTarget(e, f.REPETITION_MANDATORY_WITH_SEPARATOR, t, n) || super.walkOption(e, t, n);
-	}
-	walkMany(e, t, n) {
-		this.checkIsTarget(e, f.REPETITION, t, n) || super.walkOption(e, t, n);
-	}
-	walkManySep(e, t, n) {
-		this.checkIsTarget(e, f.REPETITION_WITH_SEPARATOR, t, n) || super.walkOption(e, t, n);
-	}
-}, b = class extends s {
-	constructor(e, t, n) {
-		super(), this.targetOccurrence = e, this.targetProdType = t, this.targetRef = n, this.result = [];
-	}
-	checkIsTarget(e, t) {
-		e.idx === this.targetOccurrence && this.targetProdType === t && (this.targetRef === void 0 || e === this.targetRef) && (this.result = e.definition);
-	}
-	visitOption(e) {
-		this.checkIsTarget(e, f.OPTION);
-	}
-	visitRepetition(e) {
-		this.checkIsTarget(e, f.REPETITION);
-	}
-	visitRepetitionMandatory(e) {
-		this.checkIsTarget(e, f.REPETITION_MANDATORY);
-	}
-	visitRepetitionMandatoryWithSeparator(e) {
-		this.checkIsTarget(e, f.REPETITION_MANDATORY_WITH_SEPARATOR);
-	}
-	visitRepetitionWithSeparator(e) {
-		this.checkIsTarget(e, f.REPETITION_WITH_SEPARATOR);
-	}
-	visitAlternation(e) {
-		this.checkIsTarget(e, f.ALTERNATION);
-	}
-};
-function x(e) {
-	let t = Array(e);
-	for (let n = 0; n < e; n++) t[n] = [];
-	return t;
-}
-function S(e) {
-	let t = [""];
-	for (let n = 0; n < e.length; n++) {
-		let r = e[n], i = [];
-		for (let e = 0; e < t.length; e++) {
-			let n = t[e];
-			i.push(n + "_" + r.tokenTypeIdx);
-			for (let e = 0; e < r.categoryMatches.length; e++) {
-				let t = "_" + r.categoryMatches[e];
-				i.push(n + t);
-			}
-		}
-		t = i;
-	}
-	return t;
-}
-function C(e, t, n) {
-	for (let r = 0; r < e.length; r++) {
-		if (r === n) continue;
-		let i = e[r];
-		for (let e = 0; e < t.length; e++) if (i[t[e]] === !0) return !1;
-	}
-	return !0;
-}
-function w(e, t) {
-	let n = e.map((e) => d([e], 1)), r = x(n.length), i = n.map((e) => {
-		let t = {};
-		return e.forEach((e) => {
-			S(e.partialPath).forEach((e) => {
-				t[e] = !0;
-			});
-		}), t;
-	}), a = n;
-	for (let e = 1; e <= t; e++) {
-		let n = a;
-		a = x(n.length);
-		for (let o = 0; o < n.length; o++) {
-			let s = n[o];
-			for (let n = 0; n < s.length; n++) {
-				let c = s[n].partialPath, l = s[n].suffixDef, u = S(c);
-				if (C(i, u, o) || l.length === 0 || c.length === t) {
-					let e = r[o];
-					if (D(e, c) === !1) {
-						e.push(c);
-						for (let e = 0; e < u.length; e++) {
-							let t = u[e];
-							i[o][t] = !0;
-						}
-					}
-				} else {
-					let t = d(l, e + 1, c);
-					a[o] = a[o].concat(t), t.forEach((e) => {
-						S(e.partialPath).forEach((e) => {
-							i[o][e] = !0;
-						});
-					});
-				}
-			}
-		}
-	}
-	return r;
-}
-function T(e, t, n, r) {
-	let i = new b(e, f.ALTERNATION, r);
-	return t.accept(i), w(i.result, n);
-}
-function E(e, n, r, i) {
-	let a = new b(e, r);
-	n.accept(a);
-	let o = a.result, s = new y(n, e, r).startWalking();
-	return w([new t({ definition: o }), new t({ definition: s })], i);
-}
-function D(e, t) {
-	compareOtherPath: for (let n = 0; n < e.length; n++) {
-		let r = e[n];
-		if (r.length === t.length) {
-			for (let e = 0; e < r.length; e++) {
-				let n = t[e], i = r[e];
-				if (!(n === i || i.categoryMatchesMap[n.tokenTypeIdx] !== void 0)) continue compareOtherPath;
-			}
-			return !0;
-		}
-	}
-	return !1;
-}
-function O(e, t) {
-	return e.length < t.length && e.every((e, n) => {
-		let r = t[n];
-		return e === r || r.categoryMatchesMap[e.tokenTypeIdx];
-	});
-}
-function k(e) {
-	return e.every((e) => e.every((e) => e.every((e) => e.categoryMatches.length === 0)));
-}
-//#endregion
-export { f as PROD_TYPE, _ as buildAlternativesLookAheadFunc, g as buildLookaheadFuncForOptionalProd, h as buildLookaheadFuncForOr, v as buildSingleAlternativeLookaheadFunction, D as containsPath, m as getLookaheadPaths, E as getLookaheadPathsForOptionalProd, T as getLookaheadPathsForOr, p as getProdType, O as isStrictPrefixOfPath };
-
-//# sourceMappingURL=lookahead.js.map