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

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

@@ -0,0 +1,248 @@
+import isEmpty_default from "../../../../../lodash-es/isEmpty.js";
+import flatten_default from "../../../../../lodash-es/flatten.js";
+import forEach_default from "../../../../../lodash-es/forEach.js";
+import every_default from "../../../../../lodash-es/every.js";
+import map_default from "../../../../../lodash-es/map.js";
+import has_default from "../../../../../lodash-es/has.js";
+import reduce_default from "../../../../../lodash-es/reduce.js";
+import { Alternation, Alternative, Option, Repetition, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator } from "../../../../../@chevrotain/gast/lib/src/model.js";
+import { GAstVisitor } from "../../../../../@chevrotain/gast/lib/src/visitor.js";
+import { RestWalker } from "./rest.js";
+import { tokenStructuredMatcher, tokenStructuredMatcherNoCategories } from "../../scan/tokens.js";
+import { possiblePathsFrom } from "./interpreter.js";
+var PROD_TYPE;
+(function(a) {
+	a[a.OPTION = 0] = "OPTION", a[a.REPETITION = 1] = "REPETITION", a[a.REPETITION_MANDATORY = 2] = "REPETITION_MANDATORY", a[a.REPETITION_MANDATORY_WITH_SEPARATOR = 3] = "REPETITION_MANDATORY_WITH_SEPARATOR", a[a.REPETITION_WITH_SEPARATOR = 4] = "REPETITION_WITH_SEPARATOR", a[a.ALTERNATION = 5] = "ALTERNATION";
+})(PROD_TYPE ||= {});
+function getProdType(a) {
+	/* istanbul ignore else */
+	if (a instanceof Option || a === "Option") return PROD_TYPE.OPTION;
+	if (a instanceof Repetition || a === "Repetition") return PROD_TYPE.REPETITION;
+	if (a instanceof RepetitionMandatory || a === "RepetitionMandatory") return PROD_TYPE.REPETITION_MANDATORY;
+	if (a instanceof RepetitionMandatoryWithSeparator || a === "RepetitionMandatoryWithSeparator") return PROD_TYPE.REPETITION_MANDATORY_WITH_SEPARATOR;
+	if (a instanceof RepetitionWithSeparator || a === "RepetitionWithSeparator") return PROD_TYPE.REPETITION_WITH_SEPARATOR;
+	if (a instanceof Alternation || a === "Alternation") return PROD_TYPE.ALTERNATION;
+	throw Error("non exhaustive match");
+}
+function getLookaheadPaths(a) {
+	let { occurrence: T, rule: E, prodType: D, maxLookahead: O } = a, k = getProdType(D);
+	return k === PROD_TYPE.ALTERNATION ? getLookaheadPathsForOr(T, E, O) : getLookaheadPathsForOptionalProd(T, E, k, O);
+}
+function buildLookaheadFuncForOr(a, T, E, D, O, k) {
+	let A = getLookaheadPathsForOr(a, T, E);
+	return k(A, D, areTokenCategoriesNotUsed(A) ? tokenStructuredMatcherNoCategories : tokenStructuredMatcher, O);
+}
+function buildLookaheadFuncForOptionalProd(a, T, E, D, O, k) {
+	let A = getLookaheadPathsForOptionalProd(a, T, O, E), j = areTokenCategoriesNotUsed(A) ? tokenStructuredMatcherNoCategories : tokenStructuredMatcher;
+	return k(A[0], j, D);
+}
+function buildAlternativesLookAheadFunc(a, j, M, N) {
+	let P = a.length, F = every_default(a, (a) => every_default(a, (a) => a.length === 1));
+	if (j) return function(T) {
+		let E = map_default(T, (a) => a.GATE);
+		for (let T = 0; T < P; T++) {
+			let D = a[T], O = D.length, k = E[T];
+			if (!(k !== void 0 && k.call(this) === !1)) nextPath: for (let a = 0; a < O; a++) {
+				let E = D[a], O = E.length;
+				for (let a = 0; a < O; a++) if (M(this.LA(a + 1), E[a]) === !1) continue nextPath;
+				return T;
+			}
+		}
+	};
+	if (F && !N) {
+		let D = reduce_default(map_default(a, (a) => flatten_default(a)), (a, T, D) => (forEach_default(T, (T) => {
+			has_default(a, T.tokenTypeIdx) || (a[T.tokenTypeIdx] = D), forEach_default(T.categoryMatches, (T) => {
+				has_default(a, T) || (a[T] = D);
+			});
+		}), a), {});
+		return function() {
+			return D[this.LA(1).tokenTypeIdx];
+		};
+	} else return function() {
+		for (let T = 0; T < P; T++) {
+			let E = a[T], D = E.length;
+			nextPath: for (let a = 0; a < D; a++) {
+				let D = E[a], O = D.length;
+				for (let a = 0; a < O; a++) if (M(this.LA(a + 1), D[a]) === !1) continue nextPath;
+				return T;
+			}
+		}
+	};
+}
+function buildSingleAlternativeLookaheadFunction(O, k, j) {
+	let M = every_default(O, (a) => a.length === 1), N = O.length;
+	if (M && !j) {
+		let D = flatten_default(O);
+		if (D.length === 1 && isEmpty_default(D[0].categoryMatches)) {
+			let a = D[0].tokenTypeIdx;
+			return function() {
+				return this.LA(1).tokenTypeIdx === a;
+			};
+		} else {
+			let a = reduce_default(D, (a, T, D) => (a[T.tokenTypeIdx] = !0, forEach_default(T.categoryMatches, (T) => {
+				a[T] = !0;
+			}), a), []);
+			return function() {
+				return a[this.LA(1).tokenTypeIdx] === !0;
+			};
+		}
+	} else return function() {
+		nextPath: for (let a = 0; a < N; a++) {
+			let T = O[a], E = T.length;
+			for (let a = 0; a < E; a++) if (k(this.LA(a + 1), T[a]) === !1) continue nextPath;
+			return !0;
+		}
+		return !1;
+	};
+}
+var RestDefinitionFinderWalker = class extends RestWalker {
+	constructor(a, T, E) {
+		super(), this.topProd = a, this.targetOccurrence = T, this.targetProdType = E;
+	}
+	startWalking() {
+		return this.walk(this.topProd), this.restDef;
+	}
+	checkIsTarget(a, T, E, D) {
+		return a.idx === this.targetOccurrence && this.targetProdType === T ? (this.restDef = E.concat(D), !0) : !1;
+	}
+	walkOption(a, T, E) {
+		this.checkIsTarget(a, PROD_TYPE.OPTION, T, E) || super.walkOption(a, T, E);
+	}
+	walkAtLeastOne(a, T, E) {
+		this.checkIsTarget(a, PROD_TYPE.REPETITION_MANDATORY, T, E) || super.walkOption(a, T, E);
+	}
+	walkAtLeastOneSep(a, T, E) {
+		this.checkIsTarget(a, PROD_TYPE.REPETITION_MANDATORY_WITH_SEPARATOR, T, E) || super.walkOption(a, T, E);
+	}
+	walkMany(a, T, E) {
+		this.checkIsTarget(a, PROD_TYPE.REPETITION, T, E) || super.walkOption(a, T, E);
+	}
+	walkManySep(a, T, E) {
+		this.checkIsTarget(a, PROD_TYPE.REPETITION_WITH_SEPARATOR, T, E) || super.walkOption(a, T, E);
+	}
+}, InsideDefinitionFinderVisitor = class extends GAstVisitor {
+	constructor(a, T, E) {
+		super(), this.targetOccurrence = a, this.targetProdType = T, this.targetRef = E, this.result = [];
+	}
+	checkIsTarget(a, T) {
+		a.idx === this.targetOccurrence && this.targetProdType === T && (this.targetRef === void 0 || a === this.targetRef) && (this.result = a.definition);
+	}
+	visitOption(a) {
+		this.checkIsTarget(a, PROD_TYPE.OPTION);
+	}
+	visitRepetition(a) {
+		this.checkIsTarget(a, PROD_TYPE.REPETITION);
+	}
+	visitRepetitionMandatory(a) {
+		this.checkIsTarget(a, PROD_TYPE.REPETITION_MANDATORY);
+	}
+	visitRepetitionMandatoryWithSeparator(a) {
+		this.checkIsTarget(a, PROD_TYPE.REPETITION_MANDATORY_WITH_SEPARATOR);
+	}
+	visitRepetitionWithSeparator(a) {
+		this.checkIsTarget(a, PROD_TYPE.REPETITION_WITH_SEPARATOR);
+	}
+	visitAlternation(a) {
+		this.checkIsTarget(a, PROD_TYPE.ALTERNATION);
+	}
+};
+function initializeArrayOfArrays(a) {
+	let T = Array(a);
+	for (let E = 0; E < a; E++) T[E] = [];
+	return T;
+}
+function pathToHashKeys(a) {
+	let T = [""];
+	for (let E = 0; E < a.length; E++) {
+		let D = a[E], O = [];
+		for (let a = 0; a < T.length; a++) {
+			let E = T[a];
+			O.push(E + "_" + D.tokenTypeIdx);
+			for (let a = 0; a < D.categoryMatches.length; a++) {
+				let T = "_" + D.categoryMatches[a];
+				O.push(E + T);
+			}
+		}
+		T = O;
+	}
+	return T;
+}
+function isUniquePrefixHash(a, T, E) {
+	for (let D = 0; D < a.length; D++) {
+		if (D === E) continue;
+		let O = a[D];
+		for (let a = 0; a < T.length; a++) if (O[T[a]] === !0) return !1;
+	}
+	return !0;
+}
+function lookAheadSequenceFromAlternatives(T, D) {
+	let k = map_default(T, (a) => possiblePathsFrom([a], 1)), A = initializeArrayOfArrays(k.length), j = map_default(k, (a) => {
+		let T = {};
+		return forEach_default(a, (a) => {
+			forEach_default(pathToHashKeys(a.partialPath), (a) => {
+				T[a] = !0;
+			});
+		}), T;
+	}), M = k;
+	for (let T = 1; T <= D; T++) {
+		let O = M;
+		M = initializeArrayOfArrays(O.length);
+		for (let k = 0; k < O.length; k++) {
+			let N = O[k];
+			for (let O = 0; O < N.length; O++) {
+				let P = N[O].partialPath, F = N[O].suffixDef, I = pathToHashKeys(P);
+				if (isUniquePrefixHash(j, I, k) || isEmpty_default(F) || P.length === D) {
+					let a = A[k];
+					if (containsPath(a, P) === !1) {
+						a.push(P);
+						for (let a = 0; a < I.length; a++) {
+							let T = I[a];
+							j[k][T] = !0;
+						}
+					}
+				} else {
+					let a = possiblePathsFrom(F, T + 1, P);
+					M[k] = M[k].concat(a), forEach_default(a, (a) => {
+						forEach_default(pathToHashKeys(a.partialPath), (a) => {
+							j[k][a] = !0;
+						});
+					});
+				}
+			}
+		}
+	}
+	return A;
+}
+function getLookaheadPathsForOr(a, T, E, D) {
+	let O = new InsideDefinitionFinderVisitor(a, PROD_TYPE.ALTERNATION, D);
+	return T.accept(O), lookAheadSequenceFromAlternatives(O.result, E);
+}
+function getLookaheadPathsForOptionalProd(a, T, E, D) {
+	let O = new InsideDefinitionFinderVisitor(a, E);
+	T.accept(O);
+	let k = O.result, A = new RestDefinitionFinderWalker(T, a, E).startWalking();
+	return lookAheadSequenceFromAlternatives([new Alternative({ definition: k }), new Alternative({ definition: A })], D);
+}
+function containsPath(a, T) {
+	compareOtherPath: for (let E = 0; E < a.length; E++) {
+		let D = a[E];
+		if (D.length === T.length) {
+			for (let a = 0; a < D.length; a++) {
+				let E = T[a], O = D[a];
+				if (!(E === O || O.categoryMatchesMap[E.tokenTypeIdx] !== void 0)) continue compareOtherPath;
+			}
+			return !0;
+		}
+	}
+	return !1;
+}
+function isStrictPrefixOfPath(a, T) {
+	return a.length < T.length && every_default(a, (a, E) => {
+		let D = T[E];
+		return a === D || D.categoryMatchesMap[a.tokenTypeIdx];
+	});
+}
+function areTokenCategoriesNotUsed(T) {
+	return every_default(T, (T) => every_default(T, (T) => every_default(T, (T) => isEmpty_default(T.categoryMatches))));
+}
+export { PROD_TYPE, buildAlternativesLookAheadFunc, buildLookaheadFuncForOptionalProd, buildLookaheadFuncForOr, buildSingleAlternativeLookaheadFunction, containsPath, getLookaheadPaths, getLookaheadPathsForOptionalProd, getLookaheadPathsForOr, getProdType, isStrictPrefixOfPath };

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

