@plumile/ui 0.1.113 → 0.1.115

package/lib/esm/node_modules/chevrotain/lib/src/parse/parser/traits/recognizer_engine.js

@@ -1,291 +0,0 @@
-import { augmentTokenTypes as e, isTokenType as t, tokenStructuredMatcher as n, tokenStructuredMatcherNoCategories as r } from "../../../scan/tokens.js";
-import { EOF as i } from "../../../scan/tokens_public.js";
-import { NextTerminalAfterAtLeastOneSepWalker as a, NextTerminalAfterAtLeastOneWalker as o, NextTerminalAfterManySepWalker as s, NextTerminalAfterManyWalker as c } from "../../grammar/interpreter.js";
-import { PROD_TYPE as l } from "../../grammar/lookahead.js";
-import { MismatchedTokenException as u, NotAllInputParsedException as d, isRecognitionException as f } from "../../exceptions_public.js";
-import "./recoverable.js";
-import { AT_LEAST_ONE_IDX as p, AT_LEAST_ONE_SEP_IDX as m, MANY_SEP_IDX as h } from "../../grammar/keys.js";
-import { DEFAULT_RULE_CONFIG as g, END_OF_FILE as _ } from "../parser.js";
-//#region ../../node_modules/chevrotain/lib/src/parse/parser/traits/recognizer_engine.js
-var v = class {
-	initRecognizerEngine(a, o) {
-		if (this.className = this.constructor.name, this.shortRuleNameToFull = {}, this.fullRuleNameToShort = {}, this.ruleShortNameIdx = 256, this.tokenMatcher = r, this.subruleIdx = 0, this.currRuleShortName = 0, this.definedRulesNames = [], this.tokensMap = {}, this.isBackTrackingStack = [], this.RULE_STACK = [], this.RULE_STACK_IDX = -1, this.RULE_OCCURRENCE_STACK = [], this.RULE_OCCURRENCE_STACK_IDX = -1, this.gastProductionsCache = {}, Object.hasOwn(o, "serializedGrammar")) throw Error("The Parser's configuration can no longer contain a <serializedGrammar> property.\n	See: https://chevrotain.io/docs/changes/BREAKING_CHANGES.html#_6-0-0\n	For Further details.");
-		if (Array.isArray(a)) {
-			if (a.length === 0) throw Error("A Token Vocabulary cannot be empty.\n	Note that the first argument for the parser constructor\n	is no longer a Token vector (since v4.0).");
-			if (typeof a[0].startOffset == "number") throw Error("The Parser constructor no longer accepts a token vector as the first argument.\n	See: https://chevrotain.io/docs/changes/BREAKING_CHANGES.html#_4-0-0\n	For Further details.");
-		}
-		if (Array.isArray(a)) this.tokensMap = a.reduce((e, t) => (e[t.name] = t, e), {});
-		else if (Object.hasOwn(a, "modes") && Object.values(a.modes).flat().every(t)) {
-			let e = Object.values(a.modes).flat(), t = [...new Set(e)];
-			this.tokensMap = t.reduce((e, t) => (e[t.name] = t, e), {});
-		} else if (typeof a == "object" && a) this.tokensMap = Object.assign({}, a);
-		else throw Error("<tokensDictionary> argument must be An Array of Token constructors, A dictionary of Token constructors or an IMultiModeLexerDefinition");
-		this.tokensMap.EOF = i;
-		let s = (Object.hasOwn(a, "modes") ? Object.values(a.modes).flat() : Object.values(a)).every((e) => e.categoryMatches?.length == 0);
-		this.tokenMatcher = s ? r : n, e(Object.values(this.tokensMap));
-	}
-	defineRule(e, t, n) {
-		if (this.selfAnalysisDone) throw Error(`Grammar rule <${e}> may not be defined after the 'performSelfAnalysis' method has been called'\nMake sure that all grammar rule definitions are done before 'performSelfAnalysis' is called.`);
-		let r = Object.hasOwn(n, "resyncEnabled") ? n.resyncEnabled : g.resyncEnabled, i = Object.hasOwn(n, "recoveryValueFunc") ? n.recoveryValueFunc : g.recoveryValueFunc, a = this.ruleShortNameIdx << 12;
-		this.ruleShortNameIdx++, this.shortRuleNameToFull[a] = e, this.fullRuleNameToShort[e] = a;
-		let o;
-		return o = this.outputCst === !0 ? function(...n) {
-			try {
-				this.ruleInvocationStateUpdate(a, e, this.subruleIdx), t.apply(this, n);
-				let r = this.CST_STACK[this.CST_STACK.length - 1];
-				return this.cstPostRule(r), r;
-			} catch (e) {
-				return this.invokeRuleCatch(e, r, i);
-			} finally {
-				this.ruleFinallyStateUpdate();
-			}
-		} : function(...n) {
-			try {
-				return this.ruleInvocationStateUpdate(a, e, this.subruleIdx), t.apply(this, n);
-			} catch (e) {
-				return this.invokeRuleCatch(e, r, i);
-			} finally {
-				this.ruleFinallyStateUpdate();
-			}
-		}, Object.assign(function(...t) {
-			this.onBeforeParse(e);
-			try {
-				return o.apply(this, t);
-			} finally {
-				this.onAfterParse(e);
-			}
-		}, {
-			ruleName: e,
-			originalGrammarAction: t,
-			coreRule: o
-		});
-	}
-	invokeRuleCatch(e, t, n) {
-		let r = this.RULE_STACK_IDX === 0, i = t && !this.isBackTracking() && this.recoveryEnabled;
-		if (f(e)) {
-			let t = e;
-			if (i) {
-				let r = this.findReSyncTokenType();
-				if (this.isInCurrentRuleReSyncSet(r)) if (t.resyncedTokens = this.reSyncTo(r), this.outputCst) {
-					let e = this.CST_STACK[this.CST_STACK.length - 1];
-					return e.recoveredNode = !0, e;
-				} else return n(e);
-				else {
-					if (this.outputCst) {
-						let e = this.CST_STACK[this.CST_STACK.length - 1];
-						e.recoveredNode = !0, t.partialCstResult = e;
-					}
-					throw t;
-				}
-			} else if (r) return this.moveToTerminatedState(), n(e);
-			else throw t;
-		} else throw e;
-	}
-	optionInternal(e, t) {
-		let n = this.getKeyForAutomaticLookahead(512, t);
-		return this.optionInternalLogic(e, t, n);
-	}
-	optionInternalLogic(e, t, n) {
-		let r = this.getLaFuncFromCache(n), i;
-		if (typeof e != "function") {
-			i = e.DEF;
-			let t = e.GATE;
-			if (t !== void 0) {
-				let e = r;
-				r = () => t.call(this) && e.call(this);
-			}
-		} else i = e;
-		if (r.call(this) === !0) return i.call(this);
-	}
-	atLeastOneInternal(e, t) {
-		let n = this.getKeyForAutomaticLookahead(p, e);
-		return this.atLeastOneInternalLogic(e, t, n);
-	}
-	atLeastOneInternalLogic(e, t, n) {
-		let r = this.getLaFuncFromCache(n), i;
-		if (typeof t != "function") {
-			i = t.DEF;
-			let e = t.GATE;
-			if (e !== void 0) {
-				let t = r;
-				r = () => e.call(this) && t.call(this);
-			}
-		} else i = t;
-		if (r.call(this) === !0) {
-			let e = this.doSingleRepetition(i);
-			for (; r.call(this) === !0 && e === !0;) e = this.doSingleRepetition(i);
-		} else throw this.raiseEarlyExitException(e, l.REPETITION_MANDATORY, t.ERR_MSG);
-		this.attemptInRepetitionRecovery(this.atLeastOneInternal, [e, t], r, p, e, o);
-	}
-	atLeastOneSepFirstInternal(e, t) {
-		let n = this.getKeyForAutomaticLookahead(m, e);
-		this.atLeastOneSepFirstInternalLogic(e, t, n);
-	}
-	atLeastOneSepFirstInternalLogic(e, t, n) {
-		let r = t.DEF, i = t.SEP;
-		if (this.getLaFuncFromCache(n).call(this) === !0) {
-			r.call(this);
-			let t = () => this.tokenMatcher(this.LA_FAST(1), i);
-			for (; this.tokenMatcher(this.LA_FAST(1), i) === !0;) this.CONSUME(i), r.call(this);
-			this.attemptInRepetitionRecovery(this.repetitionSepSecondInternal, [
-				e,
-				i,
-				t,
-				r,
-				a
-			], t, m, e, a);
-		} else throw this.raiseEarlyExitException(e, l.REPETITION_MANDATORY_WITH_SEPARATOR, t.ERR_MSG);
-	}
-	manyInternal(e, t) {
-		let n = this.getKeyForAutomaticLookahead(768, e);
-		return this.manyInternalLogic(e, t, n);
-	}
-	manyInternalLogic(e, t, n) {
-		let r = this.getLaFuncFromCache(n), i;
-		if (typeof t != "function") {
-			i = t.DEF;
-			let e = t.GATE;
-			if (e !== void 0) {
-				let t = r;
-				r = () => e.call(this) && t.call(this);
-			}
-		} else i = t;
-		let a = !0;
-		for (; r.call(this) === !0 && a === !0;) a = this.doSingleRepetition(i);
-		this.attemptInRepetitionRecovery(this.manyInternal, [e, t], r, 768, e, c, a);
-	}
-	manySepFirstInternal(e, t) {
-		let n = this.getKeyForAutomaticLookahead(h, e);
-		this.manySepFirstInternalLogic(e, t, n);
-	}
-	manySepFirstInternalLogic(e, t, n) {
-		let r = t.DEF, i = t.SEP;
-		if (this.getLaFuncFromCache(n).call(this) === !0) {
-			r.call(this);
-			let t = () => this.tokenMatcher(this.LA_FAST(1), i);
-			for (; this.tokenMatcher(this.LA_FAST(1), i) === !0;) this.CONSUME(i), r.call(this);
-			this.attemptInRepetitionRecovery(this.repetitionSepSecondInternal, [
-				e,
-				i,
-				t,
-				r,
-				s
-			], t, h, e, s);
-		}
-	}
-	repetitionSepSecondInternal(e, t, n, r, i) {
-		for (; n();) this.CONSUME(t), r.call(this);
-		/* istanbul ignore else */
-		this.attemptInRepetitionRecovery(this.repetitionSepSecondInternal, [
-			e,
-			t,
-			n,
-			r,
-			i
-		], n, m, e, i);
-	}
-	doSingleRepetition(e) {
-		let t = this.getLexerPosition();
-		return e.call(this), this.getLexerPosition() > t;
-	}
-	orInternal(e, t) {
-		let n = this.getKeyForAutomaticLookahead(256, t), r = Array.isArray(e) ? e : e.DEF, i = this.getLaFuncFromCache(n).call(this, r);
-		if (i !== void 0) return r[i].ALT.call(this);
-		this.raiseNoAltException(t, e.ERR_MSG);
-	}
-	ruleFinallyStateUpdate() {
-		this.RULE_STACK_IDX--, this.RULE_OCCURRENCE_STACK_IDX--, this.RULE_STACK_IDX >= 0 && (this.currRuleShortName = this.RULE_STACK[this.RULE_STACK_IDX]), this.cstFinallyStateUpdate();
-	}
-	subruleInternal(e, t, n) {
-		let r;
-		try {
-			let i = n === void 0 ? void 0 : n.ARGS;
-			return this.subruleIdx = t, r = e.coreRule.apply(this, i), this.cstPostNonTerminal(r, n !== void 0 && n.LABEL !== void 0 ? n.LABEL : e.ruleName), r;
-		} catch (t) {
-			throw this.subruleInternalError(t, n, e.ruleName);
-		}
-	}
-	subruleInternalError(e, t, n) {
-		throw f(e) && e.partialCstResult !== void 0 && (this.cstPostNonTerminal(e.partialCstResult, t !== void 0 && t.LABEL !== void 0 ? t.LABEL : n), delete e.partialCstResult), e;
-	}
-	consumeInternal(e, t, n) {
-		let r;
-		try {
-			let t = this.LA_FAST(1);
-			this.tokenMatcher(t, e) === !0 ? (this.consumeToken(), r = t) : this.consumeInternalError(e, t, n);
-		} catch (n) {
-			r = this.consumeInternalRecovery(e, t, n);
-		}
-		return this.cstPostTerminal(n !== void 0 && n.LABEL !== void 0 ? n.LABEL : e.name, r), r;
-	}
-	consumeInternalError(e, t, n) {
-		let r, i = this.LA(0);
-		throw r = n !== void 0 && n.ERR_MSG ? n.ERR_MSG : this.errorMessageProvider.buildMismatchTokenMessage({
-			expected: e,
-			actual: t,
-			previous: i,
-			ruleName: this.getCurrRuleFullName()
-		}), this.SAVE_ERROR(new u(r, t, i));
-	}
-	consumeInternalRecovery(e, t, n) {
-		if (this.recoveryEnabled && n.name === "MismatchedTokenException" && !this.isBackTracking()) {
-			let r = this.getFollowsForInRuleRecovery(e, t);
-			try {
-				return this.tryInRuleRecovery(e, r);
-			} catch (e) {
-				throw e.name === "InRuleRecoveryException" ? n : e;
-			}
-		} else throw n;
-	}
-	saveRecogState() {
-		let e = this.errors, t = this.RULE_STACK.slice(0, this.RULE_STACK_IDX + 1);
-		return {
-			errors: e,
-			lexerState: this.exportLexerState(),
-			RULE_STACK: t,
-			CST_STACK: this.CST_STACK
-		};
-	}
-	reloadRecogState(e) {
-		this.errors = e.errors, this.importLexerState(e.lexerState);
-		let t = e.RULE_STACK;
-		for (let e = 0; e < t.length; e++) this.RULE_STACK[e] = t[e];
-		this.RULE_STACK_IDX = t.length - 1, this.RULE_STACK_IDX >= 0 && (this.currRuleShortName = this.RULE_STACK[this.RULE_STACK_IDX]);
-	}
-	ruleInvocationStateUpdate(e, t, n) {
-		this.RULE_OCCURRENCE_STACK[++this.RULE_OCCURRENCE_STACK_IDX] = n, this.RULE_STACK[++this.RULE_STACK_IDX] = e, this.currRuleShortName = e, this.cstInvocationStateUpdate(t);
-	}
-	isBackTracking() {
-		return this.isBackTrackingStack.length !== 0;
-	}
-	getCurrRuleFullName() {
-		let e = this.currRuleShortName;
-		return this.shortRuleNameToFull[e];
-	}
-	shortRuleNameToFullName(e) {
-		return this.shortRuleNameToFull[e];
-	}
-	isAtEndOfInput() {
-		return this.tokenMatcher(this.LA(1), i);
-	}
-	reset() {
-		this.resetLexerState(), this.subruleIdx = 0, this.currRuleShortName = 0, this.isBackTrackingStack = [], this.errors = [], this.RULE_STACK_IDX = -1, this.RULE_OCCURRENCE_STACK_IDX = -1, this.CST_STACK = [];
-	}
-	onBeforeParse(e) {
-		for (let e = 0; e < this.maxLookahead + 1; e++) this.tokVector.push(_);
-	}
-	onAfterParse(e) {
-		if (this.isAtEndOfInput() === !1) {
-			let e = this.LA(1), t = this.errorMessageProvider.buildNotAllInputParsedMessage({
-				firstRedundant: e,
-				ruleName: this.getCurrRuleFullName()
-			});
-			this.SAVE_ERROR(new d(t, e));
-		}
-		for (; this.tokVector.at(-1) === _;) this.tokVector.pop();
-	}
-};
-//#endregion
-export { v as RecognizerEngine };
-
-//# sourceMappingURL=recognizer_engine.js.map

