@loopstack/loopstack-studio 0.25.0 → 0.25.2

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

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

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

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