@loopstack/loopstack-studio 0.28.0 → 0.29.0

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

@@ -1,14 +0,0 @@
-import { defaultGrammarResolverErrorProvider, defaultGrammarValidatorErrorProvider } from "../../errors_public.js";
-import { resolveGrammar } from "../resolver.js";
-import { validateGrammar } from "../checks.js";
-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(e) {
-	let r = e.errMsgProvider ?? defaultGrammarValidatorErrorProvider;
-	return validateGrammar(e.rules, e.tokenTypes, r, e.grammarName);
-}
-export { resolveGrammar$1 as resolveGrammar, validateGrammar$1 as validateGrammar };

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

@@ -1,262 +0,0 @@
-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, 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 = [...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, a = []) {
-		this.found || super.walk(e, a);
-	}
-	walkProdRef(e, a, o) {
-		if (e.referencedRule.name === this.nextProductionName && e.idx === this.nextProductionOccurrence) {
-			let s = a.concat(o);
-			this.updateExpectedNext(), this.walk(e.referencedRule, s);
-		}
-	}
-	updateExpectedNext() {
-		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, 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, 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, a) {
-		super(), this.topRule = e, this.occurrence = a, this.result = {
-			token: void 0,
-			occurrence: void 0,
-			isEndOfRule: void 0
-		};
-	}
-	startWalking() {
-		return this.walk(this.topRule), this.result;
-	}
-}, NextTerminalAfterManyWalker = class extends AbstractNextTerminalAfterProductionWalker {
-	walkMany(e, a, o) {
-		if (e.idx === this.occurrence) {
-			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, a, o);
-	}
-}, NextTerminalAfterManySepWalker = class extends AbstractNextTerminalAfterProductionWalker {
-	walkManySep(e, a, o) {
-		if (e.idx === this.occurrence) {
-			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, a, o);
-	}
-}, NextTerminalAfterAtLeastOneWalker = class extends AbstractNextTerminalAfterProductionWalker {
-	walkAtLeastOne(e, a, o) {
-		if (e.idx === this.occurrence) {
-			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, a, o);
-	}
-}, NextTerminalAfterAtLeastOneSepWalker = class extends AbstractNextTerminalAfterProductionWalker {
-	walkAtLeastOneSep(e, a, o) {
-		if (e.idx === this.occurrence) {
-			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, a, o);
-	}
-};
-function possiblePathsFrom(u, d, f = []) {
-	f = [...f];
-	let p = [], m = 0;
-	function h(e) {
-		return e.concat(u.slice(m + 1));
-	}
-	function g(e) {
-		let a = possiblePathsFrom(h(e), d, f);
-		return p.concat(a);
-	}
-	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");
-		m++;
-	}
-	return p.push({
-		partialPath: f,
-		suffixDef: u.slice(m)
-	}), p;
-}
-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: d,
-		ruleStack: [],
-		occurrenceStack: []
-	}); S.length !== 0;) {
-		let d = S.pop();
-		if (d === _) {
-			v && S.at(-1).idx <= b && S.pop();
-			continue;
-		}
-		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 (E === h) {
-			let e = {
-				idx: C,
-				def: m.slice(1),
-				ruleStack: w.slice(0, -1),
-				occurrenceStack: T.slice(0, -1)
-			};
-			S.push(e);
-		} else if (E instanceof Terminal)
- /* istanbul ignore else */
-		if (C < y - 1) {
-			let e = C + 1, a = f[e];
-			if (p(a, E.terminalType)) {
-				let a = {
-					idx: e,
-					def: m.slice(1),
-					ruleStack: w,
-					occurrenceStack: T
-				};
-				S.push(a);
-			}
-		} 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 (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: a
-			};
-			S.push(o);
-		} else if (E instanceof Option) {
-			let e = {
-				idx: C,
-				def: m.slice(1),
-				ruleStack: w,
-				occurrenceStack: T
-			};
-			S.push(e), S.push(_);
-			let a = {
-				idx: C,
-				def: E.definition.concat(m.slice(1)),
-				ruleStack: w,
-				occurrenceStack: T
-			};
-			S.push(a);
-		} else if (E instanceof RepetitionMandatory) {
-			let e = new Repetition({
-				definition: E.definition,
-				idx: E.idx
-			}), a = {
-				idx: C,
-				def: E.definition.concat([e], m.slice(1)),
-				ruleStack: w,
-				occurrenceStack: T
-			};
-			S.push(a);
-		} else if (E instanceof RepetitionMandatoryWithSeparator) {
-			let e = new Repetition({
-				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
-			};
-			S.push(a);
-		} else if (E instanceof RepetitionWithSeparator) {
-			let e = {
-				idx: C,
-				def: m.slice(1),
-				ruleStack: w,
-				occurrenceStack: T
-			};
-			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
-			};
-			S.push(o);
-		} else if (E instanceof Repetition) {
-			let e = {
-				idx: C,
-				def: m.slice(1),
-				ruleStack: w,
-				occurrenceStack: T
-			};
-			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
-			};
-			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
-			};
-			S.push(a), S.push(_);
-		}
-		else if (E instanceof Alternative) S.push({
-			idx: C,
-			def: E.definition.concat(m.slice(1)),
-			ruleStack: w,
-			occurrenceStack: T
-		});
-		else if (E instanceof Rule) S.push(expandTopLevelRule(E, C, w, T));
-		else throw Error("non exhaustive match");
-	}
-	return x;
-}
-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: c,
-		occurrenceStack: l
-	};
-}
-export { NextAfterTokenWalker, NextTerminalAfterAtLeastOneSepWalker, NextTerminalAfterAtLeastOneWalker, NextTerminalAfterManySepWalker, NextTerminalAfterManyWalker, nextPossibleTokensAfter, possiblePathsFrom };

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

