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

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

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

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

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