@@ -0,0 +1,32 @@
+import forEach_default from "../../../../../lodash-es/forEach.js";
+import values_default from "../../../../../lodash-es/values.js";
+import { GAstVisitor } from "../../../../../@chevrotain/gast/lib/src/visitor.js";
+import { ParserDefinitionErrorType } from "../parser/parser.js";
+function resolveGrammar(e, i) {
+	let a = new GastRefResolverVisitor(e, i);
+	return a.resolveRefs(), a.errors;
+}
+var GastRefResolverVisitor = class extends GAstVisitor {
+	constructor(e, i) {
+		super(), this.nameToTopRule = e, this.errMsgProvider = i, this.errors = [];
+	}
+	resolveRefs() {
+		forEach_default(values_default(this.nameToTopRule), (e) => {
+			this.currTopLevel = e, e.accept(this);
+		});
+	}
+	visitNonTerminal(e) {
+		let i = this.nameToTopRule[e.nonTerminalName];
+		if (i) e.referencedRule = i;
+		else {
+			let i = this.errMsgProvider.buildRuleNotFoundError(this.currTopLevel, e);
+			this.errors.push({
+				message: i,
+				type: ParserDefinitionErrorType.UNRESOLVED_SUBRULE_REF,
+				ruleName: this.currTopLevel.name,
+				unresolvedRefName: e.nonTerminalName
+			});
+		}
+	}
+};
+export { resolveGrammar };

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

