@windrun-huaiin/third-ui 13.1.4 → 13.1.5

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

@@ -1,500 +0,0 @@
-import { first } from './first.mjs';
-import { RestWalker } from './rest.mjs';
-import { Alternative, NonTerminal, Option, RepetitionMandatory, Repetition, RepetitionMandatoryWithSeparator, Terminal, RepetitionWithSeparator, Alternation, Rule } from '../../../../../../../@chevrotain_gast@11.1.2/node_modules/@chevrotain/gast/lib/src/model.mjs';
-import clone from '../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/clone.mjs';
-import forEach from '../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/forEach.mjs';
-import isEmpty from '../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/isEmpty.mjs';
-import drop from '../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/drop.mjs';
-import dropRight from '../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/dropRight.mjs';
-import last from '../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/last.mjs';
-import head from '../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/head.mjs';
-
-class AbstractNextPossibleTokensWalker extends RestWalker {
-    constructor(topProd, path) {
-        super();
-        this.topProd = topProd;
-        this.path = path;
-        this.possibleTokTypes = [];
-        this.nextProductionName = "";
-        this.nextProductionOccurrence = 0;
-        this.found = false;
-        this.isAtEndOfPath = false;
-    }
-    startWalking() {
-        this.found = false;
-        if (this.path.ruleStack[0] !== this.topProd.name) {
-            throw Error("The path does not start with the walker's top Rule!");
-        }
-        // immutable for the win
-        this.ruleStack = clone(this.path.ruleStack).reverse(); // intelij bug requires assertion
-        this.occurrenceStack = clone(this.path.occurrenceStack).reverse(); // intelij bug requires assertion
-        // already verified that the first production is valid, we now seek the 2nd production
-        this.ruleStack.pop();
-        this.occurrenceStack.pop();
-        this.updateExpectedNext();
-        this.walk(this.topProd);
-        return this.possibleTokTypes;
-    }
-    walk(prod, prevRest = []) {
-        // stop scanning once we found the path
-        if (!this.found) {
-            super.walk(prod, prevRest);
-        }
-    }
-    walkProdRef(refProd, currRest, prevRest) {
-        // found the next production, need to keep walking in it
-        if (refProd.referencedRule.name === this.nextProductionName &&
-            refProd.idx === this.nextProductionOccurrence) {
-            const fullRest = currRest.concat(prevRest);
-            this.updateExpectedNext();
-            this.walk(refProd.referencedRule, fullRest);
-        }
-    }
-    updateExpectedNext() {
-        // need to consume the Terminal
-        if (isEmpty(this.ruleStack)) {
-            // must reset nextProductionXXX to avoid walking down another Top Level production while what we are
-            // really seeking is the last Terminal...
-            this.nextProductionName = "";
-            this.nextProductionOccurrence = 0;
-            this.isAtEndOfPath = true;
-        }
-        else {
-            this.nextProductionName = this.ruleStack.pop();
-            this.nextProductionOccurrence = this.occurrenceStack.pop();
-        }
-    }
-}
-class NextAfterTokenWalker extends AbstractNextPossibleTokensWalker {
-    constructor(topProd, path) {
-        super(topProd, path);
-        this.path = path;
-        this.nextTerminalName = "";
-        this.nextTerminalOccurrence = 0;
-        this.nextTerminalName = this.path.lastTok.name;
-        this.nextTerminalOccurrence = this.path.lastTokOccurrence;
-    }
-    walkTerminal(terminal, currRest, prevRest) {
-        if (this.isAtEndOfPath &&
-            terminal.terminalType.name === this.nextTerminalName &&
-            terminal.idx === this.nextTerminalOccurrence &&
-            !this.found) {
-            const fullRest = currRest.concat(prevRest);
-            const restProd = new Alternative({ definition: fullRest });
-            this.possibleTokTypes = first(restProd);
-            this.found = true;
-        }
-    }
-}
-/**
- * This walker only "walks" a single "TOP" level in the Grammar Ast, this means
- * it never "follows" production refs
- */
-class AbstractNextTerminalAfterProductionWalker extends RestWalker {
-    constructor(topRule, occurrence) {
-        super();
-        this.topRule = topRule;
-        this.occurrence = occurrence;
-        this.result = {
-            token: undefined,
-            occurrence: undefined,
-            isEndOfRule: undefined,
-        };
-    }
-    startWalking() {
-        this.walk(this.topRule);
-        return this.result;
-    }
-}
-class NextTerminalAfterManyWalker extends AbstractNextTerminalAfterProductionWalker {
-    walkMany(manyProd, currRest, prevRest) {
-        if (manyProd.idx === this.occurrence) {
-            const firstAfterMany = head(currRest.concat(prevRest));
-            this.result.isEndOfRule = firstAfterMany === undefined;
-            if (firstAfterMany instanceof Terminal) {
-                this.result.token = firstAfterMany.terminalType;
-                this.result.occurrence = firstAfterMany.idx;
-            }
-        }
-        else {
-            super.walkMany(manyProd, currRest, prevRest);
-        }
-    }
-}
-class NextTerminalAfterManySepWalker extends AbstractNextTerminalAfterProductionWalker {
-    walkManySep(manySepProd, currRest, prevRest) {
-        if (manySepProd.idx === this.occurrence) {
-            const firstAfterManySep = head(currRest.concat(prevRest));
-            this.result.isEndOfRule = firstAfterManySep === undefined;
-            if (firstAfterManySep instanceof Terminal) {
-                this.result.token = firstAfterManySep.terminalType;
-                this.result.occurrence = firstAfterManySep.idx;
-            }
-        }
-        else {
-            super.walkManySep(manySepProd, currRest, prevRest);
-        }
-    }
-}
-class NextTerminalAfterAtLeastOneWalker extends AbstractNextTerminalAfterProductionWalker {
-    walkAtLeastOne(atLeastOneProd, currRest, prevRest) {
-        if (atLeastOneProd.idx === this.occurrence) {
-            const firstAfterAtLeastOne = head(currRest.concat(prevRest));
-            this.result.isEndOfRule = firstAfterAtLeastOne === undefined;
-            if (firstAfterAtLeastOne instanceof Terminal) {
-                this.result.token = firstAfterAtLeastOne.terminalType;
-                this.result.occurrence = firstAfterAtLeastOne.idx;
-            }
-        }
-        else {
-            super.walkAtLeastOne(atLeastOneProd, currRest, prevRest);
-        }
-    }
-}
-// TODO: reduce code duplication in the AfterWalkers
-class NextTerminalAfterAtLeastOneSepWalker extends AbstractNextTerminalAfterProductionWalker {
-    walkAtLeastOneSep(atleastOneSepProd, currRest, prevRest) {
-        if (atleastOneSepProd.idx === this.occurrence) {
-            const firstAfterfirstAfterAtLeastOneSep = head(currRest.concat(prevRest));
-            this.result.isEndOfRule = firstAfterfirstAfterAtLeastOneSep === undefined;
-            if (firstAfterfirstAfterAtLeastOneSep instanceof Terminal) {
-                this.result.token = firstAfterfirstAfterAtLeastOneSep.terminalType;
-                this.result.occurrence = firstAfterfirstAfterAtLeastOneSep.idx;
-            }
-        }
-        else {
-            super.walkAtLeastOneSep(atleastOneSepProd, currRest, prevRest);
-        }
-    }
-}
-function possiblePathsFrom(targetDef, maxLength, currPath = []) {
-    // avoid side effects
-    currPath = clone(currPath);
-    let result = [];
-    let i = 0;
-    // TODO: avoid inner funcs
-    function remainingPathWith(nextDef) {
-        return nextDef.concat(drop(targetDef, i + 1));
-    }
-    // TODO: avoid inner funcs
-    function getAlternativesForProd(definition) {
-        const alternatives = possiblePathsFrom(remainingPathWith(definition), maxLength, currPath);
-        return result.concat(alternatives);
-    }
-    /**
-     * Mandatory productions will halt the loop as the paths computed from their recursive calls will already contain the
-     * following (rest) of the targetDef.
-     *
-     * For optional productions (Option/Repetition/...) the loop will continue to represent the paths that do not include the
-     * the optional production.
-     */
-    while (currPath.length < maxLength && i < targetDef.length) {
-        const prod = targetDef[i];
-        /* istanbul ignore else */
-        if (prod instanceof Alternative) {
-            return getAlternativesForProd(prod.definition);
-        }
-        else if (prod instanceof NonTerminal) {
-            return getAlternativesForProd(prod.definition);
-        }
-        else if (prod instanceof Option) {
-            result = getAlternativesForProd(prod.definition);
-        }
-        else if (prod instanceof RepetitionMandatory) {
-            const newDef = prod.definition.concat([
-                new Repetition({
-                    definition: prod.definition,
-                }),
-            ]);
-            return getAlternativesForProd(newDef);
-        }
-        else if (prod instanceof RepetitionMandatoryWithSeparator) {
-            const newDef = [
-                new Alternative({ definition: prod.definition }),
-                new Repetition({
-                    definition: [new Terminal({ terminalType: prod.separator })].concat(prod.definition),
-                }),
-            ];
-            return getAlternativesForProd(newDef);
-        }
-        else if (prod instanceof RepetitionWithSeparator) {
-            const newDef = prod.definition.concat([
-                new Repetition({
-                    definition: [new Terminal({ terminalType: prod.separator })].concat(prod.definition),
-                }),
-            ]);
-            result = getAlternativesForProd(newDef);
-        }
-        else if (prod instanceof Repetition) {
-            const newDef = prod.definition.concat([
-                new Repetition({
-                    definition: prod.definition,
-                }),
-            ]);
-            result = getAlternativesForProd(newDef);
-        }
-        else if (prod instanceof Alternation) {
-            forEach(prod.definition, (currAlt) => {
-                // TODO: this is a limited check for empty alternatives
-                //   It would prevent a common case of infinite loops during parser initialization.
-                //   However **in-directly** empty alternatives may still cause issues.
-                if (isEmpty(currAlt.definition) === false) {
-                    result = getAlternativesForProd(currAlt.definition);
-                }
-            });
-            return result;
-        }
-        else if (prod instanceof Terminal) {
-            currPath.push(prod.terminalType);
-        }
-        else {
-            throw Error("non exhaustive match");
-        }
-        i++;
-    }
-    result.push({
-        partialPath: currPath,
-        suffixDef: drop(targetDef, i),
-    });
-    return result;
-}
-function nextPossibleTokensAfter(initialDef, tokenVector, tokMatcher, maxLookAhead) {
-    const EXIT_NON_TERMINAL = "EXIT_NONE_TERMINAL";
-    // to avoid creating a new Array each time.
-    const EXIT_NON_TERMINAL_ARR = [EXIT_NON_TERMINAL];
-    const EXIT_ALTERNATIVE = "EXIT_ALTERNATIVE";
-    let foundCompletePath = false;
-    const tokenVectorLength = tokenVector.length;
-    const minimalAlternativesIndex = tokenVectorLength - maxLookAhead - 1;
-    const result = [];
-    const possiblePaths = [];
-    possiblePaths.push({
-        idx: -1,
-        def: initialDef,
-        ruleStack: [],
-        occurrenceStack: [],
-    });
-    while (!isEmpty(possiblePaths)) {
-        const currPath = possiblePaths.pop();
-        // skip alternatives if no more results can be found (assuming deterministic grammar with fixed lookahead)
-        if (currPath === EXIT_ALTERNATIVE) {
-            if (foundCompletePath &&
-                last(possiblePaths).idx <= minimalAlternativesIndex) {
-                // remove irrelevant alternative
-                possiblePaths.pop();
-            }
-            continue;
-        }
-        const currDef = currPath.def;
-        const currIdx = currPath.idx;
-        const currRuleStack = currPath.ruleStack;
-        const currOccurrenceStack = currPath.occurrenceStack;
-        // For Example: an empty path could exist in a valid grammar in the case of an EMPTY_ALT
-        if (isEmpty(currDef)) {
-            continue;
-        }
-        const prod = currDef[0];
-        /* istanbul ignore else */
-        if (prod === EXIT_NON_TERMINAL) {
-            const nextPath = {
-                idx: currIdx,
-                def: drop(currDef),
-                ruleStack: dropRight(currRuleStack),
-                occurrenceStack: dropRight(currOccurrenceStack),
-            };
-            possiblePaths.push(nextPath);
-        }
-        else if (prod instanceof Terminal) {
-            /* istanbul ignore else */
-            if (currIdx < tokenVectorLength - 1) {
-                const nextIdx = currIdx + 1;
-                const actualToken = tokenVector[nextIdx];
-                if (tokMatcher(actualToken, prod.terminalType)) {
-                    const nextPath = {
-                        idx: nextIdx,
-                        def: drop(currDef),
-                        ruleStack: currRuleStack,
-                        occurrenceStack: currOccurrenceStack,
-                    };
-                    possiblePaths.push(nextPath);
-                }
-                // end of the line
-            }
-            else if (currIdx === tokenVectorLength - 1) {
-                // IGNORE ABOVE ELSE
-                result.push({
-                    nextTokenType: prod.terminalType,
-                    nextTokenOccurrence: prod.idx,
-                    ruleStack: currRuleStack,
-                    occurrenceStack: currOccurrenceStack,
-                });
-                foundCompletePath = true;
-            }
-            else {
-                throw Error("non exhaustive match");
-            }
-        }
-        else if (prod instanceof NonTerminal) {
-            const newRuleStack = clone(currRuleStack);
-            newRuleStack.push(prod.nonTerminalName);
-            const newOccurrenceStack = clone(currOccurrenceStack);
-            newOccurrenceStack.push(prod.idx);
-            const nextPath = {
-                idx: currIdx,
-                def: prod.definition.concat(EXIT_NON_TERMINAL_ARR, drop(currDef)),
-                ruleStack: newRuleStack,
-                occurrenceStack: newOccurrenceStack,
-            };
-            possiblePaths.push(nextPath);
-        }
-        else if (prod instanceof Option) {
-            // the order of alternatives is meaningful, FILO (Last path will be traversed first).
-            const nextPathWithout = {
-                idx: currIdx,
-                def: drop(currDef),
-                ruleStack: currRuleStack,
-                occurrenceStack: currOccurrenceStack,
-            };
-            possiblePaths.push(nextPathWithout);
-            // required marker to avoid backtracking paths whose higher priority alternatives already matched
-            possiblePaths.push(EXIT_ALTERNATIVE);
-            const nextPathWith = {
-                idx: currIdx,
-                def: prod.definition.concat(drop(currDef)),
-                ruleStack: currRuleStack,
-                occurrenceStack: currOccurrenceStack,
-            };
-            possiblePaths.push(nextPathWith);
-        }
-        else if (prod instanceof RepetitionMandatory) {
-            // TODO:(THE NEW operators here take a while...) (convert once?)
-            const secondIteration = new Repetition({
-                definition: prod.definition,
-                idx: prod.idx,
-            });
-            const nextDef = prod.definition.concat([secondIteration], drop(currDef));
-            const nextPath = {
-                idx: currIdx,
-                def: nextDef,
-                ruleStack: currRuleStack,
-                occurrenceStack: currOccurrenceStack,
-            };
-            possiblePaths.push(nextPath);
-        }
-        else if (prod instanceof RepetitionMandatoryWithSeparator) {
-            // TODO:(THE NEW operators here take a while...) (convert once?)
-            const separatorGast = new Terminal({
-                terminalType: prod.separator,
-            });
-            const secondIteration = new Repetition({
-                definition: [separatorGast].concat(prod.definition),
-                idx: prod.idx,
-            });
-            const nextDef = prod.definition.concat([secondIteration], drop(currDef));
-            const nextPath = {
-                idx: currIdx,
-                def: nextDef,
-                ruleStack: currRuleStack,
-                occurrenceStack: currOccurrenceStack,
-            };
-            possiblePaths.push(nextPath);
-        }
-        else if (prod instanceof RepetitionWithSeparator) {
-            // the order of alternatives is meaningful, FILO (Last path will be traversed first).
-            const nextPathWithout = {
-                idx: currIdx,
-                def: drop(currDef),
-                ruleStack: currRuleStack,
-                occurrenceStack: currOccurrenceStack,
-            };
-            possiblePaths.push(nextPathWithout);
-            // required marker to avoid backtracking paths whose higher priority alternatives already matched
-            possiblePaths.push(EXIT_ALTERNATIVE);
-            const separatorGast = new Terminal({
-                terminalType: prod.separator,
-            });
-            const nthRepetition = new Repetition({
-                definition: [separatorGast].concat(prod.definition),
-                idx: prod.idx,
-            });
-            const nextDef = prod.definition.concat([nthRepetition], drop(currDef));
-            const nextPathWith = {
-                idx: currIdx,
-                def: nextDef,
-                ruleStack: currRuleStack,
-                occurrenceStack: currOccurrenceStack,
-            };
-            possiblePaths.push(nextPathWith);
-        }
-        else if (prod instanceof Repetition) {
-            // the order of alternatives is meaningful, FILO (Last path will be traversed first).
-            const nextPathWithout = {
-                idx: currIdx,
-                def: drop(currDef),
-                ruleStack: currRuleStack,
-                occurrenceStack: currOccurrenceStack,
-            };
-            possiblePaths.push(nextPathWithout);
-            // required marker to avoid backtracking paths whose higher priority alternatives already matched
-            possiblePaths.push(EXIT_ALTERNATIVE);
-            // TODO: an empty repetition will cause infinite loops here, will the parser detect this in selfAnalysis?
-            const nthRepetition = new Repetition({
-                definition: prod.definition,
-                idx: prod.idx,
-            });
-            const nextDef = prod.definition.concat([nthRepetition], drop(currDef));
-            const nextPathWith = {
-                idx: currIdx,
-                def: nextDef,
-                ruleStack: currRuleStack,
-                occurrenceStack: currOccurrenceStack,
-            };
-            possiblePaths.push(nextPathWith);
-        }
-        else if (prod instanceof Alternation) {
-            // the order of alternatives is meaningful, FILO (Last path will be traversed first).
-            for (let i = prod.definition.length - 1; i >= 0; i--) {
-                const currAlt = prod.definition[i];
-                const currAltPath = {
-                    idx: currIdx,
-                    def: currAlt.definition.concat(drop(currDef)),
-                    ruleStack: currRuleStack,
-                    occurrenceStack: currOccurrenceStack,
-                };
-                possiblePaths.push(currAltPath);
-                possiblePaths.push(EXIT_ALTERNATIVE);
-            }
-        }
-        else if (prod instanceof Alternative) {
-            possiblePaths.push({
-                idx: currIdx,
-                def: prod.definition.concat(drop(currDef)),
-                ruleStack: currRuleStack,
-                occurrenceStack: currOccurrenceStack,
-            });
-        }
-        else if (prod instanceof Rule) {
-            // last because we should only encounter at most a single one of these per invocation.
-            possiblePaths.push(expandTopLevelRule(prod, currIdx, currRuleStack, currOccurrenceStack));
-        }
-        else {
-            throw Error("non exhaustive match");
-        }
-    }
-    return result;
-}
-function expandTopLevelRule(topRule, currIdx, currRuleStack, currOccurrenceStack) {
-    const newRuleStack = clone(currRuleStack);
-    newRuleStack.push(topRule.name);
-    const newCurrOccurrenceStack = clone(currOccurrenceStack);
-    // top rule is always assumed to have been called with occurrence index 1
-    newCurrOccurrenceStack.push(1);
-    return {
-        idx: currIdx,
-        def: topRule.definition,
-        ruleStack: newRuleStack,
-        occurrenceStack: newCurrOccurrenceStack,
-    };
-}
-
-export { AbstractNextPossibleTokensWalker, AbstractNextTerminalAfterProductionWalker, NextAfterTokenWalker, NextTerminalAfterAtLeastOneSepWalker, NextTerminalAfterAtLeastOneWalker, NextTerminalAfterManySepWalker, NextTerminalAfterManyWalker, nextPossibleTokensAfter, possiblePathsFrom };

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

