@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/grammar/lookahead.mjs

@@ -1,387 +0,0 @@
-import { every, isEmpty, map, forEach, flatten, reduce, has } from "lodash-es";
-import { possiblePathsFrom } from "./interpreter.mjs";
-import { RestWalker } from "./rest.mjs";
-import { tokenStructuredMatcherNoCategories, tokenStructuredMatcher } from "../../scan/tokens.mjs";
-import { Option, Repetition, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Alternation, Alternative } from "../../../../../../../@chevrotain_gast@11.0.3/node_modules/@chevrotain/gast/lib/src/model.mjs";
-import { GAstVisitor } from "../../../../../../../@chevrotain_gast@11.0.3/node_modules/@chevrotain/gast/lib/src/visitor.mjs";
-var PROD_TYPE;
-(function(PROD_TYPE2) {
-  PROD_TYPE2[PROD_TYPE2["OPTION"] = 0] = "OPTION";
-  PROD_TYPE2[PROD_TYPE2["REPETITION"] = 1] = "REPETITION";
-  PROD_TYPE2[PROD_TYPE2["REPETITION_MANDATORY"] = 2] = "REPETITION_MANDATORY";
-  PROD_TYPE2[PROD_TYPE2["REPETITION_MANDATORY_WITH_SEPARATOR"] = 3] = "REPETITION_MANDATORY_WITH_SEPARATOR";
-  PROD_TYPE2[PROD_TYPE2["REPETITION_WITH_SEPARATOR"] = 4] = "REPETITION_WITH_SEPARATOR";
-  PROD_TYPE2[PROD_TYPE2["ALTERNATION"] = 5] = "ALTERNATION";
-})(PROD_TYPE || (PROD_TYPE = {}));
-function getProdType(prod) {
-  if (prod instanceof Option || prod === "Option") {
-    return PROD_TYPE.OPTION;
-  } else if (prod instanceof Repetition || prod === "Repetition") {
-    return PROD_TYPE.REPETITION;
-  } else if (prod instanceof RepetitionMandatory || prod === "RepetitionMandatory") {
-    return PROD_TYPE.REPETITION_MANDATORY;
-  } else if (prod instanceof RepetitionMandatoryWithSeparator || prod === "RepetitionMandatoryWithSeparator") {
-    return PROD_TYPE.REPETITION_MANDATORY_WITH_SEPARATOR;
-  } else if (prod instanceof RepetitionWithSeparator || prod === "RepetitionWithSeparator") {
-    return PROD_TYPE.REPETITION_WITH_SEPARATOR;
-  } else if (prod instanceof Alternation || prod === "Alternation") {
-    return PROD_TYPE.ALTERNATION;
-  } else {
-    throw Error("non exhaustive match");
-  }
-}
-function getLookaheadPaths(options) {
-  const { occurrence, rule, prodType, maxLookahead } = options;
-  const type = getProdType(prodType);
-  if (type === PROD_TYPE.ALTERNATION) {
-    return getLookaheadPathsForOr(occurrence, rule, maxLookahead);
-  } else {
-    return getLookaheadPathsForOptionalProd(occurrence, rule, type, maxLookahead);
-  }
-}
-function buildLookaheadFuncForOr(occurrence, ruleGrammar, maxLookahead, hasPredicates, dynamicTokensEnabled, laFuncBuilder) {
-  const lookAheadPaths = getLookaheadPathsForOr(occurrence, ruleGrammar, maxLookahead);
-  const tokenMatcher = areTokenCategoriesNotUsed(lookAheadPaths) ? tokenStructuredMatcherNoCategories : tokenStructuredMatcher;
-  return laFuncBuilder(lookAheadPaths, hasPredicates, tokenMatcher, dynamicTokensEnabled);
-}
-function buildLookaheadFuncForOptionalProd(occurrence, ruleGrammar, k, dynamicTokensEnabled, prodType, lookaheadBuilder) {
-  const lookAheadPaths = getLookaheadPathsForOptionalProd(occurrence, ruleGrammar, prodType, k);
-  const tokenMatcher = areTokenCategoriesNotUsed(lookAheadPaths) ? tokenStructuredMatcherNoCategories : tokenStructuredMatcher;
-  return lookaheadBuilder(lookAheadPaths[0], tokenMatcher, dynamicTokensEnabled);
-}
-function buildAlternativesLookAheadFunc(alts, hasPredicates, tokenMatcher, dynamicTokensEnabled) {
-  const numOfAlts = alts.length;
-  const areAllOneTokenLookahead = every(alts, (currAlt) => {
-    return every(currAlt, (currPath) => {
-      return currPath.length === 1;
-    });
-  });
-  if (hasPredicates) {
-    return function(orAlts) {
-      const predicates = map(orAlts, (currAlt) => currAlt.GATE);
-      for (let t = 0; t < numOfAlts; t++) {
-        const currAlt = alts[t];
-        const currNumOfPaths = currAlt.length;
-        const currPredicate = predicates[t];
-        if (currPredicate !== void 0 && currPredicate.call(this) === false) {
-          continue;
-        }
-        nextPath: for (let j = 0; j < currNumOfPaths; j++) {
-          const currPath = currAlt[j];
-          const currPathLength = currPath.length;
-          for (let i = 0; i < currPathLength; i++) {
-            const nextToken = this.LA(i + 1);
-            if (tokenMatcher(nextToken, currPath[i]) === false) {
-              continue nextPath;
-            }
-          }
-          return t;
-        }
-      }
-      return void 0;
-    };
-  } else if (areAllOneTokenLookahead && !dynamicTokensEnabled) {
-    const singleTokenAlts = map(alts, (currAlt) => {
-      return flatten(currAlt);
-    });
-    const choiceToAlt = reduce(singleTokenAlts, (result, currAlt, idx) => {
-      forEach(currAlt, (currTokType) => {
-        if (!has(result, currTokType.tokenTypeIdx)) {
-          result[currTokType.tokenTypeIdx] = idx;
-        }
-        forEach(currTokType.categoryMatches, (currExtendingType) => {
-          if (!has(result, currExtendingType)) {
-            result[currExtendingType] = idx;
-          }
-        });
-      });
-      return result;
-    }, {});
-    return function() {
-      const nextToken = this.LA(1);
-      return choiceToAlt[nextToken.tokenTypeIdx];
-    };
-  } else {
-    return function() {
-      for (let t = 0; t < numOfAlts; t++) {
-        const currAlt = alts[t];
-        const currNumOfPaths = currAlt.length;
-        nextPath: for (let j = 0; j < currNumOfPaths; j++) {
-          const currPath = currAlt[j];
-          const currPathLength = currPath.length;
-          for (let i = 0; i < currPathLength; i++) {
-            const nextToken = this.LA(i + 1);
-            if (tokenMatcher(nextToken, currPath[i]) === false) {
-              continue nextPath;
-            }
-          }
-          return t;
-        }
-      }
-      return void 0;
-    };
-  }
-}
-function buildSingleAlternativeLookaheadFunction(alt, tokenMatcher, dynamicTokensEnabled) {
-  const areAllOneTokenLookahead = every(alt, (currPath) => {
-    return currPath.length === 1;
-  });
-  const numOfPaths = alt.length;
-  if (areAllOneTokenLookahead && !dynamicTokensEnabled) {
-    const singleTokensTypes = flatten(alt);
-    if (singleTokensTypes.length === 1 && isEmpty(singleTokensTypes[0].categoryMatches)) {
-      const expectedTokenType = singleTokensTypes[0];
-      const expectedTokenUniqueKey = expectedTokenType.tokenTypeIdx;
-      return function() {
-        return this.LA(1).tokenTypeIdx === expectedTokenUniqueKey;
-      };
-    } else {
-      const choiceToAlt = reduce(singleTokensTypes, (result, currTokType, idx) => {
-        result[currTokType.tokenTypeIdx] = true;
-        forEach(currTokType.categoryMatches, (currExtendingType) => {
-          result[currExtendingType] = true;
-        });
-        return result;
-      }, []);
-      return function() {
-        const nextToken = this.LA(1);
-        return choiceToAlt[nextToken.tokenTypeIdx] === true;
-      };
-    }
-  } else {
-    return function() {
-      nextPath: for (let j = 0; j < numOfPaths; j++) {
-        const currPath = alt[j];
-        const currPathLength = currPath.length;
-        for (let i = 0; i < currPathLength; i++) {
-          const nextToken = this.LA(i + 1);
-          if (tokenMatcher(nextToken, currPath[i]) === false) {
-            continue nextPath;
-          }
-        }
-        return true;
-      }
-      return false;
-    };
-  }
-}
-class RestDefinitionFinderWalker extends RestWalker {
-  constructor(topProd, targetOccurrence, targetProdType) {
-    super();
-    this.topProd = topProd;
-    this.targetOccurrence = targetOccurrence;
-    this.targetProdType = targetProdType;
-  }
-  startWalking() {
-    this.walk(this.topProd);
-    return this.restDef;
-  }
-  checkIsTarget(node, expectedProdType, currRest, prevRest) {
-    if (node.idx === this.targetOccurrence && this.targetProdType === expectedProdType) {
-      this.restDef = currRest.concat(prevRest);
-      return true;
-    }
-    return false;
-  }
-  walkOption(optionProd, currRest, prevRest) {
-    if (!this.checkIsTarget(optionProd, PROD_TYPE.OPTION, currRest, prevRest)) {
-      super.walkOption(optionProd, currRest, prevRest);
-    }
-  }
-  walkAtLeastOne(atLeastOneProd, currRest, prevRest) {
-    if (!this.checkIsTarget(atLeastOneProd, PROD_TYPE.REPETITION_MANDATORY, currRest, prevRest)) {
-      super.walkOption(atLeastOneProd, currRest, prevRest);
-    }
-  }
-  walkAtLeastOneSep(atLeastOneSepProd, currRest, prevRest) {
-    if (!this.checkIsTarget(atLeastOneSepProd, PROD_TYPE.REPETITION_MANDATORY_WITH_SEPARATOR, currRest, prevRest)) {
-      super.walkOption(atLeastOneSepProd, currRest, prevRest);
-    }
-  }
-  walkMany(manyProd, currRest, prevRest) {
-    if (!this.checkIsTarget(manyProd, PROD_TYPE.REPETITION, currRest, prevRest)) {
-      super.walkOption(manyProd, currRest, prevRest);
-    }
-  }
-  walkManySep(manySepProd, currRest, prevRest) {
-    if (!this.checkIsTarget(manySepProd, PROD_TYPE.REPETITION_WITH_SEPARATOR, currRest, prevRest)) {
-      super.walkOption(manySepProd, currRest, prevRest);
-    }
-  }
-}
-class InsideDefinitionFinderVisitor extends GAstVisitor {
-  constructor(targetOccurrence, targetProdType, targetRef) {
-    super();
-    this.targetOccurrence = targetOccurrence;
-    this.targetProdType = targetProdType;
-    this.targetRef = targetRef;
-    this.result = [];
-  }
-  checkIsTarget(node, expectedProdName) {
-    if (node.idx === this.targetOccurrence && this.targetProdType === expectedProdName && (this.targetRef === void 0 || node === this.targetRef)) {
-      this.result = node.definition;
-    }
-  }
-  visitOption(node) {
-    this.checkIsTarget(node, PROD_TYPE.OPTION);
-  }
-  visitRepetition(node) {
-    this.checkIsTarget(node, PROD_TYPE.REPETITION);
-  }
-  visitRepetitionMandatory(node) {
-    this.checkIsTarget(node, PROD_TYPE.REPETITION_MANDATORY);
-  }
-  visitRepetitionMandatoryWithSeparator(node) {
-    this.checkIsTarget(node, PROD_TYPE.REPETITION_MANDATORY_WITH_SEPARATOR);
-  }
-  visitRepetitionWithSeparator(node) {
-    this.checkIsTarget(node, PROD_TYPE.REPETITION_WITH_SEPARATOR);
-  }
-  visitAlternation(node) {
-    this.checkIsTarget(node, PROD_TYPE.ALTERNATION);
-  }
-}
-function initializeArrayOfArrays(size) {
-  const result = new Array(size);
-  for (let i = 0; i < size; i++) {
-    result[i] = [];
-  }
-  return result;
-}
-function pathToHashKeys(path) {
-  let keys = [""];
-  for (let i = 0; i < path.length; i++) {
-    const tokType = path[i];
-    const longerKeys = [];
-    for (let j = 0; j < keys.length; j++) {
-      const currShorterKey = keys[j];
-      longerKeys.push(currShorterKey + "_" + tokType.tokenTypeIdx);
-      for (let t = 0; t < tokType.categoryMatches.length; t++) {
-        const categoriesKeySuffix = "_" + tokType.categoryMatches[t];
-        longerKeys.push(currShorterKey + categoriesKeySuffix);
-      }
-    }
-    keys = longerKeys;
-  }
-  return keys;
-}
-function isUniquePrefixHash(altKnownPathsKeys, searchPathKeys, idx) {
-  for (let currAltIdx = 0; currAltIdx < altKnownPathsKeys.length; currAltIdx++) {
-    if (currAltIdx === idx) {
-      continue;
-    }
-    const otherAltKnownPathsKeys = altKnownPathsKeys[currAltIdx];
-    for (let searchIdx = 0; searchIdx < searchPathKeys.length; searchIdx++) {
-      const searchKey = searchPathKeys[searchIdx];
-      if (otherAltKnownPathsKeys[searchKey] === true) {
-        return false;
-      }
-    }
-  }
-  return true;
-}
-function lookAheadSequenceFromAlternatives(altsDefs, k) {
-  const partialAlts = map(altsDefs, (currAlt) => possiblePathsFrom([currAlt], 1));
-  const finalResult = initializeArrayOfArrays(partialAlts.length);
-  const altsHashes = map(partialAlts, (currAltPaths) => {
-    const dict = {};
-    forEach(currAltPaths, (item) => {
-      const keys = pathToHashKeys(item.partialPath);
-      forEach(keys, (currKey) => {
-        dict[currKey] = true;
-      });
-    });
-    return dict;
-  });
-  let newData = partialAlts;
-  for (let pathLength = 1; pathLength <= k; pathLength++) {
-    const currDataset = newData;
-    newData = initializeArrayOfArrays(currDataset.length);
-    for (let altIdx = 0; altIdx < currDataset.length; altIdx++) {
-      const currAltPathsAndSuffixes = currDataset[altIdx];
-      for (let currPathIdx = 0; currPathIdx < currAltPathsAndSuffixes.length; currPathIdx++) {
-        const currPathPrefix = currAltPathsAndSuffixes[currPathIdx].partialPath;
-        const suffixDef = currAltPathsAndSuffixes[currPathIdx].suffixDef;
-        const prefixKeys = pathToHashKeys(currPathPrefix);
-        const isUnique = isUniquePrefixHash(altsHashes, prefixKeys, altIdx);
-        if (isUnique || isEmpty(suffixDef) || currPathPrefix.length === k) {
-          const currAltResult = finalResult[altIdx];
-          if (containsPath(currAltResult, currPathPrefix) === false) {
-            currAltResult.push(currPathPrefix);
-            for (let j = 0; j < prefixKeys.length; j++) {
-              const currKey = prefixKeys[j];
-              altsHashes[altIdx][currKey] = true;
-            }
-          }
-        } else {
-          const newPartialPathsAndSuffixes = possiblePathsFrom(suffixDef, pathLength + 1, currPathPrefix);
-          newData[altIdx] = newData[altIdx].concat(newPartialPathsAndSuffixes);
-          forEach(newPartialPathsAndSuffixes, (item) => {
-            const prefixKeys2 = pathToHashKeys(item.partialPath);
-            forEach(prefixKeys2, (key) => {
-              altsHashes[altIdx][key] = true;
-            });
-          });
-        }
-      }
-    }
-  }
-  return finalResult;
-}
-function getLookaheadPathsForOr(occurrence, ruleGrammar, k, orProd) {
-  const visitor = new InsideDefinitionFinderVisitor(occurrence, PROD_TYPE.ALTERNATION, orProd);
-  ruleGrammar.accept(visitor);
-  return lookAheadSequenceFromAlternatives(visitor.result, k);
-}
-function getLookaheadPathsForOptionalProd(occurrence, ruleGrammar, prodType, k) {
-  const insideDefVisitor = new InsideDefinitionFinderVisitor(occurrence, prodType);
-  ruleGrammar.accept(insideDefVisitor);
-  const insideDef = insideDefVisitor.result;
-  const afterDefWalker = new RestDefinitionFinderWalker(ruleGrammar, occurrence, prodType);
-  const afterDef = afterDefWalker.startWalking();
-  const insideFlat = new Alternative({ definition: insideDef });
-  const afterFlat = new Alternative({ definition: afterDef });
-  return lookAheadSequenceFromAlternatives([insideFlat, afterFlat], k);
-}
-function containsPath(alternative, searchPath) {
-  compareOtherPath: for (let i = 0; i < alternative.length; i++) {
-    const otherPath = alternative[i];
-    if (otherPath.length !== searchPath.length) {
-      continue;
-    }
-    for (let j = 0; j < otherPath.length; j++) {
-      const searchTok = searchPath[j];
-      const otherTok = otherPath[j];
-      const matchingTokens = searchTok === otherTok || otherTok.categoryMatchesMap[searchTok.tokenTypeIdx] !== void 0;
-      if (matchingTokens === false) {
-        continue compareOtherPath;
-      }
-    }
-    return true;
-  }
-  return false;
-}
-function isStrictPrefixOfPath(prefix, other) {
-  return prefix.length < other.length && every(prefix, (tokType, idx) => {
-    const otherTokType = other[idx];
-    return tokType === otherTokType || otherTokType.categoryMatchesMap[tokType.tokenTypeIdx];
-  });
-}
-function areTokenCategoriesNotUsed(lookAheadPaths) {
-  return every(lookAheadPaths, (singleAltPaths) => every(singleAltPaths, (singlePath) => every(singlePath, (token) => isEmpty(token.categoryMatches))));
-}
-export {
-  PROD_TYPE,
-  areTokenCategoriesNotUsed,
-  buildAlternativesLookAheadFunc,
-  buildLookaheadFuncForOptionalProd,
-  buildLookaheadFuncForOr,
-  buildSingleAlternativeLookaheadFunction,
-  containsPath,
-  getLookaheadPaths,
-  getLookaheadPathsForOptionalProd,
-  getLookaheadPathsForOr,
-  getProdType,
-  isStrictPrefixOfPath,
-  lookAheadSequenceFromAlternatives
-};

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/grammar/resolver.mjs

