@windrun-huaiin/third-ui 7.0.0 → 7.1.1

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

@@ -0,0 +1,106 @@
+import { NonTerminal, Terminal, Alternative, Option, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Repetition, Alternation } from '../../../../../../../@chevrotain_gast@11.0.3/node_modules/@chevrotain/gast/lib/src/model.mjs';
+import forEach from '../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/forEach.mjs';
+import drop from '../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/drop.mjs';
+
+/**
+ *  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 NonTerminal) {
+                this.walkProdRef(subProd, currRest, prevRest);
+            }
+            else if (subProd instanceof Terminal) {
+                this.walkTerminal(subProd, currRest, prevRest);
+            }
+            else if (subProd instanceof Alternative) {
+                this.walkFlat(subProd, currRest, prevRest);
+            }
+            else if (subProd instanceof Option) {
+                this.walkOption(subProd, currRest, prevRest);
+            }
+            else if (subProd instanceof RepetitionMandatory) {
+                this.walkAtLeastOne(subProd, currRest, prevRest);
+            }
+            else if (subProd instanceof RepetitionMandatoryWithSeparator) {
+                this.walkAtLeastOneSep(subProd, currRest, prevRest);
+            }
+            else if (subProd instanceof RepetitionWithSeparator) {
+                this.walkManySep(subProd, currRest, prevRest);
+            }
+            else if (subProd instanceof Repetition) {
+                this.walkMany(subProd, currRest, prevRest);
+            }
+            else if (subProd instanceof 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 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 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 Alternative({ definition: [alt] });
+            this.walk(prodWrapper, fullOrRest);
+        });
+    }
+}
+function restForRepetitionWithSeparator(repSepProd, currRest, prevRest) {
+    const repSepRest = [
+        new Option({
+            definition: [
+                new Terminal({ terminalType: repSepProd.separator }),
+            ].concat(repSepProd.definition),
+        }),
+    ];
+    const fullRepSepRest = repSepRest.concat(currRest, prevRest);
+    return fullRepSepRest;
+}
+
+export { RestWalker };

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/parser/parser.js

@@ -0,0 +1,208 @@
+'use strict';
+
+var toFastProperties = require('../../../../../../../@chevrotain_utils@11.0.3/node_modules/@chevrotain/utils/lib/src/to-fast-properties.js');
+var follow = require('../grammar/follow.js');
+var tokens_public = require('../../scan/tokens_public.js');
+var errors_public = require('../errors_public.js');
+var gast_resolver_public = require('../grammar/gast/gast_resolver_public.js');
+var recoverable = require('./traits/recoverable.js');
+var looksahead = require('./traits/looksahead.js');
+var tree_builder = require('./traits/tree_builder.js');
+var lexer_adapter = require('./traits/lexer_adapter.js');
+var recognizer_api = require('./traits/recognizer_api.js');
+var recognizer_engine = require('./traits/recognizer_engine.js');
+var error_handler = require('./traits/error_handler.js');
+var context_assist = require('./traits/context_assist.js');
+var gast_recorder = require('./traits/gast_recorder.js');
+var perf_tracer = require('./traits/perf_tracer.js');
+var apply_mixins = require('./utils/apply_mixins.js');
+var checks = require('../grammar/checks.js');
+var clone = require('../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/clone.js');
+var forEach = require('../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/forEach.js');
+var values = require('../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/values.js');
+var isEmpty = require('../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/isEmpty.js');
+var map = require('../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/map.js');
+var has = require('../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/has.js');
+
+const END_OF_FILE = tokens_public.createTokenInstance(tokens_public.EOF, "", NaN, NaN, NaN, NaN, NaN, NaN);
+Object.freeze(END_OF_FILE);
+const DEFAULT_PARSER_CONFIG = Object.freeze({
+    recoveryEnabled: false,
+    maxLookahead: 3,
+    dynamicTokensEnabled: false,
+    outputCst: true,
+    errorMessageProvider: errors_public.defaultParserErrorProvider,
+    nodeLocationTracking: "none",
+    traceInitPerf: false,
+    skipValidations: false,
+});
+const DEFAULT_RULE_CONFIG = Object.freeze({
+    recoveryValueFunc: () => undefined,
+    resyncEnabled: true,
+});
+exports.ParserDefinitionErrorType = void 0;
+(function (ParserDefinitionErrorType) {
+    ParserDefinitionErrorType[ParserDefinitionErrorType["INVALID_RULE_NAME"] = 0] = "INVALID_RULE_NAME";
+    ParserDefinitionErrorType[ParserDefinitionErrorType["DUPLICATE_RULE_NAME"] = 1] = "DUPLICATE_RULE_NAME";
+    ParserDefinitionErrorType[ParserDefinitionErrorType["INVALID_RULE_OVERRIDE"] = 2] = "INVALID_RULE_OVERRIDE";
+    ParserDefinitionErrorType[ParserDefinitionErrorType["DUPLICATE_PRODUCTIONS"] = 3] = "DUPLICATE_PRODUCTIONS";
+    ParserDefinitionErrorType[ParserDefinitionErrorType["UNRESOLVED_SUBRULE_REF"] = 4] = "UNRESOLVED_SUBRULE_REF";
+    ParserDefinitionErrorType[ParserDefinitionErrorType["LEFT_RECURSION"] = 5] = "LEFT_RECURSION";
+    ParserDefinitionErrorType[ParserDefinitionErrorType["NONE_LAST_EMPTY_ALT"] = 6] = "NONE_LAST_EMPTY_ALT";
+    ParserDefinitionErrorType[ParserDefinitionErrorType["AMBIGUOUS_ALTS"] = 7] = "AMBIGUOUS_ALTS";
+    ParserDefinitionErrorType[ParserDefinitionErrorType["CONFLICT_TOKENS_RULES_NAMESPACE"] = 8] = "CONFLICT_TOKENS_RULES_NAMESPACE";
+    ParserDefinitionErrorType[ParserDefinitionErrorType["INVALID_TOKEN_NAME"] = 9] = "INVALID_TOKEN_NAME";
+    ParserDefinitionErrorType[ParserDefinitionErrorType["NO_NON_EMPTY_LOOKAHEAD"] = 10] = "NO_NON_EMPTY_LOOKAHEAD";
+    ParserDefinitionErrorType[ParserDefinitionErrorType["AMBIGUOUS_PREFIX_ALTS"] = 11] = "AMBIGUOUS_PREFIX_ALTS";
+    ParserDefinitionErrorType[ParserDefinitionErrorType["TOO_MANY_ALTS"] = 12] = "TOO_MANY_ALTS";
+    ParserDefinitionErrorType[ParserDefinitionErrorType["CUSTOM_LOOKAHEAD_VALIDATION"] = 13] = "CUSTOM_LOOKAHEAD_VALIDATION";
+})(exports.ParserDefinitionErrorType || (exports.ParserDefinitionErrorType = {}));
+function EMPTY_ALT(value = undefined) {
+    return function () {
+        return value;
+    };
+}
+class Parser {
+    /**
+     *  @deprecated use the **instance** method with the same name instead
+     */
+    static performSelfAnalysis(parserInstance) {
+        throw Error("The **static** `performSelfAnalysis` method has been deprecated." +
+            "\t\nUse the **instance** method with the same name instead.");
+    }
+    performSelfAnalysis() {
+        this.TRACE_INIT("performSelfAnalysis", () => {
+            let defErrorsMsgs;
+            this.selfAnalysisDone = true;
+            const className = this.className;
+            this.TRACE_INIT("toFastProps", () => {
+                // Without this voodoo magic the parser would be x3-x4 slower
+                // It seems it is better to invoke `toFastProperties` **before**
+                // Any manipulations of the `this` object done during the recording phase.
+                toFastProperties.toFastProperties(this);
+            });
+            this.TRACE_INIT("Grammar Recording", () => {
+                try {
+                    this.enableRecording();
+                    // Building the GAST
+                    forEach(this.definedRulesNames, (currRuleName) => {
+                        const wrappedRule = this[currRuleName];
+                        const originalGrammarAction = wrappedRule["originalGrammarAction"];
+                        let recordedRuleGast;
+                        this.TRACE_INIT(`${currRuleName} Rule`, () => {
+                            recordedRuleGast = this.topLevelRuleRecord(currRuleName, originalGrammarAction);
+                        });
+                        this.gastProductionsCache[currRuleName] = recordedRuleGast;
+                    });
+                }
+                finally {
+                    this.disableRecording();
+                }
+            });
+            let resolverErrors = [];
+            this.TRACE_INIT("Grammar Resolving", () => {
+                resolverErrors = gast_resolver_public.resolveGrammar({
+                    rules: values(this.gastProductionsCache),
+                });
+                this.definitionErrors = this.definitionErrors.concat(resolverErrors);
+            });
+            this.TRACE_INIT("Grammar Validations", () => {
+                // only perform additional grammar validations IFF no resolving errors have occurred.
+                // as unresolved grammar may lead to unhandled runtime exceptions in the follow up validations.
+                if (isEmpty(resolverErrors) && this.skipValidations === false) {
+                    const validationErrors = gast_resolver_public.validateGrammar({
+                        rules: values(this.gastProductionsCache),
+                        tokenTypes: values(this.tokensMap),
+                        errMsgProvider: errors_public.defaultGrammarValidatorErrorProvider,
+                        grammarName: className,
+                    });
+                    const lookaheadValidationErrors = checks.validateLookahead({
+                        lookaheadStrategy: this.lookaheadStrategy,
+                        rules: values(this.gastProductionsCache),
+                        tokenTypes: values(this.tokensMap),
+                        grammarName: className,
+                    });
+                    this.definitionErrors = this.definitionErrors.concat(validationErrors, lookaheadValidationErrors);
+                }
+            });
+            // this analysis may fail if the grammar is not perfectly valid
+            if (isEmpty(this.definitionErrors)) {
+                // The results of these computations are not needed unless error recovery is enabled.
+                if (this.recoveryEnabled) {
+                    this.TRACE_INIT("computeAllProdsFollows", () => {
+                        const allFollows = follow.computeAllProdsFollows(values(this.gastProductionsCache));
+                        this.resyncFollows = allFollows;
+                    });
+                }
+                this.TRACE_INIT("ComputeLookaheadFunctions", () => {
+                    var _a, _b;
+                    (_b = (_a = this.lookaheadStrategy).initialize) === null || _b === void 0 ? void 0 : _b.call(_a, {
+                        rules: values(this.gastProductionsCache),
+                    });
+                    this.preComputeLookaheadFunctions(values(this.gastProductionsCache));
+                });
+            }
+            if (!Parser.DEFER_DEFINITION_ERRORS_HANDLING &&
+                !isEmpty(this.definitionErrors)) {
+                defErrorsMsgs = map(this.definitionErrors, (defError) => defError.message);
+                throw new Error(`Parser Definition Errors detected:\n ${defErrorsMsgs.join("\n-------------------------------\n")}`);
+            }
+        });
+    }
+    constructor(tokenVocabulary, config) {
+        this.definitionErrors = [];
+        this.selfAnalysisDone = false;
+        const that = this;
+        that.initErrorHandler(config);
+        that.initLexerAdapter();
+        that.initLooksAhead(config);
+        that.initRecognizerEngine(tokenVocabulary, config);
+        that.initRecoverable(config);
+        that.initTreeBuilder(config);
+        that.initContentAssist();
+        that.initGastRecorder(config);
+        that.initPerformanceTracer(config);
+        if (has(config, "ignoredIssues")) {
+            throw new Error("The <ignoredIssues> IParserConfig property has been deprecated.\n\t" +
+                "Please use the <IGNORE_AMBIGUITIES> flag on the relevant DSL method instead.\n\t" +
+                "See: https://chevrotain.io/docs/guide/resolving_grammar_errors.html#IGNORING_AMBIGUITIES\n\t" +
+                "For further details.");
+        }
+        this.skipValidations = has(config, "skipValidations")
+            ? config.skipValidations // casting assumes the end user passing the correct type
+            : DEFAULT_PARSER_CONFIG.skipValidations;
+    }
+}
+// Set this flag to true if you don't want the Parser to throw error when problems in it's definition are detected.
+// (normally during the parser's constructor).
+// This is a design time flag, it will not affect the runtime error handling of the parser, just design time errors,
+// for example: duplicate rule names, referencing an unresolved subrule, ect...
+// This flag should not be enabled during normal usage, it is used in special situations, for example when
+// needing to display the parser definition errors in some GUI(online playground).
+Parser.DEFER_DEFINITION_ERRORS_HANDLING = false;
+apply_mixins.applyMixins(Parser, [
+    recoverable.Recoverable,
+    looksahead.LooksAhead,
+    tree_builder.TreeBuilder,
+    lexer_adapter.LexerAdapter,
+    recognizer_engine.RecognizerEngine,
+    recognizer_api.RecognizerApi,
+    error_handler.ErrorHandler,
+    context_assist.ContentAssist,
+    gast_recorder.GastRecorder,
+    perf_tracer.PerformanceTracer,
+]);
+class EmbeddedActionsParser extends Parser {
+    constructor(tokenVocabulary, config = DEFAULT_PARSER_CONFIG) {
+        const configClone = clone(config);
+        configClone.outputCst = false;
+        super(tokenVocabulary, configClone);
+    }
+}
+
+exports.DEFAULT_PARSER_CONFIG = DEFAULT_PARSER_CONFIG;
+exports.DEFAULT_RULE_CONFIG = DEFAULT_RULE_CONFIG;
+exports.EMPTY_ALT = EMPTY_ALT;
+exports.END_OF_FILE = END_OF_FILE;
+exports.EmbeddedActionsParser = EmbeddedActionsParser;
+exports.Parser = Parser;

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