@@ -1,33 +0,0 @@
-'use strict';
-
-// Lookahead keys are 32Bit integers in the form
-// TTTTTTTT-ZZZZZZZZZZZZ-YYYY-XXXXXXXX
-// XXXX -> Occurrence Index bitmap.
-// YYYY -> DSL Method Type bitmap.
-// ZZZZZZZZZZZZZZZ -> Rule short Index bitmap.
-// TTTTTTTTT -> alternation alternative index bitmap
-const BITS_FOR_METHOD_TYPE = 4;
-const BITS_FOR_OCCURRENCE_IDX = 8;
-// short string used as part of mapping keys.
-// being short improves the performance when composing KEYS for maps out of these
-// The 5 - 8 bits (16 possible values, are reserved for the DSL method indices)
-const OR_IDX = 1 << BITS_FOR_OCCURRENCE_IDX;
-const OPTION_IDX = 2 << BITS_FOR_OCCURRENCE_IDX;
-const MANY_IDX = 3 << BITS_FOR_OCCURRENCE_IDX;
-const AT_LEAST_ONE_IDX = 4 << BITS_FOR_OCCURRENCE_IDX;
-const MANY_SEP_IDX = 5 << BITS_FOR_OCCURRENCE_IDX;
-const AT_LEAST_ONE_SEP_IDX = 6 << BITS_FOR_OCCURRENCE_IDX;
-// this actually returns a number, but it is always used as a string (object prop key)
-function getKeyForAutomaticLookahead(ruleIdx, dslMethodIdx, occurrence) {
-    return occurrence | dslMethodIdx | ruleIdx;
-}
-
-exports.AT_LEAST_ONE_IDX = AT_LEAST_ONE_IDX;
-exports.AT_LEAST_ONE_SEP_IDX = AT_LEAST_ONE_SEP_IDX;
-exports.BITS_FOR_METHOD_TYPE = BITS_FOR_METHOD_TYPE;
-exports.BITS_FOR_OCCURRENCE_IDX = BITS_FOR_OCCURRENCE_IDX;
-exports.MANY_IDX = MANY_IDX;
-exports.MANY_SEP_IDX = MANY_SEP_IDX;
-exports.OPTION_IDX = OPTION_IDX;
-exports.OR_IDX = OR_IDX;
-exports.getKeyForAutomaticLookahead = getKeyForAutomaticLookahead;

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

