qidian-vue-ui 1.1.55 → 1.1.57

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

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

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

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

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

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

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

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

@@ -1 +0,0 @@
-{"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]}