@loopstack/loopstack-studio 0.25.0 → 0.25.2

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

@@ -1,248 +1,241 @@
-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";
+(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";
 })(PROD_TYPE ||= {});
-function getProdType(a) {
+function getProdType(b) {
 	/* 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;
+	if (b instanceof Option || b === "Option") return PROD_TYPE.OPTION;
+	if (b instanceof Repetition || b === "Repetition") return PROD_TYPE.REPETITION;
+	if (b instanceof RepetitionMandatory || b === "RepetitionMandatory") return PROD_TYPE.REPETITION_MANDATORY;
+	if (b instanceof RepetitionMandatoryWithSeparator || b === "RepetitionMandatoryWithSeparator") return PROD_TYPE.REPETITION_MANDATORY_WITH_SEPARATOR;
+	if (b instanceof RepetitionWithSeparator || b === "RepetitionWithSeparator") return PROD_TYPE.REPETITION_WITH_SEPARATOR;
+	if (b instanceof Alternation || b === "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 getLookaheadPaths(e) {
+	let { occurrence: b, rule: x, prodType: S, maxLookahead: C } = e, w = getProdType(S);
+	return w === PROD_TYPE.ALTERNATION ? getLookaheadPathsForOr(b, x, C) : getLookaheadPathsForOptionalProd(b, x, w, C);
 }
-function buildLookaheadFuncForOr(a, T, E, D, O, k) {
-	let A = getLookaheadPathsForOr(a, T, E);
-	return k(A, D, areTokenCategoriesNotUsed(A) ? tokenStructuredMatcherNoCategories : tokenStructuredMatcher, O);
+function buildLookaheadFuncForOr(e, b, x, S, C, w) {
+	let T = getLookaheadPathsForOr(e, b, x);
+	return w(T, S, areTokenCategoriesNotUsed(T) ? tokenStructuredMatcherNoCategories : tokenStructuredMatcher, C);
 }
-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 buildLookaheadFuncForOptionalProd(e, b, x, S, C, w) {
+	let T = getLookaheadPathsForOptionalProd(e, b, C, x), E = areTokenCategoriesNotUsed(T) ? tokenStructuredMatcherNoCategories : tokenStructuredMatcher;
+	return w(T[0], E, S);
 }
-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;
+function buildAlternativesLookAheadFunc(e, b, x, S) {
+	let C = e.length, w = e.every((e) => e.every((e) => e.length === 1));
+	if (b) return function(b) {
+		let S = b.map((e) => e.GATE);
+		for (let b = 0; b < C; b++) {
+			let C = e[b], w = C.length, T = S[b];
+			if (!(T !== void 0 && T.call(this) === !1)) nextPath: for (let e = 0; e < w; e++) {
+				let S = C[e], w = S.length;
+				for (let e = 0; e < w; e++) if (x(this.LA_FAST(e + 1), S[e]) === !1) continue nextPath;
+				return b;
 			}
 		}
 	};
-	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);
+	if (w && !S) {
+		let b = e.map((e) => e.flat()).reduce((e, b, x) => (b.forEach((b) => {
+			b.tokenTypeIdx in e || (e[b.tokenTypeIdx] = x), b.categoryMatches.forEach((b) => {
+				Object.hasOwn(e, b) || (e[b] = x);
 			});
-		}), a), {});
+		}), e), {});
 		return function() {
-			return D[this.LA(1).tokenTypeIdx];
+			return b[this.LA_FAST(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;
+		for (let b = 0; b < C; b++) {
+			let S = e[b], C = S.length;
+			nextPath: for (let e = 0; e < C; e++) {
+				let C = S[e], w = C.length;
+				for (let e = 0; e < w; e++) if (x(this.LA_FAST(e + 1), C[e]) === !1) continue nextPath;
+				return b;
 			}
 		}
 	};
 }
-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;
+function buildSingleAlternativeLookaheadFunction(e, b, x) {
+	let S = e.every((e) => e.length === 1), C = e.length;
+	if (S && !x) {
+		let b = e.flat();
+		if (b.length === 1 && b[0].categoryMatches.length === 0) {
+			let e = b[0].tokenTypeIdx;
 			return function() {
-				return this.LA(1).tokenTypeIdx === a;
+				return this.LA_FAST(1).tokenTypeIdx === e;
 			};
 		} else {
-			let a = reduce_default(D, (a, T, D) => (a[T.tokenTypeIdx] = !0, forEach_default(T.categoryMatches, (T) => {
-				a[T] = !0;
-			}), a), []);
+			let e = b.reduce((e, b, x) => (e[b.tokenTypeIdx] = !0, b.categoryMatches.forEach((b) => {
+				e[b] = !0;
+			}), e), []);
 			return function() {
-				return a[this.LA(1).tokenTypeIdx] === !0;
+				return e[this.LA_FAST(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;
+		nextPath: for (let x = 0; x < C; x++) {
+			let S = e[x], C = S.length;
+			for (let e = 0; e < C; e++) if (b(this.LA_FAST(e + 1), S[e]) === !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;
+	constructor(e, b, x) {
+		super(), this.topProd = e, this.targetOccurrence = b, this.targetProdType = x;
 	}
 	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;
+	checkIsTarget(e, b, x, S) {
+		return e.idx === this.targetOccurrence && this.targetProdType === b ? (this.restDef = x.concat(S), !0) : !1;
 	}
-	walkOption(a, T, E) {
-		this.checkIsTarget(a, PROD_TYPE.OPTION, T, E) || super.walkOption(a, T, E);
+	walkOption(e, b, x) {
+		this.checkIsTarget(e, PROD_TYPE.OPTION, b, x) || super.walkOption(e, b, x);
 	}
-	walkAtLeastOne(a, T, E) {
-		this.checkIsTarget(a, PROD_TYPE.REPETITION_MANDATORY, T, E) || super.walkOption(a, T, E);
+	walkAtLeastOne(e, b, x) {
+		this.checkIsTarget(e, PROD_TYPE.REPETITION_MANDATORY, b, x) || super.walkOption(e, b, x);
 	}
-	walkAtLeastOneSep(a, T, E) {
-		this.checkIsTarget(a, PROD_TYPE.REPETITION_MANDATORY_WITH_SEPARATOR, T, E) || super.walkOption(a, T, E);
+	walkAtLeastOneSep(e, b, x) {
+		this.checkIsTarget(e, PROD_TYPE.REPETITION_MANDATORY_WITH_SEPARATOR, b, x) || super.walkOption(e, b, x);
 	}
-	walkMany(a, T, E) {
-		this.checkIsTarget(a, PROD_TYPE.REPETITION, T, E) || super.walkOption(a, T, E);
+	walkMany(e, b, x) {
+		this.checkIsTarget(e, PROD_TYPE.REPETITION, b, x) || super.walkOption(e, b, x);
 	}
-	walkManySep(a, T, E) {
-		this.checkIsTarget(a, PROD_TYPE.REPETITION_WITH_SEPARATOR, T, E) || super.walkOption(a, T, E);
+	walkManySep(e, b, x) {
+		this.checkIsTarget(e, PROD_TYPE.REPETITION_WITH_SEPARATOR, b, x) || super.walkOption(e, b, x);
 	}
 }, InsideDefinitionFinderVisitor = class extends GAstVisitor {
-	constructor(a, T, E) {
-		super(), this.targetOccurrence = a, this.targetProdType = T, this.targetRef = E, this.result = [];
+	constructor(e, b, x) {
+		super(), this.targetOccurrence = e, this.targetProdType = b, this.targetRef = x, this.result = [];
 	}
-	checkIsTarget(a, T) {
-		a.idx === this.targetOccurrence && this.targetProdType === T && (this.targetRef === void 0 || a === this.targetRef) && (this.result = a.definition);
+	checkIsTarget(e, b) {
+		e.idx === this.targetOccurrence && this.targetProdType === b && (this.targetRef === void 0 || e === this.targetRef) && (this.result = e.definition);
 	}
-	visitOption(a) {
-		this.checkIsTarget(a, PROD_TYPE.OPTION);
+	visitOption(e) {
+		this.checkIsTarget(e, PROD_TYPE.OPTION);
 	}
-	visitRepetition(a) {
-		this.checkIsTarget(a, PROD_TYPE.REPETITION);
+	visitRepetition(e) {
+		this.checkIsTarget(e, PROD_TYPE.REPETITION);
 	}
-	visitRepetitionMandatory(a) {
-		this.checkIsTarget(a, PROD_TYPE.REPETITION_MANDATORY);
+	visitRepetitionMandatory(e) {
+		this.checkIsTarget(e, PROD_TYPE.REPETITION_MANDATORY);
 	}
-	visitRepetitionMandatoryWithSeparator(a) {
-		this.checkIsTarget(a, PROD_TYPE.REPETITION_MANDATORY_WITH_SEPARATOR);
+	visitRepetitionMandatoryWithSeparator(e) {
+		this.checkIsTarget(e, PROD_TYPE.REPETITION_MANDATORY_WITH_SEPARATOR);
 	}
-	visitRepetitionWithSeparator(a) {
-		this.checkIsTarget(a, PROD_TYPE.REPETITION_WITH_SEPARATOR);
+	visitRepetitionWithSeparator(e) {
+		this.checkIsTarget(e, PROD_TYPE.REPETITION_WITH_SEPARATOR);
 	}
-	visitAlternation(a) {
-		this.checkIsTarget(a, PROD_TYPE.ALTERNATION);
+	visitAlternation(e) {
+		this.checkIsTarget(e, PROD_TYPE.ALTERNATION);
 	}
 };
-function initializeArrayOfArrays(a) {
-	let T = Array(a);
-	for (let E = 0; E < a; E++) T[E] = [];
-	return T;
+function initializeArrayOfArrays(e) {
+	let b = Array(e);
+	for (let x = 0; x < e; x++) b[x] = [];
+	return b;
 }
-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);
+function pathToHashKeys(e) {
+	let b = [""];
+	for (let x = 0; x < e.length; x++) {
+		let S = e[x], C = [];
+		for (let e = 0; e < b.length; e++) {
+			let x = b[e];
+			C.push(x + "_" + S.tokenTypeIdx);
+			for (let e = 0; e < S.categoryMatches.length; e++) {
+				let b = "_" + S.categoryMatches[e];
+				C.push(x + b);
 			}
 		}
-		T = O;
+		b = C;
 	}
-	return T;
+	return b;
 }
-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;
+function isUniquePrefixHash(e, b, x) {
+	for (let S = 0; S < e.length; S++) {
+		if (S === x) continue;
+		let C = e[S];
+		for (let e = 0; e < b.length; e++) if (C[b[e]] === !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;
+function lookAheadSequenceFromAlternatives(e, b) {
+	let x = e.map((e) => possiblePathsFrom([e], 1)), S = initializeArrayOfArrays(x.length), C = x.map((e) => {
+		let b = {};
+		return e.forEach((e) => {
+			pathToHashKeys(e.partialPath).forEach((e) => {
+				b[e] = !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;
+		}), b;
+	}), w = x;
+	for (let e = 1; e <= b; e++) {
+		let x = w;
+		w = initializeArrayOfArrays(x.length);
+		for (let T = 0; T < x.length; T++) {
+			let E = x[T];
+			for (let x = 0; x < E.length; x++) {
+				let D = E[x].partialPath, O = E[x].suffixDef, k = pathToHashKeys(D);
+				if (isUniquePrefixHash(C, k, T) || O.length === 0 || D.length === b) {
+					let e = S[T];
+					if (containsPath(e, D) === !1) {
+						e.push(D);
+						for (let e = 0; e < k.length; e++) {
+							let b = k[e];
+							C[T][b] = !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;
+					let b = possiblePathsFrom(O, e + 1, D);
+					w[T] = w[T].concat(b), b.forEach((e) => {
+						pathToHashKeys(e.partialPath).forEach((e) => {
+							C[T][e] = !0;
 						});
 					});
 				}
 			}
 		}
 	}
-	return A;
+	return S;
 }
-function getLookaheadPathsForOr(a, T, E, D) {
-	let O = new InsideDefinitionFinderVisitor(a, PROD_TYPE.ALTERNATION, D);
-	return T.accept(O), lookAheadSequenceFromAlternatives(O.result, E);
+function getLookaheadPathsForOr(e, b, x, S) {
+	let C = new InsideDefinitionFinderVisitor(e, PROD_TYPE.ALTERNATION, S);
+	return b.accept(C), lookAheadSequenceFromAlternatives(C.result, x);
 }
-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 getLookaheadPathsForOptionalProd(e, x, S, C) {
+	let w = new InsideDefinitionFinderVisitor(e, S);
+	x.accept(w);
+	let T = w.result, E = new RestDefinitionFinderWalker(x, e, S).startWalking();
+	return lookAheadSequenceFromAlternatives([new Alternative({ definition: T }), new Alternative({ definition: E })], C);
 }
-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;
+function containsPath(e, b) {
+	compareOtherPath: for (let x = 0; x < e.length; x++) {
+		let S = e[x];
+		if (S.length === b.length) {
+			for (let e = 0; e < S.length; e++) {
+				let x = b[e], C = S[e];
+				if (!(x === C || C.categoryMatchesMap[x.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 isStrictPrefixOfPath(e, b) {
+	return e.length < b.length && e.every((e, x) => {
+		let S = b[x];
+		return e === S || S.categoryMatchesMap[e.tokenTypeIdx];
 	});
 }
-function areTokenCategoriesNotUsed(T) {
-	return every_default(T, (T) => every_default(T, (T) => every_default(T, (T) => isEmpty_default(T.categoryMatches))));
+function areTokenCategoriesNotUsed(e) {
+	return e.every((e) => e.every((e) => e.every((e) => e.categoryMatches.length === 0)));
 }
 export { PROD_TYPE, buildAlternativesLookAheadFunc, buildLookaheadFuncForOptionalProd, buildLookaheadFuncForOr, buildSingleAlternativeLookaheadFunction, containsPath, getLookaheadPaths, getLookaheadPathsForOptionalProd, getLookaheadPathsForOr, getProdType, isStrictPrefixOfPath };

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

@@ -1,27 +1,25 @@
-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;
+function resolveGrammar(e, n) {
+	let r = new GastRefResolverVisitor(e, n);
+	return r.resolveRefs(), r.errors;
 }
 var GastRefResolverVisitor = class extends GAstVisitor {
-	constructor(e, i) {
-		super(), this.nameToTopRule = e, this.errMsgProvider = i, this.errors = [];
+	constructor(e, n) {
+		super(), this.nameToTopRule = e, this.errMsgProvider = n, this.errors = [];
 	}
 	resolveRefs() {
-		forEach_default(values_default(this.nameToTopRule), (e) => {
+		Object.values(this.nameToTopRule).forEach((e) => {
 			this.currTopLevel = e, e.accept(this);
 		});
 	}
 	visitNonTerminal(e) {
-		let i = this.nameToTopRule[e.nonTerminalName];
-		if (i) e.referencedRule = i;
+		let r = this.nameToTopRule[e.nonTerminalName];
+		if (r) e.referencedRule = r;
 		else {
-			let i = this.errMsgProvider.buildRuleNotFoundError(this.currTopLevel, e);
+			let r = this.errMsgProvider.buildRuleNotFoundError(this.currTopLevel, e);
 			this.errors.push({
-				message: i,
+				message: r,
 				type: ParserDefinitionErrorType.UNRESOLVED_SUBRULE_REF,
 				ruleName: this.currTopLevel.name,
 				unresolvedRefName: e.nonTerminalName

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

@@ -1,58 +1,56 @@
-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);
+	walk(l, u = []) {
+		l.definition.forEach((d, f) => {
+			let p = l.definition.slice(f + 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);
+			if (d instanceof NonTerminal) this.walkProdRef(d, p, u);
+			else if (d instanceof Terminal) this.walkTerminal(d, p, u);
+			else if (d instanceof Alternative) this.walkFlat(d, p, u);
+			else if (d instanceof Option) this.walkOption(d, p, u);
+			else if (d instanceof RepetitionMandatory) this.walkAtLeastOne(d, p, u);
+			else if (d instanceof RepetitionMandatoryWithSeparator) this.walkAtLeastOneSep(d, p, u);
+			else if (d instanceof RepetitionWithSeparator) this.walkManySep(d, p, u);
+			else if (d instanceof Repetition) this.walkMany(d, p, u);
+			else if (d instanceof Alternation) this.walkOr(d, p, u);
 			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);
+	walkTerminal(e, a, o) {}
+	walkProdRef(e, a, o) {}
+	walkFlat(e, a, o) {
+		let s = a.concat(o);
+		this.walk(e, s);
 	}
-	walkOption(e, o, s) {
-		let c = o.concat(s);
-		this.walk(e, c);
+	walkOption(e, a, o) {
+		let s = a.concat(o);
+		this.walk(e, s);
 	}
-	walkAtLeastOne(e, o, s) {
-		let c = [new Option({ definition: e.definition })].concat(o, s);
+	walkAtLeastOne(e, a, o) {
+		let c = [new Option({ definition: e.definition })].concat(a, o);
 		this.walk(e, c);
 	}
-	walkAtLeastOneSep(e, o, s) {
-		let c = restForRepetitionWithSeparator(e, o, s);
-		this.walk(e, c);
+	walkAtLeastOneSep(e, a, o) {
+		let s = restForRepetitionWithSeparator(e, a, o);
+		this.walk(e, s);
 	}
-	walkMany(e, o, s) {
-		let c = [new Option({ definition: e.definition })].concat(o, s);
+	walkMany(e, a, o) {
+		let c = [new Option({ definition: e.definition })].concat(a, o);
 		this.walk(e, c);
 	}
-	walkManySep(e, o, s) {
-		let c = restForRepetitionWithSeparator(e, o, s);
-		this.walk(e, c);
+	walkManySep(e, a, o) {
+		let s = restForRepetitionWithSeparator(e, a, o);
+		this.walk(e, s);
 	}
-	walkOr(e, s, l) {
-		let u = s.concat(l);
-		forEach_default(e.definition, (e) => {
+	walkOr(e, o, s) {
+		let c = o.concat(s);
+		e.definition.forEach((e) => {
 			let o = new Alternative({ definition: [e] });
-			this.walk(o, u);
+			this.walk(o, c);
 		});
 	}
 };
-function restForRepetitionWithSeparator(e, o, s) {
-	return [new Option({ definition: [new Terminal({ terminalType: e.separator })].concat(e.definition) })].concat(o, s);
+function restForRepetitionWithSeparator(e, a, o) {
+	return [new Option({ definition: [new Terminal({ terminalType: e.separator })].concat(e.definition) })].concat(a, o);
 }
 export { RestWalker };