@windrun-huaiin/third-ui 13.1.4 → 14.0.0

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

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

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

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

@@ -1,108 +0,0 @@
-'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;