@loopstack/loopstack-studio 0.25.0 → 0.25.2

package/dist/node_modules/chevrotain/lib/src/scan/tokens_public.js

@@ -1,42 +1,39 @@
-import has_default from "../../../../lodash-es/has.js";
-import isString_default from "../../../../lodash-es/isString.js";
-import isUndefined_default from "../../../../lodash-es/isUndefined.js";
 import { augmentTokenTypes, tokenStructuredMatcher } from "./tokens.js";
 import { Lexer } from "./lexer_public.js";
 function tokenLabel(e) {
 	return hasTokenLabel(e) ? e.LABEL : e.name;
 }
 function hasTokenLabel(e) {
-	return isString_default(e.LABEL) && e.LABEL !== "";
+	return typeof e.LABEL == "string" && e.LABEL !== "";
 }
 var PARENT = "parent", CATEGORIES = "categories", LABEL = "label", GROUP = "group", PUSH_MODE = "push_mode", POP_MODE = "pop_mode", LONGER_ALT = "longer_alt", LINE_BREAKS = "line_breaks", START_CHARS_HINT = "start_chars_hint";
 function createToken(e) {
 	return createTokenInternal(e);
 }
-function createTokenInternal(h) {
-	let v = h.pattern, y = {};
-	if (y.name = h.name, isUndefined_default(v) || (y.PATTERN = v), has_default(h, PARENT)) throw "The parent property is no longer supported.\nSee: https://github.com/chevrotain/chevrotain/issues/564#issuecomment-349062346 for details.";
-	return has_default(h, CATEGORIES) && (y.CATEGORIES = h[CATEGORIES]), augmentTokenTypes([y]), has_default(h, LABEL) && (y.LABEL = h[LABEL]), has_default(h, GROUP) && (y.GROUP = h[GROUP]), has_default(h, POP_MODE) && (y.POP_MODE = h[POP_MODE]), has_default(h, PUSH_MODE) && (y.PUSH_MODE = h[PUSH_MODE]), has_default(h, LONGER_ALT) && (y.LONGER_ALT = h[LONGER_ALT]), has_default(h, LINE_BREAKS) && (y.LINE_BREAKS = h[LINE_BREAKS]), has_default(h, START_CHARS_HINT) && (y.START_CHARS_HINT = h[START_CHARS_HINT]), y;
+function createTokenInternal(f) {
+	let p = f.pattern, m = {};
+	if (m.name = f.name, p !== void 0 && (m.PATTERN = p), Object.hasOwn(f, PARENT)) throw "The parent property is no longer supported.\nSee: https://github.com/chevrotain/chevrotain/issues/564#issuecomment-349062346 for details.";
+	return Object.hasOwn(f, CATEGORIES) && (m.CATEGORIES = f[CATEGORIES]), augmentTokenTypes([m]), Object.hasOwn(f, LABEL) && (m.LABEL = f[LABEL]), Object.hasOwn(f, GROUP) && (m.GROUP = f[GROUP]), Object.hasOwn(f, POP_MODE) && (m.POP_MODE = f[POP_MODE]), Object.hasOwn(f, PUSH_MODE) && (m.PUSH_MODE = f[PUSH_MODE]), Object.hasOwn(f, LONGER_ALT) && (m.LONGER_ALT = f[LONGER_ALT]), Object.hasOwn(f, LINE_BREAKS) && (m.LINE_BREAKS = f[LINE_BREAKS]), Object.hasOwn(f, START_CHARS_HINT) && (m.START_CHARS_HINT = f[START_CHARS_HINT]), m;
 }
 const EOF = createToken({
 	name: "EOF",
 	pattern: Lexer.NA
 });
 augmentTokenTypes([EOF]);
-function createTokenInstance(e, h, g, _, v, y, b, x) {
+function createTokenInstance(e, f, p, m, h, g, _, v) {
 	return {
-		image: h,
-		startOffset: g,
-		endOffset: _,
-		startLine: v,
-		endLine: y,
-		startColumn: b,
-		endColumn: x,
+		image: f,
+		startOffset: p,
+		endOffset: m,
+		startLine: h,
+		endLine: g,
+		startColumn: _,
+		endColumn: v,
 		tokenTypeIdx: e.tokenTypeIdx,
 		tokenType: e
 	};
 }
-function tokenMatcher(e, h) {
-	return tokenStructuredMatcher(e, h);
+function tokenMatcher(e, p) {
+	return tokenStructuredMatcher(e, p);
 }
 export { EOF, createToken, createTokenInstance, hasTokenLabel, tokenLabel, tokenMatcher };

package/dist/node_modules/chevrotain-allstar/lib/all-star-lookahead.js

@@ -1,50 +1,50 @@
 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 map_default from "../../lodash-es/map.js";
-import flatMap_default from "../../lodash-es/flatMap.js";
-import min_default from "../../lodash-es/min.js";
-import reduce_default from "../../lodash-es/reduce.js";
-import uniqBy_default from "../../lodash-es/uniqBy.js";
 import { Alternation, NonTerminal, Option, Repetition, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Terminal } from "../../@chevrotain/gast/lib/src/model.js";
 import { tokenLabel, tokenMatcher } from "../../chevrotain/lib/src/scan/tokens_public.js";
 import { getLookaheadPaths } from "../../chevrotain/lib/src/parse/grammar/lookahead.js";
 import { LLkLookaheadStrategy } from "../../chevrotain/lib/src/parse/grammar/llk_lookahead.js";
 import "../../chevrotain/lib/src/api.js";
+import map_default from "../../lodash-es/map.js";
 import { ATN_RULE_STOP, AtomTransition, EpsilonTransition, RuleTransition, buildATNKey, createATN } from "./atn.js";
 import { ATNConfigSet, DFA_ERROR, getATNConfigKey } from "./dfa.js";
-function createDFACache(d, B) {
-	let V = {};
-	return (H) => {
-		let U = H.toString(), W = V[U];
-		return W === void 0 ? (W = {
-			atnStartState: d,
-			decision: B,
+import min_default from "../../lodash-es/min.js";
+import flatMap_default from "../../lodash-es/flatMap.js";
+import uniqBy_default from "../../lodash-es/uniqBy.js";
+import flatten_default from "../../lodash-es/flatten.js";
+import forEach_default from "../../lodash-es/forEach.js";
+import reduce_default from "../../lodash-es/reduce.js";
+function createDFACache(h, W) {
+	let G = {};
+	return (K) => {
+		let q = K.toString(), J = G[q];
+		return J === void 0 ? (J = {
+			atnStartState: h,
+			decision: W,
 			states: {}
-		}, V[U] = W, W) : W;
+		}, G[q] = J, J) : J;
 	};
 }
 var PredicateSet = class {
 	constructor() {
 		this.predicates = [];
 	}
-	is(d) {
-		return d >= this.predicates.length || this.predicates[d];
+	is(h) {
+		return h >= this.predicates.length || this.predicates[h];
 	}
-	set(d, B) {
-		this.predicates[d] = B;
+	set(h, W) {
+		this.predicates[h] = W;
 	}
 	toString() {
-		let d = "", B = this.predicates.length;
-		for (let V = 0; V < B; V++) d += this.predicates[V] === !0 ? "1" : "0";
-		return d;
+		let h = "", W = this.predicates.length;
+		for (let G = 0; G < W; G++) h += this.predicates[G] === !0 ? "1" : "0";
+		return h;
 	}
 }, EMPTY_PREDICATES = new PredicateSet(), LLStarLookaheadStrategy = class extends LLkLookaheadStrategy {
-	constructor(d) {
-		super(), this.logging = d?.logging ?? ((d) => console.log(d));
+	constructor(h) {
+		super(), this.logging = h?.logging ?? ((h) => console.log(h));
 	}
-	initialize(d) {
-		this.atn = createATN(d.rules), this.dfas = initATNSimulator(this.atn);
+	initialize(h) {
+		this.atn = createATN(h.rules), this.dfas = initATNSimulator(this.atn);
 	}
 	validateAmbiguousAlternationAlternatives() {
 		return [];
@@ -52,295 +52,295 @@ var PredicateSet = class {
 	validateEmptyOrAlternatives() {
 		return [];
 	}
-	buildLookaheadForAlternation(d) {
-		let { prodOccurrence: B, rule: U, hasPredicates: W, dynamicTokensEnabled: K } = d, q = this.dfas, J = this.logging, Y = buildATNKey(U, "Alternation", B), X = this.atn.decisionMap[Y].decision, Z = map_default(getLookaheadPaths({
+	buildLookaheadForAlternation(h) {
+		let { prodOccurrence: W, rule: G, hasPredicates: K, dynamicTokensEnabled: q } = h, J = this.dfas, Y = this.logging, X = buildATNKey(G, "Alternation", W), Z = this.atn.decisionMap[X].decision, Q = map_default(getLookaheadPaths({
 			maxLookahead: 1,
-			occurrence: B,
+			occurrence: W,
 			prodType: "Alternation",
-			rule: U
-		}), (d) => map_default(d, (d) => d[0]));
-		if (isLL1Sequence(Z, !1) && !K) {
-			let d = reduce_default(Z, (d, B, H) => (forEach_default(B, (B) => {
-				B && (d[B.tokenTypeIdx] = H, forEach_default(B.categoryMatches, (B) => {
-					d[B] = H;
+			rule: G
+		}), (h) => map_default(h, (h) => h[0]));
+		if (isLL1Sequence(Q, !1) && !q) {
+			let h = reduce_default(Q, (h, W, G) => (forEach_default(W, (W) => {
+				W && (h[W.tokenTypeIdx] = G, forEach_default(W.categoryMatches, (W) => {
+					h[W] = G;
 				}));
-			}), d), {});
-			return W ? function(B) {
-				let V = d[this.LA(1).tokenTypeIdx];
-				if (B !== void 0 && V !== void 0) {
-					let d = B[V]?.GATE;
-					if (d !== void 0 && d.call(this) === !1) return;
+			}), h), {});
+			return K ? function(W) {
+				let G = h[this.LA_FAST(1).tokenTypeIdx];
+				if (W !== void 0 && G !== void 0) {
+					let h = W[G]?.GATE;
+					if (h !== void 0 && h.call(this) === !1) return;
 				}
-				return V;
+				return G;
 			} : function() {
-				return d[this.LA(1).tokenTypeIdx];
+				return h[this.LA_FAST(1).tokenTypeIdx];
 			};
-		} else if (W) return function(d) {
-			let B = new PredicateSet(), V = d === void 0 ? 0 : d.length;
-			for (let H = 0; H < V; H++) {
-				let V = d?.[H].GATE;
-				B.set(H, V === void 0 || V.call(this));
+		} else if (K) return function(h) {
+			let W = new PredicateSet(), G = h === void 0 ? 0 : h.length;
+			for (let K = 0; K < G; K++) {
+				let G = h?.[K].GATE;
+				W.set(K, G === void 0 || G.call(this));
 			}
-			let H = adaptivePredict.call(this, q, X, B, J);
-			return typeof H == "number" ? H : void 0;
+			let K = adaptivePredict.call(this, J, Z, W, Y);
+			return typeof K == "number" ? K : void 0;
 		};
 		else return function() {
-			let d = adaptivePredict.call(this, q, X, EMPTY_PREDICATES, J);
-			return typeof d == "number" ? d : void 0;
+			let h = adaptivePredict.call(this, J, Z, EMPTY_PREDICATES, Y);
+			return typeof h == "number" ? h : void 0;
 		};
 	}
-	buildLookaheadForOptional(U) {
-		let { prodOccurrence: W, rule: K, prodType: q, dynamicTokensEnabled: J } = U, Y = this.dfas, X = this.logging, Z = buildATNKey(K, q, W), Q = this.atn.decisionMap[Z].decision, $ = map_default(getLookaheadPaths({
+	buildLookaheadForOptional(W) {
+		let { prodOccurrence: G, rule: K, prodType: q, dynamicTokensEnabled: J } = W, Y = this.dfas, X = this.logging, Z = buildATNKey(K, q, G), Q = this.atn.decisionMap[Z].decision, $ = map_default(getLookaheadPaths({
 			maxLookahead: 1,
-			occurrence: W,
+			occurrence: G,
 			prodType: q,
 			rule: K
-		}), (d) => map_default(d, (d) => d[0]));
+		}), (h) => map_default(h, (h) => h[0]));
 		if (isLL1Sequence($) && $[0][0] && !J) {
-			let H = $[0], U = flatten_default(H);
-			if (U.length === 1 && isEmpty_default(U[0].categoryMatches)) {
-				let d = U[0].tokenTypeIdx;
+			let W = $[0], G = flatten_default(W);
+			if (G.length === 1 && isEmpty_default(G[0].categoryMatches)) {
+				let h = G[0].tokenTypeIdx;
 				return function() {
-					return this.LA(1).tokenTypeIdx === d;
+					return this.LA_FAST(1).tokenTypeIdx === h;
 				};
 			} else {
-				let d = reduce_default(U, (d, B) => (B !== void 0 && (d[B.tokenTypeIdx] = !0, forEach_default(B.categoryMatches, (B) => {
-					d[B] = !0;
-				})), d), {});
+				let h = reduce_default(G, (h, W) => (W !== void 0 && (h[W.tokenTypeIdx] = !0, forEach_default(W.categoryMatches, (W) => {
+					h[W] = !0;
+				})), h), {});
 				return function() {
-					return d[this.LA(1).tokenTypeIdx] === !0;
+					return h[this.LA_FAST(1).tokenTypeIdx] === !0;
 				};
 			}
 		}
 		return function() {
-			let d = adaptivePredict.call(this, Y, Q, EMPTY_PREDICATES, X);
-			return typeof d == "object" ? !1 : d === 0;
+			let h = adaptivePredict.call(this, Y, Q, EMPTY_PREDICATES, X);
+			return typeof h == "object" ? !1 : h === 0;
 		};
 	}
 };
-function isLL1Sequence(d, B = !0) {
-	let V = /* @__PURE__ */ new Set();
-	for (let H of d) {
-		let d = /* @__PURE__ */ new Set();
-		for (let U of H) {
-			if (U === void 0) {
-				if (B) break;
+function isLL1Sequence(h, W = !0) {
+	let G = /* @__PURE__ */ new Set();
+	for (let K of h) {
+		let h = /* @__PURE__ */ new Set();
+		for (let q of K) {
+			if (q === void 0) {
+				if (W) break;
 				return !1;
 			}
-			let H = [U.tokenTypeIdx].concat(U.categoryMatches);
-			for (let B of H) if (V.has(B)) {
-				if (!d.has(B)) return !1;
-			} else V.add(B), d.add(B);
+			let K = [q.tokenTypeIdx].concat(q.categoryMatches);
+			for (let W of K) if (G.has(W)) {
+				if (!h.has(W)) return !1;
+			} else G.add(W), h.add(W);
 		}
 	}
 	return !0;
 }
-function initATNSimulator(d) {
-	let B = d.decisionStates.length, V = Array(B);
-	for (let H = 0; H < B; H++) V[H] = createDFACache(d.decisionStates[H], H);
-	return V;
+function initATNSimulator(h) {
+	let W = h.decisionStates.length, G = Array(W);
+	for (let K = 0; K < W; K++) G[K] = createDFACache(h.decisionStates[K], K);
+	return G;
 }
-function adaptivePredict(d, B, V, H) {
-	let U = d[B](V), W = U.start;
-	return W === void 0 && (W = addDFAState(U, newDFAState(computeStartState(U.atnStartState))), U.start = W), performLookahead.apply(this, [
-		U,
-		W,
-		V,
-		H
+function adaptivePredict(h, W, G, K) {
+	let q = h[W](G), J = q.start;
+	return J === void 0 && (J = addDFAState(q, newDFAState(computeStartState(q.atnStartState))), q.start = J), performLookahead.apply(this, [
+		q,
+		J,
+		G,
+		K
 	]);
 }
-function performLookahead(d, B, V, H) {
-	let U = B, W = 1, G = [], K = this.LA(W++);
+function performLookahead(h, W, G, K) {
+	let q = W, J = 1, Y = [], X = this.LA_FAST(J++);
 	for (;;) {
-		let B = getExistingTargetState(U, K);
-		if (B === void 0 && (B = computeLookaheadTarget.apply(this, [
-			d,
-			U,
-			K,
-			W,
-			V,
-			H
-		])), B === DFA_ERROR) return buildAdaptivePredictError(G, U, K);
-		if (B.isAcceptState === !0) return B.prediction;
-		U = B, G.push(K), K = this.LA(W++);
+		let W = getExistingTargetState(q, X);
+		if (W === void 0 && (W = computeLookaheadTarget.apply(this, [
+			h,
+			q,
+			X,
+			J,
+			G,
+			K
+		])), W === DFA_ERROR) return buildAdaptivePredictError(Y, q, X);
+		if (W.isAcceptState === !0) return W.prediction;
+		q = W, Y.push(X), X = this.LA(J++);
 	}
 }
-function computeLookaheadTarget(d, B, V, H, U, G) {
-	let K = computeReachSet(B.configs, V, U);
-	if (K.size === 0) return addDFAEdge(d, B, V, DFA_ERROR), DFA_ERROR;
-	let q = newDFAState(K), J = getUniqueAlt(K, U);
-	if (J !== void 0) q.isAcceptState = !0, q.prediction = J, q.configs.uniqueAlt = J;
-	else if (hasConflictTerminatingPrediction(K)) {
-		let B = min_default(K.alts);
-		q.isAcceptState = !0, q.prediction = B, q.configs.uniqueAlt = B, reportLookaheadAmbiguity.apply(this, [
-			d,
-			H,
-			K.alts,
-			G
+function computeLookaheadTarget(h, W, G, K, q, J) {
+	let Y = computeReachSet(W.configs, G, q);
+	if (Y.size === 0) return addDFAEdge(h, W, G, DFA_ERROR), DFA_ERROR;
+	let X = newDFAState(Y), Z = getUniqueAlt(Y, q);
+	if (Z !== void 0) X.isAcceptState = !0, X.prediction = Z, X.configs.uniqueAlt = Z;
+	else if (hasConflictTerminatingPrediction(Y)) {
+		let W = min_default(Y.alts);
+		X.isAcceptState = !0, X.prediction = W, X.configs.uniqueAlt = W, reportLookaheadAmbiguity.apply(this, [
+			h,
+			K,
+			Y.alts,
+			J
 		]);
 	}
-	return q = addDFAEdge(d, B, V, q), q;
+	return X = addDFAEdge(h, W, G, X), X;
 }
-function reportLookaheadAmbiguity(d, B, V, H) {
-	let U = [];
-	for (let d = 1; d <= B; d++) U.push(this.LA(d).tokenType);
-	let W = d.atnStartState, G = W.rule, K = W.production;
-	H(buildAmbiguityError({
-		topLevelRule: G,
-		ambiguityIndices: V,
-		production: K,
-		prefixPath: U
+function reportLookaheadAmbiguity(h, W, G, K) {
+	let q = [];
+	for (let h = 1; h <= W; h++) q.push(this.LA(h).tokenType);
+	let J = h.atnStartState, Y = J.rule, X = J.production;
+	K(buildAmbiguityError({
+		topLevelRule: Y,
+		ambiguityIndices: G,
+		production: X,
+		prefixPath: q
 	}));
 }
-function buildAmbiguityError(d) {
-	let B = map_default(d.prefixPath, (d) => tokenLabel(d)).join(", "), V = d.production.idx === 0 ? "" : d.production.idx, U = `Ambiguous Alternatives Detected: <${d.ambiguityIndices.join(", ")}> in <${getProductionDslName(d.production)}${V}> inside <${d.topLevelRule.name}> Rule,\n<${B}> may appears as a prefix path in all these alternatives.\n`;
-	return U += "See: https://chevrotain.io/docs/guide/resolving_grammar_errors.html#AMBIGUOUS_ALTERNATIVES\nFor Further details.", U;
+function buildAmbiguityError(h) {
+	let W = map_default(h.prefixPath, (h) => tokenLabel(h)).join(", "), G = h.production.idx === 0 ? "" : h.production.idx, K = `Ambiguous Alternatives Detected: <${h.ambiguityIndices.join(", ")}> in <${getProductionDslName(h.production)}${G}> inside <${h.topLevelRule.name}> Rule,\n<${W}> may appears as a prefix path in all these alternatives.\n`;
+	return K += "See: https://chevrotain.io/docs/guide/resolving_grammar_errors.html#AMBIGUOUS_ALTERNATIVES\nFor Further details.", K;
 }
-function getProductionDslName(d) {
-	if (d instanceof NonTerminal) return "SUBRULE";
-	if (d instanceof Option) return "OPTION";
-	if (d instanceof Alternation) return "OR";
-	if (d instanceof RepetitionMandatory) return "AT_LEAST_ONE";
-	if (d instanceof RepetitionMandatoryWithSeparator) return "AT_LEAST_ONE_SEP";
-	if (d instanceof RepetitionWithSeparator) return "MANY_SEP";
-	if (d instanceof Repetition) return "MANY";
-	if (d instanceof Terminal) return "CONSUME";
+function getProductionDslName(h) {
+	if (h instanceof NonTerminal) return "SUBRULE";
+	if (h instanceof Option) return "OPTION";
+	if (h instanceof Alternation) return "OR";
+	if (h instanceof RepetitionMandatory) return "AT_LEAST_ONE";
+	if (h instanceof RepetitionMandatoryWithSeparator) return "AT_LEAST_ONE_SEP";
+	if (h instanceof RepetitionWithSeparator) return "MANY_SEP";
+	if (h instanceof Repetition) return "MANY";
+	if (h instanceof Terminal) return "CONSUME";
 	throw Error("non exhaustive match");
 }
-function buildAdaptivePredictError(d, B, V) {
+function buildAdaptivePredictError(h, W, G) {
 	return {
-		actualToken: V,
-		possibleTokenTypes: uniqBy_default(flatMap_default(B.configs.elements, (d) => d.state.transitions).filter((d) => d instanceof AtomTransition).map((d) => d.tokenType), (d) => d.tokenTypeIdx),
-		tokenPath: d
+		actualToken: G,
+		possibleTokenTypes: uniqBy_default(flatMap_default(W.configs.elements, (h) => h.state.transitions).filter((h) => h instanceof AtomTransition).map((h) => h.tokenType), (h) => h.tokenTypeIdx),
+		tokenPath: h
 	};
 }
-function getExistingTargetState(d, B) {
-	return d.edges[B.tokenTypeIdx];
+function getExistingTargetState(h, W) {
+	return h.edges[W.tokenTypeIdx];
 }
-function computeReachSet(d, B, V) {
-	let H = new ATNConfigSet(), U = [];
-	for (let W of d.elements) {
-		if (V.is(W.alt) === !1) continue;
-		if (W.state.type === 7) {
-			U.push(W);
+function computeReachSet(h, W, G) {
+	let K = new ATNConfigSet(), q = [];
+	for (let J of h.elements) {
+		if (G.is(J.alt) === !1) continue;
+		if (J.state.type === 7) {
+			q.push(J);
 			continue;
 		}
-		let d = W.state.transitions.length;
-		for (let V = 0; V < d; V++) {
-			let d = W.state.transitions[V], U = getReachableTarget(d, B);
-			U !== void 0 && H.add({
-				state: U,
-				alt: W.alt,
-				stack: W.stack
+		let h = J.state.transitions.length;
+		for (let G = 0; G < h; G++) {
+			let h = J.state.transitions[G], q = getReachableTarget(h, W);
+			q !== void 0 && K.add({
+				state: q,
+				alt: J.alt,
+				stack: J.stack
 			});
 		}
 	}
-	let W;
-	if (U.length === 0 && H.size === 1 && (W = H), W === void 0) {
-		W = new ATNConfigSet();
-		for (let d of H.elements) closure(d, W);
+	let J;
+	if (q.length === 0 && K.size === 1 && (J = K), J === void 0) {
+		J = new ATNConfigSet();
+		for (let h of K.elements) closure(h, J);
 	}
-	if (U.length > 0 && !hasConfigInRuleStopState(W)) for (let d of U) W.add(d);
-	return W;
+	if (q.length > 0 && !hasConfigInRuleStopState(J)) for (let h of q) J.add(h);
+	return J;
 }
-function getReachableTarget(d, B) {
-	if (d instanceof AtomTransition && tokenMatcher(B, d.tokenType)) return d.target;
+function getReachableTarget(h, W) {
+	if (h instanceof AtomTransition && tokenMatcher(W, h.tokenType)) return h.target;
 }
-function getUniqueAlt(d, B) {
-	let V;
-	for (let H of d.elements) if (B.is(H.alt) === !0) {
-		if (V === void 0) V = H.alt;
-		else if (V !== H.alt) return;
+function getUniqueAlt(h, W) {
+	let G;
+	for (let K of h.elements) if (W.is(K.alt) === !0) {
+		if (G === void 0) G = K.alt;
+		else if (G !== K.alt) return;
 	}
-	return V;
+	return G;
 }
-function newDFAState(d) {
+function newDFAState(h) {
 	return {
-		configs: d,
+		configs: h,
 		edges: {},
 		isAcceptState: !1,
 		prediction: -1
 	};
 }
-function addDFAEdge(d, B, V, H) {
-	return H = addDFAState(d, H), B.edges[V.tokenTypeIdx] = H, H;
+function addDFAEdge(h, W, G, K) {
+	return K = addDFAState(h, K), W.edges[G.tokenTypeIdx] = K, K;
 }
-function addDFAState(d, B) {
-	if (B === DFA_ERROR) return B;
-	let V = B.configs.key, H = d.states[V];
-	return H === void 0 ? (B.configs.finalize(), d.states[V] = B, B) : H;
+function addDFAState(h, W) {
+	if (W === DFA_ERROR) return W;
+	let G = W.configs.key, K = h.states[G];
+	return K === void 0 ? (W.configs.finalize(), h.states[G] = W, W) : K;
 }
-function computeStartState(d) {
-	let B = new ATNConfigSet(), V = d.transitions.length;
-	for (let H = 0; H < V; H++) closure({
-		state: d.transitions[H].target,
-		alt: H,
+function computeStartState(h) {
+	let W = new ATNConfigSet(), G = h.transitions.length;
+	for (let K = 0; K < G; K++) closure({
+		state: h.transitions[K].target,
+		alt: K,
 		stack: []
-	}, B);
-	return B;
+	}, W);
+	return W;
 }
-function closure(d, B) {
-	let V = d.state;
-	if (V.type === 7) {
-		if (d.stack.length > 0) {
-			let V = [...d.stack];
+function closure(h, W) {
+	let G = h.state;
+	if (G.type === 7) {
+		if (h.stack.length > 0) {
+			let G = [...h.stack];
 			closure({
-				state: V.pop(),
-				alt: d.alt,
-				stack: V
-			}, B);
-		} else B.add(d);
+				state: G.pop(),
+				alt: h.alt,
+				stack: G
+			}, W);
+		} else W.add(h);
 		return;
 	}
-	V.epsilonOnlyTransitions || B.add(d);
-	let H = V.transitions.length;
-	for (let U = 0; U < H; U++) {
-		let H = V.transitions[U], W = getEpsilonTarget(d, H);
-		W !== void 0 && closure(W, B);
+	G.epsilonOnlyTransitions || W.add(h);
+	let K = G.transitions.length;
+	for (let q = 0; q < K; q++) {
+		let K = G.transitions[q], J = getEpsilonTarget(h, K);
+		J !== void 0 && closure(J, W);
 	}
 }
-function getEpsilonTarget(d, B) {
-	if (B instanceof EpsilonTransition) return {
-		state: B.target,
-		alt: d.alt,
-		stack: d.stack
+function getEpsilonTarget(h, W) {
+	if (W instanceof EpsilonTransition) return {
+		state: W.target,
+		alt: h.alt,
+		stack: h.stack
 	};
-	if (B instanceof RuleTransition) {
-		let V = [...d.stack, B.followState];
+	if (W instanceof RuleTransition) {
+		let G = [...h.stack, W.followState];
 		return {
-			state: B.target,
-			alt: d.alt,
-			stack: V
+			state: W.target,
+			alt: h.alt,
+			stack: G
 		};
 	}
 }
-function hasConfigInRuleStopState(d) {
-	for (let B of d.elements) if (B.state.type === 7) return !0;
+function hasConfigInRuleStopState(h) {
+	for (let W of h.elements) if (W.state.type === 7) return !0;
 	return !1;
 }
-function allConfigsInRuleStopStates(d) {
-	for (let B of d.elements) if (B.state.type !== 7) return !1;
+function allConfigsInRuleStopStates(h) {
+	for (let W of h.elements) if (W.state.type !== 7) return !1;
 	return !0;
 }
-function hasConflictTerminatingPrediction(d) {
-	if (allConfigsInRuleStopStates(d)) return !0;
-	let B = getConflictingAltSets(d.elements);
-	return hasConflictingAltSet(B) && !hasStateAssociatedWithOneAlt(B);
+function hasConflictTerminatingPrediction(h) {
+	if (allConfigsInRuleStopStates(h)) return !0;
+	let W = getConflictingAltSets(h.elements);
+	return hasConflictingAltSet(W) && !hasStateAssociatedWithOneAlt(W);
 }
-function getConflictingAltSets(d) {
-	let B = /* @__PURE__ */ new Map();
-	for (let V of d) {
-		let d = getATNConfigKey(V, !1), H = B.get(d);
-		H === void 0 && (H = {}, B.set(d, H)), H[V.alt] = !0;
+function getConflictingAltSets(h) {
+	let W = /* @__PURE__ */ new Map();
+	for (let G of h) {
+		let h = getATNConfigKey(G, !1), K = W.get(h);
+		K === void 0 && (K = {}, W.set(h, K)), K[G.alt] = !0;
 	}
-	return B;
+	return W;
 }
-function hasConflictingAltSet(d) {
-	for (let B of Array.from(d.values())) if (Object.keys(B).length > 1) return !0;
+function hasConflictingAltSet(h) {
+	for (let W of Array.from(h.values())) if (Object.keys(W).length > 1) return !0;
 	return !1;
 }
-function hasStateAssociatedWithOneAlt(d) {
-	for (let B of Array.from(d.values())) if (Object.keys(B).length === 1) return !0;
+function hasStateAssociatedWithOneAlt(h) {
+	for (let W of Array.from(h.values())) if (Object.keys(W).length === 1) return !0;
 	return !1;
 }
 export { LLStarLookaheadStrategy };