@@ -1,40 +0,0 @@
-import { ParserDefinitionErrorType } from "../parser/parser.mjs";
-import { forEach, values } from "lodash-es";
-import { GAstVisitor } from "../../../../../../../@chevrotain_gast@11.0.3/node_modules/@chevrotain/gast/lib/src/visitor.mjs";
-function resolveGrammar(topLevels, errMsgProvider) {
-  const refResolver = new GastRefResolverVisitor(topLevels, errMsgProvider);
-  refResolver.resolveRefs();
-  return refResolver.errors;
-}
-class GastRefResolverVisitor extends GAstVisitor {
-  constructor(nameToTopRule, errMsgProvider) {
-    super();
-    this.nameToTopRule = nameToTopRule;
-    this.errMsgProvider = errMsgProvider;
-    this.errors = [];
-  }
-  resolveRefs() {
-    forEach(values(this.nameToTopRule), (prod) => {
-      this.currTopLevel = prod;
-      prod.accept(this);
-    });
-  }
-  visitNonTerminal(node) {
-    const ref = this.nameToTopRule[node.nonTerminalName];
-    if (!ref) {
-      const msg = this.errMsgProvider.buildRuleNotFoundError(this.currTopLevel, node);
-      this.errors.push({
-        message: msg,
-        type: ParserDefinitionErrorType.UNRESOLVED_SUBRULE_REF,
-        ruleName: this.currTopLevel.name,
-        unresolvedRefName: node.nonTerminalName
-      });
-    } else {
-      node.referencedRule = ref;
-    }
-  }
-}
-export {
-  GastRefResolverVisitor,
-  resolveGrammar
-};

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/grammar/rest.mjs