@@ -1,5 +0,0 @@
-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;
-}
-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 };

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

@@ -1,41 +0,0 @@
-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 {
-	constructor(e) {
-		this.maxLookahead = e?.maxLookahead ?? DEFAULT_PARSER_CONFIG.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 [
-				...c,
-				...l,
-				...u,
-				...d
-			];
-		}
-		return c;
-	}
-	validateNoLeftRecursion(c) {
-		return c.flatMap((c) => validateNoLeftRecursion(c, c, defaultGrammarValidatorErrorProvider));
-	}
-	validateEmptyOrAlternatives(c) {
-		return c.flatMap((c) => validateEmptyOrAlternative(c, defaultGrammarValidatorErrorProvider));
-	}
-	validateAmbiguousAlternationAlternatives(c, l) {
-		return c.flatMap((c) => validateAmbiguousAlternationAlternatives(c, l, defaultGrammarValidatorErrorProvider));
-	}
-	validateSomeNonEmptyLookaheadPath(c, l) {
-		return validateSomeNonEmptyLookaheadPath(c, l, defaultGrammarValidatorErrorProvider);
-	}
-	buildLookaheadForAlternation(e) {
-		return buildLookaheadFuncForOr(e.prodOccurrence, e.rule, e.maxLookahead, e.hasPredicates, e.dynamicTokensEnabled, buildAlternativesLookAheadFunc);
-	}
-	buildLookaheadForOptional(e) {
-		return buildLookaheadFuncForOptionalProd(e.prodOccurrence, e.rule, e.maxLookahead, e.dynamicTokensEnabled, getProdType(e.prodType), buildSingleAlternativeLookaheadFunction);
-	}
-};
-export { LLkLookaheadStrategy };

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

