@elmethis/core 1.0.0-alpha.149 → 1.0.0-alpha.150

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

@@ -1,434 +0,0 @@
-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

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