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

@@ -1,161 +0,0 @@
-import { tokenLabel, hasTokenLabel } from "../scan/tokens_public.mjs";
-import { first, map, reduce } from "lodash-es";
-import { Rule, Terminal, NonTerminal } from "../../../../../../@chevrotain_gast@11.0.3/node_modules/@chevrotain/gast/lib/src/model.mjs";
-import { getProductionDslName } from "../../../../../../@chevrotain_gast@11.0.3/node_modules/@chevrotain/gast/lib/src/helpers.mjs";
-const defaultParserErrorProvider = {
-  buildMismatchTokenMessage({ expected, actual, previous, ruleName }) {
-    const hasLabel = hasTokenLabel(expected);
-    const expectedMsg = hasLabel ? `--> ${tokenLabel(expected)} <--` : `token of type --> ${expected.name} <--`;
-    const msg = `Expecting ${expectedMsg} but found --> '${actual.image}' <--`;
-    return msg;
-  },
-  buildNotAllInputParsedMessage({ firstRedundant, ruleName }) {
-    return "Redundant input, expecting EOF but found: " + firstRedundant.image;
-  },
-  buildNoViableAltMessage({ expectedPathsPerAlt, actual, previous, customUserDescription, ruleName }) {
-    const errPrefix = "Expecting: ";
-    const actualText = first(actual).image;
-    const errSuffix = "\nbut found: '" + actualText + "'";
-    if (customUserDescription) {
-      return errPrefix + customUserDescription + errSuffix;
-    } else {
-      const allLookAheadPaths = reduce(expectedPathsPerAlt, (result, currAltPaths) => result.concat(currAltPaths), []);
-      const nextValidTokenSequences = map(allLookAheadPaths, (currPath) => `[${map(currPath, (currTokenType) => tokenLabel(currTokenType)).join(", ")}]`);
-      const nextValidSequenceItems = map(nextValidTokenSequences, (itemMsg, idx) => `  ${idx + 1}. ${itemMsg}`);
-      const calculatedDescription = `one of these possible Token sequences:
-${nextValidSequenceItems.join("\n")}`;
-      return errPrefix + calculatedDescription + errSuffix;
-    }
-  },
-  buildEarlyExitMessage({ expectedIterationPaths, actual, customUserDescription, ruleName }) {
-    const errPrefix = "Expecting: ";
-    const actualText = first(actual).image;
-    const errSuffix = "\nbut found: '" + actualText + "'";
-    if (customUserDescription) {
-      return errPrefix + customUserDescription + errSuffix;
-    } else {
-      const nextValidTokenSequences = map(expectedIterationPaths, (currPath) => `[${map(currPath, (currTokenType) => tokenLabel(currTokenType)).join(",")}]`);
-      const calculatedDescription = `expecting at least one iteration which starts with one of these possible Token sequences::
-  <${nextValidTokenSequences.join(" ,")}>`;
-      return errPrefix + calculatedDescription + errSuffix;
-    }
-  }
-};
-Object.freeze(defaultParserErrorProvider);
-const defaultGrammarResolverErrorProvider = {
-  buildRuleNotFoundError(topLevelRule, undefinedRule) {
-    const msg = "Invalid grammar, reference to a rule which is not defined: ->" + undefinedRule.nonTerminalName + "<-\ninside top level rule: ->" + topLevelRule.name + "<-";
-    return msg;
-  }
-};
-const defaultGrammarValidatorErrorProvider = {
-  buildDuplicateFoundError(topLevelRule, duplicateProds) {
-    function getExtraProductionArgument(prod) {
-      if (prod instanceof Terminal) {
-        return prod.terminalType.name;
-      } else if (prod instanceof NonTerminal) {
-        return prod.nonTerminalName;
-      } else {
-        return "";
-      }
-    }
-    const topLevelName = topLevelRule.name;
-    const duplicateProd = first(duplicateProds);
-    const index = duplicateProd.idx;
-    const dslName = getProductionDslName(duplicateProd);
-    const extraArgument = getExtraProductionArgument(duplicateProd);
-    const hasExplicitIndex = index > 0;
-    let msg = `->${dslName}${hasExplicitIndex ? index : ""}<- ${extraArgument ? `with argument: ->${extraArgument}<-` : ""}
-                  appears more than once (${duplicateProds.length} times) in the top level rule: ->${topLevelName}<-.                  
-                  For further details see: https://chevrotain.io/docs/FAQ.html#NUMERICAL_SUFFIXES 
-                  `;
-    msg = msg.replace(/[ \t]+/g, " ");
-    msg = msg.replace(/\s\s+/g, "\n");
-    return msg;
-  },
-  buildNamespaceConflictError(rule) {
-    const errMsg = `Namespace conflict found in grammar.
-The grammar has both a Terminal(Token) and a Non-Terminal(Rule) named: <${rule.name}>.
-To resolve this make sure each Terminal and Non-Terminal names are unique
-This is easy to accomplish by using the convention that Terminal names start with an uppercase letter
-and Non-Terminal names start with a lower case letter.`;
-    return errMsg;
-  },
-  buildAlternationPrefixAmbiguityError(options) {
-    const pathMsg = map(options.prefixPath, (currTok) => tokenLabel(currTok)).join(", ");
-    const occurrence = options.alternation.idx === 0 ? "" : options.alternation.idx;
-    const errMsg = `Ambiguous alternatives: <${options.ambiguityIndices.join(" ,")}> due to common lookahead prefix
-in <OR${occurrence}> inside <${options.topLevelRule.name}> Rule,
-<${pathMsg}> may appears as a prefix path in all these alternatives.
-See: https://chevrotain.io/docs/guide/resolving_grammar_errors.html#COMMON_PREFIX
-For Further details.`;
-    return errMsg;
-  },
-  buildAlternationAmbiguityError(options) {
-    const pathMsg = map(options.prefixPath, (currtok) => tokenLabel(currtok)).join(", ");
-    const occurrence = options.alternation.idx === 0 ? "" : options.alternation.idx;
-    let currMessage = `Ambiguous Alternatives Detected: <${options.ambiguityIndices.join(" ,")}> in <OR${occurrence}> inside <${options.topLevelRule.name}> Rule,
-<${pathMsg}> may appears as a prefix path in all these alternatives.
-`;
-    currMessage = currMessage + `See: https://chevrotain.io/docs/guide/resolving_grammar_errors.html#AMBIGUOUS_ALTERNATIVES
-For Further details.`;
-    return currMessage;
-  },
-  buildEmptyRepetitionError(options) {
-    let dslName = getProductionDslName(options.repetition);
-    if (options.repetition.idx !== 0) {
-      dslName += options.repetition.idx;
-    }
-    const errMsg = `The repetition <${dslName}> within Rule <${options.topLevelRule.name}> can never consume any tokens.
-This could lead to an infinite loop.`;
-    return errMsg;
-  },
-  // TODO: remove - `errors_public` from nyc.config.js exclude
-  //       once this method is fully removed from this file
-  buildTokenNameError(options) {
-    return "deprecated";
-  },
-  buildEmptyAlternationError(options) {
-    const errMsg = `Ambiguous empty alternative: <${options.emptyChoiceIdx + 1}> in <OR${options.alternation.idx}> inside <${options.topLevelRule.name}> Rule.
-Only the last alternative may be an empty alternative.`;
-    return errMsg;
-  },
-  buildTooManyAlternativesError(options) {
-    const errMsg = `An Alternation cannot have more than 256 alternatives:
-<OR${options.alternation.idx}> inside <${options.topLevelRule.name}> Rule.
- has ${options.alternation.definition.length + 1} alternatives.`;
-    return errMsg;
-  },
-  buildLeftRecursionError(options) {
-    const ruleName = options.topLevelRule.name;
-    const pathNames = map(options.leftRecursionPath, (currRule) => currRule.name);
-    const leftRecursivePath = `${ruleName} --> ${pathNames.concat([ruleName]).join(" --> ")}`;
-    const errMsg = `Left Recursion found in grammar.
-rule: <${ruleName}> can be invoked from itself (directly or indirectly)
-without consuming any Tokens. The grammar path that causes this is: 
- ${leftRecursivePath}
- To fix this refactor your grammar to remove the left recursion.
-see: https://en.wikipedia.org/wiki/LL_parser#Left_factoring.`;
-    return errMsg;
-  },
-  // TODO: remove - `errors_public` from nyc.config.js exclude
-  //       once this method is fully removed from this file
-  buildInvalidRuleNameError(options) {
-    return "deprecated";
-  },
-  buildDuplicateRuleNameError(options) {
-    let ruleName;
-    if (options.topLevelRule instanceof Rule) {
-      ruleName = options.topLevelRule.name;
-    } else {
-      ruleName = options.topLevelRule;
-    }
-    const errMsg = `Duplicate definition, rule: ->${ruleName}<- is already defined in the grammar: ->${options.grammarName}<-`;
-    return errMsg;
-  }
-};
-export {
-  defaultGrammarResolverErrorProvider,
-  defaultGrammarValidatorErrorProvider,
-  defaultParserErrorProvider
-};

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