@@ -1,241 +0,0 @@
-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(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(b) {
-	/* istanbul ignore else */
-	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(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(e, b, x, S, C, w) {
-	let T = getLookaheadPathsForOr(e, b, x);
-	return w(T, S, areTokenCategoriesNotUsed(T) ? tokenStructuredMatcherNoCategories : tokenStructuredMatcher, C);
-}
-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(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 (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);
-			});
-		}), e), {});
-		return function() {
-			return b[this.LA_FAST(1).tokenTypeIdx];
-		};
-	} else return function() {
-		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(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_FAST(1).tokenTypeIdx === e;
-			};
-		} else {
-			let e = b.reduce((e, b, x) => (e[b.tokenTypeIdx] = !0, b.categoryMatches.forEach((b) => {
-				e[b] = !0;
-			}), e), []);
-			return function() {
-				return e[this.LA_FAST(1).tokenTypeIdx] === !0;
-			};
-		}
-	} else return function() {
-		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(e, b, x) {
-		super(), this.topProd = e, this.targetOccurrence = b, this.targetProdType = x;
-	}
-	startWalking() {
-		return this.walk(this.topProd), this.restDef;
-	}
-	checkIsTarget(e, b, x, S) {
-		return e.idx === this.targetOccurrence && this.targetProdType === b ? (this.restDef = x.concat(S), !0) : !1;
-	}
-	walkOption(e, b, x) {
-		this.checkIsTarget(e, PROD_TYPE.OPTION, b, x) || super.walkOption(e, b, x);
-	}
-	walkAtLeastOne(e, b, x) {
-		this.checkIsTarget(e, PROD_TYPE.REPETITION_MANDATORY, b, x) || super.walkOption(e, b, x);
-	}
-	walkAtLeastOneSep(e, b, x) {
-		this.checkIsTarget(e, PROD_TYPE.REPETITION_MANDATORY_WITH_SEPARATOR, b, x) || super.walkOption(e, b, x);
-	}
-	walkMany(e, b, x) {
-		this.checkIsTarget(e, PROD_TYPE.REPETITION, b, x) || super.walkOption(e, b, x);
-	}
-	walkManySep(e, b, x) {
-		this.checkIsTarget(e, PROD_TYPE.REPETITION_WITH_SEPARATOR, b, x) || super.walkOption(e, b, x);
-	}
-}, InsideDefinitionFinderVisitor = class extends GAstVisitor {
-	constructor(e, b, x) {
-		super(), this.targetOccurrence = e, this.targetProdType = b, this.targetRef = x, this.result = [];
-	}
-	checkIsTarget(e, b) {
-		e.idx === this.targetOccurrence && this.targetProdType === b && (this.targetRef === void 0 || e === this.targetRef) && (this.result = e.definition);
-	}
-	visitOption(e) {
-		this.checkIsTarget(e, PROD_TYPE.OPTION);
-	}
-	visitRepetition(e) {
-		this.checkIsTarget(e, PROD_TYPE.REPETITION);
-	}
-	visitRepetitionMandatory(e) {
-		this.checkIsTarget(e, PROD_TYPE.REPETITION_MANDATORY);
-	}
-	visitRepetitionMandatoryWithSeparator(e) {
-		this.checkIsTarget(e, PROD_TYPE.REPETITION_MANDATORY_WITH_SEPARATOR);
-	}
-	visitRepetitionWithSeparator(e) {
-		this.checkIsTarget(e, PROD_TYPE.REPETITION_WITH_SEPARATOR);
-	}
-	visitAlternation(e) {
-		this.checkIsTarget(e, PROD_TYPE.ALTERNATION);
-	}
-};
-function initializeArrayOfArrays(e) {
-	let b = Array(e);
-	for (let x = 0; x < e; x++) b[x] = [];
-	return b;
-}
-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);
-			}
-		}
-		b = C;
-	}
-	return b;
-}
-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(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;
-			});
-		}), 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 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 S;
-}
-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(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(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(e, b) {
-	return e.length < b.length && e.every((e, x) => {
-		let S = b[x];
-		return e === S || S.categoryMatchesMap[e.tokenTypeIdx];
-	});
-}
-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,30 +0,0 @@
-import { GAstVisitor } from "../../../../../@chevrotain/gast/lib/src/visitor.js";
-import { ParserDefinitionErrorType } from "../parser/parser.js";
-function resolveGrammar(e, n) {
-	let r = new GastRefResolverVisitor(e, n);
-	return r.resolveRefs(), r.errors;
-}
-var GastRefResolverVisitor = class extends GAstVisitor {
-	constructor(e, n) {
-		super(), this.nameToTopRule = e, this.errMsgProvider = n, this.errors = [];
-	}
-	resolveRefs() {
-		Object.values(this.nameToTopRule).forEach((e) => {
-			this.currTopLevel = e, e.accept(this);
-		});
-	}
-	visitNonTerminal(e) {
-		let r = this.nameToTopRule[e.nonTerminalName];
-		if (r) e.referencedRule = r;
-		else {
-			let r = this.errMsgProvider.buildRuleNotFoundError(this.currTopLevel, e);
-			this.errors.push({
-				message: r,
-				type: ParserDefinitionErrorType.UNRESOLVED_SUBRULE_REF,
-				ruleName: this.currTopLevel.name,
-				unresolvedRefName: e.nonTerminalName
-			});
-		}
-	}
-};
-export { resolveGrammar };

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

@@ -1,56 +0,0 @@
-import { Alternation, Alternative, NonTerminal, Option, Repetition, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Terminal } from "../../../../../@chevrotain/gast/lib/src/model.js";
-var RestWalker = class {
-	walk(l, u = []) {
-		l.definition.forEach((d, f) => {
-			let p = l.definition.slice(f + 1);
-			/* istanbul ignore else */
-			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, a, o) {}
-	walkProdRef(e, a, o) {}
-	walkFlat(e, a, o) {
-		let s = a.concat(o);
-		this.walk(e, s);
-	}
-	walkOption(e, a, o) {
-		let s = a.concat(o);
-		this.walk(e, s);
-	}
-	walkAtLeastOne(e, a, o) {
-		let c = [new Option({ definition: e.definition })].concat(a, o);
-		this.walk(e, c);
-	}
-	walkAtLeastOneSep(e, a, o) {
-		let s = restForRepetitionWithSeparator(e, a, o);
-		this.walk(e, s);
-	}
-	walkMany(e, a, o) {
-		let c = [new Option({ definition: e.definition })].concat(a, o);
-		this.walk(e, c);
-	}
-	walkManySep(e, a, o) {
-		let s = restForRepetitionWithSeparator(e, a, o);
-		this.walk(e, s);
-	}
-	walkOr(e, o, s) {
-		let c = o.concat(s);
-		e.definition.forEach((e) => {
-			let o = new Alternative({ definition: [e] });
-			this.walk(o, c);
-		});
-	}
-};
-function restForRepetitionWithSeparator(e, a, o) {
-	return [new Option({ definition: [new Terminal({ terminalType: e.separator })].concat(e.definition) })].concat(a, o);
-}
-export { RestWalker };