@@ -0,0 +1,201 @@
+import { toFastProperties } from '../../../../../../../@chevrotain_utils@11.0.3/node_modules/@chevrotain/utils/lib/src/to-fast-properties.mjs';
+import { computeAllProdsFollows } from '../grammar/follow.mjs';
+import { createTokenInstance, EOF } from '../../scan/tokens_public.mjs';
+import { defaultParserErrorProvider, defaultGrammarValidatorErrorProvider } from '../errors_public.mjs';
+import { resolveGrammar, validateGrammar } from '../grammar/gast/gast_resolver_public.mjs';
+import { Recoverable } from './traits/recoverable.mjs';
+import { LooksAhead } from './traits/looksahead.mjs';
+import { TreeBuilder } from './traits/tree_builder.mjs';
+import { LexerAdapter } from './traits/lexer_adapter.mjs';
+import { RecognizerApi } from './traits/recognizer_api.mjs';
+import { RecognizerEngine } from './traits/recognizer_engine.mjs';
+import { ErrorHandler } from './traits/error_handler.mjs';
+import { ContentAssist } from './traits/context_assist.mjs';
+import { GastRecorder } from './traits/gast_recorder.mjs';
+import { PerformanceTracer } from './traits/perf_tracer.mjs';
+import { applyMixins } from './utils/apply_mixins.mjs';
+import { validateLookahead } from '../grammar/checks.mjs';
+import clone from '../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/clone.mjs';
+import forEach from '../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/forEach.mjs';
+import values from '../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/values.mjs';
+import isEmpty from '../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/isEmpty.mjs';
+import map from '../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/map.mjs';
+import has from '../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/has.mjs';
+
+const END_OF_FILE = createTokenInstance(EOF, "", NaN, NaN, NaN, NaN, NaN, NaN);
+Object.freeze(END_OF_FILE);
+const DEFAULT_PARSER_CONFIG = Object.freeze({
+    recoveryEnabled: false,
+    maxLookahead: 3,
+    dynamicTokensEnabled: false,
+    outputCst: true,
+    errorMessageProvider: defaultParserErrorProvider,
+    nodeLocationTracking: "none",
+    traceInitPerf: false,
+    skipValidations: false,
+});
+const DEFAULT_RULE_CONFIG = Object.freeze({
+    recoveryValueFunc: () => undefined,
+    resyncEnabled: true,
+});
+var ParserDefinitionErrorType;
+(function (ParserDefinitionErrorType) {
+    ParserDefinitionErrorType[ParserDefinitionErrorType["INVALID_RULE_NAME"] = 0] = "INVALID_RULE_NAME";
+    ParserDefinitionErrorType[ParserDefinitionErrorType["DUPLICATE_RULE_NAME"] = 1] = "DUPLICATE_RULE_NAME";
+    ParserDefinitionErrorType[ParserDefinitionErrorType["INVALID_RULE_OVERRIDE"] = 2] = "INVALID_RULE_OVERRIDE";
+    ParserDefinitionErrorType[ParserDefinitionErrorType["DUPLICATE_PRODUCTIONS"] = 3] = "DUPLICATE_PRODUCTIONS";
+    ParserDefinitionErrorType[ParserDefinitionErrorType["UNRESOLVED_SUBRULE_REF"] = 4] = "UNRESOLVED_SUBRULE_REF";
+    ParserDefinitionErrorType[ParserDefinitionErrorType["LEFT_RECURSION"] = 5] = "LEFT_RECURSION";
+    ParserDefinitionErrorType[ParserDefinitionErrorType["NONE_LAST_EMPTY_ALT"] = 6] = "NONE_LAST_EMPTY_ALT";
+    ParserDefinitionErrorType[ParserDefinitionErrorType["AMBIGUOUS_ALTS"] = 7] = "AMBIGUOUS_ALTS";
+    ParserDefinitionErrorType[ParserDefinitionErrorType["CONFLICT_TOKENS_RULES_NAMESPACE"] = 8] = "CONFLICT_TOKENS_RULES_NAMESPACE";
+    ParserDefinitionErrorType[ParserDefinitionErrorType["INVALID_TOKEN_NAME"] = 9] = "INVALID_TOKEN_NAME";
+    ParserDefinitionErrorType[ParserDefinitionErrorType["NO_NON_EMPTY_LOOKAHEAD"] = 10] = "NO_NON_EMPTY_LOOKAHEAD";
+    ParserDefinitionErrorType[ParserDefinitionErrorType["AMBIGUOUS_PREFIX_ALTS"] = 11] = "AMBIGUOUS_PREFIX_ALTS";
+    ParserDefinitionErrorType[ParserDefinitionErrorType["TOO_MANY_ALTS"] = 12] = "TOO_MANY_ALTS";
+    ParserDefinitionErrorType[ParserDefinitionErrorType["CUSTOM_LOOKAHEAD_VALIDATION"] = 13] = "CUSTOM_LOOKAHEAD_VALIDATION";
+})(ParserDefinitionErrorType || (ParserDefinitionErrorType = {}));
+function EMPTY_ALT(value = undefined) {
+    return function () {
+        return value;
+    };
+}
+class Parser {
+    /**
+     *  @deprecated use the **instance** method with the same name instead
+     */
+    static performSelfAnalysis(parserInstance) {
+        throw Error("The **static** `performSelfAnalysis` method has been deprecated." +
+            "\t\nUse the **instance** method with the same name instead.");
+    }
+    performSelfAnalysis() {
+        this.TRACE_INIT("performSelfAnalysis", () => {
+            let defErrorsMsgs;
+            this.selfAnalysisDone = true;
+            const className = this.className;
+            this.TRACE_INIT("toFastProps", () => {
+                // Without this voodoo magic the parser would be x3-x4 slower
+                // It seems it is better to invoke `toFastProperties` **before**
+                // Any manipulations of the `this` object done during the recording phase.
+                toFastProperties(this);
+            });
+            this.TRACE_INIT("Grammar Recording", () => {
+                try {
+                    this.enableRecording();
+                    // Building the GAST
+                    forEach(this.definedRulesNames, (currRuleName) => {
+                        const wrappedRule = this[currRuleName];
+                        const originalGrammarAction = wrappedRule["originalGrammarAction"];
+                        let recordedRuleGast;
+                        this.TRACE_INIT(`${currRuleName} Rule`, () => {
+                            recordedRuleGast = this.topLevelRuleRecord(currRuleName, originalGrammarAction);
+                        });
+                        this.gastProductionsCache[currRuleName] = recordedRuleGast;
+                    });
+                }
+                finally {
+                    this.disableRecording();
+                }
+            });
+            let resolverErrors = [];
+            this.TRACE_INIT("Grammar Resolving", () => {
+                resolverErrors = resolveGrammar({
+                    rules: values(this.gastProductionsCache),
+                });
+                this.definitionErrors = this.definitionErrors.concat(resolverErrors);
+            });
+            this.TRACE_INIT("Grammar Validations", () => {
+                // only perform additional grammar validations IFF no resolving errors have occurred.
+                // as unresolved grammar may lead to unhandled runtime exceptions in the follow up validations.
+                if (isEmpty(resolverErrors) && this.skipValidations === false) {
+                    const validationErrors = validateGrammar({
+                        rules: values(this.gastProductionsCache),
+                        tokenTypes: values(this.tokensMap),
+                        errMsgProvider: defaultGrammarValidatorErrorProvider,
+                        grammarName: className,
+                    });
+                    const lookaheadValidationErrors = validateLookahead({
+                        lookaheadStrategy: this.lookaheadStrategy,
+                        rules: values(this.gastProductionsCache),
+                        tokenTypes: values(this.tokensMap),
+                        grammarName: className,
+                    });
+                    this.definitionErrors = this.definitionErrors.concat(validationErrors, lookaheadValidationErrors);
+                }
+            });
+            // this analysis may fail if the grammar is not perfectly valid
+            if (isEmpty(this.definitionErrors)) {
+                // The results of these computations are not needed unless error recovery is enabled.
+                if (this.recoveryEnabled) {
+                    this.TRACE_INIT("computeAllProdsFollows", () => {
+                        const allFollows = computeAllProdsFollows(values(this.gastProductionsCache));
+                        this.resyncFollows = allFollows;
+                    });
+                }
+                this.TRACE_INIT("ComputeLookaheadFunctions", () => {
+                    var _a, _b;
+                    (_b = (_a = this.lookaheadStrategy).initialize) === null || _b === void 0 ? void 0 : _b.call(_a, {
+                        rules: values(this.gastProductionsCache),
+                    });
+                    this.preComputeLookaheadFunctions(values(this.gastProductionsCache));
+                });
+            }
+            if (!Parser.DEFER_DEFINITION_ERRORS_HANDLING &&
+                !isEmpty(this.definitionErrors)) {
+                defErrorsMsgs = map(this.definitionErrors, (defError) => defError.message);
+                throw new Error(`Parser Definition Errors detected:\n ${defErrorsMsgs.join("\n-------------------------------\n")}`);
+            }
+        });
+    }
+    constructor(tokenVocabulary, config) {
+        this.definitionErrors = [];
+        this.selfAnalysisDone = false;
+        const that = this;
+        that.initErrorHandler(config);
+        that.initLexerAdapter();
+        that.initLooksAhead(config);
+        that.initRecognizerEngine(tokenVocabulary, config);
+        that.initRecoverable(config);
+        that.initTreeBuilder(config);
+        that.initContentAssist();
+        that.initGastRecorder(config);
+        that.initPerformanceTracer(config);
+        if (has(config, "ignoredIssues")) {
+            throw new Error("The <ignoredIssues> IParserConfig property has been deprecated.\n\t" +
+                "Please use the <IGNORE_AMBIGUITIES> flag on the relevant DSL method instead.\n\t" +
+                "See: https://chevrotain.io/docs/guide/resolving_grammar_errors.html#IGNORING_AMBIGUITIES\n\t" +
+                "For further details.");
+        }
+        this.skipValidations = has(config, "skipValidations")
+            ? config.skipValidations // casting assumes the end user passing the correct type
+            : DEFAULT_PARSER_CONFIG.skipValidations;
+    }
+}
+// Set this flag to true if you don't want the Parser to throw error when problems in it's definition are detected.
+// (normally during the parser's constructor).
+// This is a design time flag, it will not affect the runtime error handling of the parser, just design time errors,
+// for example: duplicate rule names, referencing an unresolved subrule, ect...
+// This flag should not be enabled during normal usage, it is used in special situations, for example when
+// needing to display the parser definition errors in some GUI(online playground).
+Parser.DEFER_DEFINITION_ERRORS_HANDLING = false;
+applyMixins(Parser, [
+    Recoverable,
+    LooksAhead,
+    TreeBuilder,
+    LexerAdapter,
+    RecognizerEngine,
+    RecognizerApi,
+    ErrorHandler,
+    ContentAssist,
+    GastRecorder,
+    PerformanceTracer,
+]);
+class EmbeddedActionsParser extends Parser {
+    constructor(tokenVocabulary, config = DEFAULT_PARSER_CONFIG) {
+        const configClone = clone(config);
+        configClone.outputCst = false;
+        super(tokenVocabulary, configClone);
+    }
+}
+
+export { DEFAULT_PARSER_CONFIG, DEFAULT_RULE_CONFIG, EMPTY_ALT, END_OF_FILE, EmbeddedActionsParser, Parser, ParserDefinitionErrorType };

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/parser/traits/context_assist.js

