@windrun-huaiin/third-ui 12.0.3 → 13.0.0

package/dist/node_modules/.pnpm/chevrotain@11.1.2/node_modules/chevrotain/lib/src/parse/grammar/lookahead.mjs

@@ -0,0 +1,480 @@
+import { possiblePathsFrom } from './interpreter.mjs';
+import { RestWalker } from './rest.mjs';
+import { tokenStructuredMatcherNoCategories, tokenStructuredMatcher } from '../../scan/tokens.mjs';
+import { Option, Repetition, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Alternation, Alternative } from '../../../../../../../@chevrotain_gast@11.1.2/node_modules/@chevrotain/gast/lib/src/model.mjs';
+import { GAstVisitor } from '../../../../../../../@chevrotain_gast@11.1.2/node_modules/@chevrotain/gast/lib/src/visitor.mjs';
+import every from '../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/every.mjs';
+import isEmpty from '../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/isEmpty.mjs';
+import map from '../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/map.mjs';
+import forEach from '../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/forEach.mjs';
+import flatten from '../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/flatten.mjs';
+import reduce from '../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/reduce.mjs';
+import has from '../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/has.mjs';
+
+var PROD_TYPE;
+(function (PROD_TYPE) {
+    PROD_TYPE[PROD_TYPE["OPTION"] = 0] = "OPTION";
+    PROD_TYPE[PROD_TYPE["REPETITION"] = 1] = "REPETITION";
+    PROD_TYPE[PROD_TYPE["REPETITION_MANDATORY"] = 2] = "REPETITION_MANDATORY";
+    PROD_TYPE[PROD_TYPE["REPETITION_MANDATORY_WITH_SEPARATOR"] = 3] = "REPETITION_MANDATORY_WITH_SEPARATOR";
+    PROD_TYPE[PROD_TYPE["REPETITION_WITH_SEPARATOR"] = 4] = "REPETITION_WITH_SEPARATOR";
+    PROD_TYPE[PROD_TYPE["ALTERNATION"] = 5] = "ALTERNATION";
+})(PROD_TYPE || (PROD_TYPE = {}));
+function getProdType(prod) {
+    /* istanbul ignore else */
+    if (prod instanceof Option || prod === "Option") {
+        return PROD_TYPE.OPTION;
+    }
+    else if (prod instanceof Repetition || prod === "Repetition") {
+        return PROD_TYPE.REPETITION;
+    }
+    else if (prod instanceof RepetitionMandatory ||
+        prod === "RepetitionMandatory") {
+        return PROD_TYPE.REPETITION_MANDATORY;
+    }
+    else if (prod instanceof RepetitionMandatoryWithSeparator ||
+        prod === "RepetitionMandatoryWithSeparator") {
+        return PROD_TYPE.REPETITION_MANDATORY_WITH_SEPARATOR;
+    }
+    else if (prod instanceof RepetitionWithSeparator ||
+        prod === "RepetitionWithSeparator") {
+        return PROD_TYPE.REPETITION_WITH_SEPARATOR;
+    }
+    else if (prod instanceof Alternation || prod === "Alternation") {
+        return PROD_TYPE.ALTERNATION;
+    }
+    else {
+        throw Error("non exhaustive match");
+    }
+}
+function getLookaheadPaths(options) {
+    const { occurrence, rule, prodType, maxLookahead } = options;
+    const type = getProdType(prodType);
+    if (type === PROD_TYPE.ALTERNATION) {
+        return getLookaheadPathsForOr(occurrence, rule, maxLookahead);
+    }
+    else {
+        return getLookaheadPathsForOptionalProd(occurrence, rule, type, maxLookahead);
+    }
+}
+function buildLookaheadFuncForOr(occurrence, ruleGrammar, maxLookahead, hasPredicates, dynamicTokensEnabled, laFuncBuilder) {
+    const lookAheadPaths = getLookaheadPathsForOr(occurrence, ruleGrammar, maxLookahead);
+    const tokenMatcher = areTokenCategoriesNotUsed(lookAheadPaths)
+        ? tokenStructuredMatcherNoCategories
+        : tokenStructuredMatcher;
+    return laFuncBuilder(lookAheadPaths, hasPredicates, tokenMatcher, dynamicTokensEnabled);
+}
+/**
+ *  When dealing with an Optional production (OPTION/MANY/2nd iteration of AT_LEAST_ONE/...) we need to compare
+ *  the lookahead "inside" the production and the lookahead immediately "after" it in the same top level rule (context free).
+ *
+ *  Example: given a production:
+ *  ABC(DE)?DF
+ *
+ *  The optional '(DE)?' should only be entered if we see 'DE'. a single Token 'D' is not sufficient to distinguish between the two
+ *  alternatives.
+ *
+ *  @returns A Lookahead function which will return true IFF the parser should parse the Optional production.
+ */
+function buildLookaheadFuncForOptionalProd(occurrence, ruleGrammar, k, dynamicTokensEnabled, prodType, lookaheadBuilder) {
+    const lookAheadPaths = getLookaheadPathsForOptionalProd(occurrence, ruleGrammar, prodType, k);
+    const tokenMatcher = areTokenCategoriesNotUsed(lookAheadPaths)
+        ? tokenStructuredMatcherNoCategories
+        : tokenStructuredMatcher;
+    return lookaheadBuilder(lookAheadPaths[0], tokenMatcher, dynamicTokensEnabled);
+}
+function buildAlternativesLookAheadFunc(alts, hasPredicates, tokenMatcher, dynamicTokensEnabled) {
+    const numOfAlts = alts.length;
+    const areAllOneTokenLookahead = every(alts, (currAlt) => {
+        return every(currAlt, (currPath) => {
+            return currPath.length === 1;
+        });
+    });
+    // This version takes into account the predicates as well.
+    if (hasPredicates) {
+        /**
+         * @returns {number} - The chosen alternative index
+         */
+        return function (orAlts) {
+            // unfortunately the predicates must be extracted every single time
+            // as they cannot be cached due to references to parameters(vars) which are no longer valid.
+            // note that in the common case of no predicates, no cpu time will be wasted on this (see else block)
+            const predicates = map(orAlts, (currAlt) => currAlt.GATE);
+            for (let t = 0; t < numOfAlts; t++) {
+                const currAlt = alts[t];
+                const currNumOfPaths = currAlt.length;
+                const currPredicate = predicates[t];
+                if (currPredicate !== undefined && currPredicate.call(this) === false) {
+                    // if the predicate does not match there is no point in checking the paths
+                    continue;
+                }
+                nextPath: for (let j = 0; j < currNumOfPaths; j++) {
+                    const currPath = currAlt[j];
+                    const currPathLength = currPath.length;
+                    for (let i = 0; i < currPathLength; i++) {
+                        const nextToken = this.LA(i + 1);
+                        if (tokenMatcher(nextToken, currPath[i]) === false) {
+                            // mismatch in current path
+                            // try the next pth
+                            continue nextPath;
+                        }
+                    }
+                    // found a full path that matches.
+                    // this will also work for an empty ALT as the loop will be skipped
+                    return t;
+                }
+                // none of the paths for the current alternative matched
+                // try the next alternative
+            }
+            // none of the alternatives could be matched
+            return undefined;
+        };
+    }
+    else if (areAllOneTokenLookahead && !dynamicTokensEnabled) {
+        // optimized (common) case of all the lookaheads paths requiring only
+        // a single token lookahead. These Optimizations cannot work if dynamically defined Tokens are used.
+        const singleTokenAlts = map(alts, (currAlt) => {
+            return flatten(currAlt);
+        });
+        const choiceToAlt = reduce(singleTokenAlts, (result, currAlt, idx) => {
+            forEach(currAlt, (currTokType) => {
+                if (!has(result, currTokType.tokenTypeIdx)) {
+                    result[currTokType.tokenTypeIdx] = idx;
+                }
+                forEach(currTokType.categoryMatches, (currExtendingType) => {
+                    if (!has(result, currExtendingType)) {
+                        result[currExtendingType] = idx;
+                    }
+                });
+            });
+            return result;
+        }, {});
+        /**
+         * @returns {number} - The chosen alternative index
+         */
+        return function () {
+            const nextToken = this.LA(1);
+            return choiceToAlt[nextToken.tokenTypeIdx];
+        };
+    }
+    else {
+        // optimized lookahead without needing to check the predicates at all.
+        // this causes code duplication which is intentional to improve performance.
+        /**
+         * @returns {number} - The chosen alternative index
+         */
+        return function () {
+            for (let t = 0; t < numOfAlts; t++) {
+                const currAlt = alts[t];
+                const currNumOfPaths = currAlt.length;
+                nextPath: for (let j = 0; j < currNumOfPaths; j++) {
+                    const currPath = currAlt[j];
+                    const currPathLength = currPath.length;
+                    for (let i = 0; i < currPathLength; i++) {
+                        const nextToken = this.LA(i + 1);
+                        if (tokenMatcher(nextToken, currPath[i]) === false) {
+                            // mismatch in current path
+                            // try the next pth
+                            continue nextPath;
+                        }
+                    }
+                    // found a full path that matches.
+                    // this will also work for an empty ALT as the loop will be skipped
+                    return t;
+                }
+                // none of the paths for the current alternative matched
+                // try the next alternative
+            }
+            // none of the alternatives could be matched
+            return undefined;
+        };
+    }
+}
+function buildSingleAlternativeLookaheadFunction(alt, tokenMatcher, dynamicTokensEnabled) {
+    const areAllOneTokenLookahead = every(alt, (currPath) => {
+        return currPath.length === 1;
+    });
+    const numOfPaths = alt.length;
+    // optimized (common) case of all the lookaheads paths requiring only
+    // a single token lookahead.
+    if (areAllOneTokenLookahead && !dynamicTokensEnabled) {
+        const singleTokensTypes = flatten(alt);
+        if (singleTokensTypes.length === 1 &&
+            isEmpty(singleTokensTypes[0].categoryMatches)) {
+            const expectedTokenType = singleTokensTypes[0];
+            const expectedTokenUniqueKey = expectedTokenType.tokenTypeIdx;
+            return function () {
+                return this.LA(1).tokenTypeIdx === expectedTokenUniqueKey;
+            };
+        }
+        else {
+            const choiceToAlt = reduce(singleTokensTypes, (result, currTokType, idx) => {
+                result[currTokType.tokenTypeIdx] = true;
+                forEach(currTokType.categoryMatches, (currExtendingType) => {
+                    result[currExtendingType] = true;
+                });
+                return result;
+            }, []);
+            return function () {
+                const nextToken = this.LA(1);
+                return choiceToAlt[nextToken.tokenTypeIdx] === true;
+            };
+        }
+    }
+    else {
+        return function () {
+            nextPath: for (let j = 0; j < numOfPaths; j++) {
+                const currPath = alt[j];
+                const currPathLength = currPath.length;
+                for (let i = 0; i < currPathLength; i++) {
+                    const nextToken = this.LA(i + 1);
+                    if (tokenMatcher(nextToken, currPath[i]) === false) {
+                        // mismatch in current path
+                        // try the next pth
+                        continue nextPath;
+                    }
+                }
+                // found a full path that matches.
+                return true;
+            }
+            // none of the paths matched
+            return false;
+        };
+    }
+}
+class RestDefinitionFinderWalker extends RestWalker {
+    constructor(topProd, targetOccurrence, targetProdType) {
+        super();
+        this.topProd = topProd;
+        this.targetOccurrence = targetOccurrence;
+        this.targetProdType = targetProdType;
+    }
+    startWalking() {
+        this.walk(this.topProd);
+        return this.restDef;
+    }
+    checkIsTarget(node, expectedProdType, currRest, prevRest) {
+        if (node.idx === this.targetOccurrence &&
+            this.targetProdType === expectedProdType) {
+            this.restDef = currRest.concat(prevRest);
+            return true;
+        }
+        // performance optimization, do not iterate over the entire Grammar ast after we have found the target
+        return false;
+    }
+    walkOption(optionProd, currRest, prevRest) {
+        if (!this.checkIsTarget(optionProd, PROD_TYPE.OPTION, currRest, prevRest)) {
+            super.walkOption(optionProd, currRest, prevRest);
+        }
+    }
+    walkAtLeastOne(atLeastOneProd, currRest, prevRest) {
+        if (!this.checkIsTarget(atLeastOneProd, PROD_TYPE.REPETITION_MANDATORY, currRest, prevRest)) {
+            super.walkOption(atLeastOneProd, currRest, prevRest);
+        }
+    }
+    walkAtLeastOneSep(atLeastOneSepProd, currRest, prevRest) {
+        if (!this.checkIsTarget(atLeastOneSepProd, PROD_TYPE.REPETITION_MANDATORY_WITH_SEPARATOR, currRest, prevRest)) {
+            super.walkOption(atLeastOneSepProd, currRest, prevRest);
+        }
+    }
+    walkMany(manyProd, currRest, prevRest) {
+        if (!this.checkIsTarget(manyProd, PROD_TYPE.REPETITION, currRest, prevRest)) {
+            super.walkOption(manyProd, currRest, prevRest);
+        }
+    }
+    walkManySep(manySepProd, currRest, prevRest) {
+        if (!this.checkIsTarget(manySepProd, PROD_TYPE.REPETITION_WITH_SEPARATOR, currRest, prevRest)) {
+            super.walkOption(manySepProd, currRest, prevRest);
+        }
+    }
+}
+/**
+ * Returns the definition of a target production in a top level level rule.
+ */
+class InsideDefinitionFinderVisitor extends GAstVisitor {
+    constructor(targetOccurrence, targetProdType, targetRef) {
+        super();
+        this.targetOccurrence = targetOccurrence;
+        this.targetProdType = targetProdType;
+        this.targetRef = targetRef;
+        this.result = [];
+    }
+    checkIsTarget(node, expectedProdName) {
+        if (node.idx === this.targetOccurrence &&
+            this.targetProdType === expectedProdName &&
+            (this.targetRef === undefined || node === this.targetRef)) {
+            this.result = node.definition;
+        }
+    }
+    visitOption(node) {
+        this.checkIsTarget(node, PROD_TYPE.OPTION);
+    }
+    visitRepetition(node) {
+        this.checkIsTarget(node, PROD_TYPE.REPETITION);
+    }
+    visitRepetitionMandatory(node) {
+        this.checkIsTarget(node, PROD_TYPE.REPETITION_MANDATORY);
+    }
+    visitRepetitionMandatoryWithSeparator(node) {
+        this.checkIsTarget(node, PROD_TYPE.REPETITION_MANDATORY_WITH_SEPARATOR);
+    }
+    visitRepetitionWithSeparator(node) {
+        this.checkIsTarget(node, PROD_TYPE.REPETITION_WITH_SEPARATOR);
+    }
+    visitAlternation(node) {
+        this.checkIsTarget(node, PROD_TYPE.ALTERNATION);
+    }
+}
+function initializeArrayOfArrays(size) {
+    const result = new Array(size);
+    for (let i = 0; i < size; i++) {
+        result[i] = [];
+    }
+    return result;
+}
+/**
+ * A sort of hash function between a Path in the grammar and a string.
+ * Note that this returns multiple "hashes" to support the scenario of token categories.
+ * -  A single path with categories may match multiple **actual** paths.
+ */
+function pathToHashKeys(path) {
+    let keys = [""];
+    for (let i = 0; i < path.length; i++) {
+        const tokType = path[i];
+        const longerKeys = [];
+        for (let j = 0; j < keys.length; j++) {
+            const currShorterKey = keys[j];
+            longerKeys.push(currShorterKey + "_" + tokType.tokenTypeIdx);
+            for (let t = 0; t < tokType.categoryMatches.length; t++) {
+                const categoriesKeySuffix = "_" + tokType.categoryMatches[t];
+                longerKeys.push(currShorterKey + categoriesKeySuffix);
+            }
+        }
+        keys = longerKeys;
+    }
+    return keys;
+}
+/**
+ * Imperative style due to being called from a hot spot
+ */
+function isUniquePrefixHash(altKnownPathsKeys, searchPathKeys, idx) {
+    for (let currAltIdx = 0; currAltIdx < altKnownPathsKeys.length; currAltIdx++) {
+        // We only want to test vs the other alternatives
+        if (currAltIdx === idx) {
+            continue;
+        }
+        const otherAltKnownPathsKeys = altKnownPathsKeys[currAltIdx];
+        for (let searchIdx = 0; searchIdx < searchPathKeys.length; searchIdx++) {
+            const searchKey = searchPathKeys[searchIdx];
+            if (otherAltKnownPathsKeys[searchKey] === true) {
+                return false;
+            }
+        }
+    }
+    // None of the SearchPathKeys were found in any of the other alternatives
+    return true;
+}
+function lookAheadSequenceFromAlternatives(altsDefs, k) {
+    const partialAlts = map(altsDefs, (currAlt) => possiblePathsFrom([currAlt], 1));
+    const finalResult = initializeArrayOfArrays(partialAlts.length);
+    const altsHashes = map(partialAlts, (currAltPaths) => {
+        const dict = {};
+        forEach(currAltPaths, (item) => {
+            const keys = pathToHashKeys(item.partialPath);
+            forEach(keys, (currKey) => {
+                dict[currKey] = true;
+            });
+        });
+        return dict;
+    });
+    let newData = partialAlts;
+    // maxLookahead loop
+    for (let pathLength = 1; pathLength <= k; pathLength++) {
+        const currDataset = newData;
+        newData = initializeArrayOfArrays(currDataset.length);
+        // alternatives loop
+        for (let altIdx = 0; altIdx < currDataset.length; altIdx++) {
+            const currAltPathsAndSuffixes = currDataset[altIdx];
+            // paths in current alternative loop
+            for (let currPathIdx = 0; currPathIdx < currAltPathsAndSuffixes.length; currPathIdx++) {
+                const currPathPrefix = currAltPathsAndSuffixes[currPathIdx].partialPath;
+                const suffixDef = currAltPathsAndSuffixes[currPathIdx].suffixDef;
+                const prefixKeys = pathToHashKeys(currPathPrefix);
+                const isUnique = isUniquePrefixHash(altsHashes, prefixKeys, altIdx);
+                // End of the line for this path.
+                if (isUnique || isEmpty(suffixDef) || currPathPrefix.length === k) {
+                    const currAltResult = finalResult[altIdx];
+                    // TODO: Can we implement a containsPath using Maps/Dictionaries?
+                    if (containsPath(currAltResult, currPathPrefix) === false) {
+                        currAltResult.push(currPathPrefix);
+                        // Update all new  keys for the current path.
+                        for (let j = 0; j < prefixKeys.length; j++) {
+                            const currKey = prefixKeys[j];
+                            altsHashes[altIdx][currKey] = true;
+                        }
+                    }
+                }
+                // Expand longer paths
+                else {
+                    const newPartialPathsAndSuffixes = possiblePathsFrom(suffixDef, pathLength + 1, currPathPrefix);
+                    newData[altIdx] = newData[altIdx].concat(newPartialPathsAndSuffixes);
+                    // Update keys for new known paths
+                    forEach(newPartialPathsAndSuffixes, (item) => {
+                        const prefixKeys = pathToHashKeys(item.partialPath);
+                        forEach(prefixKeys, (key) => {
+                            altsHashes[altIdx][key] = true;
+                        });
+                    });
+                }
+            }
+        }
+    }
+    return finalResult;
+}
+function getLookaheadPathsForOr(occurrence, ruleGrammar, k, orProd) {
+    const visitor = new InsideDefinitionFinderVisitor(occurrence, PROD_TYPE.ALTERNATION, orProd);
+    ruleGrammar.accept(visitor);
+    return lookAheadSequenceFromAlternatives(visitor.result, k);
+}
+function getLookaheadPathsForOptionalProd(occurrence, ruleGrammar, prodType, k) {
+    const insideDefVisitor = new InsideDefinitionFinderVisitor(occurrence, prodType);
+    ruleGrammar.accept(insideDefVisitor);
+    const insideDef = insideDefVisitor.result;
+    const afterDefWalker = new RestDefinitionFinderWalker(ruleGrammar, occurrence, prodType);
+    const afterDef = afterDefWalker.startWalking();
+    const insideFlat = new Alternative({ definition: insideDef });
+    const afterFlat = new Alternative({ definition: afterDef });
+    return lookAheadSequenceFromAlternatives([insideFlat, afterFlat], k);
+}
+function containsPath(alternative, searchPath) {
+    compareOtherPath: for (let i = 0; i < alternative.length; i++) {
+        const otherPath = alternative[i];
+        if (otherPath.length !== searchPath.length) {
+            continue;
+        }
+        for (let j = 0; j < otherPath.length; j++) {
+            const searchTok = searchPath[j];
+            const otherTok = otherPath[j];
+            const matchingTokens = searchTok === otherTok ||
+                otherTok.categoryMatchesMap[searchTok.tokenTypeIdx] !== undefined;
+            if (matchingTokens === false) {
+                continue compareOtherPath;
+            }
+        }
+        return true;
+    }
+    return false;
+}
+function isStrictPrefixOfPath(prefix, other) {
+    return (prefix.length < other.length &&
+        every(prefix, (tokType, idx) => {
+            const otherTokType = other[idx];
+            return (tokType === otherTokType ||
+                otherTokType.categoryMatchesMap[tokType.tokenTypeIdx]);
+        }));
+}
+function areTokenCategoriesNotUsed(lookAheadPaths) {
+    return every(lookAheadPaths, (singleAltPaths) => every(singleAltPaths, (singlePath) => every(singlePath, (token) => isEmpty(token.categoryMatches))));
+}
+
+export { PROD_TYPE, areTokenCategoriesNotUsed, buildAlternativesLookAheadFunc, buildLookaheadFuncForOptionalProd, buildLookaheadFuncForOr, buildSingleAlternativeLookaheadFunction, containsPath, getLookaheadPaths, getLookaheadPathsForOptionalProd, getLookaheadPathsForOr, getProdType, isStrictPrefixOfPath, lookAheadSequenceFromAlternatives };

