@windrun-huaiin/third-ui 13.1.3 → 13.1.5

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

@@ -1,106 +0,0 @@
-import { NonTerminal, Terminal, Alternative, Option, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Repetition, Alternation } from '../../../../../../../@chevrotain_gast@11.1.2/node_modules/@chevrotain/gast/lib/src/model.mjs';
-import forEach from '../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/forEach.mjs';
-import drop from '../../../../../../../lodash-es@4.17.23/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.1.2/node_modules/chevrotain/lib/src/parse/parser/parser.js

@@ -1,208 +0,0 @@
-'use strict';
-
-var toFastProperties = require('../../../../../../../@chevrotain_utils@11.1.2/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.23/node_modules/lodash-es/clone.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');
-var isEmpty = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/isEmpty.js');
-var map = require('../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/map.js');
-var has = require('../../../../../../../lodash-es@4.17.23/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, etc...
-// 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.1.2/node_modules/chevrotain/lib/src/parse/parser/parser.mjs

@@ -1,201 +0,0 @@
-import { toFastProperties } from '../../../../../../../@chevrotain_utils@11.1.2/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.23/node_modules/lodash-es/clone.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';
-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 has from '../../../../../../../lodash-es@4.17.23/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, etc...
-// 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.1.2/node_modules/chevrotain/lib/src/parse/parser/traits/context_assist.js

@@ -1,27 +0,0 @@
-'use strict';
-
-var interpreter = require('../../grammar/interpreter.js');
-var isUndefined = require('../../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/isUndefined.js');
-var head = require('../../../../../../../../lodash-es@4.17.23/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.1.2/node_modules/chevrotain/lib/src/parse/parser/traits/context_assist.mjs

@@ -1,25 +0,0 @@
-import { nextPossibleTokensAfter, NextAfterTokenWalker } from '../../grammar/interpreter.mjs';
-import isUndefined from '../../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/isUndefined.mjs';
-import head from '../../../../../../../../lodash-es@4.17.23/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.1.2/node_modules/chevrotain/lib/src/parse/parser/traits/error_handler.js

@@ -1,79 +0,0 @@
-'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.23/node_modules/lodash-es/has.js');
-var clone = require('../../../../../../../../lodash-es@4.17.23/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;