@loopstack/loopstack-studio 0.20.2 → 0.21.0-rc.0

package/dist/node_modules/chevrotain/lib/src/parse/grammar/checks.js

@@ -0,0 +1,299 @@
+import isEmpty_default from "../../../../../lodash-es/isEmpty.js";
+import flatten_default from "../../../../../lodash-es/flatten.js";
+import clone_default from "../../../../../lodash-es/clone.js";
+import compact_default from "../../../../../lodash-es/compact.js";
+import difference_default from "../../../../../lodash-es/difference.js";
+import drop_default from "../../../../../lodash-es/drop.js";
+import dropRight_default from "../../../../../lodash-es/dropRight.js";
+import forEach_default from "../../../../../lodash-es/forEach.js";
+import filter_default from "../../../../../lodash-es/filter.js";
+import head_default from "../../../../../lodash-es/head.js";
+import map_default from "../../../../../lodash-es/map.js";
+import flatMap_default from "../../../../../lodash-es/flatMap.js";
+import groupBy_default from "../../../../../lodash-es/groupBy.js";
+import values_default from "../../../../../lodash-es/values.js";
+import includes_default from "../../../../../lodash-es/includes.js";
+import pickBy_default from "../../../../../lodash-es/pickBy.js";
+import reduce_default from "../../../../../lodash-es/reduce.js";
+import reject_default from "../../../../../lodash-es/reject.js";
+import { Alternation, Alternative, NonTerminal, Option, Repetition, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Terminal } from "../../../../../@chevrotain/gast/lib/src/model.js";
+import { GAstVisitor } from "../../../../../@chevrotain/gast/lib/src/visitor.js";
+import { getProductionDslName, isOptionalProd } from "../../../../../@chevrotain/gast/lib/src/helpers.js";
+import { tokenStructuredMatcher } from "../../scan/tokens.js";
+import { nextPossibleTokensAfter } from "./interpreter.js";
+import { containsPath, getLookaheadPathsForOptionalProd, getLookaheadPathsForOr, getProdType, isStrictPrefixOfPath } from "./lookahead.js";
+import { ParserDefinitionErrorType } from "../parser/parser.js";
+function validateLookahead(h) {
+	return map_default(h.lookaheadStrategy.validate({
+		rules: h.rules,
+		tokenTypes: h.tokenTypes,
+		grammarName: h.grammarName
+	}), (h) => Object.assign({ type: ParserDefinitionErrorType.CUSTOM_LOOKAHEAD_VALIDATION }, h));
+}
+function validateGrammar(h, W, G, K) {
+	let q = flatMap_default(h, (h) => validateDuplicateProductions(h, G)), J = checkTerminalAndNoneTerminalsNameSpace(h, W, G), Y = flatMap_default(h, (h) => validateTooManyAlts(h, G)), X = flatMap_default(h, (W) => validateRuleDoesNotAlreadyExist(W, h, K, G));
+	return q.concat(J, Y, X);
+}
+function validateDuplicateProductions(h, W) {
+	let G = new OccurrenceValidationCollector();
+	h.accept(G);
+	let K = G.allProductions;
+	return map_default(values_default(pickBy_default(groupBy_default(K, identifyProductionForDuplicates), (h) => h.length > 1)), (G) => {
+		let K = head_default(G), q = W.buildDuplicateFoundError(h, G), J = getProductionDslName(K), Y = {
+			message: q,
+			type: ParserDefinitionErrorType.DUPLICATE_PRODUCTIONS,
+			ruleName: h.name,
+			dslName: J,
+			occurrence: K.idx
+		}, X = getExtraProductionArgument(K);
+		return X && (Y.parameter = X), Y;
+	});
+}
+function identifyProductionForDuplicates(h) {
+	return `${getProductionDslName(h)}_#_${h.idx}_#_${getExtraProductionArgument(h)}`;
+}
+function getExtraProductionArgument(h) {
+	return h instanceof Terminal ? h.terminalType.name : h instanceof NonTerminal ? h.nonTerminalName : "";
+}
+var OccurrenceValidationCollector = class extends GAstVisitor {
+	constructor() {
+		super(...arguments), this.allProductions = [];
+	}
+	visitNonTerminal(h) {
+		this.allProductions.push(h);
+	}
+	visitOption(h) {
+		this.allProductions.push(h);
+	}
+	visitRepetitionWithSeparator(h) {
+		this.allProductions.push(h);
+	}
+	visitRepetitionMandatory(h) {
+		this.allProductions.push(h);
+	}
+	visitRepetitionMandatoryWithSeparator(h) {
+		this.allProductions.push(h);
+	}
+	visitRepetition(h) {
+		this.allProductions.push(h);
+	}
+	visitAlternation(h) {
+		this.allProductions.push(h);
+	}
+	visitTerminal(h) {
+		this.allProductions.push(h);
+	}
+};
+function validateRuleDoesNotAlreadyExist(h, W, G, K) {
+	let q = [];
+	if (reduce_default(W, (W, G) => G.name === h.name ? W + 1 : W, 0) > 1) {
+		let W = K.buildDuplicateRuleNameError({
+			topLevelRule: h,
+			grammarName: G
+		});
+		q.push({
+			message: W,
+			type: ParserDefinitionErrorType.DUPLICATE_RULE_NAME,
+			ruleName: h.name
+		});
+	}
+	return q;
+}
+function validateRuleIsOverridden(h, W, G) {
+	let K = [], q;
+	return includes_default(W, h) || (q = `Invalid rule override, rule: ->${h}<- cannot be overridden in the grammar: ->${G}<-as it is not defined in any of the super grammars `, K.push({
+		message: q,
+		type: ParserDefinitionErrorType.INVALID_RULE_OVERRIDE,
+		ruleName: h
+	})), K;
+}
+function validateNoLeftRecursion(W, K, J, Y = []) {
+	let X = [], Z = getFirstNoneTerminal(K.definition);
+	if (isEmpty_default(Z)) return [];
+	{
+		let h = W.name;
+		includes_default(Z, W) && X.push({
+			message: J.buildLeftRecursionError({
+				topLevelRule: W,
+				leftRecursionPath: Y
+			}),
+			type: ParserDefinitionErrorType.LEFT_RECURSION,
+			ruleName: h
+		});
+		let K = flatMap_default(difference_default(Z, Y.concat([W])), (h) => {
+			let K = clone_default(Y);
+			return K.push(h), validateNoLeftRecursion(W, h, J, K);
+		});
+		return X.concat(K);
+	}
+}
+function getFirstNoneTerminal(G) {
+	let K = [];
+	if (isEmpty_default(G)) return K;
+	let q = head_default(G);
+	/* istanbul ignore else */
+	if (q instanceof NonTerminal) K.push(q.referencedRule);
+	else if (q instanceof Alternative || q instanceof Option || q instanceof RepetitionMandatory || q instanceof RepetitionMandatoryWithSeparator || q instanceof RepetitionWithSeparator || q instanceof Repetition) K = K.concat(getFirstNoneTerminal(q.definition));
+	else if (q instanceof Alternation) K = flatten_default(map_default(q.definition, (h) => getFirstNoneTerminal(h.definition)));
+	else if (!(q instanceof Terminal)) throw Error("non exhaustive match");
+	let Y = isOptionalProd(q), X = G.length > 1;
+	if (Y && X) {
+		let h = drop_default(G);
+		return K.concat(getFirstNoneTerminal(h));
+	} else return K;
+}
+var OrCollector = class extends GAstVisitor {
+	constructor() {
+		super(...arguments), this.alternations = [];
+	}
+	visitAlternation(h) {
+		this.alternations.push(h);
+	}
+};
+function validateEmptyOrAlternative(W, G) {
+	let K = new OrCollector();
+	W.accept(K);
+	let q = K.alternations;
+	return flatMap_default(q, (K) => flatMap_default(dropRight_default(K.definition), (q, J) => isEmpty_default(nextPossibleTokensAfter([q], [], tokenStructuredMatcher, 1)) ? [{
+		message: G.buildEmptyAlternationError({
+			topLevelRule: W,
+			alternation: K,
+			emptyChoiceIdx: J
+		}),
+		type: ParserDefinitionErrorType.NONE_LAST_EMPTY_ALT,
+		ruleName: W.name,
+		occurrence: K.idx,
+		alternative: J + 1
+	}] : []));
+}
+function validateAmbiguousAlternationAlternatives(h, W, G) {
+	let K = new OrCollector();
+	h.accept(K);
+	let q = K.alternations;
+	return q = reject_default(q, (h) => h.ignoreAmbiguities === !0), flatMap_default(q, (K) => {
+		let q = K.idx, J = getLookaheadPathsForOr(q, h, K.maxLookahead || W, K), Y = checkAlternativesAmbiguities(J, K, h, G), X = checkPrefixAlternativesAmbiguities(J, K, h, G);
+		return Y.concat(X);
+	});
+}
+var RepetitionCollector = class extends GAstVisitor {
+	constructor() {
+		super(...arguments), this.allProductions = [];
+	}
+	visitRepetitionWithSeparator(h) {
+		this.allProductions.push(h);
+	}
+	visitRepetitionMandatory(h) {
+		this.allProductions.push(h);
+	}
+	visitRepetitionMandatoryWithSeparator(h) {
+		this.allProductions.push(h);
+	}
+	visitRepetition(h) {
+		this.allProductions.push(h);
+	}
+};
+function validateTooManyAlts(h, W) {
+	let G = new OrCollector();
+	h.accept(G);
+	let K = G.alternations;
+	return flatMap_default(K, (G) => G.definition.length > 255 ? [{
+		message: W.buildTooManyAlternativesError({
+			topLevelRule: h,
+			alternation: G
+		}),
+		type: ParserDefinitionErrorType.TOO_MANY_ALTS,
+		ruleName: h.name,
+		occurrence: G.idx
+	}] : []);
+}
+function validateSomeNonEmptyLookaheadPath(G, K, q) {
+	let J = [];
+	return forEach_default(G, (G) => {
+		let Y = new RepetitionCollector();
+		G.accept(Y);
+		let Z = Y.allProductions;
+		forEach_default(Z, (Y) => {
+			let X = getProdType(Y), Z = Y.maxLookahead || K, Q = Y.idx, $ = getLookaheadPathsForOptionalProd(Q, G, X, Z)[0];
+			if (isEmpty_default(flatten_default($))) {
+				let h = q.buildEmptyRepetitionError({
+					topLevelRule: G,
+					repetition: Y
+				});
+				J.push({
+					message: h,
+					type: ParserDefinitionErrorType.NO_NON_EMPTY_LOOKAHEAD,
+					ruleName: G.name
+				});
+			}
+		});
+	}), J;
+}
+function checkAlternativesAmbiguities(h, W, G, K) {
+	let q = [];
+	return map_default(reduce_default(h, (G, K, J) => (W.definition[J].ignoreAmbiguities === !0 || forEach_default(K, (K) => {
+		let Y = [J];
+		forEach_default(h, (h, G) => {
+			J !== G && containsPath(h, K) && W.definition[G].ignoreAmbiguities !== !0 && Y.push(G);
+		}), Y.length > 1 && !containsPath(q, K) && (q.push(K), G.push({
+			alts: Y,
+			path: K
+		}));
+	}), G), []), (h) => {
+		let q = map_default(h.alts, (h) => h + 1);
+		return {
+			message: K.buildAlternationAmbiguityError({
+				topLevelRule: G,
+				alternation: W,
+				ambiguityIndices: q,
+				prefixPath: h.path
+			}),
+			type: ParserDefinitionErrorType.AMBIGUOUS_ALTS,
+			ruleName: G.name,
+			occurrence: W.idx,
+			alternatives: h.alts
+		};
+	});
+}
+function checkPrefixAlternativesAmbiguities(h, W, G, q) {
+	let J = reduce_default(h, (h, W, G) => {
+		let K = map_default(W, (h) => ({
+			idx: G,
+			path: h
+		}));
+		return h.concat(K);
+	}, []);
+	return compact_default(flatMap_default(J, (h) => {
+		if (W.definition[h.idx].ignoreAmbiguities === !0) return [];
+		let K = h.idx, Y = h.path;
+		return map_default(filter_default(J, (h) => W.definition[h.idx].ignoreAmbiguities !== !0 && h.idx < K && isStrictPrefixOfPath(h.path, Y)), (h) => {
+			let J = [h.idx + 1, K + 1], Y = W.idx === 0 ? "" : W.idx;
+			return {
+				message: q.buildAlternationPrefixAmbiguityError({
+					topLevelRule: G,
+					alternation: W,
+					ambiguityIndices: J,
+					prefixPath: h.path
+				}),
+				type: ParserDefinitionErrorType.AMBIGUOUS_PREFIX_ALTS,
+				ruleName: G.name,
+				occurrence: Y,
+				alternatives: J
+			};
+		});
+	}));
+}
+function checkTerminalAndNoneTerminalsNameSpace(h, W, G) {
+	let K = [], q = map_default(W, (h) => h.name);
+	return forEach_default(h, (h) => {
+		let W = h.name;
+		if (includes_default(q, W)) {
+			let q = G.buildNamespaceConflictError(h);
+			K.push({
+				message: q,
+				type: ParserDefinitionErrorType.CONFLICT_TOKENS_RULES_NAMESPACE,
+				ruleName: W
+			});
+		}
+	}), K;
+}
+export { validateAmbiguousAlternationAlternatives, validateEmptyOrAlternative, validateGrammar, validateLookahead, validateNoLeftRecursion, validateRuleIsOverridden, validateSomeNonEmptyLookaheadPath };

