@loopstack/loopstack-studio 0.25.0 → 0.25.2

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

@@ -1,21 +1,3 @@
-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";
@@ -23,277 +5,271 @@ 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 validateLookahead(a) {
+	return a.lookaheadStrategy.validate({
+		rules: a.rules,
+		tokenTypes: a.tokenTypes,
+		grammarName: a.grammarName
+	}).map((a) => Object.assign({ type: ParserDefinitionErrorType.CUSTOM_LOOKAHEAD_VALIDATION }, a));
 }
-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 validateGrammar(a, D, O, k) {
+	let A = a.flatMap((a) => validateDuplicateProductions(a, O)), j = checkTerminalAndNoneTerminalsNameSpace(a, D, O), M = a.flatMap((a) => validateTooManyAlts(a, O)), N = a.flatMap((D) => validateRuleDoesNotAlreadyExist(D, a, k, O));
+	return A.concat(j, M, N);
 }
-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,
+function validateDuplicateProductions(a, D) {
+	let O = new OccurrenceValidationCollector();
+	a.accept(O);
+	let k = O.allProductions, A = Object.groupBy(k, identifyProductionForDuplicates), j = Object.fromEntries(Object.entries(A).filter(([a, D]) => D.length > 1));
+	return Object.values(j).map((O) => {
+		let k = O[0], A = D.buildDuplicateFoundError(a, O), j = getProductionDslName(k), M = {
+			message: A,
 			type: ParserDefinitionErrorType.DUPLICATE_PRODUCTIONS,
-			ruleName: h.name,
-			dslName: J,
-			occurrence: K.idx
-		}, X = getExtraProductionArgument(K);
-		return X && (Y.parameter = X), Y;
+			ruleName: a.name,
+			dslName: j,
+			occurrence: k.idx
+		}, N = getExtraProductionArgument(k);
+		return N && (M.parameter = N), M;
 	});
 }