package/lib/esm/node_modules/chevrotain/lib/src/parse/parser/traits/recognizer_engine.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"recognizer_engine.js","names":[],"sources":["../../../../../../../../../../../node_modules/chevrotain/lib/src/parse/parser/traits/recognizer_engine.js"],"sourcesContent":["import { 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, } from \"../../grammar/keys.js\";\nimport { isRecognitionException, MismatchedTokenException, NotAllInputParsedException, } from \"../../exceptions_public.js\";\nimport { PROD_TYPE } from \"../../grammar/lookahead.js\";\nimport { NextTerminalAfterAtLeastOneSepWalker, NextTerminalAfterAtLeastOneWalker, NextTerminalAfterManySepWalker, NextTerminalAfterManyWalker, } from \"../../grammar/interpreter.js\";\nimport { DEFAULT_RULE_CONFIG, END_OF_FILE, } from \"../parser.js\";\nimport { IN_RULE_RECOVERY_EXCEPTION } from \"./recoverable.js\";\nimport { EOF } from \"../../../scan/tokens_public.js\";\nimport { augmentTokenTypes, isTokenType, tokenStructuredMatcher, tokenStructuredMatcherNoCategories, } from \"../../../scan/tokens.js\";\n/**\n * This trait is responsible for the runtime parsing engine\n * Used by the official API (recognizer_api.ts)\n */\nexport class RecognizerEngine {\n    initRecognizerEngine(tokenVocabulary, config) {\n        this.className = this.constructor.name;\n        // TODO: would using an ES6 Map or plain object be faster (CST building scenario)\n        this.shortRuleNameToFull = {};\n        this.fullRuleNameToShort = {};\n        this.ruleShortNameIdx = 256;\n        this.tokenMatcher = tokenStructuredMatcherNoCategories;\n        this.subruleIdx = 0;\n        this.currRuleShortName = 0;\n        this.definedRulesNames = [];\n        this.tokensMap = {};\n        this.isBackTrackingStack = [];\n        this.RULE_STACK = [];\n        this.RULE_STACK_IDX = -1;\n        this.RULE_OCCURRENCE_STACK = [];\n        this.RULE_OCCURRENCE_STACK_IDX = -1;\n        this.gastProductionsCache = {};\n        if (Object.hasOwn(config, \"serializedGrammar\")) {\n            throw Error(\"The Parser's configuration can no longer contain a <serializedGrammar> property.\\n\" +\n                \"\\tSee: https://chevrotain.io/docs/changes/BREAKING_CHANGES.html#_6-0-0\\n\" +\n                \"\\tFor Further details.\");\n        }\n        if (Array.isArray(tokenVocabulary)) {\n            // This only checks for Token vocabularies provided as arrays.\n            // That is good enough because the main objective is to detect users of pre-V4.0 APIs\n            // rather than all edge cases of empty Token vocabularies.\n            if (tokenVocabulary.length === 0) {\n                throw Error(\"A Token Vocabulary cannot be empty.\\n\" +\n                    \"\\tNote that the first argument for the parser constructor\\n\" +\n                    \"\\tis no longer a Token vector (since v4.0).\");\n            }\n            if (typeof tokenVocabulary[0].startOffset === \"number\") {\n                throw Error(\"The Parser constructor no longer accepts a token vector as the first argument.\\n\" +\n                    \"\\tSee: https://chevrotain.io/docs/changes/BREAKING_CHANGES.html#_4-0-0\\n\" +\n                    \"\\tFor Further details.\");\n            }\n        }\n        if (Array.isArray(tokenVocabulary)) {\n            this.tokensMap = tokenVocabulary.reduce((acc, tokType) => {\n                acc[tokType.name] = tokType;\n                return acc;\n            }, {});\n        }\n        else if (Object.hasOwn(tokenVocabulary, \"modes\") &&\n            Object.values(tokenVocabulary.modes)\n                .flat()\n                .every(isTokenType)) {\n            const allTokenTypes = Object.values(tokenVocabulary.modes).flat();\n            const uniqueTokens = [...new Set(allTokenTypes)];\n            this.tokensMap = uniqueTokens.reduce((acc, tokType) => {\n                acc[tokType.name] = tokType;\n                return acc;\n            }, {});\n        }\n        else if (typeof tokenVocabulary === \"object\" &&\n            tokenVocabulary !== null) {\n            this.tokensMap = Object.assign({}, tokenVocabulary);\n        }\n        else {\n            throw new Error(\"<tokensDictionary> argument must be An Array of Token constructors,\" +\n                \" A dictionary of Token constructors or an IMultiModeLexerDefinition\");\n        }\n        // always add EOF to the tokenNames -> constructors map. it is useful to assure all the input has been\n        // parsed with a clear error message (\"expecting EOF but found ...\")\n        this.tokensMap[\"EOF\"] = EOF;\n        const allTokenTypes = Object.hasOwn(tokenVocabulary, \"modes\")\n            ? Object.values(tokenVocabulary.modes).flat()\n            : Object.values(tokenVocabulary);\n        const noTokenCategoriesUsed = allTokenTypes.every(\n        // intentional \"==\" to also cover \"undefined\"\n        (tokenConstructor) => { var _a; return ((_a = tokenConstructor.categoryMatches) === null || _a === void 0 ? void 0 : _a.length) == 0; });\n        this.tokenMatcher = noTokenCategoriesUsed\n            ? tokenStructuredMatcherNoCategories\n            : tokenStructuredMatcher;\n        // Because ES2015+ syntax should be supported for creating Token classes\n        // We cannot assume that the Token classes were created using the \"extendToken\" utilities\n        // Therefore we must augment the Token classes both on Lexer initialization and on Parser initialization\n        augmentTokenTypes(Object.values(this.tokensMap));\n    }\n    defineRule(ruleName, impl, config) {\n        if (this.selfAnalysisDone) {\n            throw Error(`Grammar rule <${ruleName}> may not be defined after the 'performSelfAnalysis' method has been called'\\n` +\n                `Make sure that all grammar rule definitions are done before 'performSelfAnalysis' is called.`);\n        }\n        const resyncEnabled = Object.hasOwn(config, \"resyncEnabled\")\n            ? config.resyncEnabled // assumes end user provides the correct config value/type\n            : DEFAULT_RULE_CONFIG.resyncEnabled;\n        const recoveryValueFunc = Object.hasOwn(config, \"recoveryValueFunc\")\n            ? config.recoveryValueFunc // assumes end user provides the correct config value/type\n            : DEFAULT_RULE_CONFIG.recoveryValueFunc;\n        // performance optimization: Use small integers as keys for the longer human readable \"full\" rule names.\n        // this greatly improves Map access time (as much as 8% for some performance benchmarks).\n        const shortName = this.ruleShortNameIdx << (BITS_FOR_METHOD_TYPE + BITS_FOR_OCCURRENCE_IDX);\n        this.ruleShortNameIdx++;\n        this.shortRuleNameToFull[shortName] = ruleName;\n        this.fullRuleNameToShort[ruleName] = shortName;\n        let coreRuleFunction;\n        // Micro optimization, only check the condition **once** on rule definition\n        // instead of **every single** rule invocation.\n        if (this.outputCst === true) {\n            coreRuleFunction = function invokeRuleWithTry(...args) {\n                try {\n                    this.ruleInvocationStateUpdate(shortName, ruleName, this.subruleIdx);\n                    impl.apply(this, args);\n                    const cst = this.CST_STACK[this.CST_STACK.length - 1];\n                    this.cstPostRule(cst);\n                    return cst;\n                }\n                catch (e) {\n                    return this.invokeRuleCatch(e, resyncEnabled, recoveryValueFunc);\n                }\n                finally {\n                    this.ruleFinallyStateUpdate();\n                }\n            };\n        }\n        else {\n            coreRuleFunction = function invokeRuleWithTryCst(...args) {\n                try {\n                    this.ruleInvocationStateUpdate(shortName, ruleName, this.subruleIdx);\n                    return impl.apply(this, args);\n                }\n                catch (e) {\n                    return this.invokeRuleCatch(e, resyncEnabled, recoveryValueFunc);\n                }\n                finally {\n                    this.ruleFinallyStateUpdate();\n                }\n            };\n        }\n        // wrapper to allow before/after parsing hooks\n        const rootRuleFunction = function rootRule(...args) {\n            this.onBeforeParse(ruleName);\n            try {\n                return coreRuleFunction.apply(this, args);\n            }\n            finally {\n                this.onAfterParse(ruleName);\n            }\n        };\n        const wrappedGrammarRule = Object.assign(rootRuleFunction, { ruleName, originalGrammarAction: impl, coreRule: coreRuleFunction });\n        return wrappedGrammarRule;\n    }\n    invokeRuleCatch(e, resyncEnabledConfig, recoveryValueFunc) {\n        const isFirstInvokedRule = this.RULE_STACK_IDX === 0;\n        // note the reSync is always enabled for the first rule invocation, because we must always be able to\n        // reSync with EOF and just output some INVALID ParseTree\n        // during backtracking reSync recovery is disabled, otherwise we can't be certain the backtracking\n        // path is really the most valid one\n        const reSyncEnabled = resyncEnabledConfig && !this.isBackTracking() && this.recoveryEnabled;\n        if (isRecognitionException(e)) {\n            const recogError = e;\n            if (reSyncEnabled) {\n                const reSyncTokType = this.findReSyncTokenType();\n                if (this.isInCurrentRuleReSyncSet(reSyncTokType)) {\n                    recogError.resyncedTokens = this.reSyncTo(reSyncTokType);\n                    if (this.outputCst) {\n                        const partialCstResult = this.CST_STACK[this.CST_STACK.length - 1];\n                        partialCstResult.recoveredNode = true;\n                        return partialCstResult;\n                    }\n                    else {\n                        return recoveryValueFunc(e);\n                    }\n                }\n                else {\n                    if (this.outputCst) {\n                        const partialCstResult = this.CST_STACK[this.CST_STACK.length - 1];\n                        partialCstResult.recoveredNode = true;\n                        recogError.partialCstResult = partialCstResult;\n                    }\n                    // to be handled Further up the call stack\n                    throw recogError;\n                }\n            }\n            else if (isFirstInvokedRule) {\n                // otherwise a Redundant input error will be created as well and we cannot guarantee that this is indeed the case\n                this.moveToTerminatedState();\n                // the parser should never throw one of its own errors outside its flow.\n                // even if error recovery is disabled\n                return recoveryValueFunc(e);\n            }\n            else {\n                // to be recovered Further up the call stack\n                throw recogError;\n            }\n        }\n        else {\n            // some other Error type which we don't know how to handle (for example a built in JavaScript Error)\n            throw e;\n        }\n    }\n    // Implementation of parsing DSL\n    optionInternal(actionORMethodDef, occurrence) {\n        const key = this.getKeyForAutomaticLookahead(OPTION_IDX, occurrence);\n        return this.optionInternalLogic(actionORMethodDef, occurrence, key);\n    }\n    optionInternalLogic(actionORMethodDef, occurrence, key) {\n        let lookAheadFunc = this.getLaFuncFromCache(key);\n        let action;\n        if (typeof actionORMethodDef !== \"function\") {\n            action = actionORMethodDef.DEF;\n            const predicate = actionORMethodDef.GATE;\n            // predicate present\n            if (predicate !== undefined) {\n                const orgLookaheadFunction = lookAheadFunc;\n                lookAheadFunc = () => {\n                    return predicate.call(this) && orgLookaheadFunction.call(this);\n                };\n            }\n        }\n        else {\n            action = actionORMethodDef;\n        }\n        if (lookAheadFunc.call(this) === true) {\n            return action.call(this);\n        }\n        return undefined;\n    }\n    atLeastOneInternal(prodOccurrence, actionORMethodDef) {\n        const laKey = this.getKeyForAutomaticLookahead(AT_LEAST_ONE_IDX, prodOccurrence);\n        return this.atLeastOneInternalLogic(prodOccurrence, actionORMethodDef, laKey);\n    }\n    atLeastOneInternalLogic(prodOccurrence, actionORMethodDef, key) {\n        let lookAheadFunc = this.getLaFuncFromCache(key);\n        let action;\n        if (typeof actionORMethodDef !== \"function\") {\n            action = actionORMethodDef.DEF;\n            const predicate = actionORMethodDef.GATE;\n            // predicate present\n            if (predicate !== undefined) {\n                const orgLookaheadFunction = lookAheadFunc;\n                lookAheadFunc = () => {\n                    return predicate.call(this) && orgLookaheadFunction.call(this);\n                };\n            }\n        }\n        else {\n            action = actionORMethodDef;\n        }\n        if (lookAheadFunc.call(this) === true) {\n            let notStuck = this.doSingleRepetition(action);\n            while (lookAheadFunc.call(this) === true &&\n                notStuck === true) {\n                notStuck = this.doSingleRepetition(action);\n            }\n        }\n        else {\n            throw this.raiseEarlyExitException(prodOccurrence, PROD_TYPE.REPETITION_MANDATORY, actionORMethodDef.ERR_MSG);\n        }\n        // note that while it may seem that this can cause an error because by using a recursive call to\n        // AT_LEAST_ONE we change the grammar to AT_LEAST_TWO, AT_LEAST_THREE ... , the possible recursive call\n        // from the tryInRepetitionRecovery(...) will only happen IFF there really are TWO/THREE/.... items.\n        // Performance optimization: \"attemptInRepetitionRecovery\" will be defined as NOOP unless recovery is enabled\n        this.attemptInRepetitionRecovery(this.atLeastOneInternal, [prodOccurrence, actionORMethodDef], lookAheadFunc, AT_LEAST_ONE_IDX, prodOccurrence, NextTerminalAfterAtLeastOneWalker);\n    }\n    atLeastOneSepFirstInternal(prodOccurrence, options) {\n        const laKey = this.getKeyForAutomaticLookahead(AT_LEAST_ONE_SEP_IDX, prodOccurrence);\n        this.atLeastOneSepFirstInternalLogic(prodOccurrence, options, laKey);\n    }\n    atLeastOneSepFirstInternalLogic(prodOccurrence, options, key) {\n        const action = options.DEF;\n        const separator = options.SEP;\n        const firstIterationLookaheadFunc = this.getLaFuncFromCache(key);\n        // 1st iteration\n        if (firstIterationLookaheadFunc.call(this) === true) {\n            action.call(this);\n            //  TODO: Optimization can move this function construction into \"attemptInRepetitionRecovery\"\n            //  because it is only needed in error recovery scenarios.\n            const separatorLookAheadFunc = () => {\n                return this.tokenMatcher(this.LA_FAST(1), separator);\n            };\n            // 2nd..nth iterations\n            while (this.tokenMatcher(this.LA_FAST(1), separator) === true) {\n                // note that this CONSUME will never enter recovery because\n                // the separatorLookAheadFunc checks that the separator really does exist.\n                this.CONSUME(separator);\n                // No need for checking infinite loop here due to consuming the separator.\n                action.call(this);\n            }\n            // Performance optimization: \"attemptInRepetitionRecovery\" will be defined as NOOP unless recovery is enabled\n            this.attemptInRepetitionRecovery(this.repetitionSepSecondInternal, [\n                prodOccurrence,\n                separator,\n                separatorLookAheadFunc,\n                action,\n                NextTerminalAfterAtLeastOneSepWalker,\n            ], separatorLookAheadFunc, AT_LEAST_ONE_SEP_IDX, prodOccurrence, NextTerminalAfterAtLeastOneSepWalker);\n        }\n        else {\n            throw this.raiseEarlyExitException(prodOccurrence, PROD_TYPE.REPETITION_MANDATORY_WITH_SEPARATOR, options.ERR_MSG);\n        }\n    }\n    manyInternal(prodOccurrence, actionORMethodDef) {\n        const laKey = this.getKeyForAutomaticLookahead(MANY_IDX, prodOccurrence);\n        return this.manyInternalLogic(prodOccurrence, actionORMethodDef, laKey);\n    }\n    manyInternalLogic(prodOccurrence, actionORMethodDef, key) {\n        let lookaheadFunction = this.getLaFuncFromCache(key);\n        let action;\n        if (typeof actionORMethodDef !== \"function\") {\n            action = actionORMethodDef.DEF;\n            const predicate = actionORMethodDef.GATE;\n            // predicate present\n            if (predicate !== undefined) {\n                const orgLookaheadFunction = lookaheadFunction;\n                lookaheadFunction = () => {\n                    return predicate.call(this) && orgLookaheadFunction.call(this);\n                };\n            }\n        }\n        else {\n            action = actionORMethodDef;\n        }\n        let notStuck = true;\n        while (lookaheadFunction.call(this) === true && notStuck === true) {\n            notStuck = this.doSingleRepetition(action);\n        }\n        // Performance optimization: \"attemptInRepetitionRecovery\" will be defined as NOOP unless recovery is enabled\n        this.attemptInRepetitionRecovery(this.manyInternal, [prodOccurrence, actionORMethodDef], lookaheadFunction, MANY_IDX, prodOccurrence, NextTerminalAfterManyWalker, \n        // The notStuck parameter is only relevant when \"attemptInRepetitionRecovery\"\n        // is invoked from manyInternal, in the MANY_SEP case and AT_LEAST_ONE[_SEP]\n        // An infinite loop cannot occur as:\n        // - Either the lookahead is guaranteed to consume something (Single Token Separator)\n        // - AT_LEAST_ONE by definition is guaranteed to consume something (or error out).\n        notStuck);\n    }\n    manySepFirstInternal(prodOccurrence, options) {\n        const laKey = this.getKeyForAutomaticLookahead(MANY_SEP_IDX, prodOccurrence);\n        this.manySepFirstInternalLogic(prodOccurrence, options, laKey);\n    }\n    manySepFirstInternalLogic(prodOccurrence, options, key) {\n        const action = options.DEF;\n        const separator = options.SEP;\n        const firstIterationLaFunc = this.getLaFuncFromCache(key);\n        // 1st iteration\n        if (firstIterationLaFunc.call(this) === true) {\n            action.call(this);\n            const separatorLookAheadFunc = () => {\n                return this.tokenMatcher(this.LA_FAST(1), separator);\n            };\n            // 2nd..nth iterations\n            while (this.tokenMatcher(this.LA_FAST(1), separator) === true) {\n                // note that this CONSUME will never enter recovery because\n                // the separatorLookAheadFunc checks that the separator really does exist.\n                this.CONSUME(separator);\n                // No need for checking infinite loop here due to consuming the separator.\n                action.call(this);\n            }\n            // Performance optimization: \"attemptInRepetitionRecovery\" will be defined as NOOP unless recovery is enabled\n            this.attemptInRepetitionRecovery(this.repetitionSepSecondInternal, [\n                prodOccurrence,\n                separator,\n                separatorLookAheadFunc,\n                action,\n                NextTerminalAfterManySepWalker,\n            ], separatorLookAheadFunc, MANY_SEP_IDX, prodOccurrence, NextTerminalAfterManySepWalker);\n        }\n    }\n    repetitionSepSecondInternal(prodOccurrence, separator, separatorLookAheadFunc, action, nextTerminalAfterWalker) {\n        while (separatorLookAheadFunc()) {\n            // note that this CONSUME will never enter recovery because\n            // the separatorLookAheadFunc checks that the separator really does exist.\n            this.CONSUME(separator);\n            action.call(this);\n        }\n        // we can only arrive to this function after an error\n        // has occurred (hence the name 'second') so the following\n        // IF will always be entered, its possible to remove it...\n        // however it is kept to avoid confusion and be consistent.\n        // Performance optimization: \"attemptInRepetitionRecovery\" will be defined as NOOP unless recovery is enabled\n        /* istanbul ignore else */\n        this.attemptInRepetitionRecovery(this.repetitionSepSecondInternal, [\n            prodOccurrence,\n            separator,\n            separatorLookAheadFunc,\n            action,\n            nextTerminalAfterWalker,\n        ], separatorLookAheadFunc, AT_LEAST_ONE_SEP_IDX, prodOccurrence, nextTerminalAfterWalker);\n    }\n    doSingleRepetition(action) {\n        const beforeIteration = this.getLexerPosition();\n        action.call(this);\n        const afterIteration = this.getLexerPosition();\n        // This boolean will indicate if this repetition progressed\n        // or if we are \"stuck\" (potential infinite loop in the repetition).\n        return afterIteration > beforeIteration;\n    }\n    orInternal(altsOrOpts, occurrence) {\n        const laKey = this.getKeyForAutomaticLookahead(OR_IDX, occurrence);\n        const alts = Array.isArray(altsOrOpts) ? altsOrOpts : altsOrOpts.DEF;\n        const laFunc = this.getLaFuncFromCache(laKey);\n        const altIdxToTake = laFunc.call(this, alts);\n        if (altIdxToTake !== undefined) {\n            const chosenAlternative = alts[altIdxToTake];\n            return chosenAlternative.ALT.call(this);\n        }\n        this.raiseNoAltException(occurrence, altsOrOpts.ERR_MSG);\n    }\n    ruleFinallyStateUpdate() {\n        this.RULE_STACK_IDX--;\n        this.RULE_OCCURRENCE_STACK_IDX--;\n        // Restore the cached short name to the parent rule.\n        // When the stack is empty (top-level rule exiting), the stale value\n        // is harmless — no DSL methods will be called before the next ruleInvocationStateUpdate.\n        if (this.RULE_STACK_IDX >= 0) {\n            this.currRuleShortName = this.RULE_STACK[this.RULE_STACK_IDX];\n        }\n        // NOOP when cst is disabled\n        this.cstFinallyStateUpdate();\n    }\n    subruleInternal(ruleToCall, idx, options) {\n        let ruleResult;\n        try {\n            const args = options !== undefined ? options.ARGS : undefined;\n            this.subruleIdx = idx;\n            // Use coreRule to bypass root-level hooks (onBeforeParse/onAfterParse)\n            ruleResult = ruleToCall.coreRule.apply(this, args);\n            this.cstPostNonTerminal(ruleResult, options !== undefined && options.LABEL !== undefined\n                ? options.LABEL\n                : ruleToCall.ruleName);\n            return ruleResult;\n        }\n        catch (e) {\n            throw this.subruleInternalError(e, options, ruleToCall.ruleName);\n        }\n    }\n    subruleInternalError(e, options, ruleName) {\n        if (isRecognitionException(e) && e.partialCstResult !== undefined) {\n            this.cstPostNonTerminal(e.partialCstResult, options !== undefined && options.LABEL !== undefined\n                ? options.LABEL\n                : ruleName);\n            delete e.partialCstResult;\n        }\n        throw e;\n    }\n    consumeInternal(tokType, idx, options) {\n        let consumedToken;\n        try {\n            const nextToken = this.LA_FAST(1);\n            if (this.tokenMatcher(nextToken, tokType) === true) {\n                this.consumeToken();\n                consumedToken = nextToken;\n            }\n            else {\n                this.consumeInternalError(tokType, nextToken, options);\n            }\n        }\n        catch (eFromConsumption) {\n            consumedToken = this.consumeInternalRecovery(tokType, idx, eFromConsumption);\n        }\n        this.cstPostTerminal(options !== undefined && options.LABEL !== undefined\n            ? options.LABEL\n            : tokType.name, consumedToken);\n        return consumedToken;\n    }\n    consumeInternalError(tokType, nextToken, options) {\n        let msg;\n        const previousToken = this.LA(0);\n        if (options !== undefined && options.ERR_MSG) {\n            msg = options.ERR_MSG;\n        }\n        else {\n            msg = this.errorMessageProvider.buildMismatchTokenMessage({\n                expected: tokType,\n                actual: nextToken,\n                previous: previousToken,\n                ruleName: this.getCurrRuleFullName(),\n            });\n        }\n        throw this.SAVE_ERROR(new MismatchedTokenException(msg, nextToken, previousToken));\n    }\n    consumeInternalRecovery(tokType, idx, eFromConsumption) {\n        // no recovery allowed during backtracking, otherwise backtracking may recover invalid syntax and accept it\n        // but the original syntax could have been parsed successfully without any backtracking + recovery\n        if (this.recoveryEnabled &&\n            // TODO: more robust checking of the exception type. Perhaps Typescript extending expressions?\n            eFromConsumption.name === \"MismatchedTokenException\" &&\n            !this.isBackTracking()) {\n            const follows = this.getFollowsForInRuleRecovery(tokType, idx);\n            try {\n                return this.tryInRuleRecovery(tokType, follows);\n            }\n            catch (eFromInRuleRecovery) {\n                if (eFromInRuleRecovery.name === IN_RULE_RECOVERY_EXCEPTION) {\n                    // failed in RuleRecovery.\n                    // throw the original error in order to trigger reSync error recovery\n                    throw eFromConsumption;\n                }\n                else {\n                    throw eFromInRuleRecovery;\n                }\n            }\n        }\n        else {\n            throw eFromConsumption;\n        }\n    }\n    saveRecogState() {\n        // errors is a getter which will clone the errors array\n        const savedErrors = this.errors;\n        // Slice only the active portion of the pre-allocated stack\n        const savedRuleStack = this.RULE_STACK.slice(0, this.RULE_STACK_IDX + 1);\n        return {\n            errors: savedErrors,\n            lexerState: this.exportLexerState(),\n            RULE_STACK: savedRuleStack,\n            CST_STACK: this.CST_STACK,\n        };\n    }\n    reloadRecogState(newState) {\n        this.errors = newState.errors;\n        this.importLexerState(newState.lexerState);\n        // Copy saved stack back into the pre-allocated array and restore the index\n        const saved = newState.RULE_STACK;\n        for (let i = 0; i < saved.length; i++) {\n            this.RULE_STACK[i] = saved[i];\n        }\n        this.RULE_STACK_IDX = saved.length - 1;\n        // Restore cached short name from the restored stack\n        if (this.RULE_STACK_IDX >= 0) {\n            this.currRuleShortName = this.RULE_STACK[this.RULE_STACK_IDX];\n        }\n    }\n    ruleInvocationStateUpdate(shortName, fullName, idxInCallingRule) {\n        this.RULE_OCCURRENCE_STACK[++this.RULE_OCCURRENCE_STACK_IDX] =\n            idxInCallingRule;\n        this.RULE_STACK[++this.RULE_STACK_IDX] = shortName;\n        this.currRuleShortName = shortName;\n        // NOOP when cst is disabled\n        this.cstInvocationStateUpdate(fullName);\n    }\n    isBackTracking() {\n        return this.isBackTrackingStack.length !== 0;\n    }\n    getCurrRuleFullName() {\n        const shortName = this.currRuleShortName;\n        return this.shortRuleNameToFull[shortName];\n    }\n    shortRuleNameToFullName(shortName) {\n        return this.shortRuleNameToFull[shortName];\n    }\n    isAtEndOfInput() {\n        return this.tokenMatcher(this.LA(1), EOF);\n    }\n    reset() {\n        this.resetLexerState();\n        this.subruleIdx = 0;\n        this.currRuleShortName = 0;\n        this.isBackTrackingStack = [];\n        this.errors = [];\n        // Reset depth counters but keep arrays allocated to avoid re-allocation.\n        // Stale number values in unused slots are harmless.\n        this.RULE_STACK_IDX = -1;\n        this.RULE_OCCURRENCE_STACK_IDX = -1;\n        // TODO: extract a specific reset for TreeBuilder trait\n        this.CST_STACK = [];\n    }\n    /**\n     * Hook called before the root-level parsing rule is invoked.\n     * This is only called when a rule is invoked directly by the consumer\n     * (e.g., `parser.json()`), not when invoked as a sub-rule via SUBRULE.\n     *\n     * Override this method to perform actions before parsing begins.\n     * The default implementation is a no-op.\n     *\n     * @param ruleName - The name of the root rule being invoked.\n     */\n    onBeforeParse(ruleName) {\n        // Pad with sentinels for bounds-free forward LA()\n        for (let i = 0; i < this.maxLookahead + 1; i++) {\n            this.tokVector.push(END_OF_FILE);\n        }\n    }\n    /**\n     * Hook called after the root-level parsing rule has completed (or thrown).\n     * This is only called when a rule is invoked directly by the consumer\n     * (e.g., `parser.json()`), not when invoked as a sub-rule via SUBRULE.\n     *\n     * This hook is called in a `finally` block, so it executes regardless of\n     * whether parsing succeeded or threw an error.\n     *\n     * Override this method to perform actions after parsing completes.\n     * The default implementation is a no-op.\n     *\n     * @param ruleName - The name of the root rule that was invoked.\n     */\n    onAfterParse(ruleName) {\n        if (this.isAtEndOfInput() === false) {\n            const firstRedundantTok = this.LA(1);\n            const errMsg = this.errorMessageProvider.buildNotAllInputParsedMessage({\n                firstRedundant: firstRedundantTok,\n                ruleName: this.getCurrRuleFullName(),\n            });\n            this.SAVE_ERROR(new NotAllInputParsedException(errMsg, firstRedundantTok));\n        }\n        // undo the padding of sentinels for bounds-free forward LA() in onBeforeParse\n        while (this.tokVector.at(-1) === END_OF_FILE) {\n            this.tokVector.pop();\n        }\n    }\n}\n//# sourceMappingURL=recognizer_engine.js.map"],"x_google_ignoreList":[0],"mappings":"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"}

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