@@ -0,0 +1,27 @@
+'use strict';
+
+var interpreter = require('../../grammar/interpreter.js');
+var isUndefined = require('../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/isUndefined.js');
+var head = require('../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/head.js');
+
+class ContentAssist {
+    initContentAssist() { }
+    computeContentAssist(startRuleName, precedingInput) {
+        const startRuleGast = this.gastProductionsCache[startRuleName];
+        if (isUndefined(startRuleGast)) {
+            throw Error(`Rule ->${startRuleName}<- does not exist in this grammar.`);
+        }
+        return interpreter.nextPossibleTokensAfter([startRuleGast], precedingInput, this.tokenMatcher, this.maxLookahead);
+    }
+    // TODO: should this be a member method or a utility? it does not have any state or usage of 'this'...
+    // TODO: should this be more explicitly part of the public API?
+    getNextPossibleTokenTypes(grammarPath) {
+        const topRuleName = head(grammarPath.ruleStack);
+        const gastProductions = this.getGAstProductions();
+        const topProduction = gastProductions[topRuleName];
+        const nextPossibleTokenTypes = new interpreter.NextAfterTokenWalker(topProduction, grammarPath).startWalking();
+        return nextPossibleTokenTypes;
+    }
+}
+
+exports.ContentAssist = ContentAssist;

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/parser/traits/context_assist.mjs