@@ -1,60 +0,0 @@
-import { includes } from "lodash-es";
-const MISMATCHED_TOKEN_EXCEPTION = "MismatchedTokenException";
-const NO_VIABLE_ALT_EXCEPTION = "NoViableAltException";
-const EARLY_EXIT_EXCEPTION = "EarlyExitException";
-const NOT_ALL_INPUT_PARSED_EXCEPTION = "NotAllInputParsedException";
-const RECOGNITION_EXCEPTION_NAMES = [
-  MISMATCHED_TOKEN_EXCEPTION,
-  NO_VIABLE_ALT_EXCEPTION,
-  EARLY_EXIT_EXCEPTION,
-  NOT_ALL_INPUT_PARSED_EXCEPTION
-];
-Object.freeze(RECOGNITION_EXCEPTION_NAMES);
-function isRecognitionException(error) {
-  return includes(RECOGNITION_EXCEPTION_NAMES, error.name);
-}
-class RecognitionException extends Error {
-  constructor(message, token) {
-    super(message);
-    this.token = token;
-    this.resyncedTokens = [];
-    Object.setPrototypeOf(this, new.target.prototype);
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, this.constructor);
-    }
-  }
-}
-class MismatchedTokenException extends RecognitionException {
-  constructor(message, token, previousToken) {
-    super(message, token);
-    this.previousToken = previousToken;
-    this.name = MISMATCHED_TOKEN_EXCEPTION;
-  }
-}
-class NoViableAltException extends RecognitionException {
-  constructor(message, token, previousToken) {
-    super(message, token);
-    this.previousToken = previousToken;
-    this.name = NO_VIABLE_ALT_EXCEPTION;
-  }
-}
-class NotAllInputParsedException extends RecognitionException {
-  constructor(message, token) {
-    super(message, token);
-    this.name = NOT_ALL_INPUT_PARSED_EXCEPTION;
-  }
-}
-class EarlyExitException extends RecognitionException {
-  constructor(message, token, previousToken) {
-    super(message, token);
-    this.previousToken = previousToken;
-    this.name = EARLY_EXIT_EXCEPTION;
-  }
-}
-export {
-  EarlyExitException,
-  MismatchedTokenException,
-  NoViableAltException,
-  NotAllInputParsedException,
-  isRecognitionException
-};

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