package/dist/node_modules/chevrotain/lib/src/parse/grammar/first.js

@@ -0,0 +1,25 @@
+import flatten_default from "../../../../../lodash-es/flatten.js";
+import map_default from "../../../../../lodash-es/map.js";
+import uniq_default from "../../../../../lodash-es/uniq.js";
+import { NonTerminal, Terminal } from "../../../../../@chevrotain/gast/lib/src/model.js";
+import { isBranchingProd, isOptionalProd, isSequenceProd } from "../../../../../@chevrotain/gast/lib/src/helpers.js";
+function first(e) {
+	/* istanbul ignore else */
+	if (e instanceof NonTerminal) return first(e.referencedRule);
+	if (e instanceof Terminal) return firstForTerminal(e);
+	if (isSequenceProd(e)) return firstForSequence(e);
+	if (isBranchingProd(e)) return firstForBranching(e);
+	throw Error("non exhaustive match");
+}
+function firstForSequence(e) {
+	let o = [], s = e.definition, c = 0, l = s.length > c, u, d = !0;
+	for (; l && d;) u = s[c], d = isOptionalProd(u), o = o.concat(first(u)), c += 1, l = s.length > c;
+	return uniq_default(o);
+}
+function firstForBranching(s) {
+	return uniq_default(flatten_default(map_default(s.definition, (e) => first(e))));
+}
+function firstForTerminal(e) {
+	return [e.terminalType];
+}
+export { first };