@@ -0,0 +1,25 @@
+import { nextPossibleTokensAfter, NextAfterTokenWalker } from '../../grammar/interpreter.mjs';
+import isUndefined from '../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/isUndefined.mjs';
+import head from '../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/head.mjs';
+
+class ContentAssist {
+    initContentAssist() { }
+    computeContentAssist(startRuleName, precedingInput) {
+        const startRuleGast = this.gastProductionsCache[startRuleName];
+        if (isUndefined(startRuleGast)) {
+            throw Error(`Rule ->${startRuleName}<- does not exist in this grammar.`);
+        }
+        return nextPossibleTokensAfter([startRuleGast], precedingInput, this.tokenMatcher, this.maxLookahead);
+    }
+    // TODO: should this be a member method or a utility? it does not have any state or usage of 'this'...
+    // TODO: should this be more explicitly part of the public API?
+    getNextPossibleTokenTypes(grammarPath) {
+        const topRuleName = head(grammarPath.ruleStack);
+        const gastProductions = this.getGAstProductions();
+        const topProduction = gastProductions[topRuleName];
+        const nextPossibleTokenTypes = new NextAfterTokenWalker(topProduction, grammarPath).startWalking();
+        return nextPossibleTokenTypes;
+    }
+}
+
+export { ContentAssist };

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/parser/traits/error_handler.js