@@ -0,0 +1,58 @@
+import drop_default from "../../../../../lodash-es/drop.js";
+import forEach_default from "../../../../../lodash-es/forEach.js";
+import { Alternation, Alternative, NonTerminal, Option, Repetition, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Terminal } from "../../../../../@chevrotain/gast/lib/src/model.js";
+var RestWalker = class {
+	walk(d, f = []) {
+		forEach_default(d.definition, (o, p) => {
+			let m = drop_default(d.definition, p + 1);
+			/* istanbul ignore else */
+			if (o instanceof NonTerminal) this.walkProdRef(o, m, f);
+			else if (o instanceof Terminal) this.walkTerminal(o, m, f);
+			else if (o instanceof Alternative) this.walkFlat(o, m, f);
+			else if (o instanceof Option) this.walkOption(o, m, f);
+			else if (o instanceof RepetitionMandatory) this.walkAtLeastOne(o, m, f);
+			else if (o instanceof RepetitionMandatoryWithSeparator) this.walkAtLeastOneSep(o, m, f);
+			else if (o instanceof RepetitionWithSeparator) this.walkManySep(o, m, f);
+			else if (o instanceof Repetition) this.walkMany(o, m, f);
+			else if (o instanceof Alternation) this.walkOr(o, m, f);
+			else throw Error("non exhaustive match");
+		});
+	}
+	walkTerminal(e, o, s) {}
+	walkProdRef(e, o, s) {}
+	walkFlat(e, o, s) {
+		let c = o.concat(s);
+		this.walk(e, c);
+	}
+	walkOption(e, o, s) {
+		let c = o.concat(s);
+		this.walk(e, c);
+	}
+	walkAtLeastOne(e, o, s) {
+		let c = [new Option({ definition: e.definition })].concat(o, s);
+		this.walk(e, c);
+	}
+	walkAtLeastOneSep(e, o, s) {
+		let c = restForRepetitionWithSeparator(e, o, s);
+		this.walk(e, c);
+	}
+	walkMany(e, o, s) {
+		let c = [new Option({ definition: e.definition })].concat(o, s);
+		this.walk(e, c);
+	}
+	walkManySep(e, o, s) {
+		let c = restForRepetitionWithSeparator(e, o, s);
+		this.walk(e, c);
+	}
+	walkOr(e, s, l) {
+		let u = s.concat(l);
+		forEach_default(e.definition, (e) => {
+			let o = new Alternative({ definition: [e] });
+			this.walk(o, u);
+		});
+	}
+};
+function restForRepetitionWithSeparator(e, o, s) {
+	return [new Option({ definition: [new Terminal({ terminalType: e.separator })].concat(e.definition) })].concat(o, s);
+}
+export { RestWalker };