package/dist/node_modules/chevrotain/lib/src/parse/grammar/follow.js

@@ -0,0 +1,29 @@
+import assign_default from "../../../../../lodash-es/assign.js";
+import forEach_default from "../../../../../lodash-es/forEach.js";
+import { Alternative } from "../../../../../@chevrotain/gast/lib/src/model.js";
+import { RestWalker } from "./rest.js";
+import { first } from "./first.js";
+import { IN } from "../constants.js";
+var ResyncFollowsWalker = class extends RestWalker {
+	constructor(e) {
+		super(), this.topProd = e, this.follows = {};
+	}
+	startWalking() {
+		return this.walk(this.topProd), this.follows;
+	}
+	walkTerminal(e, i, a) {}
+	walkProdRef(e, i, o) {
+		let s = buildBetweenProdsFollowPrefix(e.referencedRule, e.idx) + this.topProd.name, c = first(new Alternative({ definition: i.concat(o) }));
+		this.follows[s] = c;
+	}
+};
+function computeAllProdsFollows(a) {
+	let o = {};
+	return forEach_default(a, (i) => {
+		assign_default(o, new ResyncFollowsWalker(i).startWalking());
+	}), o;
+}
+function buildBetweenProdsFollowPrefix(e, i) {
+	return e.name + i + IN;
+}
+export { computeAllProdsFollows };