@@ -1,416 +0,0 @@
-import { isEmpty, includes, difference, flatMap, clone, dropRight, reject, forEach, flatten, map, first, drop, reduce, compact, filter, groupBy, pickBy, values } from "lodash-es";
-import { ParserDefinitionErrorType } from "../parser/parser.mjs";
-import { NonTerminal, Alternative, Option, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Repetition, Alternation, Terminal } 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";
-import { isOptionalProd, getProductionDslName } from "../../../../../../../@chevrotain_gast@11.0.3/node_modules/@chevrotain/gast/lib/src/helpers.mjs";
-import { getLookaheadPathsForOr, getProdType, getLookaheadPathsForOptionalProd, containsPath, isStrictPrefixOfPath } from "./lookahead.mjs";
-import { nextPossibleTokensAfter } from "./interpreter.mjs";
-import { tokenStructuredMatcher } from "../../scan/tokens.mjs";
-function validateLookahead(options) {
-  const lookaheadValidationErrorMessages = options.lookaheadStrategy.validate({
-    rules: options.rules,
-    tokenTypes: options.tokenTypes,
-    grammarName: options.grammarName
-  });
-  return map(lookaheadValidationErrorMessages, (errorMessage) => Object.assign({ type: ParserDefinitionErrorType.CUSTOM_LOOKAHEAD_VALIDATION }, errorMessage));
-}
-function validateGrammar(topLevels, tokenTypes, errMsgProvider, grammarName) {
-  const duplicateErrors = flatMap(topLevels, (currTopLevel) => validateDuplicateProductions(currTopLevel, errMsgProvider));
-  const termsNamespaceConflictErrors = checkTerminalAndNoneTerminalsNameSpace(topLevels, tokenTypes, errMsgProvider);
-  const tooManyAltsErrors = flatMap(topLevels, (curRule) => validateTooManyAlts(curRule, errMsgProvider));
-  const duplicateRulesError = flatMap(topLevels, (curRule) => validateRuleDoesNotAlreadyExist(curRule, topLevels, grammarName, errMsgProvider));
-  return duplicateErrors.concat(termsNamespaceConflictErrors, tooManyAltsErrors, duplicateRulesError);
-}
-function validateDuplicateProductions(topLevelRule, errMsgProvider) {
-  const collectorVisitor = new OccurrenceValidationCollector();
-  topLevelRule.accept(collectorVisitor);
-  const allRuleProductions = collectorVisitor.allProductions;
-  const productionGroups = groupBy(allRuleProductions, identifyProductionForDuplicates);
-  const duplicates = pickBy(productionGroups, (currGroup) => {
-    return currGroup.length > 1;
-  });
-  const errors = map(values(duplicates), (currDuplicates) => {
-    const firstProd = first(currDuplicates);
-    const msg = errMsgProvider.buildDuplicateFoundError(topLevelRule, currDuplicates);
-    const dslName = getProductionDslName(firstProd);
-    const defError = {
-      message: msg,
-      type: ParserDefinitionErrorType.DUPLICATE_PRODUCTIONS,
-      ruleName: topLevelRule.name,
-      dslName,
-      occurrence: firstProd.idx
-    };
-    const param = getExtraProductionArgument(firstProd);
-    if (param) {
-      defError.parameter = param;
-    }
-    return defError;
-  });
-  return errors;
-}
-function identifyProductionForDuplicates(prod) {
-  return `${getProductionDslName(prod)}_#_${prod.idx}_#_${getExtraProductionArgument(prod)}`;
-}
-function getExtraProductionArgument(prod) {
-  if (prod instanceof Terminal) {
-    return prod.terminalType.name;
-  } else if (prod instanceof NonTerminal) {
-    return prod.nonTerminalName;
-  } else {
-    return "";
-  }
-}
-class OccurrenceValidationCollector extends GAstVisitor {
-  constructor() {
-    super(...arguments);
-    this.allProductions = [];
-  }
-  visitNonTerminal(subrule) {
-    this.allProductions.push(subrule);
-  }
-  visitOption(option) {
-    this.allProductions.push(option);
-  }
-  visitRepetitionWithSeparator(manySep) {
-    this.allProductions.push(manySep);
-  }
-  visitRepetitionMandatory(atLeastOne) {
-    this.allProductions.push(atLeastOne);
-  }
-  visitRepetitionMandatoryWithSeparator(atLeastOneSep) {
-    this.allProductions.push(atLeastOneSep);
-  }
-  visitRepetition(many) {
-    this.allProductions.push(many);
-  }
-  visitAlternation(or) {
-    this.allProductions.push(or);
-  }
-  visitTerminal(terminal) {
-    this.allProductions.push(terminal);
-  }
-}
-function validateRuleDoesNotAlreadyExist(rule, allRules, className, errMsgProvider) {
-  const errors = [];
-  const occurrences = reduce(allRules, (result, curRule) => {
-    if (curRule.name === rule.name) {
-      return result + 1;
-    }
-    return result;
-  }, 0);
-  if (occurrences > 1) {
-    const errMsg = errMsgProvider.buildDuplicateRuleNameError({
-      topLevelRule: rule,
-      grammarName: className
-    });
-    errors.push({
-      message: errMsg,
-      type: ParserDefinitionErrorType.DUPLICATE_RULE_NAME,
-      ruleName: rule.name
-    });
-  }
-  return errors;
-}
-function validateRuleIsOverridden(ruleName, definedRulesNames, className) {
-  const errors = [];
-  let errMsg;
-  if (!includes(definedRulesNames, ruleName)) {
-    errMsg = `Invalid rule override, rule: ->${ruleName}<- cannot be overridden in the grammar: ->${className}<-as it is not defined in any of the super grammars `;
-    errors.push({
-      message: errMsg,
-      type: ParserDefinitionErrorType.INVALID_RULE_OVERRIDE,
-      ruleName
-    });
-  }
-  return errors;
-}
-function validateNoLeftRecursion(topRule, currRule, errMsgProvider, path = []) {
-  const errors = [];
-  const nextNonTerminals = getFirstNoneTerminal(currRule.definition);
-  if (isEmpty(nextNonTerminals)) {
-    return [];
-  } else {
-    const ruleName = topRule.name;
-    const foundLeftRecursion = includes(nextNonTerminals, topRule);
-    if (foundLeftRecursion) {
-      errors.push({
-        message: errMsgProvider.buildLeftRecursionError({
-          topLevelRule: topRule,
-          leftRecursionPath: path
-        }),
-        type: ParserDefinitionErrorType.LEFT_RECURSION,
-        ruleName
-      });
-    }
-    const validNextSteps = difference(nextNonTerminals, path.concat([topRule]));
-    const errorsFromNextSteps = flatMap(validNextSteps, (currRefRule) => {
-      const newPath = clone(path);
-      newPath.push(currRefRule);
-      return validateNoLeftRecursion(topRule, currRefRule, errMsgProvider, newPath);
-    });
-    return errors.concat(errorsFromNextSteps);
-  }
-}
-function getFirstNoneTerminal(definition) {
-  let result = [];
-  if (isEmpty(definition)) {
-    return result;
-  }
-  const firstProd = first(definition);
-  if (firstProd instanceof NonTerminal) {
-    result.push(firstProd.referencedRule);
-  } else if (firstProd instanceof Alternative || firstProd instanceof Option || firstProd instanceof RepetitionMandatory || firstProd instanceof RepetitionMandatoryWithSeparator || firstProd instanceof RepetitionWithSeparator || firstProd instanceof Repetition) {
-    result = result.concat(getFirstNoneTerminal(firstProd.definition));
-  } else if (firstProd instanceof Alternation) {
-    result = flatten(map(firstProd.definition, (currSubDef) => getFirstNoneTerminal(currSubDef.definition)));
-  } else if (firstProd instanceof Terminal) ;
-  else {
-    throw Error("non exhaustive match");
-  }
-  const isFirstOptional = isOptionalProd(firstProd);
-  const hasMore = definition.length > 1;
-  if (isFirstOptional && hasMore) {
-    const rest = drop(definition);
-    return result.concat(getFirstNoneTerminal(rest));
-  } else {
-    return result;
-  }
-}
-class OrCollector extends GAstVisitor {
-  constructor() {
-    super(...arguments);
-    this.alternations = [];
-  }
-  visitAlternation(node) {
-    this.alternations.push(node);
-  }
-}
-function validateEmptyOrAlternative(topLevelRule, errMsgProvider) {
-  const orCollector = new OrCollector();
-  topLevelRule.accept(orCollector);
-  const ors = orCollector.alternations;
-  const errors = flatMap(ors, (currOr) => {
-    const exceptLast = dropRight(currOr.definition);
-    return flatMap(exceptLast, (currAlternative, currAltIdx) => {
-      const possibleFirstInAlt = nextPossibleTokensAfter([currAlternative], [], tokenStructuredMatcher, 1);
-      if (isEmpty(possibleFirstInAlt)) {
-        return [
-          {
-            message: errMsgProvider.buildEmptyAlternationError({
-              topLevelRule,
-              alternation: currOr,
-              emptyChoiceIdx: currAltIdx
-            }),
-            type: ParserDefinitionErrorType.NONE_LAST_EMPTY_ALT,
-            ruleName: topLevelRule.name,
-            occurrence: currOr.idx,
-            alternative: currAltIdx + 1
-          }
-        ];
-      } else {
-        return [];
-      }
-    });
-  });
-  return errors;
-}
-function validateAmbiguousAlternationAlternatives(topLevelRule, globalMaxLookahead, errMsgProvider) {
-  const orCollector = new OrCollector();
-  topLevelRule.accept(orCollector);
-  let ors = orCollector.alternations;
-  ors = reject(ors, (currOr) => currOr.ignoreAmbiguities === true);
-  const errors = flatMap(ors, (currOr) => {
-    const currOccurrence = currOr.idx;
-    const actualMaxLookahead = currOr.maxLookahead || globalMaxLookahead;
-    const alternatives = getLookaheadPathsForOr(currOccurrence, topLevelRule, actualMaxLookahead, currOr);
-    const altsAmbiguityErrors = checkAlternativesAmbiguities(alternatives, currOr, topLevelRule, errMsgProvider);
-    const altsPrefixAmbiguityErrors = checkPrefixAlternativesAmbiguities(alternatives, currOr, topLevelRule, errMsgProvider);
-    return altsAmbiguityErrors.concat(altsPrefixAmbiguityErrors);
-  });
-  return errors;
-}
-class RepetitionCollector extends GAstVisitor {
-  constructor() {
-    super(...arguments);
-    this.allProductions = [];
-  }
-  visitRepetitionWithSeparator(manySep) {
-    this.allProductions.push(manySep);
-  }
-  visitRepetitionMandatory(atLeastOne) {
-    this.allProductions.push(atLeastOne);
-  }
-  visitRepetitionMandatoryWithSeparator(atLeastOneSep) {
-    this.allProductions.push(atLeastOneSep);
-  }
-  visitRepetition(many) {
-    this.allProductions.push(many);
-  }
-}
-function validateTooManyAlts(topLevelRule, errMsgProvider) {
-  const orCollector = new OrCollector();
-  topLevelRule.accept(orCollector);
-  const ors = orCollector.alternations;
-  const errors = flatMap(ors, (currOr) => {
-    if (currOr.definition.length > 255) {
-      return [
-        {
-          message: errMsgProvider.buildTooManyAlternativesError({
-            topLevelRule,
-            alternation: currOr
-          }),
-          type: ParserDefinitionErrorType.TOO_MANY_ALTS,
-          ruleName: topLevelRule.name,
-          occurrence: currOr.idx
-        }
-      ];
-    } else {
-      return [];
-    }
-  });
-  return errors;
-}
-function validateSomeNonEmptyLookaheadPath(topLevelRules, maxLookahead, errMsgProvider) {
-  const errors = [];
-  forEach(topLevelRules, (currTopRule) => {
-    const collectorVisitor = new RepetitionCollector();
-    currTopRule.accept(collectorVisitor);
-    const allRuleProductions = collectorVisitor.allProductions;
-    forEach(allRuleProductions, (currProd) => {
-      const prodType = getProdType(currProd);
-      const actualMaxLookahead = currProd.maxLookahead || maxLookahead;
-      const currOccurrence = currProd.idx;
-      const paths = getLookaheadPathsForOptionalProd(currOccurrence, currTopRule, prodType, actualMaxLookahead);
-      const pathsInsideProduction = paths[0];
-      if (isEmpty(flatten(pathsInsideProduction))) {
-        const errMsg = errMsgProvider.buildEmptyRepetitionError({
-          topLevelRule: currTopRule,
-          repetition: currProd
-        });
-        errors.push({
-          message: errMsg,
-          type: ParserDefinitionErrorType.NO_NON_EMPTY_LOOKAHEAD,
-          ruleName: currTopRule.name
-        });
-      }
-    });
-  });
-  return errors;
-}
-function checkAlternativesAmbiguities(alternatives, alternation, rule, errMsgProvider) {
-  const foundAmbiguousPaths = [];
-  const identicalAmbiguities = reduce(alternatives, (result, currAlt, currAltIdx) => {
-    if (alternation.definition[currAltIdx].ignoreAmbiguities === true) {
-      return result;
-    }
-    forEach(currAlt, (currPath) => {
-      const altsCurrPathAppearsIn = [currAltIdx];
-      forEach(alternatives, (currOtherAlt, currOtherAltIdx) => {
-        if (currAltIdx !== currOtherAltIdx && containsPath(currOtherAlt, currPath) && // ignore (skip) ambiguities with this "other" alternative
-        alternation.definition[currOtherAltIdx].ignoreAmbiguities !== true) {
-          altsCurrPathAppearsIn.push(currOtherAltIdx);
-        }
-      });
-      if (altsCurrPathAppearsIn.length > 1 && !containsPath(foundAmbiguousPaths, currPath)) {
-        foundAmbiguousPaths.push(currPath);
-        result.push({
-          alts: altsCurrPathAppearsIn,
-          path: currPath
-        });
-      }
-    });
-    return result;
-  }, []);
-  const currErrors = map(identicalAmbiguities, (currAmbDescriptor) => {
-    const ambgIndices = map(currAmbDescriptor.alts, (currAltIdx) => currAltIdx + 1);
-    const currMessage = errMsgProvider.buildAlternationAmbiguityError({
-      topLevelRule: rule,
-      alternation,
-      ambiguityIndices: ambgIndices,
-      prefixPath: currAmbDescriptor.path
-    });
-    return {
-      message: currMessage,
-      type: ParserDefinitionErrorType.AMBIGUOUS_ALTS,
-      ruleName: rule.name,
-      occurrence: alternation.idx,
-      alternatives: currAmbDescriptor.alts
-    };
-  });
-  return currErrors;
-}
-function checkPrefixAlternativesAmbiguities(alternatives, alternation, rule, errMsgProvider) {
-  const pathsAndIndices = reduce(alternatives, (result, currAlt, idx) => {
-    const currPathsAndIdx = map(currAlt, (currPath) => {
-      return { idx, path: currPath };
-    });
-    return result.concat(currPathsAndIdx);
-  }, []);
-  const errors = compact(flatMap(pathsAndIndices, (currPathAndIdx) => {
-    const alternativeGast = alternation.definition[currPathAndIdx.idx];
-    if (alternativeGast.ignoreAmbiguities === true) {
-      return [];
-    }
-    const targetIdx = currPathAndIdx.idx;
-    const targetPath = currPathAndIdx.path;
-    const prefixAmbiguitiesPathsAndIndices = filter(pathsAndIndices, (searchPathAndIdx) => {
-      return (
-        // ignore (skip) ambiguities with this "other" alternative
-        alternation.definition[searchPathAndIdx.idx].ignoreAmbiguities !== true && searchPathAndIdx.idx < targetIdx && // checking for strict prefix because identical lookaheads
-        // will be be detected using a different validation.
-        isStrictPrefixOfPath(searchPathAndIdx.path, targetPath)
-      );
-    });
-    const currPathPrefixErrors = map(prefixAmbiguitiesPathsAndIndices, (currAmbPathAndIdx) => {
-      const ambgIndices = [currAmbPathAndIdx.idx + 1, targetIdx + 1];
-      const occurrence = alternation.idx === 0 ? "" : alternation.idx;
-      const message = errMsgProvider.buildAlternationPrefixAmbiguityError({
-        topLevelRule: rule,
-        alternation,
-        ambiguityIndices: ambgIndices,
-        prefixPath: currAmbPathAndIdx.path
-      });
-      return {
-        message,
-        type: ParserDefinitionErrorType.AMBIGUOUS_PREFIX_ALTS,
-        ruleName: rule.name,
-        occurrence,
-        alternatives: ambgIndices
-      };
-    });
-    return currPathPrefixErrors;
-  }));
-  return errors;
-}
-function checkTerminalAndNoneTerminalsNameSpace(topLevels, tokenTypes, errMsgProvider) {
-  const errors = [];
-  const tokenNames = map(tokenTypes, (currToken) => currToken.name);
-  forEach(topLevels, (currRule) => {
-    const currRuleName = currRule.name;
-    if (includes(tokenNames, currRuleName)) {
-      const errMsg = errMsgProvider.buildNamespaceConflictError(currRule);
-      errors.push({
-        message: errMsg,
-        type: ParserDefinitionErrorType.CONFLICT_TOKENS_RULES_NAMESPACE,
-        ruleName: currRuleName
-      });
-    }
-  });
-  return errors;
-}
-export {
-  OccurrenceValidationCollector,
-  RepetitionCollector,
-  checkPrefixAlternativesAmbiguities,
-  getFirstNoneTerminal,
-  identifyProductionForDuplicates,
-  validateAmbiguousAlternationAlternatives,
-  validateEmptyOrAlternative,
-  validateGrammar,
-  validateLookahead,
-  validateNoLeftRecursion,
-  validateRuleDoesNotAlreadyExist,
-  validateRuleIsOverridden,
-  validateSomeNonEmptyLookaheadPath,
-  validateTooManyAlts
-};

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

