@loopstack/loopstack-studio 0.25.0 → 0.25.2

package/dist/node_modules/chevrotain/lib/src/parse/parser/traits/recoverable.js

@@ -1,13 +1,6 @@
-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 dropRight_default from "../../../../../../lodash-es/dropRight.js";
-import find_default from "../../../../../../lodash-es/find.js";
-import map_default from "../../../../../../lodash-es/map.js";
-import has_default from "../../../../../../lodash-es/has.js";
-import includes_default from "../../../../../../lodash-es/includes.js";
 import { IN } from "../../constants.js";
 import { EOF, createTokenInstance, tokenMatcher } from "../../../scan/tokens_public.js";
+import { NextAfterTokenWalker } from "../../grammar/interpreter.js";
 import { MismatchedTokenException } from "../../exceptions_public.js";
 import { DEFAULT_PARSER_CONFIG } from "../parser.js";
 const EOF_FOLLOW_KEY = {}, IN_RULE_RECOVERY_EXCEPTION = "InRuleRecoveryException";
@@ -17,11 +10,11 @@ var InRuleRecoveryException = class extends Error {
 	}
 }, Recoverable = class {
 	initRecoverable(e) {
-		this.firstAfterRepMap = {}, this.resyncFollows = {}, this.recoveryEnabled = has_default(e, "recoveryEnabled") ? e.recoveryEnabled : DEFAULT_PARSER_CONFIG.recoveryEnabled, this.recoveryEnabled && (this.attemptInRepetitionRecovery = attemptInRepetitionRecovery);
+		this.firstAfterRepMap = {}, this.resyncFollows = {}, this.recoveryEnabled = Object.hasOwn(e, "recoveryEnabled") ? e.recoveryEnabled : DEFAULT_PARSER_CONFIG.recoveryEnabled, this.recoveryEnabled && (this.attemptInRepetitionRecovery = attemptInRepetitionRecovery);
 	}
 	getTokenToInsert(e) {
-		let s = createTokenInstance(e, "", NaN, NaN, NaN, NaN, NaN, NaN);
-		return s.isInsertedInRecovery = !0, s;
+		let t = createTokenInstance(e, "", NaN, NaN, NaN, NaN, NaN, NaN);
+		return t.isInsertedInRecovery = !0, t;
 	}
 	canTokenTypeBeInsertedInRecovery(e) {
 		return !0;
@@ -29,116 +22,123 @@ var InRuleRecoveryException = class extends Error {
 	canTokenTypeBeDeletedInRecovery(e) {
 		return !0;
 	}
-	tryInRepetitionRecovery(e, s, c, u) {
-		let d = this.findReSyncTokenType(), f = this.exportLexerState(), p = [], m = !1, h = this.LA(1), g = this.LA(1), _ = () => {
-			let e = this.LA(0), s = new MismatchedTokenException(this.errorMessageProvider.buildMismatchTokenMessage({
-				expected: u,
-				actual: h,
+	tryInRepetitionRecovery(e, t, n, r) {
+		let i = this.findReSyncTokenType(), o = this.exportLexerState(), s = [], c = !1, l = this.LA_FAST(1), u = this.LA_FAST(1), d = () => {
+			let e = this.LA(0), t = new MismatchedTokenException(this.errorMessageProvider.buildMismatchTokenMessage({
+				expected: r,
+				actual: l,
 				previous: e,
 				ruleName: this.getCurrRuleFullName()
-			}), h, this.LA(0));
-			s.resyncedTokens = dropRight_default(p), this.SAVE_ERROR(s);
+			}), l, this.LA(0));
+			t.resyncedTokens = s.slice(0, -1), this.SAVE_ERROR(t);
 		};
-		for (; !m;) if (this.tokenMatcher(g, u)) {
-			_();
+		for (; !c;) if (this.tokenMatcher(u, r)) {
+			d();
 			return;
-		} else if (c.call(this)) {
-			_(), e.apply(this, s);
+		} else if (n.call(this)) {
+			d(), e.apply(this, t);
 			return;
-		} else this.tokenMatcher(g, d) ? m = !0 : (g = this.SKIP_TOKEN(), this.addToResyncTokens(g, p));
-		this.importLexerState(f);
+		} else this.tokenMatcher(u, i) ? c = !0 : (u = this.SKIP_TOKEN(), this.addToResyncTokens(u, s));
+		this.importLexerState(o);
 	}
-	shouldInRepetitionRecoveryBeTried(e, s, c) {
-		return !(c === !1 || this.tokenMatcher(this.LA(1), e) || this.isBackTracking() || this.canPerformInRuleRecovery(e, this.getFollowsForInRuleRecovery(e, s)));
+	shouldInRepetitionRecoveryBeTried(e, t, n) {
+		return !(n === !1 || this.tokenMatcher(this.LA_FAST(1), e) || this.isBackTracking() || this.canPerformInRuleRecovery(e, this.getFollowsForInRuleRecovery(e, t)));
 	}
-	getFollowsForInRuleRecovery(e, s) {
-		let c = this.getCurrentGrammarPath(e, s);
-		return this.getNextPossibleTokenTypes(c);
+	getNextPossibleTokenTypes(e) {
+		let t = e.ruleStack[0], n = this.getGAstProductions()[t];
+		return new NextAfterTokenWalker(n, e).startWalking();
 	}
-	tryInRuleRecovery(e, s) {
-		if (this.canRecoverWithSingleTokenInsertion(e, s)) return this.getTokenToInsert(e);
+	getFollowsForInRuleRecovery(e, t) {
+		let n = this.getCurrentGrammarPath(e, t);
+		return this.getNextPossibleTokenTypes(n);
+	}
+	tryInRuleRecovery(e, t) {
+		if (this.canRecoverWithSingleTokenInsertion(e, t)) return this.getTokenToInsert(e);
 		if (this.canRecoverWithSingleTokenDeletion(e)) {
 			let e = this.SKIP_TOKEN();
 			return this.consumeToken(), e;
 		}
 		throw new InRuleRecoveryException("sad sad panda");
 	}
-	canPerformInRuleRecovery(e, s) {
-		return this.canRecoverWithSingleTokenInsertion(e, s) || this.canRecoverWithSingleTokenDeletion(e);
+	canPerformInRuleRecovery(e, t) {
+		return this.canRecoverWithSingleTokenInsertion(e, t) || this.canRecoverWithSingleTokenDeletion(e);
 	}
-	canRecoverWithSingleTokenInsertion(s, c) {
-		if (!this.canTokenTypeBeInsertedInRecovery(s) || isEmpty_default(c)) return !1;
-		let l = this.LA(1);
-		return find_default(c, (e) => this.tokenMatcher(l, e)) !== void 0;
+	canRecoverWithSingleTokenInsertion(e, t) {
+		if (!this.canTokenTypeBeInsertedInRecovery(e) || t.length === 0) return !1;
+		let n = this.LA_FAST(1);
+		return t.find((e) => this.tokenMatcher(n, e)) !== void 0;
 	}
 	canRecoverWithSingleTokenDeletion(e) {
 		return this.canTokenTypeBeDeletedInRecovery(e) ? this.tokenMatcher(this.LA(2), e) : !1;
 	}
 	isInCurrentRuleReSyncSet(e) {
-		let s = this.getCurrFollowKey();
-		return includes_default(this.getFollowSetFromFollowKey(s), e);
+		let t = this.getCurrFollowKey();
+		return this.getFollowSetFromFollowKey(t).includes(e);
 	}
 	findReSyncTokenType() {
-		let e = this.flattenFollowSet(), s = this.LA(1), c = 2;
+		let e = this.flattenFollowSet(), t = this.LA_FAST(1), n = 2;
 		for (;;) {
-			let l = find_default(e, (e) => tokenMatcher(s, e));
-			if (l !== void 0) return l;
-			s = this.LA(c), c++;
+			let i = e.find((e) => tokenMatcher(t, e));
+			if (i !== void 0) return i;
+			t = this.LA(n), n++;
 		}
 	}
 	getCurrFollowKey() {
-		if (this.RULE_STACK.length === 1) return EOF_FOLLOW_KEY;
-		let e = this.getLastExplicitRuleShortName(), s = this.getLastExplicitRuleOccurrenceIndex(), c = this.getPreviousExplicitRuleShortName();
+		if (this.RULE_STACK_IDX === 0) return EOF_FOLLOW_KEY;
+		let e = this.currRuleShortName, t = this.getLastExplicitRuleOccurrenceIndex(), n = this.getPreviousExplicitRuleShortName();
 		return {
 			ruleName: this.shortRuleNameToFullName(e),
-			idxInCallingRule: s,
-			inRule: this.shortRuleNameToFullName(c)
+			idxInCallingRule: t,
+			inRule: this.shortRuleNameToFullName(n)
 		};
 	}
 	buildFullFollowKeyStack() {
-		let e = this.RULE_STACK, s = this.RULE_OCCURRENCE_STACK;
-		return map_default(e, (c, l) => l === 0 ? EOF_FOLLOW_KEY : {
-			ruleName: this.shortRuleNameToFullName(c),
-			idxInCallingRule: s[l],
-			inRule: this.shortRuleNameToFullName(e[l - 1])
-		});
+		let e = this.RULE_STACK, t = this.RULE_OCCURRENCE_STACK, n = this.RULE_STACK_IDX + 1, r = Array(n);
+		for (let i = 0; i < n; i++) i === 0 ? r[i] = EOF_FOLLOW_KEY : r[i] = {
+			ruleName: this.shortRuleNameToFullName(e[i]),
+			idxInCallingRule: t[i],
+			inRule: this.shortRuleNameToFullName(e[i - 1])
+		};
+		return r;
 	}
 	flattenFollowSet() {
-		return flatten_default(map_default(this.buildFullFollowKeyStack(), (e) => this.getFollowSetFromFollowKey(e)));
+		return this.buildFullFollowKeyStack().map((e) => this.getFollowSetFromFollowKey(e)).flat();
 	}
-	getFollowSetFromFollowKey(e) {
-		if (e === EOF_FOLLOW_KEY) return [EOF];
-		let s = e.ruleName + e.idxInCallingRule + IN + e.inRule;
-		return this.resyncFollows[s];
+	getFollowSetFromFollowKey(n) {
+		if (n === EOF_FOLLOW_KEY) return [EOF];
+		let r = n.ruleName + n.idxInCallingRule + IN + n.inRule;
+		return this.resyncFollows[r];
 	}
-	addToResyncTokens(e, s) {
-		return this.tokenMatcher(e, EOF) || s.push(e), s;
+	addToResyncTokens(e, n) {
+		return this.tokenMatcher(e, EOF) || n.push(e), n;
 	}
 	reSyncTo(e) {
-		let s = [], c = this.LA(1);
-		for (; this.tokenMatcher(c, e) === !1;) c = this.SKIP_TOKEN(), this.addToResyncTokens(c, s);
-		return dropRight_default(s);
+		let t = [], n = this.LA_FAST(1);
+		for (; this.tokenMatcher(n, e) === !1;) n = this.SKIP_TOKEN(), this.addToResyncTokens(n, t);
+		return t.slice(0, -1);
 	}
-	attemptInRepetitionRecovery(e, s, c, l, u, d, f) {}
-	getCurrentGrammarPath(e, s) {
+	attemptInRepetitionRecovery(e, t, n, r, i, a, o) {}
+	getCurrentGrammarPath(e, t) {
 		return {
 			ruleStack: this.getHumanReadableRuleStack(),
-			occurrenceStack: clone_default(this.RULE_OCCURRENCE_STACK),
+			occurrenceStack: this.RULE_OCCURRENCE_STACK.slice(0, this.RULE_OCCURRENCE_STACK_IDX + 1),
 			lastTok: e,
-			lastTokOccurrence: s
+			lastTokOccurrence: t
 		};
 	}
 	getHumanReadableRuleStack() {
-		return map_default(this.RULE_STACK, (e) => this.shortRuleNameToFullName(e));
+		let e = this.RULE_STACK_IDX + 1, t = Array(e);
+		for (let n = 0; n < e; n++) t[n] = this.shortRuleNameToFullName(this.RULE_STACK[n]);
+		return t;
 	}
 };
-function attemptInRepetitionRecovery(e, s, c, l, u, d, f) {
-	let p = this.getKeyForAutomaticLookahead(l, u), m = this.firstAfterRepMap[p];
-	if (m === void 0) {
-		let e = this.getCurrRuleFullName(), s = this.getGAstProductions()[e];
-		m = new d(s, u).startWalking(), this.firstAfterRepMap[p] = m;
-	}
-	let g = m.token, _ = m.occurrence, v = m.isEndOfRule;
-	this.RULE_STACK.length === 1 && v && g === void 0 && (g = EOF, _ = 1), !(g === void 0 || _ === void 0) && this.shouldInRepetitionRecoveryBeTried(g, _, f) && this.tryInRepetitionRecovery(e, s, c, g);
+function attemptInRepetitionRecovery(e, n, r, i, a, o, s) {
+	let c = this.getKeyForAutomaticLookahead(i, a), l = this.firstAfterRepMap[c];
+	if (l === void 0) {
+		let e = this.getCurrRuleFullName(), t = this.getGAstProductions()[e];
+		l = new o(t, a).startWalking(), this.firstAfterRepMap[c] = l;
+	}
+	let u = l.token, d = l.occurrence, f = l.isEndOfRule;
+	this.RULE_STACK_IDX === 0 && f && u === void 0 && (u = EOF, d = 1), !(u === void 0 || d === void 0) && this.shouldInRepetitionRecoveryBeTried(u, d, s) && this.tryInRepetitionRecovery(e, n, r, u);
 }
 export { IN_RULE_RECOVERY_EXCEPTION, Recoverable };

package/dist/node_modules/chevrotain/lib/src/parse/parser/traits/tree_builder.js

@@ -1,17 +1,13 @@
-import noop_default from "../../../../../../lodash-es/noop.js";
-import keys_default from "../../../../../../lodash-es/keys.js";
-import has_default from "../../../../../../lodash-es/has.js";
-import isUndefined_default from "../../../../../../lodash-es/isUndefined.js";
 import { addNoneTerminalToCst, addTerminalToCst, setNodeLocationFull, setNodeLocationOnlyOffset } from "../../cst/cst.js";
 import { createBaseSemanticVisitorConstructor, createBaseVisitorConstructorWithDefaults } from "../../cst/cst_visitor.js";
 import { DEFAULT_PARSER_CONFIG } from "../parser.js";
 var TreeBuilder = class {
-	initTreeBuilder(u) {
-		if (this.CST_STACK = [], this.outputCst = u.outputCst, this.nodeLocationTracking = has_default(u, "nodeLocationTracking") ? u.nodeLocationTracking : DEFAULT_PARSER_CONFIG.nodeLocationTracking, !this.outputCst) this.cstInvocationStateUpdate = noop_default, this.cstFinallyStateUpdate = noop_default, this.cstPostTerminal = noop_default, this.cstPostNonTerminal = noop_default, this.cstPostRule = noop_default;
-		else if (/full/i.test(this.nodeLocationTracking)) this.recoveryEnabled ? (this.setNodeLocationFromToken = setNodeLocationFull, this.setNodeLocationFromNode = setNodeLocationFull, this.cstPostRule = noop_default, this.setInitialNodeLocation = this.setInitialNodeLocationFullRecovery) : (this.setNodeLocationFromToken = noop_default, this.setNodeLocationFromNode = noop_default, this.cstPostRule = this.cstPostRuleFull, this.setInitialNodeLocation = this.setInitialNodeLocationFullRegular);
-		else if (/onlyOffset/i.test(this.nodeLocationTracking)) this.recoveryEnabled ? (this.setNodeLocationFromToken = setNodeLocationOnlyOffset, this.setNodeLocationFromNode = setNodeLocationOnlyOffset, this.cstPostRule = noop_default, this.setInitialNodeLocation = this.setInitialNodeLocationOnlyOffsetRecovery) : (this.setNodeLocationFromToken = noop_default, this.setNodeLocationFromNode = noop_default, this.cstPostRule = this.cstPostRuleOnlyOffset, this.setInitialNodeLocation = this.setInitialNodeLocationOnlyOffsetRegular);
-		else if (/none/i.test(this.nodeLocationTracking)) this.setNodeLocationFromToken = noop_default, this.setNodeLocationFromNode = noop_default, this.cstPostRule = noop_default, this.setInitialNodeLocation = noop_default;
-		else throw Error(`Invalid <nodeLocationTracking> config option: "${u.nodeLocationTracking}"`);
+	initTreeBuilder(e) {
+		if (this.CST_STACK = [], this.outputCst = e.outputCst, this.nodeLocationTracking = Object.hasOwn(e, "nodeLocationTracking") ? e.nodeLocationTracking : DEFAULT_PARSER_CONFIG.nodeLocationTracking, !this.outputCst) this.cstInvocationStateUpdate = () => {}, this.cstFinallyStateUpdate = () => {}, this.cstPostTerminal = () => {}, this.cstPostNonTerminal = () => {}, this.cstPostRule = () => {};
+		else if (/full/i.test(this.nodeLocationTracking)) this.recoveryEnabled ? (this.setNodeLocationFromToken = setNodeLocationFull, this.setNodeLocationFromNode = setNodeLocationFull, this.cstPostRule = () => {}, this.setInitialNodeLocation = this.setInitialNodeLocationFullRecovery) : (this.setNodeLocationFromToken = () => {}, this.setNodeLocationFromNode = () => {}, this.cstPostRule = this.cstPostRuleFull, this.setInitialNodeLocation = this.setInitialNodeLocationFullRegular);
+		else if (/onlyOffset/i.test(this.nodeLocationTracking)) this.recoveryEnabled ? (this.setNodeLocationFromToken = setNodeLocationOnlyOffset, this.setNodeLocationFromNode = setNodeLocationOnlyOffset, this.cstPostRule = () => {}, this.setInitialNodeLocation = this.setInitialNodeLocationOnlyOffsetRecovery) : (this.setNodeLocationFromToken = () => {}, this.setNodeLocationFromNode = () => {}, this.cstPostRule = this.cstPostRuleOnlyOffset, this.setInitialNodeLocation = this.setInitialNodeLocationOnlyOffsetRegular);
+		else if (/none/i.test(this.nodeLocationTracking)) this.setNodeLocationFromToken = () => {}, this.setNodeLocationFromNode = () => {}, this.cstPostRule = () => {}, this.setInitialNodeLocation = () => {};
+		else throw Error(`Invalid <nodeLocationTracking> config option: "${e.nodeLocationTracking}"`);
 	}
 	setInitialNodeLocationOnlyOffsetRecovery(e) {
 		e.location = {
@@ -21,7 +17,7 @@ var TreeBuilder = class {
 	}
 	setInitialNodeLocationOnlyOffsetRegular(e) {
 		e.location = {
-			startOffset: this.LA(1).startOffset,
+			startOffset: this.LA_FAST(1).startOffset,
 			endOffset: NaN
 		};
 	}
@@ -36,67 +32,61 @@ var TreeBuilder = class {
 		};
 	}
 	setInitialNodeLocationFullRegular(e) {
-		let u = this.LA(1);
+		let a = this.LA_FAST(1);
 		e.location = {
-			startOffset: u.startOffset,
-			startLine: u.startLine,
-			startColumn: u.startColumn,
+			startOffset: a.startOffset,
+			startLine: a.startLine,
+			startColumn: a.startColumn,
 			endOffset: NaN,
 			endLine: NaN,
 			endColumn: NaN
 		};
 	}
 	cstInvocationStateUpdate(e) {
-		let u = {
+		let a = {
 			name: e,
 			children: Object.create(null)
 		};
-		this.setInitialNodeLocation(u), this.CST_STACK.push(u);
+		this.setInitialNodeLocation(a), this.CST_STACK.push(a);
 	}
 	cstFinallyStateUpdate() {
 		this.CST_STACK.pop();
 	}
 	cstPostRuleFull(e) {
-		let u = this.LA(0), d = e.location;
-		d.startOffset <= u.startOffset ? (d.endOffset = u.endOffset, d.endLine = u.endLine, d.endColumn = u.endColumn) : (d.startOffset = NaN, d.startLine = NaN, d.startColumn = NaN);
+		let a = this.LA(0), o = e.location;
+		o.startOffset <= a.startOffset ? (o.endOffset = a.endOffset, o.endLine = a.endLine, o.endColumn = a.endColumn) : (o.startOffset = NaN, o.startLine = NaN, o.startColumn = NaN);
 	}
 	cstPostRuleOnlyOffset(e) {
-		let u = this.LA(0), d = e.location;
-		d.startOffset <= u.startOffset ? d.endOffset = u.endOffset : d.startOffset = NaN;
+		let a = this.LA(0), o = e.location;
+		o.startOffset <= a.startOffset ? o.endOffset = a.endOffset : o.startOffset = NaN;
 	}
-	cstPostTerminal(e, u) {
-		let d = this.CST_STACK[this.CST_STACK.length - 1];
-		addTerminalToCst(d, u, e), this.setNodeLocationFromToken(d.location, u);
+	cstPostTerminal(e, o) {
+		let s = this.CST_STACK[this.CST_STACK.length - 1];
+		addTerminalToCst(s, o, e), this.setNodeLocationFromToken(s.location, o);
 	}
-	cstPostNonTerminal(e, u) {
-		let d = this.CST_STACK[this.CST_STACK.length - 1];
-		addNoneTerminalToCst(d, u, e), this.setNodeLocationFromNode(d.location, e.location);
+	cstPostNonTerminal(a, o) {
+		let s = this.CST_STACK[this.CST_STACK.length - 1];
+		addNoneTerminalToCst(s, o, a), this.setNodeLocationFromNode(s.location, a.location);
 	}
 	getBaseCstVisitorConstructor() {
-		if (isUndefined_default(this.baseCstVisitorConstructor)) {
-			let e = createBaseSemanticVisitorConstructor(this.className, keys_default(this.gastProductionsCache));
+		if (this.baseCstVisitorConstructor === void 0) {
+			let e = createBaseSemanticVisitorConstructor(this.className, Object.keys(this.gastProductionsCache));
 			return this.baseCstVisitorConstructor = e, e;
 		}
 		return this.baseCstVisitorConstructor;
 	}
 	getBaseCstVisitorConstructorWithDefaults() {
-		if (isUndefined_default(this.baseCstVisitorWithDefaultsConstructor)) {
-			let e = createBaseVisitorConstructorWithDefaults(this.className, keys_default(this.gastProductionsCache), this.getBaseCstVisitorConstructor());
+		if (this.baseCstVisitorWithDefaultsConstructor === void 0) {
+			let e = createBaseVisitorConstructorWithDefaults(this.className, Object.keys(this.gastProductionsCache), this.getBaseCstVisitorConstructor());
 			return this.baseCstVisitorWithDefaultsConstructor = e, e;
 		}
 		return this.baseCstVisitorWithDefaultsConstructor;
 	}
-	getLastExplicitRuleShortName() {
-		let e = this.RULE_STACK;
-		return e[e.length - 1];
-	}
 	getPreviousExplicitRuleShortName() {
-		let e = this.RULE_STACK;
-		return e[e.length - 2];
+		return this.RULE_STACK[this.RULE_STACK_IDX - 1];
 	}
 	getLastExplicitRuleOccurrenceIndex() {
-		let e = this.RULE_OCCURRENCE_STACK;
-		return e[e.length - 1];
+		return this.RULE_OCCURRENCE_STACK[this.RULE_OCCURRENCE_STACK_IDX];
 	}
 };
 export { TreeBuilder };