package/dist/node_modules/chevrotain/lib/src/parse/grammar/gast/gast_resolver_public.js

@@ -0,0 +1,15 @@
+import defaults_default from "../../../../../../lodash-es/defaults.js";
+import forEach_default from "../../../../../../lodash-es/forEach.js";
+import { defaultGrammarResolverErrorProvider, defaultGrammarValidatorErrorProvider } from "../../errors_public.js";
+import { resolveGrammar } from "../resolver.js";
+import { validateGrammar } from "../checks.js";
+function resolveGrammar$1(a) {
+	let o = defaults_default(a, { errMsgProvider: defaultGrammarResolverErrorProvider }), s = {};
+	return forEach_default(a.rules, (e) => {
+		s[e.name] = e;
+	}), resolveGrammar(s, o.errMsgProvider);
+}
+function validateGrammar$1(i) {
+	return i = defaults_default(i, { errMsgProvider: defaultGrammarValidatorErrorProvider }), validateGrammar(i.rules, i.tokenTypes, i.errMsgProvider, i.grammarName);
+}
+export { resolveGrammar$1 as resolveGrammar, validateGrammar$1 as validateGrammar };

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

@@ -0,0 +1,269 @@
+import isEmpty_default from "../../../../../lodash-es/isEmpty.js";
+import clone_default from "../../../../../lodash-es/clone.js";
+import last_default from "../../../../../lodash-es/last.js";
+import drop_default from "../../../../../lodash-es/drop.js";
+import dropRight_default from "../../../../../lodash-es/dropRight.js";
+import forEach_default from "../../../../../lodash-es/forEach.js";
+import head_default from "../../../../../lodash-es/head.js";
+import { Alternation, Alternative, NonTerminal, Option, Repetition, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Rule, Terminal } from "../../../../../@chevrotain/gast/lib/src/model.js";
+import { RestWalker } from "./rest.js";
+import { first } from "./first.js";
+var AbstractNextPossibleTokensWalker = class extends RestWalker {
+	constructor(e, d) {
+		super(), this.topProd = e, this.path = d, 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 = clone_default(this.path.ruleStack).reverse(), this.occurrenceStack = clone_default(this.path.occurrenceStack).reverse(), this.ruleStack.pop(), this.occurrenceStack.pop(), this.updateExpectedNext(), this.walk(this.topProd), this.possibleTokTypes;
+	}
+	walk(e, d = []) {
+		this.found || super.walk(e, d);
+	}
+	walkProdRef(e, d, f) {
+		if (e.referencedRule.name === this.nextProductionName && e.idx === this.nextProductionOccurrence) {
+			let p = d.concat(f);
+			this.updateExpectedNext(), this.walk(e.referencedRule, p);
+		}
+	}
+	updateExpectedNext() {
+		isEmpty_default(this.ruleStack) ? (this.nextProductionName = "", this.nextProductionOccurrence = 0, this.isAtEndOfPath = !0) : (this.nextProductionName = this.ruleStack.pop(), this.nextProductionOccurrence = this.occurrenceStack.pop());
+	}
+}, NextAfterTokenWalker = class extends AbstractNextPossibleTokensWalker {
+	constructor(e, d) {
+		super(e, d), this.path = d, this.nextTerminalName = "", this.nextTerminalOccurrence = 0, this.nextTerminalName = this.path.lastTok.name, this.nextTerminalOccurrence = this.path.lastTokOccurrence;
+	}
+	walkTerminal(e, d, f) {
+		this.isAtEndOfPath && e.terminalType.name === this.nextTerminalName && e.idx === this.nextTerminalOccurrence && !this.found && (this.possibleTokTypes = first(new Alternative({ definition: d.concat(f) })), this.found = !0);
+	}
+}, AbstractNextTerminalAfterProductionWalker = class extends RestWalker {
+	constructor(e, d) {
+		super(), this.topRule = e, this.occurrence = d, this.result = {
+			token: void 0,
+			occurrence: void 0,
+			isEndOfRule: void 0
+		};
+	}
+	startWalking() {
+		return this.walk(this.topRule), this.result;
+	}
+}, NextTerminalAfterManyWalker = class extends AbstractNextTerminalAfterProductionWalker {
+	walkMany(e, d, f) {
+		if (e.idx === this.occurrence) {
+			let e = head_default(d.concat(f));
+			this.result.isEndOfRule = e === void 0, e instanceof Terminal && (this.result.token = e.terminalType, this.result.occurrence = e.idx);
+		} else super.walkMany(e, d, f);
+	}
+}, NextTerminalAfterManySepWalker = class extends AbstractNextTerminalAfterProductionWalker {
+	walkManySep(e, d, f) {
+		if (e.idx === this.occurrence) {
+			let e = head_default(d.concat(f));
+			this.result.isEndOfRule = e === void 0, e instanceof Terminal && (this.result.token = e.terminalType, this.result.occurrence = e.idx);
+		} else super.walkManySep(e, d, f);
+	}
+}, NextTerminalAfterAtLeastOneWalker = class extends AbstractNextTerminalAfterProductionWalker {
+	walkAtLeastOne(e, d, f) {
+		if (e.idx === this.occurrence) {
+			let e = head_default(d.concat(f));
+			this.result.isEndOfRule = e === void 0, e instanceof Terminal && (this.result.token = e.terminalType, this.result.occurrence = e.idx);
+		} else super.walkAtLeastOne(e, d, f);
+	}
+}, NextTerminalAfterAtLeastOneSepWalker = class extends AbstractNextTerminalAfterProductionWalker {
+	walkAtLeastOneSep(e, d, f) {
+		if (e.idx === this.occurrence) {
+			let e = head_default(d.concat(f));
+			this.result.isEndOfRule = e === void 0, e instanceof Terminal && (this.result.token = e.terminalType, this.result.occurrence = e.idx);
+		} else super.walkAtLeastOneSep(e, d, f);
+	}
+};
+function possiblePathsFrom(f, m, g = []) {
+	g = clone_default(g);
+	let _ = [], v = 0;
+	function y(e) {
+		return e.concat(drop_default(f, v + 1));
+	}
+	function b(e) {
+		let d = possiblePathsFrom(y(e), m, g);
+		return _.concat(d);
+	}
+	for (; g.length < m && v < f.length;) {
+		let d = f[v];
+		if (d instanceof Alternative || d instanceof NonTerminal) return b(d.definition);
+		if (d instanceof Option) _ = b(d.definition);
+		else if (d instanceof RepetitionMandatory) return b(d.definition.concat([new Repetition({ definition: d.definition })]));
+		else if (d instanceof RepetitionMandatoryWithSeparator) return b([new Alternative({ definition: d.definition }), new Repetition({ definition: [new Terminal({ terminalType: d.separator })].concat(d.definition) })]);
+		else if (d instanceof RepetitionWithSeparator) _ = b(d.definition.concat([new Repetition({ definition: [new Terminal({ terminalType: d.separator })].concat(d.definition) })]));
+		else if (d instanceof Repetition) _ = b(d.definition.concat([new Repetition({ definition: d.definition })]));
+		else if (d instanceof Alternation) return forEach_default(d.definition, (d) => {
+			isEmpty_default(d.definition) === !1 && (_ = b(d.definition));
+		}), _;
+		else if (d instanceof Terminal) g.push(d.terminalType);
+		else throw Error("non exhaustive match");
+		v++;
+	}
+	return _.push({
+		partialPath: g,
+		suffixDef: drop_default(f, v)
+	}), _;
+}
+function nextPossibleTokensAfter(h, g, v, y) {
+	let b = "EXIT_NONE_TERMINAL", x = [b], S = "EXIT_ALTERNATIVE", C = !1, w = g.length, T = w - y - 1, E = [], D = [];
+	for (D.push({
+		idx: -1,
+		def: h,
+		ruleStack: [],
+		occurrenceStack: []
+	}); !isEmpty_default(D);) {
+		let h = D.pop();
+		if (h === S) {
+			C && last_default(D).idx <= T && D.pop();
+			continue;
+		}
+		let y = h.def, O = h.idx, k = h.ruleStack, A = h.occurrenceStack;
+		if (isEmpty_default(y)) continue;
+		let j = y[0];
+		/* istanbul ignore else */
+		if (j === b) {
+			let e = {
+				idx: O,
+				def: drop_default(y),
+				ruleStack: dropRight_default(k),
+				occurrenceStack: dropRight_default(A)
+			};
+			D.push(e);
+		} else if (j instanceof Terminal)
+ /* istanbul ignore else */
+		if (O < w - 1) {
+			let e = O + 1, d = g[e];
+			if (v(d, j.terminalType)) {
+				let d = {
+					idx: e,
+					def: drop_default(y),
+					ruleStack: k,
+					occurrenceStack: A
+				};
+				D.push(d);
+			}
+		} else if (O === w - 1) E.push({
+			nextTokenType: j.terminalType,
+			nextTokenOccurrence: j.idx,
+			ruleStack: k,
+			occurrenceStack: A
+		}), C = !0;
+		else throw Error("non exhaustive match");
+		else if (j instanceof NonTerminal) {
+			let e = clone_default(k);
+			e.push(j.nonTerminalName);
+			let f = clone_default(A);
+			f.push(j.idx);
+			let m = {
+				idx: O,
+				def: j.definition.concat(x, drop_default(y)),
+				ruleStack: e,
+				occurrenceStack: f
+			};
+			D.push(m);
+		} else if (j instanceof Option) {
+			let e = {
+				idx: O,
+				def: drop_default(y),
+				ruleStack: k,
+				occurrenceStack: A
+			};
+			D.push(e), D.push(S);
+			let d = {
+				idx: O,
+				def: j.definition.concat(drop_default(y)),
+				ruleStack: k,
+				occurrenceStack: A
+			};
+			D.push(d);
+		} else if (j instanceof RepetitionMandatory) {
+			let e = new Repetition({
+				definition: j.definition,
+				idx: j.idx
+			}), d = {
+				idx: O,
+				def: j.definition.concat([e], drop_default(y)),
+				ruleStack: k,
+				occurrenceStack: A
+			};
+			D.push(d);
+		} else if (j instanceof RepetitionMandatoryWithSeparator) {
+			let e = new Repetition({
+				definition: [new Terminal({ terminalType: j.separator })].concat(j.definition),
+				idx: j.idx
+			}), d = {
+				idx: O,
+				def: j.definition.concat([e], drop_default(y)),
+				ruleStack: k,
+				occurrenceStack: A
+			};
+			D.push(d);
+		} else if (j instanceof RepetitionWithSeparator) {
+			let e = {
+				idx: O,
+				def: drop_default(y),
+				ruleStack: k,
+				occurrenceStack: A
+			};
+			D.push(e), D.push(S);
+			let d = new Repetition({
+				definition: [new Terminal({ terminalType: j.separator })].concat(j.definition),
+				idx: j.idx
+			}), f = {
+				idx: O,
+				def: j.definition.concat([d], drop_default(y)),
+				ruleStack: k,
+				occurrenceStack: A
+			};
+			D.push(f);
+		} else if (j instanceof Repetition) {
+			let e = {
+				idx: O,
+				def: drop_default(y),
+				ruleStack: k,
+				occurrenceStack: A
+			};
+			D.push(e), D.push(S);
+			let d = new Repetition({
+				definition: j.definition,
+				idx: j.idx
+			}), f = {
+				idx: O,
+				def: j.definition.concat([d], drop_default(y)),
+				ruleStack: k,
+				occurrenceStack: A
+			};
+			D.push(f);
+		} else if (j instanceof Alternation) for (let e = j.definition.length - 1; e >= 0; e--) {
+			let d = {
+				idx: O,
+				def: j.definition[e].definition.concat(drop_default(y)),
+				ruleStack: k,
+				occurrenceStack: A
+			};
+			D.push(d), D.push(S);
+		}
+		else if (j instanceof Alternative) D.push({
+			idx: O,
+			def: j.definition.concat(drop_default(y)),
+			ruleStack: k,
+			occurrenceStack: A
+		});
+		else if (j instanceof Rule) D.push(expandTopLevelRule(j, O, k, A));
+		else throw Error("non exhaustive match");
+	}
+	return E;
+}
+function expandTopLevelRule(e, f, p, m) {
+	let h = clone_default(p);
+	h.push(e.name);
+	let g = clone_default(m);
+	return g.push(1), {
+		idx: f,
+		def: e.definition,
+		ruleStack: h,
+		occurrenceStack: g
+	};
+}
+export { NextAfterTokenWalker, NextTerminalAfterAtLeastOneSepWalker, NextTerminalAfterAtLeastOneWalker, NextTerminalAfterManySepWalker, NextTerminalAfterManyWalker, nextPossibleTokensAfter, possiblePathsFrom };

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