@@ -1,23 +0,0 @@
-// Lookahead keys are 32Bit integers in the form
-// TTTTTTTT-ZZZZZZZZZZZZ-YYYY-XXXXXXXX
-// XXXX -> Occurrence Index bitmap.
-// YYYY -> DSL Method Type bitmap.
-// ZZZZZZZZZZZZZZZ -> Rule short Index bitmap.
-// TTTTTTTTT -> alternation alternative index bitmap
-const BITS_FOR_METHOD_TYPE = 4;
-const BITS_FOR_OCCURRENCE_IDX = 8;
-// short string used as part of mapping keys.
-// being short improves the performance when composing KEYS for maps out of these
-// The 5 - 8 bits (16 possible values, are reserved for the DSL method indices)
-const OR_IDX = 1 << BITS_FOR_OCCURRENCE_IDX;
-const OPTION_IDX = 2 << BITS_FOR_OCCURRENCE_IDX;
-const MANY_IDX = 3 << BITS_FOR_OCCURRENCE_IDX;
-const AT_LEAST_ONE_IDX = 4 << BITS_FOR_OCCURRENCE_IDX;
-const MANY_SEP_IDX = 5 << BITS_FOR_OCCURRENCE_IDX;
-const AT_LEAST_ONE_SEP_IDX = 6 << BITS_FOR_OCCURRENCE_IDX;
-// this actually returns a number, but it is always used as a string (object prop key)
-function getKeyForAutomaticLookahead(ruleIdx, dslMethodIdx, occurrence) {
-    return occurrence | dslMethodIdx | ruleIdx;
-}
-
-export { AT_LEAST_ONE_IDX, AT_LEAST_ONE_SEP_IDX, BITS_FOR_METHOD_TYPE, BITS_FOR_OCCURRENCE_IDX, MANY_IDX, MANY_SEP_IDX, OPTION_IDX, OR_IDX, getKeyForAutomaticLookahead };

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

