@loopstack/loopstack-studio 0.25.0 → 0.25.2

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

@@ -1,9 +1,3 @@
-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";
@@ -17,7 +11,6 @@ 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";
@@ -37,68 +30,68 @@ const DEFAULT_PARSER_CONFIG = Object.freeze({
 	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";
+(function(e) {
+	e[e.INVALID_RULE_NAME = 0] = "INVALID_RULE_NAME", e[e.DUPLICATE_RULE_NAME = 1] = "DUPLICATE_RULE_NAME", e[e.INVALID_RULE_OVERRIDE = 2] = "INVALID_RULE_OVERRIDE", e[e.DUPLICATE_PRODUCTIONS = 3] = "DUPLICATE_PRODUCTIONS", e[e.UNRESOLVED_SUBRULE_REF = 4] = "UNRESOLVED_SUBRULE_REF", e[e.LEFT_RECURSION = 5] = "LEFT_RECURSION", e[e.NONE_LAST_EMPTY_ALT = 6] = "NONE_LAST_EMPTY_ALT", e[e.AMBIGUOUS_ALTS = 7] = "AMBIGUOUS_ALTS", e[e.CONFLICT_TOKENS_RULES_NAMESPACE = 8] = "CONFLICT_TOKENS_RULES_NAMESPACE", e[e.INVALID_TOKEN_NAME = 9] = "INVALID_TOKEN_NAME", e[e.NO_NON_EMPTY_LOOKAHEAD = 10] = "NO_NON_EMPTY_LOOKAHEAD", e[e.AMBIGUOUS_PREFIX_ALTS = 11] = "AMBIGUOUS_PREFIX_ALTS", e[e.TOO_MANY_ALTS = 12] = "TOO_MANY_ALTS", e[e.CUSTOM_LOOKAHEAD_VALIDATION = 13] = "CUSTOM_LOOKAHEAD_VALIDATION";
 })(ParserDefinitionErrorType ||= {});
-function EMPTY_ALT(u = void 0) {
+function EMPTY_ALT(e = void 0) {
 	return function() {
-		return u;
+		return e;
 	};
 }
-var Parser = class D {
-	static performSelfAnalysis(u) {
+var Parser = class S {
+	static performSelfAnalysis(e) {
 		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;
+			let C;
 			this.selfAnalysisDone = !0;
-			let j = this.className;
+			let w = 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;
+					this.enableRecording(), this.definedRulesNames.forEach((e) => {
+						let x = this[e].originalGrammarAction, S;
+						this.TRACE_INIT(`${e} Rule`, () => {
+							S = this.topLevelRuleRecord(e, x);
+						}), this.gastProductionsCache[e] = S;
 					});
 				} finally {
 					this.disableRecording();
 				}
 			});
-			let M = [];
+			let T = [];
 			if (this.TRACE_INIT("Grammar Resolving", () => {
-				M = resolveGrammar({ rules: values_default(this.gastProductionsCache) }), this.definitionErrors = this.definitionErrors.concat(M);
+				T = resolveGrammar({ rules: Object.values(this.gastProductionsCache) }), this.definitionErrors = this.definitionErrors.concat(T);
 			}), 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),
+				if (T.length === 0 && this.skipValidations === !1) {
+					let e = validateGrammar({
+						rules: Object.values(this.gastProductionsCache),
+						tokenTypes: Object.values(this.tokensMap),
 						errMsgProvider: defaultGrammarValidatorErrorProvider,
-						grammarName: j
-					}), D = validateLookahead({
+						grammarName: w
+					}), x = validateLookahead({
 						lookaheadStrategy: this.lookaheadStrategy,
-						rules: values_default(this.gastProductionsCache),
-						tokenTypes: values_default(this.tokensMap),
-						grammarName: j
+						rules: Object.values(this.gastProductionsCache),
+						tokenTypes: Object.values(this.tokensMap),
+						grammarName: w
 					});
-					this.definitionErrors = this.definitionErrors.concat(u, D);
+					this.definitionErrors = this.definitionErrors.concat(e, x);
 				}
-			}), isEmpty_default(this.definitionErrors) && (this.recoveryEnabled && this.TRACE_INIT("computeAllProdsFollows", () => {
-				this.resyncFollows = computeAllProdsFollows(values_default(this.gastProductionsCache));
+			}), this.definitionErrors.length === 0 && (this.recoveryEnabled && this.TRACE_INIT("computeAllProdsFollows", () => {
+				this.resyncFollows = computeAllProdsFollows(Object.values(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")}`);
+				var e, x;
+				(x = (e = this.lookaheadStrategy).initialize) == null || x.call(e, { rules: Object.values(this.gastProductionsCache) }), this.preComputeLookaheadFunctions(Object.values(this.gastProductionsCache));
+			})), !S.DEFER_DEFINITION_ERRORS_HANDLING && this.definitionErrors.length !== 0) throw C = this.definitionErrors.map((e) => e.message), Error(`Parser Definition Errors detected:\n ${C.join("\n-------------------------------\n")}`);
 		});
 	}
-	constructor(u, D) {
+	constructor(e, x) {
 		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;
+		let S = this;
+		if (S.initErrorHandler(x), S.initLexerAdapter(), S.initLooksAhead(x), S.initRecognizerEngine(e, x), S.initRecoverable(x), S.initTreeBuilder(x), S.initGastRecorder(x), S.initPerformanceTracer(x), Object.hasOwn(x, "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 = Object.hasOwn(x, "skipValidations") ? x.skipValidations : DEFAULT_PARSER_CONFIG.skipValidations;
 	}
 };
 Parser.DEFER_DEFINITION_ERRORS_HANDLING = !1, applyMixins(Parser, [
@@ -109,14 +102,13 @@ Parser.DEFER_DEFINITION_ERRORS_HANDLING = !1, applyMixins(Parser, [
 	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);
+	constructor(e, x = DEFAULT_PARSER_CONFIG) {
+		let S = Object.assign({}, x);
+		S.outputCst = !1, super(e, S);
 	}
 };
 export { DEFAULT_PARSER_CONFIG, DEFAULT_RULE_CONFIG, EMPTY_ALT, END_OF_FILE, EmbeddedActionsParser, ParserDefinitionErrorType };

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

@@ -1,45 +1,43 @@
-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;
+		this._errors = [], this.errorMessageProvider = Object.hasOwn(e, "errorMessageProvider") ? e.errorMessageProvider : DEFAULT_PARSER_CONFIG.errorMessageProvider;
 	}
-	SAVE_ERROR(t) {
-		if (isRecognitionException(t)) return t.context = {
+	SAVE_ERROR(e) {
+		if (isRecognitionException(e)) return e.context = {
 			ruleStack: this.getHumanReadableRuleStack(),
-			ruleOccurrenceStack: clone_default(this.RULE_OCCURRENCE_STACK)
-		}, this._errors.push(t), t;
+			ruleOccurrenceStack: this.RULE_OCCURRENCE_STACK.slice(0, this.RULE_OCCURRENCE_STACK_IDX + 1)
+		}, this._errors.push(e), e;
 		throw Error("Trying to save an Error which is not a RecognitionException");
 	}
 	get errors() {
-		return clone_default(this._errors);
+		return [...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 = [];
+	raiseEarlyExitException(t, r, i) {
+		let a = this.getCurrRuleFullName(), o = this.getGAstProductions()[a], s = getLookaheadPathsForOptionalProd(t, o, r, 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,
+			customUserDescription: i,
 			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 = [];
+	raiseNoAltException(e, n) {
+		let i = this.getCurrRuleFullName(), a = this.getGAstProductions()[i], o = getLookaheadPathsForOr(e, a, 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,
+			customUserDescription: n,
 			ruleName: this.getCurrRuleFullName()
 		});
 		throw this.SAVE_ERROR(new NoViableAltException(l, this.LA(1), c));

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

@@ -1,9 +1,3 @@
-import isFunction_default from "../../../../../../lodash-es/isFunction.js";
-import isArray_default from "../../../../../../lodash-es/isArray.js";
-import last_default from "../../../../../../lodash-es/last.js";
-import forEach_default from "../../../../../../lodash-es/forEach.js";
-import has_default from "../../../../../../lodash-es/has.js";
-import some_default from "../../../../../../lodash-es/some.js";
 import { Alternation, Alternative, NonTerminal, Option, Repetition, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Rule, Terminal } from "../../../../../../@chevrotain/gast/lib/src/model.js";
 import { augmentTokenTypes, hasShortKeyProperty } from "../../../scan/tokens.js";
 import { Lexer } from "../../../scan/lexer_public.js";
@@ -23,149 +17,149 @@ var RECORDING_PHASE_CSTNODE = {
 	name: "This CSTNode indicates the Parser is in Recording Phase\n	See: https://chevrotain.io/docs/guide/internals.html#grammar-recording for details",
 	children: {}
 }, GastRecorder = class {
-	initGastRecorder(i) {
+	initGastRecorder(e) {
 		this.recordingProdStack = [], this.RECORDING_PHASE = !1;
 	}
 	enableRecording() {
 		this.RECORDING_PHASE = !0, this.TRACE_INIT("Enable Recording", () => {
-			for (let i = 0; i < 10; i++) {
-				let x = i > 0 ? i : "";
+			for (let e = 0; e < 10; e++) {
+				let x = e > 0 ? e : "";
 				this[`CONSUME${x}`] = function(x, S) {
-					return this.consumeInternalRecord(x, i, S);
+					return this.consumeInternalRecord(x, e, S);
 				}, this[`SUBRULE${x}`] = function(x, S) {
-					return this.subruleInternalRecord(x, i, S);
+					return this.subruleInternalRecord(x, e, S);
 				}, this[`OPTION${x}`] = function(x) {
-					return this.optionInternalRecord(x, i);
+					return this.optionInternalRecord(x, e);
 				}, this[`OR${x}`] = function(x) {
-					return this.orInternalRecord(x, i);
+					return this.orInternalRecord(x, e);
 				}, this[`MANY${x}`] = function(x) {
-					this.manyInternalRecord(i, x);
+					this.manyInternalRecord(e, x);
 				}, this[`MANY_SEP${x}`] = function(x) {
-					this.manySepFirstInternalRecord(i, x);
+					this.manySepFirstInternalRecord(e, x);
 				}, this[`AT_LEAST_ONE${x}`] = function(x) {
-					this.atLeastOneInternalRecord(i, x);
+					this.atLeastOneInternalRecord(e, x);
 				}, this[`AT_LEAST_ONE_SEP${x}`] = function(x) {
-					this.atLeastOneSepFirstInternalRecord(i, x);
+					this.atLeastOneSepFirstInternalRecord(e, x);
 				};
 			}
-			this.consume = function(i, x, S) {
-				return this.consumeInternalRecord(x, i, S);
-			}, this.subrule = function(i, x, S) {
-				return this.subruleInternalRecord(x, i, S);
-			}, this.option = function(i, x) {
-				return this.optionInternalRecord(x, i);
-			}, this.or = function(i, x) {
-				return this.orInternalRecord(x, i);
-			}, this.many = function(i, x) {
-				this.manyInternalRecord(i, x);
-			}, this.atLeastOne = function(i, x) {
-				this.atLeastOneInternalRecord(i, x);
+			this.consume = function(e, x, S) {
+				return this.consumeInternalRecord(x, e, S);
+			}, this.subrule = function(e, x, S) {
+				return this.subruleInternalRecord(x, e, S);
+			}, this.option = function(e, x) {
+				return this.optionInternalRecord(x, e);
+			}, this.or = function(e, x) {
+				return this.orInternalRecord(x, e);
+			}, this.many = function(e, x) {
+				this.manyInternalRecord(e, x);
+			}, this.atLeastOne = function(e, x) {
+				this.atLeastOneInternalRecord(e, x);
 			}, this.ACTION = this.ACTION_RECORD, this.BACKTRACK = this.BACKTRACK_RECORD, this.LA = this.LA_RECORD;
 		});
 	}
 	disableRecording() {
 		this.RECORDING_PHASE = !1, this.TRACE_INIT("Deleting Recording methods", () => {
-			let i = this;
+			let e = this;
 			for (let x = 0; x < 10; x++) {
 				let S = x > 0 ? x : "";
-				delete i[`CONSUME${S}`], delete i[`SUBRULE${S}`], delete i[`OPTION${S}`], delete i[`OR${S}`], delete i[`MANY${S}`], delete i[`MANY_SEP${S}`], delete i[`AT_LEAST_ONE${S}`], delete i[`AT_LEAST_ONE_SEP${S}`];
+				delete e[`CONSUME${S}`], delete e[`SUBRULE${S}`], delete e[`OPTION${S}`], delete e[`OR${S}`], delete e[`MANY${S}`], delete e[`MANY_SEP${S}`], delete e[`AT_LEAST_ONE${S}`], delete e[`AT_LEAST_ONE_SEP${S}`];
 			}
-			delete i.consume, delete i.subrule, delete i.option, delete i.or, delete i.many, delete i.atLeastOne, delete i.ACTION, delete i.BACKTRACK, delete i.LA;
+			delete e.consume, delete e.subrule, delete e.option, delete e.or, delete e.many, delete e.atLeastOne, delete e.ACTION, delete e.BACKTRACK, delete e.LA;
 		});
 	}
-	ACTION_RECORD(i) {}
-	BACKTRACK_RECORD(i, x) {
+	ACTION_RECORD(e) {}
+	BACKTRACK_RECORD(e, x) {
 		return () => !0;
 	}
-	LA_RECORD(i) {
+	LA_RECORD(e) {
 		return END_OF_FILE;
 	}
-	topLevelRuleRecord(i, x) {
+	topLevelRuleRecord(e, x) {
 		try {
 			let S = new Rule({
 				definition: [],
-				name: i
+				name: e
 			});
-			return S.name = i, this.recordingProdStack.push(S), x.call(this), this.recordingProdStack.pop(), S;
-		} catch (i) {
-			if (i.KNOWN_RECORDER_ERROR !== !0) try {
-				i.message += "\n	 This error was thrown during the \"grammar recording phase\" For more info see:\n	https://chevrotain.io/docs/guide/internals.html#grammar-recording";
+			return S.name = e, this.recordingProdStack.push(S), x.call(this), this.recordingProdStack.pop(), S;
+		} catch (e) {
+			if (e.KNOWN_RECORDER_ERROR !== !0) try {
+				e.message += "\n	 This error was thrown during the \"grammar recording phase\" For more info see:\n	https://chevrotain.io/docs/guide/internals.html#grammar-recording";
 			} catch {
-				throw i;
+				throw e;
 			}
-			throw i;
+			throw e;
 		}
 	}
-	optionInternalRecord(i, x) {
-		return recordProd.call(this, Option, i, x);
+	optionInternalRecord(e, x) {
+		return recordProd.call(this, Option, e, x);
 	}
-	atLeastOneInternalRecord(i, x) {
-		recordProd.call(this, RepetitionMandatory, x, i);
+	atLeastOneInternalRecord(e, x) {
+		recordProd.call(this, RepetitionMandatory, x, e);
 	}
-	atLeastOneSepFirstInternalRecord(i, x) {
-		recordProd.call(this, RepetitionMandatoryWithSeparator, x, i, HANDLE_SEPARATOR);
+	atLeastOneSepFirstInternalRecord(e, x) {
+		recordProd.call(this, RepetitionMandatoryWithSeparator, x, e, HANDLE_SEPARATOR);
 	}
-	manyInternalRecord(i, x) {
-		recordProd.call(this, Repetition, x, i);
+	manyInternalRecord(e, x) {
+		recordProd.call(this, Repetition, x, e);
 	}
-	manySepFirstInternalRecord(i, x) {
-		recordProd.call(this, RepetitionWithSeparator, x, i, HANDLE_SEPARATOR);
+	manySepFirstInternalRecord(e, x) {
+		recordProd.call(this, RepetitionWithSeparator, x, e, HANDLE_SEPARATOR);
 	}
-	orInternalRecord(i, x) {
-		return recordOrProd.call(this, i, x);
+	orInternalRecord(e, x) {
+		return recordOrProd.call(this, e, x);
 	}
-	subruleInternalRecord(i, x, C) {
-		if (assertMethodIdxIsValid(x), !i || has_default(i, "ruleName") === !1) {
-			let S = /* @__PURE__ */ Error(`<SUBRULE${getIdxSuffix(x)}> argument is invalid expecting a Parser method reference but got: <${JSON.stringify(i)}>\n inside top level rule: <${this.recordingProdStack[0].name}>`);
+	subruleInternalRecord(e, x, C) {
+		if (assertMethodIdxIsValid(x), !e || !Object.hasOwn(e, "ruleName")) {
+			let S = /* @__PURE__ */ Error(`<SUBRULE${getIdxSuffix(x)}> argument is invalid expecting a Parser method reference but got: <${JSON.stringify(e)}>\n inside top level rule: <${this.recordingProdStack[0].name}>`);
 			throw S.KNOWN_RECORDER_ERROR = !0, S;
 		}
-		let T = last_default(this.recordingProdStack), E = i.ruleName, D = new NonTerminal({
+		let w = this.recordingProdStack.at(-1), T = e.ruleName, E = new NonTerminal({
 			idx: x,
-			nonTerminalName: E,
+			nonTerminalName: T,
 			label: C?.LABEL,
 			referencedRule: void 0
 		});
-		return T.definition.push(D), this.outputCst ? RECORDING_PHASE_CSTNODE : RECORDING_NULL_OBJECT;
+		return w.definition.push(E), this.outputCst ? RECORDING_PHASE_CSTNODE : RECORDING_NULL_OBJECT;
 	}
-	consumeInternalRecord(i, x, C) {
-		if (assertMethodIdxIsValid(x), !hasShortKeyProperty(i)) {
-			let S = /* @__PURE__ */ Error(`<CONSUME${getIdxSuffix(x)}> argument is invalid expecting a TokenType reference but got: <${JSON.stringify(i)}>\n inside top level rule: <${this.recordingProdStack[0].name}>`);
+	consumeInternalRecord(e, x, S) {
+		if (assertMethodIdxIsValid(x), !hasShortKeyProperty(e)) {
+			let S = /* @__PURE__ */ Error(`<CONSUME${getIdxSuffix(x)}> argument is invalid expecting a TokenType reference but got: <${JSON.stringify(e)}>\n inside top level rule: <${this.recordingProdStack[0].name}>`);
 			throw S.KNOWN_RECORDER_ERROR = !0, S;
 		}
-		let w = last_default(this.recordingProdStack), T = new Terminal({
+		let C = this.recordingProdStack.at(-1), w = new Terminal({
 			idx: x,
-			terminalType: i,
-			label: C?.LABEL
+			terminalType: e,
+			label: S?.LABEL
 		});
-		return w.definition.push(T), RECORDING_PHASE_TOKEN;
+		return C.definition.push(w), RECORDING_PHASE_TOKEN;
 	}
 };
-function recordProd(x, C, T, E = !1) {
-	assertMethodIdxIsValid(T);
-	let D = last_default(this.recordingProdStack), O = isFunction_default(C) ? C : C.DEF, k = new x({
+function recordProd(e, x, S, C = !1) {
+	assertMethodIdxIsValid(S);
+	let w = this.recordingProdStack.at(-1), T = typeof x == "function" ? x : x.DEF, E = new e({
 		definition: [],
-		idx: T
+		idx: S
 	});
-	return E && (k.separator = C.SEP), has_default(C, "MAX_LOOKAHEAD") && (k.maxLookahead = C.MAX_LOOKAHEAD), this.recordingProdStack.push(k), O.call(this), D.definition.push(k), this.recordingProdStack.pop(), RECORDING_NULL_OBJECT;
+	return C && (E.separator = x.SEP), Object.hasOwn(x, "MAX_LOOKAHEAD") && (E.maxLookahead = x.MAX_LOOKAHEAD), this.recordingProdStack.push(E), T.call(this), w.definition.push(E), this.recordingProdStack.pop(), RECORDING_NULL_OBJECT;
 }
-function recordOrProd(O, k) {
-	assertMethodIdxIsValid(k);
-	let A = last_default(this.recordingProdStack), j = isArray_default(O) === !1, M = j === !1 ? O : O.DEF, N = new Alternation({
+function recordOrProd(S, C) {
+	assertMethodIdxIsValid(C);
+	let w = this.recordingProdStack.at(-1), T = Array.isArray(S) === !1, E = T === !1 ? S : S.DEF, D = new Alternation({
 		definition: [],
-		idx: k,
-		ignoreAmbiguities: j && O.IGNORE_AMBIGUITIES === !0
+		idx: C,
+		ignoreAmbiguities: T && S.IGNORE_AMBIGUITIES === !0
 	});
-	return has_default(O, "MAX_LOOKAHEAD") && (N.maxLookahead = O.MAX_LOOKAHEAD), N.hasPredicates = some_default(M, (x) => isFunction_default(x.GATE)), A.definition.push(N), forEach_default(M, (i) => {
-		let x = new Alternative({ definition: [] });
-		N.definition.push(x), has_default(i, "IGNORE_AMBIGUITIES") ? x.ignoreAmbiguities = i.IGNORE_AMBIGUITIES : has_default(i, "GATE") && (x.ignoreAmbiguities = !0), this.recordingProdStack.push(x), i.ALT.call(this), this.recordingProdStack.pop();
+	return Object.hasOwn(S, "MAX_LOOKAHEAD") && (D.maxLookahead = S.MAX_LOOKAHEAD), D.hasPredicates = E.some((e) => typeof e.GATE == "function"), w.definition.push(D), E.forEach((e) => {
+		let S = new Alternative({ definition: [] });
+		D.definition.push(S), Object.hasOwn(e, "IGNORE_AMBIGUITIES") ? S.ignoreAmbiguities = e.IGNORE_AMBIGUITIES : Object.hasOwn(e, "GATE") && (S.ignoreAmbiguities = !0), this.recordingProdStack.push(S), e.ALT.call(this), this.recordingProdStack.pop();
 	}), RECORDING_NULL_OBJECT;
 }
-function getIdxSuffix(i) {
-	return i === 0 ? "" : `${i}`;
+function getIdxSuffix(e) {
+	return e === 0 ? "" : `${e}`;
 }
-function assertMethodIdxIsValid(i) {
-	if (i < 0 || i > MAX_METHOD_IDX) {
-		let x = /* @__PURE__ */ Error(`Invalid DSL Method idx value: <${i}>\n\tIdx value must be a none negative value smaller than ${MAX_METHOD_IDX + 1}`);
+function assertMethodIdxIsValid(e) {
+	if (e < 0 || e > MAX_METHOD_IDX) {
+		let x = /* @__PURE__ */ Error(`Invalid DSL Method idx value: <${e}>\n\tIdx value must be a none negative value smaller than ${MAX_METHOD_IDX + 1}`);
 		throw x.KNOWN_RECORDER_ERROR = !0, x;
 	}
 }

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

@@ -11,7 +11,11 @@ var LexerAdapter = class {
 		return this.tokVector;
 	}
 	SKIP_TOKEN() {
-		return this.currIdx <= this.tokVector.length - 2 ? (this.consumeToken(), this.LA(1)) : END_OF_FILE;
+		return this.currIdx <= this.tokVectorLength - 2 ? (this.consumeToken(), this.LA_FAST(1)) : END_OF_FILE;
+	}
+	LA_FAST(e) {
+		let t = this.currIdx + e;
+		return this.tokVector[t];
 	}
 	LA(t) {
 		let n = this.currIdx + t;
@@ -30,7 +34,7 @@ var LexerAdapter = class {
 		this.currIdx = -1;
 	}
 	moveToTerminatedState() {
-		this.currIdx = this.tokVector.length - 1;
+		this.currIdx = this.tokVectorLength - 1;
 	}
 	getLexerPosition() {
 		return this.exportLexerState();

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

@@ -1,5 +1,3 @@
-import forEach_default from "../../../../../../lodash-es/forEach.js";
-import has_default from "../../../../../../lodash-es/has.js";
 import { GAstVisitor } from "../../../../../../@chevrotain/gast/lib/src/visitor.js";
 import { getProductionDslName } from "../../../../../../@chevrotain/gast/lib/src/helpers.js";
 import { AT_LEAST_ONE_IDX, AT_LEAST_ONE_SEP_IDX, MANY_IDX, MANY_SEP_IDX, OPTION_IDX, OR_IDX, getKeyForAutomaticLookahead } from "../../grammar/keys.js";
@@ -7,59 +5,59 @@ import { LLkLookaheadStrategy } from "../../grammar/llk_lookahead.js";
 import { DEFAULT_PARSER_CONFIG } from "../parser.js";
 var LooksAhead = class {
 	initLooksAhead(e) {
-		this.dynamicTokensEnabled = has_default(e, "dynamicTokensEnabled") ? e.dynamicTokensEnabled : DEFAULT_PARSER_CONFIG.dynamicTokensEnabled, this.maxLookahead = has_default(e, "maxLookahead") ? e.maxLookahead : DEFAULT_PARSER_CONFIG.maxLookahead, this.lookaheadStrategy = has_default(e, "lookaheadStrategy") ? e.lookaheadStrategy : new LLkLookaheadStrategy({ maxLookahead: this.maxLookahead }), this.lookAheadFuncsCache = /* @__PURE__ */ new Map();
+		this.dynamicTokensEnabled = Object.hasOwn(e, "dynamicTokensEnabled") ? e.dynamicTokensEnabled : DEFAULT_PARSER_CONFIG.dynamicTokensEnabled, this.maxLookahead = Object.hasOwn(e, "maxLookahead") ? e.maxLookahead : DEFAULT_PARSER_CONFIG.maxLookahead, this.lookaheadStrategy = Object.hasOwn(e, "lookaheadStrategy") ? e.lookaheadStrategy : new LLkLookaheadStrategy({ maxLookahead: this.maxLookahead }), this.lookAheadFuncsCache = /* @__PURE__ */ new Map();
 	}
-	preComputeLookaheadFunctions(o) {
-		forEach_default(o, (o) => {
-			this.TRACE_INIT(`${o.name} Rule Lookahead`, () => {
-				let { alternation: s, repetition: d, option: f, repetitionMandatory: p, repetitionMandatoryWithSeparator: m, repetitionWithSeparator: h } = collectMethods(o);
-				forEach_default(s, (e) => {
-					let s = e.idx === 0 ? "" : e.idx;
-					this.TRACE_INIT(`${getProductionDslName(e)}${s}`, () => {
-						let s = this.lookaheadStrategy.buildLookaheadForAlternation({
-							prodOccurrence: e.idx,
-							rule: o,
-							maxLookahead: e.maxLookahead || this.maxLookahead,
-							hasPredicates: e.hasPredicates,
+	preComputeLookaheadFunctions(e) {
+		e.forEach((e) => {
+			this.TRACE_INIT(`${e.name} Rule Lookahead`, () => {
+				let { alternation: s, repetition: l, option: u, repetitionMandatory: d, repetitionMandatoryWithSeparator: f, repetitionWithSeparator: p } = collectMethods(e);
+				s.forEach((a) => {
+					let o = a.idx === 0 ? "" : a.idx;
+					this.TRACE_INIT(`${getProductionDslName(a)}${o}`, () => {
+						let i = this.lookaheadStrategy.buildLookaheadForAlternation({
+							prodOccurrence: a.idx,
+							rule: e,
+							maxLookahead: a.maxLookahead || this.maxLookahead,
+							hasPredicates: a.hasPredicates,
 							dynamicTokensEnabled: this.dynamicTokensEnabled
-						}), c = getKeyForAutomaticLookahead(this.fullRuleNameToShort[o.name], 256, e.idx);
-						this.setLaFuncCache(c, s);
+						}), o = getKeyForAutomaticLookahead(this.fullRuleNameToShort[e.name], 256, a.idx);
+						this.setLaFuncCache(o, i);
 					});
-				}), forEach_default(d, (e) => {
-					this.computeLookaheadFunc(o, e.idx, 768, "Repetition", e.maxLookahead, getProductionDslName(e));
-				}), forEach_default(f, (e) => {
-					this.computeLookaheadFunc(o, e.idx, 512, "Option", e.maxLookahead, getProductionDslName(e));
-				}), forEach_default(p, (e) => {
-					this.computeLookaheadFunc(o, e.idx, AT_LEAST_ONE_IDX, "RepetitionMandatory", e.maxLookahead, getProductionDslName(e));
-				}), forEach_default(m, (e) => {
-					this.computeLookaheadFunc(o, e.idx, AT_LEAST_ONE_SEP_IDX, "RepetitionMandatoryWithSeparator", e.maxLookahead, getProductionDslName(e));
-				}), forEach_default(h, (e) => {
-					this.computeLookaheadFunc(o, e.idx, MANY_SEP_IDX, "RepetitionWithSeparator", e.maxLookahead, getProductionDslName(e));
+				}), l.forEach((a) => {
+					this.computeLookaheadFunc(e, a.idx, 768, "Repetition", a.maxLookahead, getProductionDslName(a));
+				}), u.forEach((a) => {
+					this.computeLookaheadFunc(e, a.idx, 512, "Option", a.maxLookahead, getProductionDslName(a));
+				}), d.forEach((o) => {
+					this.computeLookaheadFunc(e, o.idx, AT_LEAST_ONE_IDX, "RepetitionMandatory", o.maxLookahead, getProductionDslName(o));
+				}), f.forEach((a) => {
+					this.computeLookaheadFunc(e, a.idx, AT_LEAST_ONE_SEP_IDX, "RepetitionMandatoryWithSeparator", a.maxLookahead, getProductionDslName(a));
+				}), p.forEach((a) => {
+					this.computeLookaheadFunc(e, a.idx, MANY_SEP_IDX, "RepetitionWithSeparator", a.maxLookahead, getProductionDslName(a));
 				});
 			});
 		});
 	}
-	computeLookaheadFunc(e, o, s, c, l, u) {
-		this.TRACE_INIT(`${u}${o === 0 ? "" : o}`, () => {
-			let u = this.lookaheadStrategy.buildLookaheadForOptional({
-				prodOccurrence: o,
+	computeLookaheadFunc(e, i, a, o, s, c) {
+		this.TRACE_INIT(`${c}${i === 0 ? "" : i}`, () => {
+			let c = this.lookaheadStrategy.buildLookaheadForOptional({
+				prodOccurrence: i,
 				rule: e,
-				maxLookahead: l || this.maxLookahead,
+				maxLookahead: s || this.maxLookahead,
 				dynamicTokensEnabled: this.dynamicTokensEnabled,
-				prodType: c
-			}), d = getKeyForAutomaticLookahead(this.fullRuleNameToShort[e.name], s, o);
-			this.setLaFuncCache(d, u);
+				prodType: o
+			}), l = getKeyForAutomaticLookahead(this.fullRuleNameToShort[e.name], a, i);
+			this.setLaFuncCache(l, c);
 		});
 	}
-	getKeyForAutomaticLookahead(e, o) {
-		return getKeyForAutomaticLookahead(this.getLastExplicitRuleShortName(), e, o);
+	getKeyForAutomaticLookahead(e, i) {
+		return getKeyForAutomaticLookahead(this.currRuleShortName, e, i);
 	}
 	getLaFuncFromCache(e) {
 		return this.lookAheadFuncsCache.get(e);
 	}
 	/* istanbul ignore next */
-	setLaFuncCache(e, o) {
-		this.lookAheadFuncsCache.set(e, o);
+	setLaFuncCache(e, i) {
+		this.lookAheadFuncsCache.set(e, i);
 	}
 }, collectorVisitor = new class extends GAstVisitor {
 	constructor() {
@@ -103,7 +101,7 @@ var LooksAhead = class {
 }();
 function collectMethods(e) {
 	collectorVisitor.reset(), e.accept(collectorVisitor);
-	let o = collectorVisitor.dslMethods;
-	return collectorVisitor.reset(), o;
+	let i = collectorVisitor.dslMethods;
+	return collectorVisitor.reset(), i;
 }
 export { LooksAhead };

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

@@ -1,21 +1,20 @@
-import has_default from "../../../../../../lodash-es/has.js";
 import { timer } from "../../../../../../@chevrotain/utils/lib/src/timer.js";
 import { DEFAULT_PARSER_CONFIG } from "../parser.js";
 var PerformanceTracer = class {
-	initPerformanceTracer(t) {
-		if (has_default(t, "traceInitPerf")) {
-			let e = t.traceInitPerf, n = typeof e == "number";
-			this.traceInitMaxIdent = n ? e : Infinity, this.traceInitPerf = n ? e > 0 : e;
+	initPerformanceTracer(e) {
+		if (Object.hasOwn(e, "traceInitPerf")) {
+			let t = e.traceInitPerf, n = typeof t == "number";
+			this.traceInitMaxIdent = n ? t : Infinity, this.traceInitPerf = n ? t > 0 : t;
 		} else this.traceInitMaxIdent = 0, this.traceInitPerf = DEFAULT_PARSER_CONFIG.traceInitPerf;
 		this.traceInitIndent = -1;
 	}
-	TRACE_INIT(e, n) {
+	TRACE_INIT(t, n) {
 		if (this.traceInitPerf === !0) {
 			this.traceInitIndent++;
 			let r = Array(this.traceInitIndent + 1).join("	");
-			this.traceInitIndent < this.traceInitMaxIdent && console.log(`${r}--> <${e}>`);
+			this.traceInitIndent < this.traceInitMaxIdent && console.log(`${r}--> <${t}>`);
 			let { time: i, value: a } = timer(n), o = i > 10 ? console.warn : console.log;
-			return this.traceInitIndent < this.traceInitMaxIdent && o(`${r}<-- <${e}> time: ${i}ms`), this.traceInitIndent--, a;
+			return this.traceInitIndent < this.traceInitMaxIdent && o(`${r}<-- <${t}> time: ${i}ms`), this.traceInitIndent--, a;
 		} else return n();
 	}
 };