@@ -0,0 +1,5 @@
+const BITS_FOR_METHOD_TYPE = 4, BITS_FOR_OCCURRENCE_IDX = 8, OR_IDX = 256, OPTION_IDX = 512, MANY_IDX = 768, AT_LEAST_ONE_IDX = 1024, MANY_SEP_IDX = 1280, AT_LEAST_ONE_SEP_IDX = 1536;
+function getKeyForAutomaticLookahead(e, s, c) {
+	return c | s | e;
+}
+export { AT_LEAST_ONE_IDX, AT_LEAST_ONE_SEP_IDX, BITS_FOR_METHOD_TYPE, BITS_FOR_OCCURRENCE_IDX, MANY_IDX, MANY_SEP_IDX, OPTION_IDX, OR_IDX, getKeyForAutomaticLookahead };

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

@@ -0,0 +1,43 @@
+import isEmpty_default from "../../../../../lodash-es/isEmpty.js";
+import flatMap_default from "../../../../../lodash-es/flatMap.js";
+import { defaultGrammarValidatorErrorProvider } from "../errors_public.js";
+import { buildAlternativesLookAheadFunc, buildLookaheadFuncForOptionalProd, buildLookaheadFuncForOr, buildSingleAlternativeLookaheadFunction, getProdType } from "./lookahead.js";
+import { validateAmbiguousAlternationAlternatives, validateEmptyOrAlternative, validateNoLeftRecursion, validateSomeNonEmptyLookaheadPath } from "./checks.js";
+import { DEFAULT_PARSER_CONFIG } from "../parser/parser.js";
+var LLkLookaheadStrategy = class {
+	constructor(e) {
+		this.maxLookahead = e?.maxLookahead ?? DEFAULT_PARSER_CONFIG.maxLookahead;
+	}
+	validate(u) {
+		let d = this.validateNoLeftRecursion(u.rules);
+		if (isEmpty_default(d)) {
+			let e = this.validateEmptyOrAlternatives(u.rules), f = this.validateAmbiguousAlternationAlternatives(u.rules, this.maxLookahead), p = this.validateSomeNonEmptyLookaheadPath(u.rules, this.maxLookahead);
+			return [
+				...d,
+				...e,
+				...f,
+				...p
+			];
+		}
+		return d;
+	}
+	validateNoLeftRecursion(e) {
+		return flatMap_default(e, (e) => validateNoLeftRecursion(e, e, defaultGrammarValidatorErrorProvider));
+	}
+	validateEmptyOrAlternatives(e) {
+		return flatMap_default(e, (e) => validateEmptyOrAlternative(e, defaultGrammarValidatorErrorProvider));
+	}
+	validateAmbiguousAlternationAlternatives(e, f) {
+		return flatMap_default(e, (e) => validateAmbiguousAlternationAlternatives(e, f, defaultGrammarValidatorErrorProvider));
+	}
+	validateSomeNonEmptyLookaheadPath(e, u) {
+		return validateSomeNonEmptyLookaheadPath(e, u, defaultGrammarValidatorErrorProvider);
+	}
+	buildLookaheadForAlternation(e) {
+		return buildLookaheadFuncForOr(e.prodOccurrence, e.rule, e.maxLookahead, e.hasPredicates, e.dynamicTokensEnabled, buildAlternativesLookAheadFunc);
+	}
+	buildLookaheadForOptional(e) {
+		return buildLookaheadFuncForOptionalProd(e.prodOccurrence, e.rule, e.maxLookahead, e.dynamicTokensEnabled, getProdType(e.prodType), buildSingleAlternativeLookaheadFunction);
+	}
+};
+export { LLkLookaheadStrategy };