@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/gast/gast_resolver_public.js

@@ -0,0 +1,27 @@
+'use strict';
+
+var resolver = require('../resolver.js');
+var checks = require('../checks.js');
+var errors_public = require('../../errors_public.js');
+var defaults = require('../../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/defaults.js');
+var forEach = require('../../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/forEach.js');
+
+function resolveGrammar(options) {
+    const actualOptions = defaults(options, {
+        errMsgProvider: errors_public.defaultGrammarResolverErrorProvider,
+    });
+    const topRulesTable = {};
+    forEach(options.rules, (rule) => {
+        topRulesTable[rule.name] = rule;
+    });
+    return resolver.resolveGrammar(topRulesTable, actualOptions.errMsgProvider);
+}
+function validateGrammar(options) {
+    options = defaults(options, {
+        errMsgProvider: errors_public.defaultGrammarValidatorErrorProvider,
+    });
+    return checks.validateGrammar(options.rules, options.tokenTypes, options.errMsgProvider, options.grammarName);
+}
+
+exports.resolveGrammar = resolveGrammar;
+exports.validateGrammar = validateGrammar;

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

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

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

@@ -0,0 +1,510 @@
+'use strict';
+
+var first = require('./first.js');
+var rest = require('./rest.js');
+var model = require('../../../../../../../@chevrotain_gast@11.1.2/node_modules/@chevrotain/gast/lib/src/model.js');
+var clone = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/clone.js');
+var forEach = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/forEach.js');
+var isEmpty = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/isEmpty.js');
+var drop = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/drop.js');
+var dropRight = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/dropRight.js');
+var last = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/last.js');
+var head = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/head.js');
+
+class AbstractNextPossibleTokensWalker extends rest.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 model.Alternative({ definition: fullRest });
+            this.possibleTokTypes = first.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 rest.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 model.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 model.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 model.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 model.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 model.Alternative) {
+            return getAlternativesForProd(prod.definition);
+        }
+        else if (prod instanceof model.NonTerminal) {
+            return getAlternativesForProd(prod.definition);
+        }
+        else if (prod instanceof model.Option) {
+            result = getAlternativesForProd(prod.definition);
+        }
+        else if (prod instanceof model.RepetitionMandatory) {
+            const newDef = prod.definition.concat([
+                new model.Repetition({
+                    definition: prod.definition,
+                }),
+            ]);
+            return getAlternativesForProd(newDef);
+        }
+        else if (prod instanceof model.RepetitionMandatoryWithSeparator) {
+            const newDef = [
+                new model.Alternative({ definition: prod.definition }),
+                new model.Repetition({
+                    definition: [new model.Terminal({ terminalType: prod.separator })].concat(prod.definition),
+                }),
+            ];
+            return getAlternativesForProd(newDef);
+        }
+        else if (prod instanceof model.RepetitionWithSeparator) {
+            const newDef = prod.definition.concat([
+                new model.Repetition({
+                    definition: [new model.Terminal({ terminalType: prod.separator })].concat(prod.definition),
+                }),
+            ]);
+            result = getAlternativesForProd(newDef);
+        }
+        else if (prod instanceof model.Repetition) {
+            const newDef = prod.definition.concat([
+                new model.Repetition({
+                    definition: prod.definition,
+                }),
+            ]);
+            result = getAlternativesForProd(newDef);
+        }
+        else if (prod instanceof model.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 model.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 model.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 model.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 model.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 model.RepetitionMandatory) {
+            // TODO:(THE NEW operators here take a while...) (convert once?)
+            const secondIteration = new model.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 model.RepetitionMandatoryWithSeparator) {
+            // TODO:(THE NEW operators here take a while...) (convert once?)
+            const separatorGast = new model.Terminal({
+                terminalType: prod.separator,
+            });
+            const secondIteration = new model.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 model.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 model.Terminal({
+                terminalType: prod.separator,
+            });
+            const nthRepetition = new model.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 model.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 model.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 model.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 model.Alternative) {
+            possiblePaths.push({
+                idx: currIdx,
+                def: prod.definition.concat(drop(currDef)),
+                ruleStack: currRuleStack,
+                occurrenceStack: currOccurrenceStack,
+            });
+        }
+        else if (prod instanceof model.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,
+    };
+}
+
+exports.AbstractNextPossibleTokensWalker = AbstractNextPossibleTokensWalker;
+exports.AbstractNextTerminalAfterProductionWalker = AbstractNextTerminalAfterProductionWalker;
+exports.NextAfterTokenWalker = NextAfterTokenWalker;
+exports.NextTerminalAfterAtLeastOneSepWalker = NextTerminalAfterAtLeastOneSepWalker;
+exports.NextTerminalAfterAtLeastOneWalker = NextTerminalAfterAtLeastOneWalker;
+exports.NextTerminalAfterManySepWalker = NextTerminalAfterManySepWalker;
+exports.NextTerminalAfterManyWalker = NextTerminalAfterManyWalker;
+exports.nextPossibleTokensAfter = nextPossibleTokensAfter;
+exports.possiblePathsFrom = possiblePathsFrom;