@@ -1,83 +0,0 @@
-import { forEach, drop } from "lodash-es";
-import { NonTerminal, Terminal, Alternative, Option, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Repetition, Alternation } from "../../../../../../../@chevrotain_gast@11.0.3/node_modules/@chevrotain/gast/lib/src/model.mjs";
-class RestWalker {
-  walk(prod, prevRest = []) {
-    forEach(prod.definition, (subProd, index) => {
-      const currRest = drop(prod.definition, index + 1);
-      if (subProd instanceof NonTerminal) {
-        this.walkProdRef(subProd, currRest, prevRest);
-      } else if (subProd instanceof Terminal) {
-        this.walkTerminal(subProd, currRest, prevRest);
-      } else if (subProd instanceof Alternative) {
-        this.walkFlat(subProd, currRest, prevRest);
-      } else if (subProd instanceof Option) {
-        this.walkOption(subProd, currRest, prevRest);
-      } else if (subProd instanceof RepetitionMandatory) {
-        this.walkAtLeastOne(subProd, currRest, prevRest);
-      } else if (subProd instanceof RepetitionMandatoryWithSeparator) {
-        this.walkAtLeastOneSep(subProd, currRest, prevRest);
-      } else if (subProd instanceof RepetitionWithSeparator) {
-        this.walkManySep(subProd, currRest, prevRest);
-      } else if (subProd instanceof Repetition) {
-        this.walkMany(subProd, currRest, prevRest);
-      } else if (subProd instanceof Alternation) {
-        this.walkOr(subProd, currRest, prevRest);
-      } else {
-        throw Error("non exhaustive match");
-      }
-    });
-  }
-  walkTerminal(terminal, currRest, prevRest) {
-  }
-  walkProdRef(refProd, currRest, prevRest) {
-  }
-  walkFlat(flatProd, currRest, prevRest) {
-    const fullOrRest = currRest.concat(prevRest);
-    this.walk(flatProd, fullOrRest);
-  }
-  walkOption(optionProd, currRest, prevRest) {
-    const fullOrRest = currRest.concat(prevRest);
-    this.walk(optionProd, fullOrRest);
-  }
-  walkAtLeastOne(atLeastOneProd, currRest, prevRest) {
-    const fullAtLeastOneRest = [
-      new Option({ definition: atLeastOneProd.definition })
-    ].concat(currRest, prevRest);
-    this.walk(atLeastOneProd, fullAtLeastOneRest);
-  }
-  walkAtLeastOneSep(atLeastOneSepProd, currRest, prevRest) {
-    const fullAtLeastOneSepRest = restForRepetitionWithSeparator(atLeastOneSepProd, currRest, prevRest);
-    this.walk(atLeastOneSepProd, fullAtLeastOneSepRest);
-  }
-  walkMany(manyProd, currRest, prevRest) {
-    const fullManyRest = [
-      new Option({ definition: manyProd.definition })
-    ].concat(currRest, prevRest);
-    this.walk(manyProd, fullManyRest);
-  }
-  walkManySep(manySepProd, currRest, prevRest) {
-    const fullManySepRest = restForRepetitionWithSeparator(manySepProd, currRest, prevRest);
-    this.walk(manySepProd, fullManySepRest);
-  }
-  walkOr(orProd, currRest, prevRest) {
-    const fullOrRest = currRest.concat(prevRest);
-    forEach(orProd.definition, (alt) => {
-      const prodWrapper = new Alternative({ definition: [alt] });
-      this.walk(prodWrapper, fullOrRest);
-    });
-  }
-}
-function restForRepetitionWithSeparator(repSepProd, currRest, prevRest) {
-  const repSepRest = [
-    new Option({
-      definition: [
-        new Terminal({ terminalType: repSepProd.separator })
-      ].concat(repSepProd.definition)
-    })
-  ];
-  const fullRepSepRest = repSepRest.concat(currRest, prevRest);
-  return fullRepSepRest;
-}
-export {
-  RestWalker
-};

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

