@elmethis/core 1.0.0-alpha.146 → 1.0.0-alpha.148

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/parser/traits/recognizer_engine.mjs

@@ -0,0 +1,434 @@
+import { has, isArray, isEmpty, reduce, every, flatten, values, uniq, isObject, clone } from "lodash-es";
+import { BITS_FOR_METHOD_TYPE, BITS_FOR_OCCURRENCE_IDX, OPTION_IDX, AT_LEAST_ONE_IDX, AT_LEAST_ONE_SEP_IDX, MANY_IDX, MANY_SEP_IDX, OR_IDX } from "../../grammar/keys.mjs";
+import { isRecognitionException, NotAllInputParsedException, MismatchedTokenException } from "../../exceptions_public.mjs";
+import { PROD_TYPE } from "../../grammar/lookahead.mjs";
+import { NextTerminalAfterAtLeastOneWalker, NextTerminalAfterAtLeastOneSepWalker, NextTerminalAfterManyWalker, NextTerminalAfterManySepWalker } from "../../grammar/interpreter.mjs";
+import { DEFAULT_RULE_CONFIG } from "../parser.mjs";
+import { IN_RULE_RECOVERY_EXCEPTION } from "./recoverable.mjs";
+import { EOF } from "../../../scan/tokens_public.mjs";
+import { tokenStructuredMatcherNoCategories, isTokenType, tokenStructuredMatcher, augmentTokenTypes } from "../../../scan/tokens.mjs";
+class RecognizerEngine {
+  initRecognizerEngine(tokenVocabulary, config) {
+    this.className = this.constructor.name;
+    this.shortRuleNameToFull = {};
+    this.fullRuleNameToShort = {};
+    this.ruleShortNameIdx = 256;
+    this.tokenMatcher = tokenStructuredMatcherNoCategories;
+    this.subruleIdx = 0;
+    this.definedRulesNames = [];
+    this.tokensMap = {};
+    this.isBackTrackingStack = [];
+    this.RULE_STACK = [];
+    this.RULE_OCCURRENCE_STACK = [];
+    this.gastProductionsCache = {};
+    if (has(config, "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 (isArray(tokenVocabulary)) {
+      if (isEmpty(tokenVocabulary)) {
+        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 tokenVocabulary[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 (isArray(tokenVocabulary)) {
+      this.tokensMap = reduce(tokenVocabulary, (acc, tokType) => {
+        acc[tokType.name] = tokType;
+        return acc;
+      }, {});
+    } else if (has(tokenVocabulary, "modes") && every(flatten(values(tokenVocabulary.modes)), isTokenType)) {
+      const allTokenTypes2 = flatten(values(tokenVocabulary.modes));
+      const uniqueTokens = uniq(allTokenTypes2);
+      this.tokensMap = reduce(uniqueTokens, (acc, tokType) => {
+        acc[tokType.name] = tokType;
+        return acc;
+      }, {});
+    } else if (isObject(tokenVocabulary)) {
+      this.tokensMap = clone(tokenVocabulary);
+    } else {
+      throw new Error("<tokensDictionary> argument must be An Array of Token constructors, A dictionary of Token constructors or an IMultiModeLexerDefinition");
+    }
+    this.tokensMap["EOF"] = EOF;
+    const allTokenTypes = has(tokenVocabulary, "modes") ? flatten(values(tokenVocabulary.modes)) : values(tokenVocabulary);
+    const noTokenCategoriesUsed = every(allTokenTypes, (tokenConstructor) => isEmpty(tokenConstructor.categoryMatches));
+    this.tokenMatcher = noTokenCategoriesUsed ? tokenStructuredMatcherNoCategories : tokenStructuredMatcher;
+    augmentTokenTypes(values(this.tokensMap));
+  }
+  defineRule(ruleName, impl, config) {
+    if (this.selfAnalysisDone) {
+      throw Error(`Grammar rule <${ruleName}> may not be defined after the 'performSelfAnalysis' method has been called'
+Make sure that all grammar rule definitions are done before 'performSelfAnalysis' is called.`);
+    }
+    const resyncEnabled = has(config, "resyncEnabled") ? config.resyncEnabled : DEFAULT_RULE_CONFIG.resyncEnabled;
+    const recoveryValueFunc = has(config, "recoveryValueFunc") ? config.recoveryValueFunc : DEFAULT_RULE_CONFIG.recoveryValueFunc;
+    const shortName = this.ruleShortNameIdx << BITS_FOR_METHOD_TYPE + BITS_FOR_OCCURRENCE_IDX;
+    this.ruleShortNameIdx++;
+    this.shortRuleNameToFull[shortName] = ruleName;
+    this.fullRuleNameToShort[ruleName] = shortName;
+    let invokeRuleWithTry;
+    if (this.outputCst === true) {
+      invokeRuleWithTry = function invokeRuleWithTry2(...args) {
+        try {
+          this.ruleInvocationStateUpdate(shortName, ruleName, this.subruleIdx);
+          impl.apply(this, args);
+          const cst = this.CST_STACK[this.CST_STACK.length - 1];
+          this.cstPostRule(cst);
+          return cst;
+        } catch (e) {
+          return this.invokeRuleCatch(e, resyncEnabled, recoveryValueFunc);
+        } finally {
+          this.ruleFinallyStateUpdate();
+        }
+      };
+    } else {
+      invokeRuleWithTry = function invokeRuleWithTryCst(...args) {
+        try {
+          this.ruleInvocationStateUpdate(shortName, ruleName, this.subruleIdx);
+          return impl.apply(this, args);
+        } catch (e) {
+          return this.invokeRuleCatch(e, resyncEnabled, recoveryValueFunc);
+        } finally {
+          this.ruleFinallyStateUpdate();
+        }
+      };
+    }
+    const wrappedGrammarRule = Object.assign(invokeRuleWithTry, { ruleName, originalGrammarAction: impl });
+    return wrappedGrammarRule;
+  }
+  invokeRuleCatch(e, resyncEnabledConfig, recoveryValueFunc) {
+    const isFirstInvokedRule = this.RULE_STACK.length === 1;
+    const reSyncEnabled = resyncEnabledConfig && !this.isBackTracking() && this.recoveryEnabled;
+    if (isRecognitionException(e)) {
+      const recogError = e;
+      if (reSyncEnabled) {
+        const reSyncTokType = this.findReSyncTokenType();
+        if (this.isInCurrentRuleReSyncSet(reSyncTokType)) {
+          recogError.resyncedTokens = this.reSyncTo(reSyncTokType);
+          if (this.outputCst) {
+            const partialCstResult = this.CST_STACK[this.CST_STACK.length - 1];
+            partialCstResult.recoveredNode = true;
+            return partialCstResult;
+          } else {
+            return recoveryValueFunc(e);
+          }
+        } else {
+          if (this.outputCst) {
+            const partialCstResult = this.CST_STACK[this.CST_STACK.length - 1];
+            partialCstResult.recoveredNode = true;
+            recogError.partialCstResult = partialCstResult;
+          }
+          throw recogError;
+        }
+      } else if (isFirstInvokedRule) {
+        this.moveToTerminatedState();
+        return recoveryValueFunc(e);
+      } else {
+        throw recogError;
+      }
+    } else {
+      throw e;
+    }
+  }
+  // Implementation of parsing DSL
+  optionInternal(actionORMethodDef, occurrence) {
+    const key = this.getKeyForAutomaticLookahead(OPTION_IDX, occurrence);
+    return this.optionInternalLogic(actionORMethodDef, occurrence, key);
+  }
+  optionInternalLogic(actionORMethodDef, occurrence, key) {
+    let lookAheadFunc = this.getLaFuncFromCache(key);
+    let action;
+    if (typeof actionORMethodDef !== "function") {
+      action = actionORMethodDef.DEF;
+      const predicate = actionORMethodDef.GATE;
+      if (predicate !== void 0) {
+        const orgLookaheadFunction = lookAheadFunc;
+        lookAheadFunc = () => {
+          return predicate.call(this) && orgLookaheadFunction.call(this);
+        };
+      }
+    } else {
+      action = actionORMethodDef;
+    }
+    if (lookAheadFunc.call(this) === true) {
+      return action.call(this);
+    }
+    return void 0;
+  }
+  atLeastOneInternal(prodOccurrence, actionORMethodDef) {
+    const laKey = this.getKeyForAutomaticLookahead(AT_LEAST_ONE_IDX, prodOccurrence);
+    return this.atLeastOneInternalLogic(prodOccurrence, actionORMethodDef, laKey);
+  }
+  atLeastOneInternalLogic(prodOccurrence, actionORMethodDef, key) {
+    let lookAheadFunc = this.getLaFuncFromCache(key);
+    let action;
+    if (typeof actionORMethodDef !== "function") {
+      action = actionORMethodDef.DEF;
+      const predicate = actionORMethodDef.GATE;
+      if (predicate !== void 0) {
+        const orgLookaheadFunction = lookAheadFunc;
+        lookAheadFunc = () => {
+          return predicate.call(this) && orgLookaheadFunction.call(this);
+        };
+      }
+    } else {
+      action = actionORMethodDef;
+    }
+    if (lookAheadFunc.call(this) === true) {
+      let notStuck = this.doSingleRepetition(action);
+      while (lookAheadFunc.call(this) === true && notStuck === true) {
+        notStuck = this.doSingleRepetition(action);
+      }
+    } else {
+      throw this.raiseEarlyExitException(prodOccurrence, PROD_TYPE.REPETITION_MANDATORY, actionORMethodDef.ERR_MSG);
+    }
+    this.attemptInRepetitionRecovery(this.atLeastOneInternal, [prodOccurrence, actionORMethodDef], lookAheadFunc, AT_LEAST_ONE_IDX, prodOccurrence, NextTerminalAfterAtLeastOneWalker);
+  }
+  atLeastOneSepFirstInternal(prodOccurrence, options) {
+    const laKey = this.getKeyForAutomaticLookahead(AT_LEAST_ONE_SEP_IDX, prodOccurrence);
+    this.atLeastOneSepFirstInternalLogic(prodOccurrence, options, laKey);
+  }
+  atLeastOneSepFirstInternalLogic(prodOccurrence, options, key) {
+    const action = options.DEF;
+    const separator = options.SEP;
+    const firstIterationLookaheadFunc = this.getLaFuncFromCache(key);
+    if (firstIterationLookaheadFunc.call(this) === true) {
+      action.call(this);
+      const separatorLookAheadFunc = () => {
+        return this.tokenMatcher(this.LA(1), separator);
+      };
+      while (this.tokenMatcher(this.LA(1), separator) === true) {
+        this.CONSUME(separator);
+        action.call(this);
+      }
+      this.attemptInRepetitionRecovery(this.repetitionSepSecondInternal, [
+        prodOccurrence,
+        separator,
+        separatorLookAheadFunc,
+        action,
+        NextTerminalAfterAtLeastOneSepWalker
+      ], separatorLookAheadFunc, AT_LEAST_ONE_SEP_IDX, prodOccurrence, NextTerminalAfterAtLeastOneSepWalker);
+    } else {
+      throw this.raiseEarlyExitException(prodOccurrence, PROD_TYPE.REPETITION_MANDATORY_WITH_SEPARATOR, options.ERR_MSG);
+    }
+  }
+  manyInternal(prodOccurrence, actionORMethodDef) {
+    const laKey = this.getKeyForAutomaticLookahead(MANY_IDX, prodOccurrence);
+    return this.manyInternalLogic(prodOccurrence, actionORMethodDef, laKey);
+  }
+  manyInternalLogic(prodOccurrence, actionORMethodDef, key) {
+    let lookaheadFunction = this.getLaFuncFromCache(key);
+    let action;
+    if (typeof actionORMethodDef !== "function") {
+      action = actionORMethodDef.DEF;
+      const predicate = actionORMethodDef.GATE;
+      if (predicate !== void 0) {
+        const orgLookaheadFunction = lookaheadFunction;
+        lookaheadFunction = () => {
+          return predicate.call(this) && orgLookaheadFunction.call(this);
+        };
+      }
+    } else {
+      action = actionORMethodDef;
+    }
+    let notStuck = true;
+    while (lookaheadFunction.call(this) === true && notStuck === true) {
+      notStuck = this.doSingleRepetition(action);
+    }
+    this.attemptInRepetitionRecovery(
+      this.manyInternal,
+      [prodOccurrence, actionORMethodDef],
+      lookaheadFunction,
+      MANY_IDX,
+      prodOccurrence,
+      NextTerminalAfterManyWalker,
+      // The notStuck parameter is only relevant when "attemptInRepetitionRecovery"
+      // is invoked from manyInternal, in the MANY_SEP case and AT_LEAST_ONE[_SEP]
+      // An infinite loop cannot occur as:
+      // - Either the lookahead is guaranteed to consume something (Single Token Separator)
+      // - AT_LEAST_ONE by definition is guaranteed to consume something (or error out).
+      notStuck
+    );
+  }
+  manySepFirstInternal(prodOccurrence, options) {
+    const laKey = this.getKeyForAutomaticLookahead(MANY_SEP_IDX, prodOccurrence);
+    this.manySepFirstInternalLogic(prodOccurrence, options, laKey);
+  }
+  manySepFirstInternalLogic(prodOccurrence, options, key) {
+    const action = options.DEF;
+    const separator = options.SEP;
+    const firstIterationLaFunc = this.getLaFuncFromCache(key);
+    if (firstIterationLaFunc.call(this) === true) {
+      action.call(this);
+      const separatorLookAheadFunc = () => {
+        return this.tokenMatcher(this.LA(1), separator);
+      };
+      while (this.tokenMatcher(this.LA(1), separator) === true) {
+        this.CONSUME(separator);
+        action.call(this);
+      }
+      this.attemptInRepetitionRecovery(this.repetitionSepSecondInternal, [
+        prodOccurrence,
+        separator,
+        separatorLookAheadFunc,
+        action,
+        NextTerminalAfterManySepWalker
+      ], separatorLookAheadFunc, MANY_SEP_IDX, prodOccurrence, NextTerminalAfterManySepWalker);
+    }
+  }
+  repetitionSepSecondInternal(prodOccurrence, separator, separatorLookAheadFunc, action, nextTerminalAfterWalker) {
+    while (separatorLookAheadFunc()) {
+      this.CONSUME(separator);
+      action.call(this);
+    }
+    this.attemptInRepetitionRecovery(this.repetitionSepSecondInternal, [
+      prodOccurrence,
+      separator,
+      separatorLookAheadFunc,
+      action,
+      nextTerminalAfterWalker
+    ], separatorLookAheadFunc, AT_LEAST_ONE_SEP_IDX, prodOccurrence, nextTerminalAfterWalker);
+  }
+  doSingleRepetition(action) {
+    const beforeIteration = this.getLexerPosition();
+    action.call(this);
+    const afterIteration = this.getLexerPosition();
+    return afterIteration > beforeIteration;
+  }
+  orInternal(altsOrOpts, occurrence) {
+    const laKey = this.getKeyForAutomaticLookahead(OR_IDX, occurrence);
+    const alts = isArray(altsOrOpts) ? altsOrOpts : altsOrOpts.DEF;
+    const laFunc = this.getLaFuncFromCache(laKey);
+    const altIdxToTake = laFunc.call(this, alts);
+    if (altIdxToTake !== void 0) {
+      const chosenAlternative = alts[altIdxToTake];
+      return chosenAlternative.ALT.call(this);
+    }
+    this.raiseNoAltException(occurrence, altsOrOpts.ERR_MSG);
+  }
+  ruleFinallyStateUpdate() {
+    this.RULE_STACK.pop();
+    this.RULE_OCCURRENCE_STACK.pop();
+    this.cstFinallyStateUpdate();
+    if (this.RULE_STACK.length === 0 && this.isAtEndOfInput() === false) {
+      const firstRedundantTok = this.LA(1);
+      const errMsg = this.errorMessageProvider.buildNotAllInputParsedMessage({
+        firstRedundant: firstRedundantTok,
+        ruleName: this.getCurrRuleFullName()
+      });
+      this.SAVE_ERROR(new NotAllInputParsedException(errMsg, firstRedundantTok));
+    }
+  }
+  subruleInternal(ruleToCall, idx, options) {
+    let ruleResult;
+    try {
+      const args = options !== void 0 ? options.ARGS : void 0;
+      this.subruleIdx = idx;
+      ruleResult = ruleToCall.apply(this, args);
+      this.cstPostNonTerminal(ruleResult, options !== void 0 && options.LABEL !== void 0 ? options.LABEL : ruleToCall.ruleName);
+      return ruleResult;
+    } catch (e) {
+      throw this.subruleInternalError(e, options, ruleToCall.ruleName);
+    }
+  }
+  subruleInternalError(e, options, ruleName) {
+    if (isRecognitionException(e) && e.partialCstResult !== void 0) {
+      this.cstPostNonTerminal(e.partialCstResult, options !== void 0 && options.LABEL !== void 0 ? options.LABEL : ruleName);
+      delete e.partialCstResult;
+    }
+    throw e;
+  }
+  consumeInternal(tokType, idx, options) {
+    let consumedToken;
+    try {
+      const nextToken = this.LA(1);
+      if (this.tokenMatcher(nextToken, tokType) === true) {
+        this.consumeToken();
+        consumedToken = nextToken;
+      } else {
+        this.consumeInternalError(tokType, nextToken, options);
+      }
+    } catch (eFromConsumption) {
+      consumedToken = this.consumeInternalRecovery(tokType, idx, eFromConsumption);
+    }
+    this.cstPostTerminal(options !== void 0 && options.LABEL !== void 0 ? options.LABEL : tokType.name, consumedToken);
+    return consumedToken;
+  }
+  consumeInternalError(tokType, nextToken, options) {
+    let msg;
+    const previousToken = this.LA(0);
+    if (options !== void 0 && options.ERR_MSG) {
+      msg = options.ERR_MSG;
+    } else {
+      msg = this.errorMessageProvider.buildMismatchTokenMessage({
+        expected: tokType,
+        actual: nextToken,
+        previous: previousToken,
+        ruleName: this.getCurrRuleFullName()
+      });
+    }
+    throw this.SAVE_ERROR(new MismatchedTokenException(msg, nextToken, previousToken));
+  }
+  consumeInternalRecovery(tokType, idx, eFromConsumption) {
+    if (this.recoveryEnabled && // TODO: more robust checking of the exception type. Perhaps Typescript extending expressions?
+    eFromConsumption.name === "MismatchedTokenException" && !this.isBackTracking()) {
+      const follows = this.getFollowsForInRuleRecovery(tokType, idx);
+      try {
+        return this.tryInRuleRecovery(tokType, follows);
+      } catch (eFromInRuleRecovery) {
+        if (eFromInRuleRecovery.name === IN_RULE_RECOVERY_EXCEPTION) {
+          throw eFromConsumption;
+        } else {
+          throw eFromInRuleRecovery;
+        }
+      }
+    } else {
+      throw eFromConsumption;
+    }
+  }
+  saveRecogState() {
+    const savedErrors = this.errors;
+    const savedRuleStack = clone(this.RULE_STACK);
+    return {
+      errors: savedErrors,
+      lexerState: this.exportLexerState(),
+      RULE_STACK: savedRuleStack,
+      CST_STACK: this.CST_STACK
+    };
+  }
+  reloadRecogState(newState) {
+    this.errors = newState.errors;
+    this.importLexerState(newState.lexerState);
+    this.RULE_STACK = newState.RULE_STACK;
+  }
+  ruleInvocationStateUpdate(shortName, fullName, idxInCallingRule) {
+    this.RULE_OCCURRENCE_STACK.push(idxInCallingRule);
+    this.RULE_STACK.push(shortName);
+    this.cstInvocationStateUpdate(fullName);
+  }
+  isBackTracking() {
+    return this.isBackTrackingStack.length !== 0;
+  }
+  getCurrRuleFullName() {
+    const shortName = this.getLastExplicitRuleShortName();
+    return this.shortRuleNameToFull[shortName];
+  }
+  shortRuleNameToFullName(shortName) {
+    return this.shortRuleNameToFull[shortName];
+  }
+  isAtEndOfInput() {
+    return this.tokenMatcher(this.LA(1), EOF);
+  }
+  reset() {
+    this.resetLexerState();
+    this.subruleIdx = 0;
+    this.isBackTrackingStack = [];
+    this.errors = [];
+    this.RULE_STACK = [];
+    this.CST_STACK = [];
+    this.RULE_OCCURRENCE_STACK = [];
+  }
+}
+export {
+  RecognizerEngine
+};

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/parser/traits/recoverable.mjs

@@ -0,0 +1,251 @@
+import { createTokenInstance, tokenMatcher, EOF } from "../../../scan/tokens_public.mjs";
+import { has, isEmpty, find, includes, map, flatten, dropRight, clone } from "lodash-es";
+import { MismatchedTokenException } from "../../exceptions_public.mjs";
+import { IN } from "../../constants.mjs";
+import { DEFAULT_PARSER_CONFIG } from "../parser.mjs";
+const EOF_FOLLOW_KEY = {};
+const IN_RULE_RECOVERY_EXCEPTION = "InRuleRecoveryException";
+class InRuleRecoveryException extends Error {
+  constructor(message) {
+    super(message);
+    this.name = IN_RULE_RECOVERY_EXCEPTION;
+  }
+}
+class Recoverable {
+  initRecoverable(config) {
+    this.firstAfterRepMap = {};
+    this.resyncFollows = {};
+    this.recoveryEnabled = has(config, "recoveryEnabled") ? config.recoveryEnabled : DEFAULT_PARSER_CONFIG.recoveryEnabled;
+    if (this.recoveryEnabled) {
+      this.attemptInRepetitionRecovery = attemptInRepetitionRecovery;
+    }
+  }
+  getTokenToInsert(tokType) {
+    const tokToInsert = createTokenInstance(tokType, "", NaN, NaN, NaN, NaN, NaN, NaN);
+    tokToInsert.isInsertedInRecovery = true;
+    return tokToInsert;
+  }
+  canTokenTypeBeInsertedInRecovery(tokType) {
+    return true;
+  }
+  canTokenTypeBeDeletedInRecovery(tokType) {
+    return true;
+  }
+  tryInRepetitionRecovery(grammarRule, grammarRuleArgs, lookAheadFunc, expectedTokType) {
+    const reSyncTokType = this.findReSyncTokenType();
+    const savedLexerState = this.exportLexerState();
+    const resyncedTokens = [];
+    let passedResyncPoint = false;
+    const nextTokenWithoutResync = this.LA(1);
+    let currToken = this.LA(1);
+    const generateErrorMessage = () => {
+      const previousToken = this.LA(0);
+      const msg = this.errorMessageProvider.buildMismatchTokenMessage({
+        expected: expectedTokType,
+        actual: nextTokenWithoutResync,
+        previous: previousToken,
+        ruleName: this.getCurrRuleFullName()
+      });
+      const error = new MismatchedTokenException(msg, nextTokenWithoutResync, this.LA(0));
+      error.resyncedTokens = dropRight(resyncedTokens);
+      this.SAVE_ERROR(error);
+    };
+    while (!passedResyncPoint) {
+      if (this.tokenMatcher(currToken, expectedTokType)) {
+        generateErrorMessage();
+        return;
+      } else if (lookAheadFunc.call(this)) {
+        generateErrorMessage();
+        grammarRule.apply(this, grammarRuleArgs);
+        return;
+      } else if (this.tokenMatcher(currToken, reSyncTokType)) {
+        passedResyncPoint = true;
+      } else {
+        currToken = this.SKIP_TOKEN();
+        this.addToResyncTokens(currToken, resyncedTokens);
+      }
+    }
+    this.importLexerState(savedLexerState);
+  }
+  shouldInRepetitionRecoveryBeTried(expectTokAfterLastMatch, nextTokIdx, notStuck) {
+    if (notStuck === false) {
+      return false;
+    }
+    if (this.tokenMatcher(this.LA(1), expectTokAfterLastMatch)) {
+      return false;
+    }
+    if (this.isBackTracking()) {
+      return false;
+    }
+    if (this.canPerformInRuleRecovery(expectTokAfterLastMatch, this.getFollowsForInRuleRecovery(expectTokAfterLastMatch, nextTokIdx))) {
+      return false;
+    }
+    return true;
+  }
+  // Error Recovery functionality
+  getFollowsForInRuleRecovery(tokType, tokIdxInRule) {
+    const grammarPath = this.getCurrentGrammarPath(tokType, tokIdxInRule);
+    const follows = this.getNextPossibleTokenTypes(grammarPath);
+    return follows;
+  }
+  tryInRuleRecovery(expectedTokType, follows) {
+    if (this.canRecoverWithSingleTokenInsertion(expectedTokType, follows)) {
+      const tokToInsert = this.getTokenToInsert(expectedTokType);
+      return tokToInsert;
+    }
+    if (this.canRecoverWithSingleTokenDeletion(expectedTokType)) {
+      const nextTok = this.SKIP_TOKEN();
+      this.consumeToken();
+      return nextTok;
+    }
+    throw new InRuleRecoveryException("sad sad panda");
+  }
+  canPerformInRuleRecovery(expectedToken, follows) {
+    return this.canRecoverWithSingleTokenInsertion(expectedToken, follows) || this.canRecoverWithSingleTokenDeletion(expectedToken);
+  }
+  canRecoverWithSingleTokenInsertion(expectedTokType, follows) {
+    if (!this.canTokenTypeBeInsertedInRecovery(expectedTokType)) {
+      return false;
+    }
+    if (isEmpty(follows)) {
+      return false;
+    }
+    const mismatchedTok = this.LA(1);
+    const isMisMatchedTokInFollows = find(follows, (possibleFollowsTokType) => {
+      return this.tokenMatcher(mismatchedTok, possibleFollowsTokType);
+    }) !== void 0;
+    return isMisMatchedTokInFollows;
+  }
+  canRecoverWithSingleTokenDeletion(expectedTokType) {
+    if (!this.canTokenTypeBeDeletedInRecovery(expectedTokType)) {
+      return false;
+    }
+    const isNextTokenWhatIsExpected = this.tokenMatcher(this.LA(2), expectedTokType);
+    return isNextTokenWhatIsExpected;
+  }
+  isInCurrentRuleReSyncSet(tokenTypeIdx) {
+    const followKey = this.getCurrFollowKey();
+    const currentRuleReSyncSet = this.getFollowSetFromFollowKey(followKey);
+    return includes(currentRuleReSyncSet, tokenTypeIdx);
+  }
+  findReSyncTokenType() {
+    const allPossibleReSyncTokTypes = this.flattenFollowSet();
+    let nextToken = this.LA(1);
+    let k = 2;
+    while (true) {
+      const foundMatch = find(allPossibleReSyncTokTypes, (resyncTokType) => {
+        const canMatch = tokenMatcher(nextToken, resyncTokType);
+        return canMatch;
+      });
+      if (foundMatch !== void 0) {
+        return foundMatch;
+      }
+      nextToken = this.LA(k);
+      k++;
+    }
+  }
+  getCurrFollowKey() {
+    if (this.RULE_STACK.length === 1) {
+      return EOF_FOLLOW_KEY;
+    }
+    const currRuleShortName = this.getLastExplicitRuleShortName();
+    const currRuleIdx = this.getLastExplicitRuleOccurrenceIndex();
+    const prevRuleShortName = this.getPreviousExplicitRuleShortName();
+    return {
+      ruleName: this.shortRuleNameToFullName(currRuleShortName),
+      idxInCallingRule: currRuleIdx,
+      inRule: this.shortRuleNameToFullName(prevRuleShortName)
+    };
+  }
+  buildFullFollowKeyStack() {
+    const explicitRuleStack = this.RULE_STACK;
+    const explicitOccurrenceStack = this.RULE_OCCURRENCE_STACK;
+    return map(explicitRuleStack, (ruleName, idx) => {
+      if (idx === 0) {
+        return EOF_FOLLOW_KEY;
+      }
+      return {
+        ruleName: this.shortRuleNameToFullName(ruleName),
+        idxInCallingRule: explicitOccurrenceStack[idx],
+        inRule: this.shortRuleNameToFullName(explicitRuleStack[idx - 1])
+      };
+    });
+  }
+  flattenFollowSet() {
+    const followStack = map(this.buildFullFollowKeyStack(), (currKey) => {
+      return this.getFollowSetFromFollowKey(currKey);
+    });
+    return flatten(followStack);
+  }
+  getFollowSetFromFollowKey(followKey) {
+    if (followKey === EOF_FOLLOW_KEY) {
+      return [EOF];
+    }
+    const followName = followKey.ruleName + followKey.idxInCallingRule + IN + followKey.inRule;
+    return this.resyncFollows[followName];
+  }
+  // It does not make any sense to include a virtual EOF token in the list of resynced tokens
+  // as EOF does not really exist and thus does not contain any useful information (line/column numbers)
+  addToResyncTokens(token, resyncTokens) {
+    if (!this.tokenMatcher(token, EOF)) {
+      resyncTokens.push(token);
+    }
+    return resyncTokens;
+  }
+  reSyncTo(tokType) {
+    const resyncedTokens = [];
+    let nextTok = this.LA(1);
+    while (this.tokenMatcher(nextTok, tokType) === false) {
+      nextTok = this.SKIP_TOKEN();
+      this.addToResyncTokens(nextTok, resyncedTokens);
+    }
+    return dropRight(resyncedTokens);
+  }
+  attemptInRepetitionRecovery(prodFunc, args, lookaheadFunc, dslMethodIdx, prodOccurrence, nextToksWalker, notStuck) {
+  }
+  getCurrentGrammarPath(tokType, tokIdxInRule) {
+    const pathRuleStack = this.getHumanReadableRuleStack();
+    const pathOccurrenceStack = clone(this.RULE_OCCURRENCE_STACK);
+    const grammarPath = {
+      ruleStack: pathRuleStack,
+      occurrenceStack: pathOccurrenceStack,
+      lastTok: tokType,
+      lastTokOccurrence: tokIdxInRule
+    };
+    return grammarPath;
+  }
+  getHumanReadableRuleStack() {
+    return map(this.RULE_STACK, (currShortName) => this.shortRuleNameToFullName(currShortName));
+  }
+}
+function attemptInRepetitionRecovery(prodFunc, args, lookaheadFunc, dslMethodIdx, prodOccurrence, nextToksWalker, notStuck) {
+  const key = this.getKeyForAutomaticLookahead(dslMethodIdx, prodOccurrence);
+  let firstAfterRepInfo = this.firstAfterRepMap[key];
+  if (firstAfterRepInfo === void 0) {
+    const currRuleName = this.getCurrRuleFullName();
+    const ruleGrammar = this.getGAstProductions()[currRuleName];
+    const walker = new nextToksWalker(ruleGrammar, prodOccurrence);
+    firstAfterRepInfo = walker.startWalking();
+    this.firstAfterRepMap[key] = firstAfterRepInfo;
+  }
+  let expectTokAfterLastMatch = firstAfterRepInfo.token;
+  let nextTokIdx = firstAfterRepInfo.occurrence;
+  const isEndOfRule = firstAfterRepInfo.isEndOfRule;
+  if (this.RULE_STACK.length === 1 && isEndOfRule && expectTokAfterLastMatch === void 0) {
+    expectTokAfterLastMatch = EOF;
+    nextTokIdx = 1;
+  }
+  if (expectTokAfterLastMatch === void 0 || nextTokIdx === void 0) {
+    return;
+  }
+  if (this.shouldInRepetitionRecoveryBeTried(expectTokAfterLastMatch, nextTokIdx, notStuck)) {
+    this.tryInRepetitionRecovery(prodFunc, args, lookaheadFunc, expectTokAfterLastMatch);
+  }
+}
+export {
+  EOF_FOLLOW_KEY,
+  IN_RULE_RECOVERY_EXCEPTION,
+  InRuleRecoveryException,
+  Recoverable,
+  attemptInRepetitionRecovery
+};