qidian-vue-ui 1.1.50 → 1.1.51

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

@@ -0,0 +1,434 @@
+import { ParserDefinitionErrorType } from "../parser/parser.mjs";
+import { Terminal, NonTerminal, Alternative, Option, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Repetition, Alternation } 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 { getProductionDslName, isOptionalProd } from "../../../../../../../@chevrotain_gast@11.0.3/node_modules/@chevrotain/gast/lib/src/helpers.mjs";
+import { getProdType, getLookaheadPathsForOptionalProd, getLookaheadPathsForOr, containsPath, isStrictPrefixOfPath } from "./lookahead.mjs";
+import { nextPossibleTokensAfter } from "./interpreter.mjs";
+import { tokenStructuredMatcher } from "../../scan/tokens.mjs";
+import forEach from "../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/forEach.mjs";
+import map from "../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/map.mjs";
+import flatMap from "../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/flatMap.mjs";
+import groupBy from "../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/groupBy.mjs";
+import pickBy from "../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/pickBy.mjs";
+import head from "../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/head.mjs";
+import values from "../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/values.mjs";
+import reduce from "../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/reduce.mjs";
+import isEmpty from "../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/isEmpty.mjs";
+import flatten from "../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/flatten.mjs";
+import includes from "../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/includes.mjs";
+import difference from "../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/difference.mjs";
+import clone from "../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/clone.mjs";
+import dropRight from "../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/dropRight.mjs";
+import reject from "../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/reject.mjs";
+import drop from "../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/drop.mjs";
+import compact from "../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/compact.mjs";
+import filter from "../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/filter.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 = head(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 = head(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
+};
+//# sourceMappingURL=checks.mjs.map

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

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

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