@@ -1,52 +0,0 @@
-'use strict';
-
-var errors_public = require('../errors_public.js');
-var parser = require('../parser/parser.js');
-var checks = require('./checks.js');
-var lookahead = require('./lookahead.js');
-var isEmpty = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/isEmpty.js');
-var flatMap = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/flatMap.js');
-
-class LLkLookaheadStrategy {
-    constructor(options) {
-        var _a;
-        this.maxLookahead =
-            (_a = options === null || options === void 0 ? void 0 : options.maxLookahead) !== null && _a !== void 0 ? _a : parser.DEFAULT_PARSER_CONFIG.maxLookahead;
-    }
-    validate(options) {
-        const leftRecursionErrors = this.validateNoLeftRecursion(options.rules);
-        if (isEmpty(leftRecursionErrors)) {
-            const emptyAltErrors = this.validateEmptyOrAlternatives(options.rules);
-            const ambiguousAltsErrors = this.validateAmbiguousAlternationAlternatives(options.rules, this.maxLookahead);
-            const emptyRepetitionErrors = this.validateSomeNonEmptyLookaheadPath(options.rules, this.maxLookahead);
-            const allErrors = [
-                ...leftRecursionErrors,
-                ...emptyAltErrors,
-                ...ambiguousAltsErrors,
-                ...emptyRepetitionErrors,
-            ];
-            return allErrors;
-        }
-        return leftRecursionErrors;
-    }
-    validateNoLeftRecursion(rules) {
-        return flatMap(rules, (currTopRule) => checks.validateNoLeftRecursion(currTopRule, currTopRule, errors_public.defaultGrammarValidatorErrorProvider));
-    }
-    validateEmptyOrAlternatives(rules) {
-        return flatMap(rules, (currTopRule) => checks.validateEmptyOrAlternative(currTopRule, errors_public.defaultGrammarValidatorErrorProvider));
-    }
-    validateAmbiguousAlternationAlternatives(rules, maxLookahead) {
-        return flatMap(rules, (currTopRule) => checks.validateAmbiguousAlternationAlternatives(currTopRule, maxLookahead, errors_public.defaultGrammarValidatorErrorProvider));
-    }
-    validateSomeNonEmptyLookaheadPath(rules, maxLookahead) {
-        return checks.validateSomeNonEmptyLookaheadPath(rules, maxLookahead, errors_public.defaultGrammarValidatorErrorProvider);
-    }
-    buildLookaheadForAlternation(options) {
-        return lookahead.buildLookaheadFuncForOr(options.prodOccurrence, options.rule, options.maxLookahead, options.hasPredicates, options.dynamicTokensEnabled, lookahead.buildAlternativesLookAheadFunc);
-    }
-    buildLookaheadForOptional(options) {
-        return lookahead.buildLookaheadFuncForOptionalProd(options.prodOccurrence, options.rule, options.maxLookahead, options.dynamicTokensEnabled, lookahead.getProdType(options.prodType), lookahead.buildSingleAlternativeLookaheadFunction);
-    }
-}
-
-exports.LLkLookaheadStrategy = LLkLookaheadStrategy;

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