package/dist/node_modules/chevrotain/lib/src/parse/parser/parser.js

@@ -0,0 +1,122 @@
+import isEmpty_default from "../../../../../lodash-es/isEmpty.js";
+import clone_default from "../../../../../lodash-es/clone.js";
+import forEach_default from "../../../../../lodash-es/forEach.js";
+import map_default from "../../../../../lodash-es/map.js";
+import has_default from "../../../../../lodash-es/has.js";
+import values_default from "../../../../../lodash-es/values.js";
+import { toFastProperties } from "../../../../../@chevrotain/utils/lib/src/to-fast-properties.js";
+import { computeAllProdsFollows } from "../grammar/follow.js";
+import { EOF, createTokenInstance } from "../../scan/tokens_public.js";
+import { defaultGrammarValidatorErrorProvider, defaultParserErrorProvider } from "../errors_public.js";
+import { validateLookahead } from "../grammar/checks.js";
+import { resolveGrammar, validateGrammar } from "../grammar/gast/gast_resolver_public.js";
+import { Recoverable } from "./traits/recoverable.js";
+import { LooksAhead } from "./traits/looksahead.js";
+import { TreeBuilder } from "./traits/tree_builder.js";
+import { LexerAdapter } from "./traits/lexer_adapter.js";
+import { RecognizerApi } from "./traits/recognizer_api.js";
+import { RecognizerEngine } from "./traits/recognizer_engine.js";
+import { ErrorHandler } from "./traits/error_handler.js";
+import { ContentAssist } from "./traits/context_assist.js";
+import { GastRecorder } from "./traits/gast_recorder.js";
+import { PerformanceTracer } from "./traits/perf_tracer.js";
+import { applyMixins } from "./utils/apply_mixins.js";
+const END_OF_FILE = createTokenInstance(EOF, "", NaN, NaN, NaN, NaN, NaN, NaN);
+Object.freeze(END_OF_FILE);
+const DEFAULT_PARSER_CONFIG = Object.freeze({
+	recoveryEnabled: !1,
+	maxLookahead: 3,
+	dynamicTokensEnabled: !1,
+	outputCst: !0,
+	errorMessageProvider: defaultParserErrorProvider,
+	nodeLocationTracking: "none",
+	traceInitPerf: !1,
+	skipValidations: !1
+}), DEFAULT_RULE_CONFIG = Object.freeze({
+	recoveryValueFunc: () => void 0,
+	resyncEnabled: !0
+});
+var ParserDefinitionErrorType;
+(function(u) {
+	u[u.INVALID_RULE_NAME = 0] = "INVALID_RULE_NAME", u[u.DUPLICATE_RULE_NAME = 1] = "DUPLICATE_RULE_NAME", u[u.INVALID_RULE_OVERRIDE = 2] = "INVALID_RULE_OVERRIDE", u[u.DUPLICATE_PRODUCTIONS = 3] = "DUPLICATE_PRODUCTIONS", u[u.UNRESOLVED_SUBRULE_REF = 4] = "UNRESOLVED_SUBRULE_REF", u[u.LEFT_RECURSION = 5] = "LEFT_RECURSION", u[u.NONE_LAST_EMPTY_ALT = 6] = "NONE_LAST_EMPTY_ALT", u[u.AMBIGUOUS_ALTS = 7] = "AMBIGUOUS_ALTS", u[u.CONFLICT_TOKENS_RULES_NAMESPACE = 8] = "CONFLICT_TOKENS_RULES_NAMESPACE", u[u.INVALID_TOKEN_NAME = 9] = "INVALID_TOKEN_NAME", u[u.NO_NON_EMPTY_LOOKAHEAD = 10] = "NO_NON_EMPTY_LOOKAHEAD", u[u.AMBIGUOUS_PREFIX_ALTS = 11] = "AMBIGUOUS_PREFIX_ALTS", u[u.TOO_MANY_ALTS = 12] = "TOO_MANY_ALTS", u[u.CUSTOM_LOOKAHEAD_VALIDATION = 13] = "CUSTOM_LOOKAHEAD_VALIDATION";
+})(ParserDefinitionErrorType ||= {});
+function EMPTY_ALT(u = void 0) {
+	return function() {
+		return u;
+	};
+}
+var Parser = class D {
+	static performSelfAnalysis(u) {
+		throw Error("The **static** `performSelfAnalysis` method has been deprecated.	\nUse the **instance** method with the same name instead.");
+	}
+	performSelfAnalysis() {
+		this.TRACE_INIT("performSelfAnalysis", () => {
+			let A;
+			this.selfAnalysisDone = !0;
+			let j = this.className;
+			this.TRACE_INIT("toFastProps", () => {
+				toFastProperties(this);
+			}), this.TRACE_INIT("Grammar Recording", () => {
+				try {
+					this.enableRecording(), forEach_default(this.definedRulesNames, (u) => {
+						let D = this[u].originalGrammarAction, O;
+						this.TRACE_INIT(`${u} Rule`, () => {
+							O = this.topLevelRuleRecord(u, D);
+						}), this.gastProductionsCache[u] = O;
+					});
+				} finally {
+					this.disableRecording();
+				}
+			});
+			let M = [];
+			if (this.TRACE_INIT("Grammar Resolving", () => {
+				M = resolveGrammar({ rules: values_default(this.gastProductionsCache) }), this.definitionErrors = this.definitionErrors.concat(M);
+			}), this.TRACE_INIT("Grammar Validations", () => {
+				if (isEmpty_default(M) && this.skipValidations === !1) {
+					let u = validateGrammar({
+						rules: values_default(this.gastProductionsCache),
+						tokenTypes: values_default(this.tokensMap),
+						errMsgProvider: defaultGrammarValidatorErrorProvider,
+						grammarName: j
+					}), D = validateLookahead({
+						lookaheadStrategy: this.lookaheadStrategy,
+						rules: values_default(this.gastProductionsCache),
+						tokenTypes: values_default(this.tokensMap),
+						grammarName: j
+					});
+					this.definitionErrors = this.definitionErrors.concat(u, D);
+				}
+			}), isEmpty_default(this.definitionErrors) && (this.recoveryEnabled && this.TRACE_INIT("computeAllProdsFollows", () => {
+				this.resyncFollows = computeAllProdsFollows(values_default(this.gastProductionsCache));
+			}), this.TRACE_INIT("ComputeLookaheadFunctions", () => {
+				var u, D;
+				(D = (u = this.lookaheadStrategy).initialize) == null || D.call(u, { rules: values_default(this.gastProductionsCache) }), this.preComputeLookaheadFunctions(values_default(this.gastProductionsCache));
+			})), !D.DEFER_DEFINITION_ERRORS_HANDLING && !isEmpty_default(this.definitionErrors)) throw A = map_default(this.definitionErrors, (u) => u.message), Error(`Parser Definition Errors detected:\n ${A.join("\n-------------------------------\n")}`);
+		});
+	}
+	constructor(u, D) {
+		this.definitionErrors = [], this.selfAnalysisDone = !1;
+		let O = this;
+		if (O.initErrorHandler(D), O.initLexerAdapter(), O.initLooksAhead(D), O.initRecognizerEngine(u, D), O.initRecoverable(D), O.initTreeBuilder(D), O.initContentAssist(), O.initGastRecorder(D), O.initPerformanceTracer(D), has_default(D, "ignoredIssues")) throw Error("The <ignoredIssues> IParserConfig property has been deprecated.\n	Please use the <IGNORE_AMBIGUITIES> flag on the relevant DSL method instead.\n	See: https://chevrotain.io/docs/guide/resolving_grammar_errors.html#IGNORING_AMBIGUITIES\n	For further details.");
+		this.skipValidations = has_default(D, "skipValidations") ? D.skipValidations : DEFAULT_PARSER_CONFIG.skipValidations;
+	}
+};
+Parser.DEFER_DEFINITION_ERRORS_HANDLING = !1, applyMixins(Parser, [
+	Recoverable,
+	LooksAhead,
+	TreeBuilder,
+	LexerAdapter,
+	RecognizerEngine,
+	RecognizerApi,
+	ErrorHandler,
+	ContentAssist,
+	GastRecorder,
+	PerformanceTracer
+]);
+var EmbeddedActionsParser = class extends Parser {
+	constructor(u, O = DEFAULT_PARSER_CONFIG) {
+		let k = clone_default(O);
+		k.outputCst = !1, super(u, k);
+	}
+};
+export { DEFAULT_PARSER_CONFIG, DEFAULT_RULE_CONFIG, EMPTY_ALT, END_OF_FILE, EmbeddedActionsParser, ParserDefinitionErrorType };