-function identifyProductionForDuplicates(h) {
-	return `${getProductionDslName(h)}_#_${h.idx}_#_${getExtraProductionArgument(h)}`;
+function identifyProductionForDuplicates(a) {
+	return `${getProductionDslName(a)}_#_${a.idx}_#_${getExtraProductionArgument(a)}`;
 }
-function getExtraProductionArgument(h) {
-	return h instanceof Terminal ? h.terminalType.name : h instanceof NonTerminal ? h.nonTerminalName : "";
+function getExtraProductionArgument(a) {
+	return a instanceof Terminal ? a.terminalType.name : a instanceof NonTerminal ? a.nonTerminalName : "";
 }
 var OccurrenceValidationCollector = class extends GAstVisitor {
 	constructor() {
 		super(...arguments), this.allProductions = [];
 	}
-	visitNonTerminal(h) {
-		this.allProductions.push(h);
+	visitNonTerminal(a) {
+		this.allProductions.push(a);
 	}
-	visitOption(h) {
-		this.allProductions.push(h);
+	visitOption(a) {
+		this.allProductions.push(a);
 	}
-	visitRepetitionWithSeparator(h) {
-		this.allProductions.push(h);
+	visitRepetitionWithSeparator(a) {
+		this.allProductions.push(a);
 	}
-	visitRepetitionMandatory(h) {
-		this.allProductions.push(h);
+	visitRepetitionMandatory(a) {
+		this.allProductions.push(a);
 	}
-	visitRepetitionMandatoryWithSeparator(h) {
-		this.allProductions.push(h);
+	visitRepetitionMandatoryWithSeparator(a) {
+		this.allProductions.push(a);
 	}
-	visitRepetition(h) {
-		this.allProductions.push(h);
+	visitRepetition(a) {
+		this.allProductions.push(a);
 	}
-	visitAlternation(h) {
-		this.allProductions.push(h);
+	visitAlternation(a) {
+		this.allProductions.push(a);
 	}
-	visitTerminal(h) {
-		this.allProductions.push(h);
+	visitTerminal(a) {
+		this.allProductions.push(a);
 	}
 };
-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
+function validateRuleDoesNotAlreadyExist(a, D, O, k) {
+	let A = [];
+	if (D.reduce((D, O) => O.name === a.name ? D + 1 : D, 0) > 1) {
+		let D = k.buildDuplicateRuleNameError({
+			topLevelRule: a,
+			grammarName: O
 		});
-		q.push({
-			message: W,
+		A.push({
+			message: D,
 			type: ParserDefinitionErrorType.DUPLICATE_RULE_NAME,
-			ruleName: h.name
+			ruleName: a.name
 		});
 	}
-	return q;
+	return A;
 }
-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,
+function validateRuleIsOverridden(a, D, O) {
+	let k = [], A;
+	return D.includes(a) || (A = `Invalid rule override, rule: ->${a}<- cannot be overridden in the grammar: ->${O}<-as it is not defined in any of the super grammars `, k.push({
+		message: A,
 		type: ParserDefinitionErrorType.INVALID_RULE_OVERRIDE,
-		ruleName: h
-	})), K;
+		ruleName: a
+	})), k;
 }
-function validateNoLeftRecursion(W, K, J, Y = []) {
-	let X = [], Z = getFirstNoneTerminal(K.definition);
-	if (isEmpty_default(Z)) return [];
+function validateNoLeftRecursion(a, D, O, k = []) {
+	let A = [], j = getFirstNoneTerminal(D.definition);
+	if (j.length === 0) return [];
 	{
-		let h = W.name;
-		includes_default(Z, W) && X.push({
-			message: J.buildLeftRecursionError({
-				topLevelRule: W,
-				leftRecursionPath: Y
+		let D = a.name;
+		j.includes(a) && A.push({
+			message: O.buildLeftRecursionError({
+				topLevelRule: a,
+				leftRecursionPath: k
 			}),
 			type: ParserDefinitionErrorType.LEFT_RECURSION,
-			ruleName: h
+			ruleName: D
 		});
-		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);
+		let M = k.concat([a]), N = j.filter((a) => !M.includes(a)).flatMap((D) => {
+			let A = [...k];
+			return A.push(D), validateNoLeftRecursion(a, D, O, A);
 		});
-		return X.concat(K);
+		return A.concat(N);
 	}
 }
-function getFirstNoneTerminal(G) {
-	let K = [];
-	if (isEmpty_default(G)) return K;
-	let q = head_default(G);
+function getFirstNoneTerminal(P) {
+	let F = [];
+	if (P.length === 0) return F;
+	let I = P[0];
 	/* 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;
+	if (I instanceof NonTerminal) F.push(I.referencedRule);
+	else if (I instanceof Alternative || I instanceof Option || I instanceof RepetitionMandatory || I instanceof RepetitionMandatoryWithSeparator || I instanceof RepetitionWithSeparator || I instanceof Repetition) F = F.concat(getFirstNoneTerminal(I.definition));
+	else if (I instanceof Alternation) F = I.definition.map((a) => getFirstNoneTerminal(a.definition)).flat();
+	else if (!(I instanceof Terminal)) throw Error("non exhaustive match");
+	let L = isOptionalProd(I), R = P.length > 1;
+	if (L && R) {
+		let a = P.slice(1);
+		return F.concat(getFirstNoneTerminal(a));
+	} else return F;
 }
 var OrCollector = class extends GAstVisitor {
 	constructor() {
 		super(...arguments), this.alternations = [];
 	}
-	visitAlternation(h) {
-		this.alternations.push(h);
+	visitAlternation(a) {
+		this.alternations.push(a);
 	}
 };
-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
+function validateEmptyOrAlternative(a, D) {
+	let O = new OrCollector();
+	return a.accept(O), O.alternations.flatMap((O) => O.definition.slice(0, -1).flatMap((k, A) => nextPossibleTokensAfter([k], [], tokenStructuredMatcher, 1).length === 0 ? [{
+		message: D.buildEmptyAlternationError({
+			topLevelRule: a,
+			alternation: O,
+			emptyChoiceIdx: A
 		}),
 		type: ParserDefinitionErrorType.NONE_LAST_EMPTY_ALT,
-		ruleName: W.name,
-		occurrence: K.idx,
-		alternative: J + 1
+		ruleName: a.name,
+		occurrence: O.idx,
+		alternative: A + 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);
+function validateAmbiguousAlternationAlternatives(a, D, O) {
+	let k = new OrCollector();
+	a.accept(k);
+	let A = k.alternations;
+	return A = A.filter((a) => a.ignoreAmbiguities !== !0), A.flatMap((k) => {
+		let A = k.idx, j = getLookaheadPathsForOr(A, a, k.maxLookahead || D, k), M = checkAlternativesAmbiguities(j, k, a, O), N = checkPrefixAlternativesAmbiguities(j, k, a, O);
+		return M.concat(N);
 	});
 }
 var RepetitionCollector = class extends GAstVisitor {
 	constructor() {
 		super(...arguments), this.allProductions = [];
 	}
-	visitRepetitionWithSeparator(h) {
-		this.allProductions.push(h);
+	visitRepetitionWithSeparator(a) {
+		this.allProductions.push(a);
 	}
-	visitRepetitionMandatory(h) {
-		this.allProductions.push(h);
+	visitRepetitionMandatory(a) {
+		this.allProductions.push(a);
 	}
-	visitRepetitionMandatoryWithSeparator(h) {
-		this.allProductions.push(h);
+	visitRepetitionMandatoryWithSeparator(a) {
+		this.allProductions.push(a);
 	}
-	visitRepetition(h) {
-		this.allProductions.push(h);
+	visitRepetition(a) {
+		this.allProductions.push(a);
 	}
 };
-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
+function validateTooManyAlts(a, D) {
+	let O = new OrCollector();
+	return a.accept(O), O.alternations.flatMap((O) => O.definition.length > 255 ? [{
+		message: D.buildTooManyAlternativesError({
+			topLevelRule: a,
+			alternation: O
 		}),
 		type: ParserDefinitionErrorType.TOO_MANY_ALTS,
-		ruleName: h.name,
-		occurrence: G.idx
+		ruleName: a.name,
+		occurrence: O.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
+function validateSomeNonEmptyLookaheadPath(a, D, O) {
+	let k = [];
+	return a.forEach((a) => {
+		let A = new RepetitionCollector();
+		a.accept(A), A.allProductions.forEach((A) => {
+			let j = getProdType(A), M = A.maxLookahead || D, N = A.idx;
+			if (getLookaheadPathsForOptionalProd(N, a, j, M)[0].flat().length === 0) {
+				let D = O.buildEmptyRepetitionError({
+					topLevelRule: a,
+					repetition: A
 				});
-				J.push({
-					message: h,
+				k.push({
+					message: D,
 					type: ParserDefinitionErrorType.NO_NON_EMPTY_LOOKAHEAD,
-					ruleName: G.name
+					ruleName: a.name
 				});
 			}
 		});
-	}), J;
+	}), k;
 }
-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
+function checkAlternativesAmbiguities(a, D, O, k) {
+	let A = [];
+	return a.reduce((O, k, j) => (D.definition[j].ignoreAmbiguities === !0 || k.forEach((k) => {
+		let M = [j];
+		a.forEach((a, O) => {
+			j !== O && containsPath(a, k) && D.definition[O].ignoreAmbiguities !== !0 && M.push(O);
+		}), M.length > 1 && !containsPath(A, k) && (A.push(k), O.push({
+			alts: M,
+			path: k
 		}));
-	}), G), []), (h) => {
-		let q = map_default(h.alts, (h) => h + 1);
+	}), O), []).map((a) => {
+		let A = a.alts.map((a) => a + 1);
 		return {
-			message: K.buildAlternationAmbiguityError({
-				topLevelRule: G,
-				alternation: W,
-				ambiguityIndices: q,
-				prefixPath: h.path
+			message: k.buildAlternationAmbiguityError({
+				topLevelRule: O,
+				alternation: D,
+				ambiguityIndices: A,
+				prefixPath: a.path
 			}),
 			type: ParserDefinitionErrorType.AMBIGUOUS_ALTS,
-			ruleName: G.name,
-			occurrence: W.idx,
-			alternatives: h.alts
+			ruleName: O.name,
+			occurrence: D.idx,
+			alternatives: a.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
+function checkPrefixAlternativesAmbiguities(a, D, O, k) {
+	let A = a.reduce((a, D, O) => {
+		let k = D.map((a) => ({
+			idx: O,
+			path: a
 		}));
-		return h.concat(K);
+		return a.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 A.flatMap((a) => {
+		if (D.definition[a.idx].ignoreAmbiguities === !0) return [];
+		let j = a.idx, M = a.path;
+		return A.filter((a) => D.definition[a.idx].ignoreAmbiguities !== !0 && a.idx < j && isStrictPrefixOfPath(a.path, M)).map((a) => {
+			let A = [a.idx + 1, j + 1], M = D.idx === 0 ? "" : D.idx;
 			return {
-				message: q.buildAlternationPrefixAmbiguityError({
-					topLevelRule: G,
-					alternation: W,
-					ambiguityIndices: J,
-					prefixPath: h.path
+				message: k.buildAlternationPrefixAmbiguityError({
+					topLevelRule: O,
+					alternation: D,
+					ambiguityIndices: A,
+					prefixPath: a.path
 				}),
 				type: ParserDefinitionErrorType.AMBIGUOUS_PREFIX_ALTS,
-				ruleName: G.name,
-				occurrence: Y,
-				alternatives: J
+				ruleName: O.name,
+				occurrence: M,
+				alternatives: A
 			};
 		});
-	}));
+	});
 }
-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,
+function checkTerminalAndNoneTerminalsNameSpace(a, D, O) {
+	let k = [], A = D.map((a) => a.name);
+	return a.forEach((a) => {
+		let D = a.name;
+		if (A.includes(D)) {
+			let A = O.buildNamespaceConflictError(a);
+			k.push({
+				message: A,
 				type: ParserDefinitionErrorType.CONFLICT_TOKENS_RULES_NAMESPACE,
-				ruleName: W
+				ruleName: D
 			});
 		}
-	}), K;
+	}), k;
 }
 export { validateAmbiguousAlternationAlternatives, validateEmptyOrAlternative, validateGrammar, validateLookahead, validateNoLeftRecursion, validateRuleIsOverridden, validateSomeNonEmptyLookaheadPath };

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

@@ -1,23 +1,21 @@
-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) {
+function first(i) {
 	/* 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);
+	if (i instanceof NonTerminal) return first(i.referencedRule);
+	if (i instanceof Terminal) return firstForTerminal(i);
+	if (isSequenceProd(i)) return firstForSequence(i);
+	if (isBranchingProd(i)) return firstForBranching(i);
 	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);
+	let n = [], r = e.definition, a = 0, o = r.length > a, s, c = !0;
+	for (; o && c;) s = r[a], c = isOptionalProd(s), n = n.concat(first(s)), a += 1, o = r.length > a;
+	return [...new Set(n)];
 }
-function firstForBranching(s) {
-	return uniq_default(flatten_default(map_default(s.definition, (e) => first(e))));
+function firstForBranching(e) {
+	let n = e.definition.map((e) => first(e));
+	return [...new Set(n.flat())];
 }
 function firstForTerminal(e) {
 	return [e.terminalType];

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

@@ -1,5 +1,3 @@
-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";
@@ -11,19 +9,20 @@ var ResyncFollowsWalker = class extends RestWalker {
 	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;
+	walkTerminal(e, n, r) {}
+	walkProdRef(n, i, a) {
+		let o = buildBetweenProdsFollowPrefix(n.referencedRule, n.idx) + this.topProd.name, s = first(new Alternative({ definition: i.concat(a) }));
+		this.follows[o] = s;
 	}
 };
-function computeAllProdsFollows(a) {
-	let o = {};
-	return forEach_default(a, (i) => {
-		assign_default(o, new ResyncFollowsWalker(i).startWalking());
-	}), o;
+function computeAllProdsFollows(e) {
+	let n = {};
+	return e.forEach((e) => {
+		let r = new ResyncFollowsWalker(e).startWalking();
+		Object.assign(n, r);
+	}), n;
 }
-function buildBetweenProdsFollowPrefix(e, i) {
-	return e.name + i + IN;
+function buildBetweenProdsFollowPrefix(e, n) {
+	return e.name + n + IN;
 }
 export { computeAllProdsFollows };

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

@@ -1,15 +1,14 @@
-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 resolveGrammar$1(n) {
+	let i = Object.assign({ errMsgProvider: defaultGrammarResolverErrorProvider }, n), a = {};
+	return n.rules.forEach((e) => {
+		a[e.name] = e;
+	}), resolveGrammar(a, i.errMsgProvider);
 }
-function validateGrammar$1(i) {
-	return i = defaults_default(i, { errMsgProvider: defaultGrammarValidatorErrorProvider }), validateGrammar(i.rules, i.tokenTypes, i.errMsgProvider, i.grammarName);
+function validateGrammar$1(e) {
+	let r = e.errMsgProvider ?? defaultGrammarValidatorErrorProvider;
+	return validateGrammar(e.rules, e.tokenTypes, r, e.grammarName);
 }
 export { resolveGrammar$1 as resolveGrammar, validateGrammar$1 as validateGrammar };