@@ -0,0 +1,50 @@
+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";
+import uniq from "../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/uniq.mjs";
+import map from "../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/map.mjs";
+import flatten from "../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/flatten.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
+};
+//# sourceMappingURL=first.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"first.mjs","sources":["../../../../../../../../../../../../node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/grammar/first.js"],"sourcesContent":["import { flatten, map, uniq } from \"lodash-es\";\nimport { isBranchingProd, isOptionalProd, isSequenceProd, NonTerminal, Terminal, } from \"@chevrotain/gast\";\nexport function first(prod) {\n    /* istanbul ignore else */\n    if (prod instanceof NonTerminal) {\n        // this could in theory cause infinite loops if\n        // (1) prod A refs prod B.\n        // (2) prod B refs prod A\n        // (3) AB can match the empty set\n        // in other words a cycle where everything is optional so the first will keep\n        // looking ahead for the next optional part and will never exit\n        // currently there is no safeguard for this unique edge case because\n        // (1) not sure a grammar in which this can happen is useful for anything (productive)\n        return first(prod.referencedRule);\n    }\n    else if (prod instanceof Terminal) {\n        return firstForTerminal(prod);\n    }\n    else if (isSequenceProd(prod)) {\n        return firstForSequence(prod);\n    }\n    else if (isBranchingProd(prod)) {\n        return firstForBranching(prod);\n    }\n    else {\n        throw Error(\"non exhaustive match\");\n    }\n}\nexport function firstForSequence(prod) {\n    let firstSet = [];\n    const seq = prod.definition;\n    let nextSubProdIdx = 0;\n    let hasInnerProdsRemaining = seq.length > nextSubProdIdx;\n    let currSubProd;\n    // so we enter the loop at least once (if the definition is not empty\n    let isLastInnerProdOptional = true;\n    // scan a sequence until it's end or until we have found a NONE optional production in it\n    while (hasInnerProdsRemaining && isLastInnerProdOptional) {\n        currSubProd = seq[nextSubProdIdx];\n        isLastInnerProdOptional = isOptionalProd(currSubProd);\n        firstSet = firstSet.concat(first(currSubProd));\n        nextSubProdIdx = nextSubProdIdx + 1;\n        hasInnerProdsRemaining = seq.length > nextSubProdIdx;\n    }\n    return uniq(firstSet);\n}\nexport function firstForBranching(prod) {\n    const allAlternativesFirsts = map(prod.definition, (innerProd) => {\n        return first(innerProd);\n    });\n    return uniq(flatten(allAlternativesFirsts));\n}\nexport function firstForTerminal(terminal) {\n    return [terminal.terminalType];\n}\n//# sourceMappingURL=first.js.map"],"names":[],"mappings":";;;;;AAEO,SAAS,MAAM,MAAM;AAExB,MAAI,gBAAgB,aAAa;AAS7B,WAAO,MAAM,KAAK,cAAc;AAAA,EACpC,WACS,gBAAgB,UAAU;AAC/B,WAAO,iBAAiB,IAAI;AAAA,EAChC,WACS,eAAe,IAAI,GAAG;AAC3B,WAAO,iBAAiB,IAAI;AAAA,EAChC,WACS,gBAAgB,IAAI,GAAG;AAC5B,WAAO,kBAAkB,IAAI;AAAA,EACjC,OACK;AACD,UAAM,MAAM,sBAAsB;AAAA,EACtC;AACJ;AACO,SAAS,iBAAiB,MAAM;AACnC,MAAI,WAAW,CAAA;AACf,QAAM,MAAM,KAAK;AACjB,MAAI,iBAAiB;AACrB,MAAI,yBAAyB,IAAI,SAAS;AAC1C,MAAI;AAEJ,MAAI,0BAA0B;AAE9B,SAAO,0BAA0B,yBAAyB;AACtD,kBAAc,IAAI,cAAc;AAChC,8BAA0B,eAAe,WAAW;AACpD,eAAW,SAAS,OAAO,MAAM,WAAW,CAAC;AAC7C,qBAAiB,iBAAiB;AAClC,6BAAyB,IAAI,SAAS;AAAA,EAC1C;AACA,SAAO,KAAK,QAAQ;AACxB;AACO,SAAS,kBAAkB,MAAM;AACpC,QAAM,wBAAwB,IAAI,KAAK,YAAY,CAAC,cAAc;AAC9D,WAAO,MAAM,SAAS;AAAA,EAC1B,CAAC;AACD,SAAO,KAAK,QAAQ,qBAAqB,CAAC;AAC9C;AACO,SAAS,iBAAiB,UAAU;AACvC,SAAO,CAAC,SAAS,YAAY;AACjC;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,43 @@
+import { RestWalker } from "./rest.mjs";
+import { first } from "./first.mjs";
+import { IN } from "../constants.mjs";
+import { Alternative } from "../../../../../../../@chevrotain_gast@11.0.3/node_modules/@chevrotain/gast/lib/src/model.mjs";
+import forEach from "../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/forEach.mjs";
+import assign from "../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/assign.mjs";
+class ResyncFollowsWalker extends RestWalker {
+  constructor(topProd) {
+    super();
+    this.topProd = topProd;
+    this.follows = {};
+  }
+  startWalking() {
+    this.walk(this.topProd);
+    return this.follows;
+  }
+  walkTerminal(terminal, currRest, prevRest) {
+  }
+  walkProdRef(refProd, currRest, prevRest) {
+    const followName = buildBetweenProdsFollowPrefix(refProd.referencedRule, refProd.idx) + this.topProd.name;
+    const fullRest = currRest.concat(prevRest);
+    const restProd = new Alternative({ definition: fullRest });
+    const t_in_topProd_follows = first(restProd);
+    this.follows[followName] = t_in_topProd_follows;
+  }
+}
+function computeAllProdsFollows(topProductions) {
+  const reSyncFollows = {};
+  forEach(topProductions, (topProd) => {
+    const currRefsFollow = new ResyncFollowsWalker(topProd).startWalking();
+    assign(reSyncFollows, currRefsFollow);
+  });
+  return reSyncFollows;
+}
+function buildBetweenProdsFollowPrefix(inner, occurenceInParent) {
+  return inner.name + occurenceInParent + IN;
+}
+export {
+  ResyncFollowsWalker,
+  buildBetweenProdsFollowPrefix,
+  computeAllProdsFollows
+};
+//# sourceMappingURL=follow.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"follow.mjs","sources":["../../../../../../../../../../../../node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/grammar/follow.js"],"sourcesContent":["import { RestWalker } from \"./rest.js\";\nimport { first } from \"./first.js\";\nimport { assign, forEach } from \"lodash-es\";\nimport { IN } from \"../constants.js\";\nimport { Alternative } from \"@chevrotain/gast\";\n// This ResyncFollowsWalker computes all of the follows required for RESYNC\n// (skipping reference production).\nexport class ResyncFollowsWalker extends RestWalker {\n    constructor(topProd) {\n        super();\n        this.topProd = topProd;\n        this.follows = {};\n    }\n    startWalking() {\n        this.walk(this.topProd);\n        return this.follows;\n    }\n    walkTerminal(terminal, currRest, prevRest) {\n        // do nothing! just like in the public sector after 13:00\n    }\n    walkProdRef(refProd, currRest, prevRest) {\n        const followName = buildBetweenProdsFollowPrefix(refProd.referencedRule, refProd.idx) +\n            this.topProd.name;\n        const fullRest = currRest.concat(prevRest);\n        const restProd = new Alternative({ definition: fullRest });\n        const t_in_topProd_follows = first(restProd);\n        this.follows[followName] = t_in_topProd_follows;\n    }\n}\nexport function computeAllProdsFollows(topProductions) {\n    const reSyncFollows = {};\n    forEach(topProductions, (topProd) => {\n        const currRefsFollow = new ResyncFollowsWalker(topProd).startWalking();\n        assign(reSyncFollows, currRefsFollow);\n    });\n    return reSyncFollows;\n}\nexport function buildBetweenProdsFollowPrefix(inner, occurenceInParent) {\n    return inner.name + occurenceInParent + IN;\n}\nexport function buildInProdFollowPrefix(terminal) {\n    const terminalName = terminal.terminalType.name;\n    return terminalName + terminal.idx + IN;\n}\n//# sourceMappingURL=follow.js.map"],"names":[],"mappings":";;;;;;AAOO,MAAM,4BAA4B,WAAW;AAAA,EAChD,YAAY,SAAS;AACjB,UAAK;AACL,SAAK,UAAU;AACf,SAAK,UAAU,CAAA;AAAA,EACnB;AAAA,EACA,eAAe;AACX,SAAK,KAAK,KAAK,OAAO;AACtB,WAAO,KAAK;AAAA,EAChB;AAAA,EACA,aAAa,UAAU,UAAU,UAAU;AAAA,EAE3C;AAAA,EACA,YAAY,SAAS,UAAU,UAAU;AACrC,UAAM,aAAa,8BAA8B,QAAQ,gBAAgB,QAAQ,GAAG,IAChF,KAAK,QAAQ;AACjB,UAAM,WAAW,SAAS,OAAO,QAAQ;AACzC,UAAM,WAAW,IAAI,YAAY,EAAE,YAAY,SAAQ,CAAE;AACzD,UAAM,uBAAuB,MAAM,QAAQ;AAC3C,SAAK,QAAQ,UAAU,IAAI;AAAA,EAC/B;AACJ;AACO,SAAS,uBAAuB,gBAAgB;AACnD,QAAM,gBAAgB,CAAA;AACtB,UAAQ,gBAAgB,CAAC,YAAY;AACjC,UAAM,iBAAiB,IAAI,oBAAoB,OAAO,EAAE,aAAY;AACpE,WAAO,eAAe,cAAc;AAAA,EACxC,CAAC;AACD,SAAO;AACX;AACO,SAAS,8BAA8B,OAAO,mBAAmB;AACpE,SAAO,MAAM,OAAO,oBAAoB;AAC5C;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,26 @@
+import { resolveGrammar as resolveGrammar$1 } from "../resolver.mjs";
+import { validateGrammar as validateGrammar$1 } from "../checks.mjs";
+import { defaultGrammarResolverErrorProvider, defaultGrammarValidatorErrorProvider } from "../../errors_public.mjs";
+import defaults from "../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/defaults.mjs";
+import forEach from "../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/forEach.mjs";
+function resolveGrammar(options) {
+  const actualOptions = defaults(options, {
+    errMsgProvider: defaultGrammarResolverErrorProvider
+  });
+  const topRulesTable = {};
+  forEach(options.rules, (rule) => {
+    topRulesTable[rule.name] = rule;
+  });
+  return resolveGrammar$1(topRulesTable, actualOptions.errMsgProvider);
+}
+function validateGrammar(options) {
+  options = defaults(options, {
+    errMsgProvider: defaultGrammarValidatorErrorProvider
+  });
+  return validateGrammar$1(options.rules, options.tokenTypes, options.errMsgProvider, options.grammarName);
+}
+export {
+  resolveGrammar,
+  validateGrammar
+};
+//# sourceMappingURL=gast_resolver_public.mjs.map

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/grammar/gast/gast_resolver_public.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"gast_resolver_public.mjs","sources":["../../../../../../../../../../../../../node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/grammar/gast/gast_resolver_public.js"],"sourcesContent":["import { defaults, forEach } from \"lodash-es\";\nimport { resolveGrammar as orgResolveGrammar } from \"../resolver.js\";\nimport { validateGrammar as orgValidateGrammar } from \"../checks.js\";\nimport { defaultGrammarResolverErrorProvider, defaultGrammarValidatorErrorProvider, } from \"../../errors_public.js\";\nexport function resolveGrammar(options) {\n    const actualOptions = defaults(options, {\n        errMsgProvider: defaultGrammarResolverErrorProvider,\n    });\n    const topRulesTable = {};\n    forEach(options.rules, (rule) => {\n        topRulesTable[rule.name] = rule;\n    });\n    return orgResolveGrammar(topRulesTable, actualOptions.errMsgProvider);\n}\nexport function validateGrammar(options) {\n    options = defaults(options, {\n        errMsgProvider: defaultGrammarValidatorErrorProvider,\n    });\n    return orgValidateGrammar(options.rules, options.tokenTypes, options.errMsgProvider, options.grammarName);\n}\n//# sourceMappingURL=gast_resolver_public.js.map"],"names":["orgResolveGrammar","orgValidateGrammar"],"mappings":";;;;;AAIO,SAAS,eAAe,SAAS;AACpC,QAAM,gBAAgB,SAAS,SAAS;AAAA,IACpC,gBAAgB;AAAA,EACxB,CAAK;AACD,QAAM,gBAAgB,CAAA;AACtB,UAAQ,QAAQ,OAAO,CAAC,SAAS;AAC7B,kBAAc,KAAK,IAAI,IAAI;AAAA,EAC/B,CAAC;AACD,SAAOA,iBAAkB,eAAe,cAAc,cAAc;AACxE;AACO,SAAS,gBAAgB,SAAS;AACrC,YAAU,SAAS,SAAS;AAAA,IACxB,gBAAgB;AAAA,EACxB,CAAK;AACD,SAAOC,kBAAmB,QAAQ,OAAO,QAAQ,YAAY,QAAQ,gBAAgB,QAAQ,WAAW;AAC5G;","x_google_ignoreList":[0]}