package/dist/node_modules/.pnpm/chevrotain@11.1.2/node_modules/chevrotain/lib/src/parse/grammar/resolver.js

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

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

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

package/dist/node_modules/.pnpm/chevrotain@11.1.2/node_modules/chevrotain/lib/src/parse/grammar/rest.js

@@ -0,0 +1,108 @@
+'use strict';
+
+var model = require('../../../../../../../@chevrotain_gast@11.1.2/node_modules/@chevrotain/gast/lib/src/model.js');
+var forEach = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/forEach.js');
+var drop = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/drop.js');
+
+/**
+ *  A Grammar Walker that computes the "remaining" grammar "after" a productions in the grammar.
+ */
+class RestWalker {
+    walk(prod, prevRest = []) {
+        forEach(prod.definition, (subProd, index) => {
+            const currRest = drop(prod.definition, index + 1);
+            /* istanbul ignore else */
+            if (subProd instanceof model.NonTerminal) {
+                this.walkProdRef(subProd, currRest, prevRest);
+            }
+            else if (subProd instanceof model.Terminal) {
+                this.walkTerminal(subProd, currRest, prevRest);
+            }
+            else if (subProd instanceof model.Alternative) {
+                this.walkFlat(subProd, currRest, prevRest);
+            }
+            else if (subProd instanceof model.Option) {
+                this.walkOption(subProd, currRest, prevRest);
+            }
+            else if (subProd instanceof model.RepetitionMandatory) {
+                this.walkAtLeastOne(subProd, currRest, prevRest);
+            }
+            else if (subProd instanceof model.RepetitionMandatoryWithSeparator) {
+                this.walkAtLeastOneSep(subProd, currRest, prevRest);
+            }
+            else if (subProd instanceof model.RepetitionWithSeparator) {
+                this.walkManySep(subProd, currRest, prevRest);
+            }
+            else if (subProd instanceof model.Repetition) {
+                this.walkMany(subProd, currRest, prevRest);
+            }
+            else if (subProd instanceof model.Alternation) {
+                this.walkOr(subProd, currRest, prevRest);
+            }
+            else {
+                throw Error("non exhaustive match");
+            }
+        });
+    }
+    walkTerminal(terminal, currRest, prevRest) { }
+    walkProdRef(refProd, currRest, prevRest) { }
+    walkFlat(flatProd, currRest, prevRest) {
+        // ABCDEF => after the D the rest is EF
+        const fullOrRest = currRest.concat(prevRest);
+        this.walk(flatProd, fullOrRest);
+    }
+    walkOption(optionProd, currRest, prevRest) {
+        // ABC(DE)?F => after the (DE)? the rest is F
+        const fullOrRest = currRest.concat(prevRest);
+        this.walk(optionProd, fullOrRest);
+    }
+    walkAtLeastOne(atLeastOneProd, currRest, prevRest) {
+        // ABC(DE)+F => after the (DE)+ the rest is (DE)?F
+        const fullAtLeastOneRest = [
+            new model.Option({ definition: atLeastOneProd.definition }),
+        ].concat(currRest, prevRest);
+        this.walk(atLeastOneProd, fullAtLeastOneRest);
+    }
+    walkAtLeastOneSep(atLeastOneSepProd, currRest, prevRest) {
+        // ABC DE(,DE)* F => after the (,DE)+ the rest is (,DE)?F
+        const fullAtLeastOneSepRest = restForRepetitionWithSeparator(atLeastOneSepProd, currRest, prevRest);
+        this.walk(atLeastOneSepProd, fullAtLeastOneSepRest);
+    }
+    walkMany(manyProd, currRest, prevRest) {
+        // ABC(DE)*F => after the (DE)* the rest is (DE)?F
+        const fullManyRest = [
+            new model.Option({ definition: manyProd.definition }),
+        ].concat(currRest, prevRest);
+        this.walk(manyProd, fullManyRest);
+    }
+    walkManySep(manySepProd, currRest, prevRest) {
+        // ABC (DE(,DE)*)? F => after the (,DE)* the rest is (,DE)?F
+        const fullManySepRest = restForRepetitionWithSeparator(manySepProd, currRest, prevRest);
+        this.walk(manySepProd, fullManySepRest);
+    }
+    walkOr(orProd, currRest, prevRest) {
+        // ABC(D|E|F)G => when finding the (D|E|F) the rest is G
+        const fullOrRest = currRest.concat(prevRest);
+        // walk all different alternatives
+        forEach(orProd.definition, (alt) => {
+            // wrapping each alternative in a single definition wrapper
+            // to avoid errors in computing the rest of that alternative in the invocation to computeInProdFollows
+            // (otherwise for OR([alt1,alt2]) alt2 will be considered in 'rest' of alt1
+            const prodWrapper = new model.Alternative({ definition: [alt] });
+            this.walk(prodWrapper, fullOrRest);
+        });
+    }
+}
+function restForRepetitionWithSeparator(repSepProd, currRest, prevRest) {
+    const repSepRest = [
+        new model.Option({
+            definition: [
+                new model.Terminal({ terminalType: repSepProd.separator }),
+            ].concat(repSepProd.definition),
+        }),
+    ];
+    const fullRepSepRest = repSepRest.concat(currRest, prevRest);
+    return fullRepSepRest;
+}
+
+exports.RestWalker = RestWalker;