@@ -1,181 +0,0 @@
-import { clone, forEach, values, isEmpty, map, has } from "lodash-es";
-import { toFastProperties } from "../../../../../../../@chevrotain_utils@11.0.3/node_modules/@chevrotain/utils/lib/src/to-fast-properties.mjs";
-import { computeAllProdsFollows } from "../grammar/follow.mjs";
-import { createTokenInstance, EOF } from "../../scan/tokens_public.mjs";
-import { defaultParserErrorProvider, defaultGrammarValidatorErrorProvider } from "../errors_public.mjs";
-import { resolveGrammar, validateGrammar } from "../grammar/gast/gast_resolver_public.mjs";
-import { Recoverable } from "./traits/recoverable.mjs";
-import { LooksAhead } from "./traits/looksahead.mjs";
-import { TreeBuilder } from "./traits/tree_builder.mjs";
-import { LexerAdapter } from "./traits/lexer_adapter.mjs";
-import { RecognizerApi } from "./traits/recognizer_api.mjs";
-import { RecognizerEngine } from "./traits/recognizer_engine.mjs";
-import { ErrorHandler } from "./traits/error_handler.mjs";
-import { ContentAssist } from "./traits/context_assist.mjs";
-import { GastRecorder } from "./traits/gast_recorder.mjs";
-import { PerformanceTracer } from "./traits/perf_tracer.mjs";
-import { applyMixins } from "./utils/apply_mixins.mjs";
-import { validateLookahead } from "../grammar/checks.mjs";
-const END_OF_FILE = createTokenInstance(EOF, "", NaN, NaN, NaN, NaN, NaN, NaN);
-Object.freeze(END_OF_FILE);
-const DEFAULT_PARSER_CONFIG = Object.freeze({
-  recoveryEnabled: false,
-  maxLookahead: 3,
-  dynamicTokensEnabled: false,
-  outputCst: true,
-  errorMessageProvider: defaultParserErrorProvider,
-  nodeLocationTracking: "none",
-  traceInitPerf: false,
-  skipValidations: false
-});
-const DEFAULT_RULE_CONFIG = Object.freeze({
-  recoveryValueFunc: () => void 0,
-  resyncEnabled: true
-});
-var ParserDefinitionErrorType;
-(function(ParserDefinitionErrorType2) {
-  ParserDefinitionErrorType2[ParserDefinitionErrorType2["INVALID_RULE_NAME"] = 0] = "INVALID_RULE_NAME";
-  ParserDefinitionErrorType2[ParserDefinitionErrorType2["DUPLICATE_RULE_NAME"] = 1] = "DUPLICATE_RULE_NAME";
-  ParserDefinitionErrorType2[ParserDefinitionErrorType2["INVALID_RULE_OVERRIDE"] = 2] = "INVALID_RULE_OVERRIDE";
-  ParserDefinitionErrorType2[ParserDefinitionErrorType2["DUPLICATE_PRODUCTIONS"] = 3] = "DUPLICATE_PRODUCTIONS";
-  ParserDefinitionErrorType2[ParserDefinitionErrorType2["UNRESOLVED_SUBRULE_REF"] = 4] = "UNRESOLVED_SUBRULE_REF";
-  ParserDefinitionErrorType2[ParserDefinitionErrorType2["LEFT_RECURSION"] = 5] = "LEFT_RECURSION";
-  ParserDefinitionErrorType2[ParserDefinitionErrorType2["NONE_LAST_EMPTY_ALT"] = 6] = "NONE_LAST_EMPTY_ALT";
-  ParserDefinitionErrorType2[ParserDefinitionErrorType2["AMBIGUOUS_ALTS"] = 7] = "AMBIGUOUS_ALTS";
-  ParserDefinitionErrorType2[ParserDefinitionErrorType2["CONFLICT_TOKENS_RULES_NAMESPACE"] = 8] = "CONFLICT_TOKENS_RULES_NAMESPACE";
-  ParserDefinitionErrorType2[ParserDefinitionErrorType2["INVALID_TOKEN_NAME"] = 9] = "INVALID_TOKEN_NAME";
-  ParserDefinitionErrorType2[ParserDefinitionErrorType2["NO_NON_EMPTY_LOOKAHEAD"] = 10] = "NO_NON_EMPTY_LOOKAHEAD";
-  ParserDefinitionErrorType2[ParserDefinitionErrorType2["AMBIGUOUS_PREFIX_ALTS"] = 11] = "AMBIGUOUS_PREFIX_ALTS";
-  ParserDefinitionErrorType2[ParserDefinitionErrorType2["TOO_MANY_ALTS"] = 12] = "TOO_MANY_ALTS";
-  ParserDefinitionErrorType2[ParserDefinitionErrorType2["CUSTOM_LOOKAHEAD_VALIDATION"] = 13] = "CUSTOM_LOOKAHEAD_VALIDATION";
-})(ParserDefinitionErrorType || (ParserDefinitionErrorType = {}));
-function EMPTY_ALT(value = void 0) {
-  return function() {
-    return value;
-  };
-}
-class Parser {
-  /**
-   *  @deprecated use the **instance** method with the same name instead
-   */
-  static performSelfAnalysis(parserInstance) {
-    throw Error("The **static** `performSelfAnalysis` method has been deprecated.	\nUse the **instance** method with the same name instead.");
-  }
-  performSelfAnalysis() {
-    this.TRACE_INIT("performSelfAnalysis", () => {
-      let defErrorsMsgs;
-      this.selfAnalysisDone = true;
-      const className = this.className;
-      this.TRACE_INIT("toFastProps", () => {
-        toFastProperties(this);
-      });
-      this.TRACE_INIT("Grammar Recording", () => {
-        try {
-          this.enableRecording();
-          forEach(this.definedRulesNames, (currRuleName) => {
-            const wrappedRule = this[currRuleName];
-            const originalGrammarAction = wrappedRule["originalGrammarAction"];
-            let recordedRuleGast;
-            this.TRACE_INIT(`${currRuleName} Rule`, () => {
-              recordedRuleGast = this.topLevelRuleRecord(currRuleName, originalGrammarAction);
-            });
-            this.gastProductionsCache[currRuleName] = recordedRuleGast;
-          });
-        } finally {
-          this.disableRecording();
-        }
-      });
-      let resolverErrors = [];
-      this.TRACE_INIT("Grammar Resolving", () => {
-        resolverErrors = resolveGrammar({
-          rules: values(this.gastProductionsCache)
-        });
-        this.definitionErrors = this.definitionErrors.concat(resolverErrors);
-      });
-      this.TRACE_INIT("Grammar Validations", () => {
-        if (isEmpty(resolverErrors) && this.skipValidations === false) {
-          const validationErrors = validateGrammar({
-            rules: values(this.gastProductionsCache),
-            tokenTypes: values(this.tokensMap),
-            errMsgProvider: defaultGrammarValidatorErrorProvider,
-            grammarName: className
-          });
-          const lookaheadValidationErrors = validateLookahead({
-            lookaheadStrategy: this.lookaheadStrategy,
-            rules: values(this.gastProductionsCache),
-            tokenTypes: values(this.tokensMap),
-            grammarName: className
-          });
-          this.definitionErrors = this.definitionErrors.concat(validationErrors, lookaheadValidationErrors);
-        }
-      });
-      if (isEmpty(this.definitionErrors)) {
-        if (this.recoveryEnabled) {
-          this.TRACE_INIT("computeAllProdsFollows", () => {
-            const allFollows = computeAllProdsFollows(values(this.gastProductionsCache));
-            this.resyncFollows = allFollows;
-          });
-        }
-        this.TRACE_INIT("ComputeLookaheadFunctions", () => {
-          var _a, _b;
-          (_b = (_a = this.lookaheadStrategy).initialize) === null || _b === void 0 ? void 0 : _b.call(_a, {
-            rules: values(this.gastProductionsCache)
-          });
-          this.preComputeLookaheadFunctions(values(this.gastProductionsCache));
-        });
-      }
-      if (!Parser.DEFER_DEFINITION_ERRORS_HANDLING && !isEmpty(this.definitionErrors)) {
-        defErrorsMsgs = map(this.definitionErrors, (defError) => defError.message);
-        throw new Error(`Parser Definition Errors detected:
- ${defErrorsMsgs.join("\n-------------------------------\n")}`);
-      }
-    });
-  }
-  constructor(tokenVocabulary, config) {
-    this.definitionErrors = [];
-    this.selfAnalysisDone = false;
-    const that = this;
-    that.initErrorHandler(config);
-    that.initLexerAdapter();
-    that.initLooksAhead(config);
-    that.initRecognizerEngine(tokenVocabulary, config);
-    that.initRecoverable(config);
-    that.initTreeBuilder(config);
-    that.initContentAssist();
-    that.initGastRecorder(config);
-    that.initPerformanceTracer(config);
-    if (has(config, "ignoredIssues")) {
-      throw new Error("The <ignoredIssues> IParserConfig property has been deprecated.\n	Please use the <IGNORE_AMBIGUITIES> flag on the relevant DSL method instead.\n	See: https://chevrotain.io/docs/guide/resolving_grammar_errors.html#IGNORING_AMBIGUITIES\n	For further details.");
-    }
-    this.skipValidations = has(config, "skipValidations") ? config.skipValidations : DEFAULT_PARSER_CONFIG.skipValidations;
-  }
-}
-Parser.DEFER_DEFINITION_ERRORS_HANDLING = false;
-applyMixins(Parser, [
-  Recoverable,
-  LooksAhead,
-  TreeBuilder,
-  LexerAdapter,
-  RecognizerEngine,
-  RecognizerApi,
-  ErrorHandler,
-  ContentAssist,
-  GastRecorder,
-  PerformanceTracer
-]);
-class EmbeddedActionsParser extends Parser {
-  constructor(tokenVocabulary, config = DEFAULT_PARSER_CONFIG) {
-    const configClone = clone(config);
-    configClone.outputCst = false;
-    super(tokenVocabulary, configClone);
-  }
-}
-export {
-  DEFAULT_PARSER_CONFIG,
-  DEFAULT_RULE_CONFIG,
-  EMPTY_ALT,
-  END_OF_FILE,
-  EmbeddedActionsParser,
-  Parser,
-  ParserDefinitionErrorType
-};