package/dist/node_modules/chevrotain/lib/src/parse/parser/traits/context_assist.js

@@ -0,0 +1,16 @@
+import head_default from "../../../../../../lodash-es/head.js";
+import isUndefined_default from "../../../../../../lodash-es/isUndefined.js";
+import { NextAfterTokenWalker, nextPossibleTokensAfter } from "../../grammar/interpreter.js";
+var ContentAssist = class {
+	initContentAssist() {}
+	computeContentAssist(e, n) {
+		let i = this.gastProductionsCache[e];
+		if (isUndefined_default(i)) throw Error(`Rule ->${e}<- does not exist in this grammar.`);
+		return nextPossibleTokensAfter([i], n, this.tokenMatcher, this.maxLookahead);
+	}
+	getNextPossibleTokenTypes(t) {
+		let r = head_default(t.ruleStack), i = this.getGAstProductions()[r];
+		return new NextAfterTokenWalker(i, t).startWalking();
+	}
+};
+export { ContentAssist };

package/dist/node_modules/chevrotain/lib/src/parse/parser/traits/error_handler.js

@@ -0,0 +1,48 @@
+import clone_default from "../../../../../../lodash-es/clone.js";
+import has_default from "../../../../../../lodash-es/has.js";
+import { getLookaheadPathsForOptionalProd, getLookaheadPathsForOr } from "../../grammar/lookahead.js";
+import { EarlyExitException, NoViableAltException, isRecognitionException } from "../../exceptions_public.js";
+import { DEFAULT_PARSER_CONFIG } from "../parser.js";
+var ErrorHandler = class {
+	initErrorHandler(e) {
+		this._errors = [], this.errorMessageProvider = has_default(e, "errorMessageProvider") ? e.errorMessageProvider : DEFAULT_PARSER_CONFIG.errorMessageProvider;
+	}
+	SAVE_ERROR(t) {
+		if (isRecognitionException(t)) return t.context = {
+			ruleStack: this.getHumanReadableRuleStack(),
+			ruleOccurrenceStack: clone_default(this.RULE_OCCURRENCE_STACK)
+		}, this._errors.push(t), t;
+		throw Error("Trying to save an Error which is not a RecognitionException");
+	}
+	get errors() {
+		return clone_default(this._errors);
+	}
+	set errors(e) {
+		this._errors = e;
+	}
+	raiseEarlyExitException(e, t, r) {
+		let a = this.getCurrRuleFullName(), o = this.getGAstProductions()[a], s = getLookaheadPathsForOptionalProd(e, o, t, this.maxLookahead)[0], c = [];
+		for (let e = 1; e <= this.maxLookahead; e++) c.push(this.LA(e));
+		let l = this.errorMessageProvider.buildEarlyExitMessage({
+			expectedIterationPaths: s,
+			actual: c,
+			previous: this.LA(0),
+			customUserDescription: r,
+			ruleName: a
+		});
+		throw this.SAVE_ERROR(new EarlyExitException(l, this.LA(1), this.LA(0)));
+	}
+	raiseNoAltException(e, t) {
+		let n = this.getCurrRuleFullName(), i = this.getGAstProductions()[n], o = getLookaheadPathsForOr(e, i, this.maxLookahead), s = [];
+		for (let e = 1; e <= this.maxLookahead; e++) s.push(this.LA(e));
+		let c = this.LA(0), l = this.errorMessageProvider.buildNoViableAltMessage({
+			expectedPathsPerAlt: o,
+			actual: s,
+			previous: c,
+			customUserDescription: t,
+			ruleName: this.getCurrRuleFullName()
+		});
+		throw this.SAVE_ERROR(new NoViableAltException(l, this.LA(1), c));
+	}
+};
+export { ErrorHandler };