@@ -1,147 +0,0 @@
-import { IN as e } from "../../constants.js";
-import { EOF as t, createTokenInstance as n, tokenMatcher as r } from "../../../scan/tokens_public.js";
-import { NextAfterTokenWalker as i } from "../../grammar/interpreter.js";
-import { MismatchedTokenException as a } from "../../exceptions_public.js";
-import { DEFAULT_PARSER_CONFIG as o } from "../parser.js";
-//#region ../../node_modules/chevrotain/lib/src/parse/parser/traits/recoverable.js
-var s = {}, c = "InRuleRecoveryException", l = class extends Error {
-	constructor(e) {
-		super(e), this.name = c;
-	}
-}, u = class {
-	initRecoverable(e) {
-		this.firstAfterRepMap = {}, this.resyncFollows = {}, this.recoveryEnabled = Object.hasOwn(e, "recoveryEnabled") ? e.recoveryEnabled : o.recoveryEnabled, this.recoveryEnabled && (this.attemptInRepetitionRecovery = d);
-	}
-	getTokenToInsert(e) {
-		let t = n(e, "", NaN, NaN, NaN, NaN, NaN, NaN);
-		return t.isInsertedInRecovery = !0, t;
-	}
-	canTokenTypeBeInsertedInRecovery(e) {
-		return !0;
-	}
-	canTokenTypeBeDeletedInRecovery(e) {
-		return !0;
-	}
-	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 a(this.errorMessageProvider.buildMismatchTokenMessage({
-				expected: r,
-				actual: l,
-				previous: e,
-				ruleName: this.getCurrRuleFullName()
-			}), l, this.LA(0));
-			t.resyncedTokens = s.slice(0, -1), this.SAVE_ERROR(t);
-		};
-		for (; !c;) if (this.tokenMatcher(u, r)) {
-			d();
-			return;
-		} else if (n.call(this)) {
-			d(), e.apply(this, t);
-			return;
-		} else this.tokenMatcher(u, i) ? c = !0 : (u = this.SKIP_TOKEN(), this.addToResyncTokens(u, s));
-		this.importLexerState(o);
-	}
-	shouldInRepetitionRecoveryBeTried(e, t, n) {
-		return !(n === !1 || this.tokenMatcher(this.LA_FAST(1), e) || this.isBackTracking() || this.canPerformInRuleRecovery(e, this.getFollowsForInRuleRecovery(e, t)));
-	}
-	getNextPossibleTokenTypes(e) {
-		let t = e.ruleStack[0], n = this.getGAstProductions()[t];
-		return new i(n, e).startWalking();
-	}
-	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 l("sad sad panda");
-	}
-	canPerformInRuleRecovery(e, t) {
-		return this.canRecoverWithSingleTokenInsertion(e, t) || this.canRecoverWithSingleTokenDeletion(e);
-	}
-	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 t = this.getCurrFollowKey();
-		return this.getFollowSetFromFollowKey(t).includes(e);
-	}
-	findReSyncTokenType() {
-		let e = this.flattenFollowSet(), t = this.LA_FAST(1), n = 2;
-		for (;;) {
-			let i = e.find((e) => r(t, e));
-			if (i !== void 0) return i;
-			t = this.LA(n), n++;
-		}
-	}
-	getCurrFollowKey() {
-		if (this.RULE_STACK_IDX === 0) return s;
-		let e = this.currRuleShortName, t = this.getLastExplicitRuleOccurrenceIndex(), n = this.getPreviousExplicitRuleShortName();
-		return {
-			ruleName: this.shortRuleNameToFullName(e),
-			idxInCallingRule: t,
-			inRule: this.shortRuleNameToFullName(n)
-		};
-	}
-	buildFullFollowKeyStack() {
-		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] = s : r[i] = {
-			ruleName: this.shortRuleNameToFullName(e[i]),
-			idxInCallingRule: t[i],
-			inRule: this.shortRuleNameToFullName(e[i - 1])
-		};
-		return r;
-	}
-	flattenFollowSet() {
-		return this.buildFullFollowKeyStack().map((e) => this.getFollowSetFromFollowKey(e)).flat();
-	}
-	getFollowSetFromFollowKey(n) {
-		if (n === s) return [t];
-		let r = n.ruleName + n.idxInCallingRule + e + n.inRule;
-		return this.resyncFollows[r];
-	}
-	addToResyncTokens(e, n) {
-		return this.tokenMatcher(e, t) || n.push(e), n;
-	}
-	reSyncTo(e) {
-		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, t, n, r, i, a, o) {}
-	getCurrentGrammarPath(e, t) {
-		return {
-			ruleStack: this.getHumanReadableRuleStack(),
-			occurrenceStack: this.RULE_OCCURRENCE_STACK.slice(0, this.RULE_OCCURRENCE_STACK_IDX + 1),
-			lastTok: e,
-			lastTokOccurrence: t
-		};
-	}
-	getHumanReadableRuleStack() {
-		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 d(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 = t, d = 1), !(u === void 0 || d === void 0) && this.shouldInRepetitionRecoveryBeTried(u, d, s) && this.tryInRepetitionRecovery(e, n, r, u);
-}
-//#endregion
-export { c as IN_RULE_RECOVERY_EXCEPTION, u as Recoverable };
-
-//# sourceMappingURL=recoverable.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"recoverable.js","names":[],"sources":["../../../../../../../../../../../node_modules/chevrotain/lib/src/parse/parser/traits/recoverable.js"],"sourcesContent":["import { createTokenInstance, EOF, tokenMatcher, } from \"../../../scan/tokens_public.js\";\nimport { NextAfterTokenWalker, } from \"../../grammar/interpreter.js\";\nimport { MismatchedTokenException } from \"../../exceptions_public.js\";\nimport { IN } from \"../../constants.js\";\nimport { DEFAULT_PARSER_CONFIG } from \"../parser.js\";\nexport const EOF_FOLLOW_KEY = {};\nexport const IN_RULE_RECOVERY_EXCEPTION = \"InRuleRecoveryException\";\nexport class InRuleRecoveryException extends Error {\n    constructor(message) {\n        super(message);\n        this.name = IN_RULE_RECOVERY_EXCEPTION;\n    }\n}\n/**\n * This trait is responsible for the error recovery and fault tolerant logic\n */\nexport class Recoverable {\n    initRecoverable(config) {\n        this.firstAfterRepMap = {};\n        this.resyncFollows = {};\n        this.recoveryEnabled = Object.hasOwn(config, \"recoveryEnabled\")\n            ? config.recoveryEnabled // assumes end user provides the correct config value/type\n            : DEFAULT_PARSER_CONFIG.recoveryEnabled;\n        // performance optimization, NOOP will be inlined which\n        // effectively means that this optional feature does not exist\n        // when not used.\n        if (this.recoveryEnabled) {\n            this.attemptInRepetitionRecovery = attemptInRepetitionRecovery;\n        }\n    }\n    getTokenToInsert(tokType) {\n        const tokToInsert = createTokenInstance(tokType, \"\", NaN, NaN, NaN, NaN, NaN, NaN);\n        tokToInsert.isInsertedInRecovery = true;\n        return tokToInsert;\n    }\n    canTokenTypeBeInsertedInRecovery(tokType) {\n        return true;\n    }\n    canTokenTypeBeDeletedInRecovery(tokType) {\n        return true;\n    }\n    tryInRepetitionRecovery(grammarRule, grammarRuleArgs, lookAheadFunc, expectedTokType) {\n        // TODO: can the resyncTokenType be cached?\n        const reSyncTokType = this.findReSyncTokenType();\n        const savedLexerState = this.exportLexerState();\n        const resyncedTokens = [];\n        let passedResyncPoint = false;\n        const nextTokenWithoutResync = this.LA_FAST(1);\n        let currToken = this.LA_FAST(1);\n        const generateErrorMessage = () => {\n            const previousToken = this.LA(0);\n            // we are preemptively re-syncing before an error has been detected, therefor we must reproduce\n            // the error that would have been thrown\n            const msg = this.errorMessageProvider.buildMismatchTokenMessage({\n                expected: expectedTokType,\n                actual: nextTokenWithoutResync,\n                previous: previousToken,\n                ruleName: this.getCurrRuleFullName(),\n            });\n            const error = new MismatchedTokenException(msg, nextTokenWithoutResync, this.LA(0));\n            // the first token here will be the original cause of the error, this is not part of the resyncedTokens property.\n            error.resyncedTokens = resyncedTokens.slice(0, -1);\n            this.SAVE_ERROR(error);\n        };\n        while (!passedResyncPoint) {\n            // re-synced to a point where we can safely exit the repetition/\n            if (this.tokenMatcher(currToken, expectedTokType)) {\n                generateErrorMessage();\n                return; // must return here to avoid reverting the inputIdx\n            }\n            else if (lookAheadFunc.call(this)) {\n                // we skipped enough tokens so we can resync right back into another iteration of the repetition grammar rule\n                generateErrorMessage();\n                // recursive invocation in other to support multiple re-syncs in the same top level repetition grammar rule\n                grammarRule.apply(this, grammarRuleArgs);\n                return; // must return here to avoid reverting the inputIdx\n            }\n            else if (this.tokenMatcher(currToken, reSyncTokType)) {\n                passedResyncPoint = true;\n            }\n            else {\n                currToken = this.SKIP_TOKEN();\n                this.addToResyncTokens(currToken, resyncedTokens);\n            }\n        }\n        // we were unable to find a CLOSER point to resync inside the Repetition, reset the state.\n        // The parsing exception we were trying to prevent will happen in the NEXT parsing step. it may be handled by\n        // \"between rules\" resync recovery later in the flow.\n        this.importLexerState(savedLexerState);\n    }\n    shouldInRepetitionRecoveryBeTried(expectTokAfterLastMatch, nextTokIdx, notStuck) {\n        // Edge case of arriving from a MANY repetition which is stuck\n        // Attempting recovery in this case could cause an infinite loop\n        if (notStuck === false) {\n            return false;\n        }\n        // no need to recover, next token is what we expect...\n        if (this.tokenMatcher(this.LA_FAST(1), expectTokAfterLastMatch)) {\n            return false;\n        }\n        // error recovery is disabled during backtracking as it can make the parser ignore a valid grammar path\n        // and prefer some backtracking path that includes recovered errors.\n        if (this.isBackTracking()) {\n            return false;\n        }\n        // if we can perform inRule recovery (single token insertion or deletion) we always prefer that recovery algorithm\n        // because if it works, it makes the least amount of changes to the input stream (greedy algorithm)\n        //noinspection RedundantIfStatementJS\n        if (this.canPerformInRuleRecovery(expectTokAfterLastMatch, this.getFollowsForInRuleRecovery(expectTokAfterLastMatch, nextTokIdx))) {\n            return false;\n        }\n        return true;\n    }\n    // TODO: should this be a member method or a utility? it does not have any state or usage of 'this'...\n    // TODO: should this be more explicitly part of the public API?\n    getNextPossibleTokenTypes(grammarPath) {\n        const topRuleName = grammarPath.ruleStack[0];\n        const gastProductions = this.getGAstProductions();\n        const topProduction = gastProductions[topRuleName];\n        const nextPossibleTokenTypes = new NextAfterTokenWalker(topProduction, grammarPath).startWalking();\n        return nextPossibleTokenTypes;\n    }\n    // Error Recovery functionality\n    getFollowsForInRuleRecovery(tokType, tokIdxInRule) {\n        const grammarPath = this.getCurrentGrammarPath(tokType, tokIdxInRule);\n        const follows = this.getNextPossibleTokenTypes(grammarPath);\n        return follows;\n    }\n    tryInRuleRecovery(expectedTokType, follows) {\n        if (this.canRecoverWithSingleTokenInsertion(expectedTokType, follows)) {\n            const tokToInsert = this.getTokenToInsert(expectedTokType);\n            return tokToInsert;\n        }\n        if (this.canRecoverWithSingleTokenDeletion(expectedTokType)) {\n            const nextTok = this.SKIP_TOKEN();\n            this.consumeToken();\n            return nextTok;\n        }\n        throw new InRuleRecoveryException(\"sad sad panda\");\n    }\n    canPerformInRuleRecovery(expectedToken, follows) {\n        return (this.canRecoverWithSingleTokenInsertion(expectedToken, follows) ||\n            this.canRecoverWithSingleTokenDeletion(expectedToken));\n    }\n    canRecoverWithSingleTokenInsertion(expectedTokType, follows) {\n        if (!this.canTokenTypeBeInsertedInRecovery(expectedTokType)) {\n            return false;\n        }\n        // must know the possible following tokens to perform single token insertion\n        if (follows.length === 0) {\n            return false;\n        }\n        const mismatchedTok = this.LA_FAST(1);\n        const isMisMatchedTokInFollows = follows.find((possibleFollowsTokType) => {\n            return this.tokenMatcher(mismatchedTok, possibleFollowsTokType);\n        }) !== undefined;\n        return isMisMatchedTokInFollows;\n    }\n    canRecoverWithSingleTokenDeletion(expectedTokType) {\n        if (!this.canTokenTypeBeDeletedInRecovery(expectedTokType)) {\n            return false;\n        }\n        const isNextTokenWhatIsExpected = this.tokenMatcher(\n        // not using LA_FAST because LA(2) might be un-safe with maxLookahead=1\n        // in some edge cases (?)\n        this.LA(2), expectedTokType);\n        return isNextTokenWhatIsExpected;\n    }\n    isInCurrentRuleReSyncSet(tokenTypeIdx) {\n        const followKey = this.getCurrFollowKey();\n        const currentRuleReSyncSet = this.getFollowSetFromFollowKey(followKey);\n        return currentRuleReSyncSet.includes(tokenTypeIdx);\n    }\n    findReSyncTokenType() {\n        const allPossibleReSyncTokTypes = this.flattenFollowSet();\n        // this loop will always terminate as EOF is always in the follow stack and also always (virtually) in the input\n        let nextToken = this.LA_FAST(1);\n        let k = 2;\n        while (true) {\n            const foundMatch = allPossibleReSyncTokTypes.find((resyncTokType) => {\n                const canMatch = tokenMatcher(nextToken, resyncTokType);\n                return canMatch;\n            });\n            if (foundMatch !== undefined) {\n                return foundMatch;\n            }\n            nextToken = this.LA(k);\n            k++;\n        }\n    }\n    getCurrFollowKey() {\n        // the length is at least one as we always add the ruleName to the stack before invoking the rule.\n        if (this.RULE_STACK_IDX === 0) {\n            return EOF_FOLLOW_KEY;\n        }\n        const currRuleShortName = this.currRuleShortName;\n        const currRuleIdx = this.getLastExplicitRuleOccurrenceIndex();\n        const prevRuleShortName = this.getPreviousExplicitRuleShortName();\n        return {\n            ruleName: this.shortRuleNameToFullName(currRuleShortName),\n            idxInCallingRule: currRuleIdx,\n            inRule: this.shortRuleNameToFullName(prevRuleShortName),\n        };\n    }\n    buildFullFollowKeyStack() {\n        const explicitRuleStack = this.RULE_STACK;\n        const explicitOccurrenceStack = this.RULE_OCCURRENCE_STACK;\n        const len = this.RULE_STACK_IDX + 1;\n        const result = new Array(len);\n        for (let idx = 0; idx < len; idx++) {\n            if (idx === 0) {\n                result[idx] = EOF_FOLLOW_KEY;\n            }\n            else {\n                result[idx] = {\n                    ruleName: this.shortRuleNameToFullName(explicitRuleStack[idx]),\n                    idxInCallingRule: explicitOccurrenceStack[idx],\n                    inRule: this.shortRuleNameToFullName(explicitRuleStack[idx - 1]),\n                };\n            }\n        }\n        return result;\n    }\n    flattenFollowSet() {\n        const followStack = this.buildFullFollowKeyStack().map((currKey) => {\n            return this.getFollowSetFromFollowKey(currKey);\n        });\n        return followStack.flat();\n    }\n    getFollowSetFromFollowKey(followKey) {\n        if (followKey === EOF_FOLLOW_KEY) {\n            return [EOF];\n        }\n        const followName = followKey.ruleName + followKey.idxInCallingRule + IN + followKey.inRule;\n        return this.resyncFollows[followName];\n    }\n    // It does not make any sense to include a virtual EOF token in the list of resynced tokens\n    // as EOF does not really exist and thus does not contain any useful information (line/column numbers)\n    addToResyncTokens(token, resyncTokens) {\n        if (!this.tokenMatcher(token, EOF)) {\n            resyncTokens.push(token);\n        }\n        return resyncTokens;\n    }\n    reSyncTo(tokType) {\n        const resyncedTokens = [];\n        let nextTok = this.LA_FAST(1);\n        while (this.tokenMatcher(nextTok, tokType) === false) {\n            nextTok = this.SKIP_TOKEN();\n            this.addToResyncTokens(nextTok, resyncedTokens);\n        }\n        // the last token is not part of the error.\n        return resyncedTokens.slice(0, -1);\n    }\n    attemptInRepetitionRecovery(prodFunc, args, lookaheadFunc, dslMethodIdx, prodOccurrence, nextToksWalker, notStuck) {\n        // by default this is a NO-OP\n        // The actual implementation is with the function(not method) below\n    }\n    getCurrentGrammarPath(tokType, tokIdxInRule) {\n        const pathRuleStack = this.getHumanReadableRuleStack();\n        const pathOccurrenceStack = this.RULE_OCCURRENCE_STACK.slice(0, this.RULE_OCCURRENCE_STACK_IDX + 1);\n        const grammarPath = {\n            ruleStack: pathRuleStack,\n            occurrenceStack: pathOccurrenceStack,\n            lastTok: tokType,\n            lastTokOccurrence: tokIdxInRule,\n        };\n        return grammarPath;\n    }\n    getHumanReadableRuleStack() {\n        const len = this.RULE_STACK_IDX + 1;\n        const result = new Array(len);\n        for (let i = 0; i < len; i++) {\n            result[i] = this.shortRuleNameToFullName(this.RULE_STACK[i]);\n        }\n        return result;\n    }\n}\nexport function attemptInRepetitionRecovery(prodFunc, args, lookaheadFunc, dslMethodIdx, prodOccurrence, nextToksWalker, notStuck) {\n    const key = this.getKeyForAutomaticLookahead(dslMethodIdx, prodOccurrence);\n    let firstAfterRepInfo = this.firstAfterRepMap[key];\n    if (firstAfterRepInfo === undefined) {\n        const currRuleName = this.getCurrRuleFullName();\n        const ruleGrammar = this.getGAstProductions()[currRuleName];\n        const walker = new nextToksWalker(ruleGrammar, prodOccurrence);\n        firstAfterRepInfo = walker.startWalking();\n        this.firstAfterRepMap[key] = firstAfterRepInfo;\n    }\n    let expectTokAfterLastMatch = firstAfterRepInfo.token;\n    let nextTokIdx = firstAfterRepInfo.occurrence;\n    const isEndOfRule = firstAfterRepInfo.isEndOfRule;\n    // special edge case of a TOP most repetition after which the input should END.\n    // this will force an attempt for inRule recovery in that scenario.\n    if (this.RULE_STACK_IDX === 0 &&\n        isEndOfRule &&\n        expectTokAfterLastMatch === undefined) {\n        expectTokAfterLastMatch = EOF;\n        nextTokIdx = 1;\n    }\n    // We don't have anything to re-sync to...\n    // this condition was extracted from `shouldInRepetitionRecoveryBeTried` to act as a type-guard\n    if (expectTokAfterLastMatch === undefined || nextTokIdx === undefined) {\n        return;\n    }\n    if (this.shouldInRepetitionRecoveryBeTried(expectTokAfterLastMatch, nextTokIdx, notStuck)) {\n        // TODO: performance optimization: instead of passing the original args here, we modify\n        // the args param (or create a new one) and make sure the lookahead func is explicitly provided\n        // to avoid searching the cache for it once more.\n        this.tryInRepetitionRecovery(prodFunc, args, lookaheadFunc, expectTokAfterLastMatch);\n    }\n}\n//# sourceMappingURL=recoverable.js.map"],"x_google_ignoreList":[0],"mappings":"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"}