@@ -0,0 +1,79 @@
+'use strict';
+
+var exceptions_public = require('../../exceptions_public.js');
+var lookahead = require('../../grammar/lookahead.js');
+var parser = require('../parser.js');
+var has = require('../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/has.js');
+var clone = require('../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/clone.js');
+
+/**
+ * Trait responsible for runtime parsing errors.
+ */
+class ErrorHandler {
+    initErrorHandler(config) {
+        this._errors = [];
+        this.errorMessageProvider = has(config, "errorMessageProvider")
+            ? config.errorMessageProvider // assumes end user provides the correct config value/type
+            : parser.DEFAULT_PARSER_CONFIG.errorMessageProvider;
+    }
+    SAVE_ERROR(error) {
+        if (exceptions_public.isRecognitionException(error)) {
+            error.context = {
+                ruleStack: this.getHumanReadableRuleStack(),
+                ruleOccurrenceStack: clone(this.RULE_OCCURRENCE_STACK),
+            };
+            this._errors.push(error);
+            return error;
+        }
+        else {
+            throw Error("Trying to save an Error which is not a RecognitionException");
+        }
+    }
+    get errors() {
+        return clone(this._errors);
+    }
+    set errors(newErrors) {
+        this._errors = newErrors;
+    }
+    // TODO: consider caching the error message computed information
+    raiseEarlyExitException(occurrence, prodType, userDefinedErrMsg) {
+        const ruleName = this.getCurrRuleFullName();
+        const ruleGrammar = this.getGAstProductions()[ruleName];
+        const lookAheadPathsPerAlternative = lookahead.getLookaheadPathsForOptionalProd(occurrence, ruleGrammar, prodType, this.maxLookahead);
+        const insideProdPaths = lookAheadPathsPerAlternative[0];
+        const actualTokens = [];
+        for (let i = 1; i <= this.maxLookahead; i++) {
+            actualTokens.push(this.LA(i));
+        }
+        const msg = this.errorMessageProvider.buildEarlyExitMessage({
+            expectedIterationPaths: insideProdPaths,
+            actual: actualTokens,
+            previous: this.LA(0),
+            customUserDescription: userDefinedErrMsg,
+            ruleName: ruleName,
+        });
+        throw this.SAVE_ERROR(new exceptions_public.EarlyExitException(msg, this.LA(1), this.LA(0)));
+    }
+    // TODO: consider caching the error message computed information
+    raiseNoAltException(occurrence, errMsgTypes) {
+        const ruleName = this.getCurrRuleFullName();
+        const ruleGrammar = this.getGAstProductions()[ruleName];
+        // TODO: getLookaheadPathsForOr can be slow for large enough maxLookahead and certain grammars, consider caching ?
+        const lookAheadPathsPerAlternative = lookahead.getLookaheadPathsForOr(occurrence, ruleGrammar, this.maxLookahead);
+        const actualTokens = [];
+        for (let i = 1; i <= this.maxLookahead; i++) {
+            actualTokens.push(this.LA(i));
+        }
+        const previousToken = this.LA(0);
+        const errMsg = this.errorMessageProvider.buildNoViableAltMessage({
+            expectedPathsPerAlt: lookAheadPathsPerAlternative,
+            actual: actualTokens,
+            previous: previousToken,
+            customUserDescription: errMsgTypes,
+            ruleName: this.getCurrRuleFullName(),
+        });
+        throw this.SAVE_ERROR(new exceptions_public.NoViableAltException(errMsg, this.LA(1), previousToken));
+    }
+}
+
+exports.ErrorHandler = ErrorHandler;