@@ -1,50 +0,0 @@
-import { defaultGrammarValidatorErrorProvider } from '../errors_public.mjs';
-import { DEFAULT_PARSER_CONFIG } from '../parser/parser.mjs';
-import { validateSomeNonEmptyLookaheadPath, validateNoLeftRecursion, validateEmptyOrAlternative, validateAmbiguousAlternationAlternatives } from './checks.mjs';
-import { buildLookaheadFuncForOr, buildLookaheadFuncForOptionalProd, getProdType, buildAlternativesLookAheadFunc, buildSingleAlternativeLookaheadFunction } from './lookahead.mjs';
-import isEmpty from '../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/isEmpty.mjs';
-import flatMap from '../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/flatMap.mjs';
-
-class LLkLookaheadStrategy {
-    constructor(options) {
-        var _a;
-        this.maxLookahead =
-            (_a = options === null || options === void 0 ? void 0 : options.maxLookahead) !== null && _a !== void 0 ? _a : DEFAULT_PARSER_CONFIG.maxLookahead;
-    }
-    validate(options) {
-        const leftRecursionErrors = this.validateNoLeftRecursion(options.rules);
-        if (isEmpty(leftRecursionErrors)) {
-            const emptyAltErrors = this.validateEmptyOrAlternatives(options.rules);
-            const ambiguousAltsErrors = this.validateAmbiguousAlternationAlternatives(options.rules, this.maxLookahead);
-            const emptyRepetitionErrors = this.validateSomeNonEmptyLookaheadPath(options.rules, this.maxLookahead);
-            const allErrors = [
-                ...leftRecursionErrors,
-                ...emptyAltErrors,
-                ...ambiguousAltsErrors,
-                ...emptyRepetitionErrors,
-            ];
-            return allErrors;
-        }
-        return leftRecursionErrors;
-    }
-    validateNoLeftRecursion(rules) {
-        return flatMap(rules, (currTopRule) => validateNoLeftRecursion(currTopRule, currTopRule, defaultGrammarValidatorErrorProvider));
-    }
-    validateEmptyOrAlternatives(rules) {
-        return flatMap(rules, (currTopRule) => validateEmptyOrAlternative(currTopRule, defaultGrammarValidatorErrorProvider));
-    }
-    validateAmbiguousAlternationAlternatives(rules, maxLookahead) {
-        return flatMap(rules, (currTopRule) => validateAmbiguousAlternationAlternatives(currTopRule, maxLookahead, defaultGrammarValidatorErrorProvider));
-    }
-    validateSomeNonEmptyLookaheadPath(rules, maxLookahead) {
-        return validateSomeNonEmptyLookaheadPath(rules, maxLookahead, defaultGrammarValidatorErrorProvider);
-    }
-    buildLookaheadForAlternation(options) {
-        return buildLookaheadFuncForOr(options.prodOccurrence, options.rule, options.maxLookahead, options.hasPredicates, options.dynamicTokensEnabled, buildAlternativesLookAheadFunc);
-    }
-    buildLookaheadForOptional(options) {
-        return buildLookaheadFuncForOptionalProd(options.prodOccurrence, options.rule, options.maxLookahead, options.dynamicTokensEnabled, getProdType(options.prodType), buildSingleAlternativeLookaheadFunction);
-    }
-}
-
-export { LLkLookaheadStrategy };