@loopstack/loopstack-studio 0.25.0 → 0.25.1

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

@@ -1,43 +1,37 @@
-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;
+import { Alternation as e, Alternative as t, NonTerminal as n, Option as r, Repetition as i, RepetitionMandatory as a, RepetitionMandatoryWithSeparator as o, RepetitionWithSeparator as s, Rule as c, Terminal as l } from "../../../../../@chevrotain/gast/lib/src/model.js";
+import { RestWalker as u } from "./rest.js";
+import { first as d } from "./first.js";
+//#region ../../node_modules/chevrotain/lib/src/parse/grammar/interpreter.js
+var f = class extends u {
+	constructor(e, t) {
+		super(), this.topProd = e, this.path = t, 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, t = []) {
+		this.found || super.walk(e, t);
 	}
-	walkProdRef(e, d, f) {
+	walkProdRef(e, t, n) {
 		if (e.referencedRule.name === this.nextProductionName && e.idx === this.nextProductionOccurrence) {
-			let p = d.concat(f);
-			this.updateExpectedNext(), this.walk(e.referencedRule, p);
+			let r = t.concat(n);
+			this.updateExpectedNext(), this.walk(e.referencedRule, r);
 		}
 	}
 	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;
+}, p = class extends f {
+	constructor(e, t) {
+		super(e, t), this.path = t, 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, n, r) {
+		this.isAtEndOfPath && e.terminalType.name === this.nextTerminalName && e.idx === this.nextTerminalOccurrence && !this.found && (this.possibleTokTypes = d(new t({ definition: n.concat(r) })), this.found = !0);
 	}
-}, AbstractNextTerminalAfterProductionWalker = class extends RestWalker {
-	constructor(e, d) {
-		super(), this.topRule = e, this.occurrence = d, this.result = {
+}, m = class extends u {
+	constructor(e, t) {
+		super(), this.topRule = e, this.occurrence = t, this.result = {
 			token: void 0,
 			occurrence: void 0,
 			isEndOfRule: void 0
@@ -46,224 +40,225 @@ var AbstractNextPossibleTokensWalker = class extends RestWalker {
 	startWalking() {
 		return this.walk(this.topRule), this.result;
 	}
-}, NextTerminalAfterManyWalker = class extends AbstractNextTerminalAfterProductionWalker {
-	walkMany(e, d, f) {
+}, h = class extends m {
+	walkMany(e, t, n) {
 		if (e.idx === this.occurrence) {
-			let e = head_default(d.concat(f));
-			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);
+			let e = t.concat(n)[0];
+			this.result.isEndOfRule = e === void 0, e instanceof l && (this.result.token = e.terminalType, this.result.occurrence = e.idx);
+		} else super.walkMany(e, t, n);
 	}
-}, NextTerminalAfterManySepWalker = class extends AbstractNextTerminalAfterProductionWalker {
-	walkManySep(e, d, f) {
+}, g = class extends m {
+	walkManySep(e, t, n) {
 		if (e.idx === this.occurrence) {
-			let e = head_default(d.concat(f));
-			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);
+			let e = t.concat(n)[0];
+			this.result.isEndOfRule = e === void 0, e instanceof l && (this.result.token = e.terminalType, this.result.occurrence = e.idx);
+		} else super.walkManySep(e, t, n);
 	}
-}, NextTerminalAfterAtLeastOneWalker = class extends AbstractNextTerminalAfterProductionWalker {
-	walkAtLeastOne(e, d, f) {
+}, _ = class extends m {
+	walkAtLeastOne(e, t, n) {
 		if (e.idx === this.occurrence) {
-			let e = head_default(d.concat(f));
-			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);
+			let e = t.concat(n)[0];
+			this.result.isEndOfRule = e === void 0, e instanceof l && (this.result.token = e.terminalType, this.result.occurrence = e.idx);
+		} else super.walkAtLeastOne(e, t, n);
 	}
-}, NextTerminalAfterAtLeastOneSepWalker = class extends AbstractNextTerminalAfterProductionWalker {
-	walkAtLeastOneSep(e, d, f) {
+}, v = class extends m {
+	walkAtLeastOneSep(e, t, n) {
 		if (e.idx === this.occurrence) {
-			let e = head_default(d.concat(f));
-			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);
+			let e = t.concat(n)[0];
+			this.result.isEndOfRule = e === void 0, e instanceof l && (this.result.token = e.terminalType, this.result.occurrence = e.idx);
+		} else super.walkAtLeastOneSep(e, t, n);
 	}
 };
-function possiblePathsFrom(f, m, g = []) {
-	g = clone_default(g);
-	let _ = [], v = 0;
-	function y(e) {
-		return e.concat(drop_default(f, v + 1));
+function y(c, u, d = []) {
+	d = [...d];
+	let f = [], p = 0;
+	function m(e) {
+		return e.concat(c.slice(p + 1));
 	}
-	function b(e) {
-		let d = possiblePathsFrom(y(e), m, g);
-		return _.concat(d);
+	function h(e) {
+		let t = y(m(e), u, d);
+		return f.concat(t);
 	}
-	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 (; d.length < u && p < c.length;) {
+		let u = c[p];
+		if (u instanceof t || u instanceof n) return h(u.definition);
+		if (u instanceof r) f = h(u.definition);
+		else if (u instanceof a) return h(u.definition.concat([new i({ definition: u.definition })]));
+		else if (u instanceof o) return h([new t({ definition: u.definition }), new i({ definition: [new l({ terminalType: u.separator })].concat(u.definition) })]);
+		else if (u instanceof s) f = h(u.definition.concat([new i({ definition: [new l({ terminalType: u.separator })].concat(u.definition) })]));
+		else if (u instanceof i) f = h(u.definition.concat([new i({ definition: u.definition })]));
+		else if (u instanceof e) return u.definition.forEach((e) => {
+			e.definition.length !== 0 && (f = h(e.definition));
+		}), f;
+		else if (u instanceof l) d.push(u.terminalType);
 		else throw Error("non exhaustive match");
-		v++;
+		p++;
 	}
-	return _.push({
-		partialPath: g,
-		suffixDef: drop_default(f, v)
-	}), _;
+	return f.push({
+		partialPath: d,
+		suffixDef: c.slice(p)
+	}), f;
 }
-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 b(u, d, f, p) {
+	let m = "EXIT_NONE_TERMINAL", h = [m], g = "EXIT_ALTERNATIVE", _ = !1, v = d.length, y = v - p - 1, b = [], S = [];
+	for (S.push({
 		idx: -1,
-		def: h,
+		def: u,
 		ruleStack: [],
 		occurrenceStack: []
-	}); !isEmpty_default(D);) {
-		let h = D.pop();
-		if (h === S) {
-			C && last_default(D).idx <= T && D.pop();
+	}); S.length !== 0;) {
+		let u = S.pop();
+		if (u === g) {
+			_ && S.at(-1).idx <= y && 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 p = u.def, C = u.idx, w = u.ruleStack, T = u.occurrenceStack;
+		if (p.length === 0) continue;
+		let E = p[0];
 		/* istanbul ignore else */
-		if (j === b) {
+		if (E === m) {
 			let e = {
-				idx: O,
-				def: drop_default(y),
-				ruleStack: dropRight_default(k),
-				occurrenceStack: dropRight_default(A)
+				idx: C,
+				def: p.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 l)
  /* istanbul ignore else */
-		if (O < w - 1) {
-			let e = O + 1, d = g[e];
-			if (v(d, j.terminalType)) {
-				let d = {
+		if (C < v - 1) {
+			let e = C + 1, t = d[e];
+			if (f(t, E.terminalType)) {
+				let t = {
 					idx: e,
-					def: drop_default(y),
-					ruleStack: k,
-					occurrenceStack: A
+					def: p.slice(1),
+					ruleStack: w,
+					occurrenceStack: T
 				};
-				D.push(d);
+				S.push(t);
 			}
-		} else if (O === w - 1) E.push({
-			nextTokenType: j.terminalType,
-			nextTokenOccurrence: j.idx,
-			ruleStack: k,
-			occurrenceStack: A
-		}), C = !0;
+		} else if (C === v - 1) b.push({
+			nextTokenType: E.terminalType,
+			nextTokenOccurrence: E.idx,
+			ruleStack: w,
+			occurrenceStack: T
+		}), _ = !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 n) {
+			let e = [...w];
+			e.push(E.nonTerminalName);
+			let t = [...T];
+			t.push(E.idx);
+			let n = {
+				idx: C,
+				def: E.definition.concat(h, p.slice(1)),
 				ruleStack: e,
-				occurrenceStack: f
+				occurrenceStack: t
 			};
-			D.push(m);
-		} else if (j instanceof Option) {
+			S.push(n);
+		} else if (E instanceof r) {
 			let e = {
-				idx: O,
-				def: drop_default(y),
-				ruleStack: k,
-				occurrenceStack: A
+				idx: C,
+				def: p.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(g);
+			let t = {
+				idx: C,
+				def: E.definition.concat(p.slice(1)),
+				ruleStack: w,
+				occurrenceStack: T
 			};
-			D.push(d);
-		} else if (j 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
+			S.push(t);
+		} else if (E instanceof a) {
+			let e = new i({
+				definition: E.definition,
+				idx: E.idx
+			}), t = {
+				idx: C,
+				def: E.definition.concat([e], p.slice(1)),
+				ruleStack: w,
+				occurrenceStack: T
 			};
-			D.push(d);
-		} else if (j 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
+			S.push(t);
+		} else if (E instanceof o) {
+			let e = new i({
+				definition: [new l({ terminalType: E.separator })].concat(E.definition),
+				idx: E.idx
+			}), t = {
+				idx: C,
+				def: E.definition.concat([e], p.slice(1)),
+				ruleStack: w,
+				occurrenceStack: T
 			};
-			D.push(d);
-		} else if (j instanceof RepetitionWithSeparator) {
+			S.push(t);
+		} else if (E instanceof s) {
 			let e = {
-				idx: O,
-				def: drop_default(y),
-				ruleStack: k,
-				occurrenceStack: A
+				idx: C,
+				def: p.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(g);
+			let t = new i({
+				definition: [new l({ terminalType: E.separator })].concat(E.definition),
+				idx: E.idx
+			}), n = {
+				idx: C,
+				def: E.definition.concat([t], p.slice(1)),
+				ruleStack: w,
+				occurrenceStack: T
 			};
-			D.push(f);
-		} else if (j instanceof Repetition) {
+			S.push(n);
+		} else if (E instanceof i) {
 			let e = {
-				idx: O,
-				def: drop_default(y),
-				ruleStack: k,
-				occurrenceStack: A
+				idx: C,
+				def: p.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(g);
+			let t = new i({
+				definition: E.definition,
+				idx: E.idx
+			}), n = {
+				idx: C,
+				def: E.definition.concat([t], p.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(n);
+		} else if (E instanceof e) for (let e = E.definition.length - 1; e >= 0; e--) {
+			let t = {
+				idx: C,
+				def: E.definition[e].definition.concat(p.slice(1)),
+				ruleStack: w,
+				occurrenceStack: T
 			};
-			D.push(d), D.push(S);
+			S.push(t), S.push(g);
 		}
-		else if (j instanceof Alternative) D.push({
-			idx: O,
-			def: j.definition.concat(drop_default(y)),
-			ruleStack: k,
-			occurrenceStack: A
+		else if (E instanceof t) S.push({
+			idx: C,
+			def: E.definition.concat(p.slice(1)),
+			ruleStack: w,
+			occurrenceStack: T
 		});
-		else if (j instanceof Rule) D.push(expandTopLevelRule(j, O, k, A));
+		else if (E instanceof c) S.push(x(E, C, w, T));
 		else throw Error("non exhaustive match");
 	}
-	return E;
+	return b;
 }
-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 x(e, t, n, r) {
+	let i = [...n];
+	i.push(e.name);
+	let a = [...r];
+	return a.push(1), {
+		idx: t,
 		def: e.definition,
-		ruleStack: h,
-		occurrenceStack: g
+		ruleStack: i,
+		occurrenceStack: a
 	};
 }
-export { NextAfterTokenWalker, NextTerminalAfterAtLeastOneSepWalker, NextTerminalAfterAtLeastOneWalker, NextTerminalAfterManySepWalker, NextTerminalAfterManyWalker, nextPossibleTokensAfter, possiblePathsFrom };
+//#endregion
+export { p as NextAfterTokenWalker, v as NextTerminalAfterAtLeastOneSepWalker, _ as NextTerminalAfterAtLeastOneWalker, g as NextTerminalAfterManySepWalker, h as NextTerminalAfterManyWalker, b as nextPossibleTokensAfter, y as possiblePathsFrom };

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

@@ -1,5 +1,6 @@
-const BITS_FOR_METHOD_TYPE = 4, BITS_FOR_OCCURRENCE_IDX = 8, OR_IDX = 256, OPTION_IDX = 512, MANY_IDX = 768, AT_LEAST_ONE_IDX = 1024, MANY_SEP_IDX = 1280, AT_LEAST_ONE_SEP_IDX = 1536;
-function getKeyForAutomaticLookahead(e, s, c) {
-	return c | s | e;
+var e = 1024, t = 1280, n = 1536;
+function r(e, t, n) {
+	return n | t | e;
 }
-export { AT_LEAST_ONE_IDX, AT_LEAST_ONE_SEP_IDX, BITS_FOR_METHOD_TYPE, BITS_FOR_OCCURRENCE_IDX, MANY_IDX, MANY_SEP_IDX, OPTION_IDX, OR_IDX, getKeyForAutomaticLookahead };
+//#endregion
+export { e as AT_LEAST_ONE_IDX, n as AT_LEAST_ONE_SEP_IDX, t as MANY_SEP_IDX, r as getKeyForAutomaticLookahead };

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

@@ -1,43 +1,43 @@
-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";
-import { DEFAULT_PARSER_CONFIG } from "../parser/parser.js";
-var LLkLookaheadStrategy = class {
+import { defaultGrammarValidatorErrorProvider as e } from "../errors_public.js";
+import { buildAlternativesLookAheadFunc as t, buildLookaheadFuncForOptionalProd as n, buildLookaheadFuncForOr as r, buildSingleAlternativeLookaheadFunction as i, getProdType as a } from "./lookahead.js";
+import { validateAmbiguousAlternationAlternatives as o, validateEmptyOrAlternative as s, validateNoLeftRecursion as c, validateSomeNonEmptyLookaheadPath as l } from "./checks.js";
+import { DEFAULT_PARSER_CONFIG as u } from "../parser/parser.js";
+//#region ../../node_modules/chevrotain/lib/src/parse/grammar/llk_lookahead.js
+var d = class {
 	constructor(e) {
-		this.maxLookahead = e?.maxLookahead ?? DEFAULT_PARSER_CONFIG.maxLookahead;
+		this.maxLookahead = e?.maxLookahead ?? u.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 t = this.validateNoLeftRecursion(e.rules);
+		if (t.length === 0) {
+			let n = this.validateEmptyOrAlternatives(e.rules), r = this.validateAmbiguousAlternationAlternatives(e.rules, this.maxLookahead), i = this.validateSomeNonEmptyLookaheadPath(e.rules, this.maxLookahead);
 			return [
-				...d,
-				...e,
-				...f,
-				...p
+				...t,
+				...n,
+				...r,
+				...i
 			];
 		}
-		return d;
+		return t;
 	}
-	validateNoLeftRecursion(e) {
-		return flatMap_default(e, (e) => validateNoLeftRecursion(e, e, defaultGrammarValidatorErrorProvider));
+	validateNoLeftRecursion(t) {
+		return t.flatMap((t) => c(t, t, e));
 	}
-	validateEmptyOrAlternatives(e) {
-		return flatMap_default(e, (e) => validateEmptyOrAlternative(e, defaultGrammarValidatorErrorProvider));
+	validateEmptyOrAlternatives(t) {
+		return t.flatMap((t) => s(t, e));
 	}
-	validateAmbiguousAlternationAlternatives(e, f) {
-		return flatMap_default(e, (e) => validateAmbiguousAlternationAlternatives(e, f, defaultGrammarValidatorErrorProvider));
+	validateAmbiguousAlternationAlternatives(t, n) {
+		return t.flatMap((t) => o(t, n, e));
 	}
-	validateSomeNonEmptyLookaheadPath(e, u) {
-		return validateSomeNonEmptyLookaheadPath(e, u, defaultGrammarValidatorErrorProvider);
+	validateSomeNonEmptyLookaheadPath(t, n) {
+		return l(t, n, e);
 	}
 	buildLookaheadForAlternation(e) {
-		return buildLookaheadFuncForOr(e.prodOccurrence, e.rule, e.maxLookahead, e.hasPredicates, e.dynamicTokensEnabled, buildAlternativesLookAheadFunc);
+		return r(e.prodOccurrence, e.rule, e.maxLookahead, e.hasPredicates, e.dynamicTokensEnabled, t);
 	}
 	buildLookaheadForOptional(e) {
-		return buildLookaheadFuncForOptionalProd(e.prodOccurrence, e.rule, e.maxLookahead, e.dynamicTokensEnabled, getProdType(e.prodType), buildSingleAlternativeLookaheadFunction);
+		return n(e.prodOccurrence, e.rule, e.maxLookahead, e.dynamicTokensEnabled, a(e.prodType), i);
 	}
 };
-export { LLkLookaheadStrategy };
+//#endregion
+export { d as LLkLookaheadStrategy };