@@ -1,47 +0,0 @@
-import { uniq, map, flatten } from "lodash-es";
-import { NonTerminal, Terminal } from "../../../../../../../@chevrotain_gast@11.0.3/node_modules/@chevrotain/gast/lib/src/model.mjs";
-import { isSequenceProd, isBranchingProd, isOptionalProd } from "../../../../../../../@chevrotain_gast@11.0.3/node_modules/@chevrotain/gast/lib/src/helpers.mjs";
-function first(prod) {
-  if (prod instanceof NonTerminal) {
-    return first(prod.referencedRule);
-  } else if (prod instanceof Terminal) {
-    return firstForTerminal(prod);
-  } else if (isSequenceProd(prod)) {
-    return firstForSequence(prod);
-  } else if (isBranchingProd(prod)) {
-    return firstForBranching(prod);
-  } else {
-    throw Error("non exhaustive match");
-  }
-}
-function firstForSequence(prod) {
-  let firstSet = [];
-  const seq = prod.definition;
-  let nextSubProdIdx = 0;
-  let hasInnerProdsRemaining = seq.length > nextSubProdIdx;
-  let currSubProd;
-  let isLastInnerProdOptional = true;
-  while (hasInnerProdsRemaining && isLastInnerProdOptional) {
-    currSubProd = seq[nextSubProdIdx];
-    isLastInnerProdOptional = isOptionalProd(currSubProd);
-    firstSet = firstSet.concat(first(currSubProd));
-    nextSubProdIdx = nextSubProdIdx + 1;
-    hasInnerProdsRemaining = seq.length > nextSubProdIdx;
-  }
-  return uniq(firstSet);
-}
-function firstForBranching(prod) {
-  const allAlternativesFirsts = map(prod.definition, (innerProd) => {
-    return first(innerProd);
-  });
-  return uniq(flatten(allAlternativesFirsts));
-}
-function firstForTerminal(terminal) {
-  return [terminal.terminalType];
-}
-export {
-  first,
-  firstForBranching,
-  firstForSequence,
-  firstForTerminal
-};