@windrun-huaiin/third-ui 13.1.4 → 14.0.0

package/dist/node_modules/.pnpm/chevrotain@11.1.2/node_modules/chevrotain/lib/src/parse/parser/traits/error_handler.mjs

@@ -1,77 +0,0 @@
-import { isRecognitionException, EarlyExitException, NoViableAltException } from '../../exceptions_public.mjs';
-import { getLookaheadPathsForOptionalProd, getLookaheadPathsForOr } from '../../grammar/lookahead.mjs';
-import { DEFAULT_PARSER_CONFIG } from '../parser.mjs';
-import has from '../../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/has.mjs';
-import clone from '../../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/clone.mjs';
-
-/**
- * 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
-            : DEFAULT_PARSER_CONFIG.errorMessageProvider;
-    }
-    SAVE_ERROR(error) {
-        if (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 = 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 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 = 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 NoViableAltException(errMsg, this.LA(1), previousToken));
-    }
-}
-
-export { ErrorHandler };

package/dist/node_modules/.pnpm/chevrotain@11.1.2/node_modules/chevrotain/lib/src/parse/parser/traits/gast_recorder.js

@@ -1,304 +0,0 @@
-'use strict';
-
-var model = require('../../../../../../../../@chevrotain_gast@11.1.2/node_modules/@chevrotain/gast/lib/src/model.js');
-var lexer_public = require('../../../scan/lexer_public.js');
-var tokens = require('../../../scan/tokens.js');
-var tokens_public = require('../../../scan/tokens_public.js');
-var parser = require('../parser.js');
-var keys = require('../../grammar/keys.js');
-var has = require('../../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/has.js');
-var last = require('../../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/last.js');
-var isFunction = require('../../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/isFunction.js');
-var some = require('../../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/some.js');
-var forEach = require('../../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/forEach.js');
-var isArray = require('../../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/isArray.js');
-
-const RECORDING_NULL_OBJECT = {
-    description: "This Object indicates the Parser is during Recording Phase",
-};
-Object.freeze(RECORDING_NULL_OBJECT);
-const HANDLE_SEPARATOR = true;
-const MAX_METHOD_IDX = Math.pow(2, keys.BITS_FOR_OCCURRENCE_IDX) - 1;
-const RFT = tokens_public.createToken({ name: "RECORDING_PHASE_TOKEN", pattern: lexer_public.Lexer.NA });
-tokens.augmentTokenTypes([RFT]);
-const RECORDING_PHASE_TOKEN = tokens_public.createTokenInstance(RFT, "This IToken indicates the Parser is in Recording Phase\n\t" +
-    "" +
-    "See: https://chevrotain.io/docs/guide/internals.html#grammar-recording for details", 
-// Using "-1" instead of NaN (as in EOF) because an actual number is less likely to
-// cause errors if the output of LA or CONSUME would be (incorrectly) used during the recording phase.
--1, -1, -1, -1, -1, -1);
-Object.freeze(RECORDING_PHASE_TOKEN);
-const RECORDING_PHASE_CSTNODE = {
-    name: "This CSTNode indicates the Parser is in Recording Phase\n\t" +
-        "See: https://chevrotain.io/docs/guide/internals.html#grammar-recording for details",
-    children: {},
-};
-/**
- * This trait handles the creation of the GAST structure for Chevrotain Grammars
- */
-class GastRecorder {
-    initGastRecorder(config) {
-        this.recordingProdStack = [];
-        this.RECORDING_PHASE = false;
-    }
-    enableRecording() {
-        this.RECORDING_PHASE = true;
-        this.TRACE_INIT("Enable Recording", () => {
-            /**
-             * Warning Dark Voodoo Magic upcoming!
-             * We are "replacing" the public parsing DSL methods API
-             * With **new** alternative implementations on the Parser **instance**
-             *
-             * So far this is the only way I've found to avoid performance regressions during parsing time.
-             * - Approx 30% performance regression was measured on Chrome 75 Canary when attempting to replace the "internal"
-             *   implementations directly instead.
-             */
-            for (let i = 0; i < 10; i++) {
-                const idx = i > 0 ? i : "";
-                this[`CONSUME${idx}`] = function (arg1, arg2) {
-                    return this.consumeInternalRecord(arg1, i, arg2);
-                };
-                this[`SUBRULE${idx}`] = function (arg1, arg2) {
-                    return this.subruleInternalRecord(arg1, i, arg2);
-                };
-                this[`OPTION${idx}`] = function (arg1) {
-                    return this.optionInternalRecord(arg1, i);
-                };
-                this[`OR${idx}`] = function (arg1) {
-                    return this.orInternalRecord(arg1, i);
-                };
-                this[`MANY${idx}`] = function (arg1) {
-                    this.manyInternalRecord(i, arg1);
-                };
-                this[`MANY_SEP${idx}`] = function (arg1) {
-                    this.manySepFirstInternalRecord(i, arg1);
-                };
-                this[`AT_LEAST_ONE${idx}`] = function (arg1) {
-                    this.atLeastOneInternalRecord(i, arg1);
-                };
-                this[`AT_LEAST_ONE_SEP${idx}`] = function (arg1) {
-                    this.atLeastOneSepFirstInternalRecord(i, arg1);
-                };
-            }
-            // DSL methods with the idx(suffix) as an argument
-            this[`consume`] = function (idx, arg1, arg2) {
-                return this.consumeInternalRecord(arg1, idx, arg2);
-            };
-            this[`subrule`] = function (idx, arg1, arg2) {
-                return this.subruleInternalRecord(arg1, idx, arg2);
-            };
-            this[`option`] = function (idx, arg1) {
-                return this.optionInternalRecord(arg1, idx);
-            };
-            this[`or`] = function (idx, arg1) {
-                return this.orInternalRecord(arg1, idx);
-            };
-            this[`many`] = function (idx, arg1) {
-                this.manyInternalRecord(idx, arg1);
-            };
-            this[`atLeastOne`] = function (idx, arg1) {
-                this.atLeastOneInternalRecord(idx, arg1);
-            };
-            this.ACTION = this.ACTION_RECORD;
-            this.BACKTRACK = this.BACKTRACK_RECORD;
-            this.LA = this.LA_RECORD;
-        });
-    }
-    disableRecording() {
-        this.RECORDING_PHASE = false;
-        // By deleting these **instance** properties, any future invocation
-        // will be deferred to the original methods on the **prototype** object
-        // This seems to get rid of any incorrect optimizations that V8 may
-        // do during the recording phase.
-        this.TRACE_INIT("Deleting Recording methods", () => {
-            const that = this;
-            for (let i = 0; i < 10; i++) {
-                const idx = i > 0 ? i : "";
-                delete that[`CONSUME${idx}`];
-                delete that[`SUBRULE${idx}`];
-                delete that[`OPTION${idx}`];
-                delete that[`OR${idx}`];
-                delete that[`MANY${idx}`];
-                delete that[`MANY_SEP${idx}`];
-                delete that[`AT_LEAST_ONE${idx}`];
-                delete that[`AT_LEAST_ONE_SEP${idx}`];
-            }
-            delete that[`consume`];
-            delete that[`subrule`];
-            delete that[`option`];
-            delete that[`or`];
-            delete that[`many`];
-            delete that[`atLeastOne`];
-            delete that.ACTION;
-            delete that.BACKTRACK;
-            delete that.LA;
-        });
-    }
-    //   Parser methods are called inside an ACTION?
-    //   Maybe try/catch/finally on ACTIONS while disabling the recorders state changes?
-    // @ts-expect-error -- noop place holder
-    ACTION_RECORD(impl) {
-        // NO-OP during recording
-    }
-    // Executing backtracking logic will break our recording logic assumptions
-    BACKTRACK_RECORD(grammarRule, args) {
-        return () => true;
-    }
-    // LA is part of the official API and may be used for custom lookahead logic
-    // by end users who may forget to wrap it in ACTION or inside a GATE
-    LA_RECORD(howMuch) {
-        // We cannot use the RECORD_PHASE_TOKEN here because someone may depend
-        // On LA return EOF at the end of the input so an infinite loop may occur.
-        return parser.END_OF_FILE;
-    }
-    topLevelRuleRecord(name, def) {
-        try {
-            const newTopLevelRule = new model.Rule({ definition: [], name: name });
-            newTopLevelRule.name = name;
-            this.recordingProdStack.push(newTopLevelRule);
-            def.call(this);
-            this.recordingProdStack.pop();
-            return newTopLevelRule;
-        }
-        catch (originalError) {
-            if (originalError.KNOWN_RECORDER_ERROR !== true) {
-                try {
-                    originalError.message =
-                        originalError.message +
-                            '\n\t This error was thrown during the "grammar recording phase" For more info see:\n\t' +
-                            "https://chevrotain.io/docs/guide/internals.html#grammar-recording";
-                }
-                catch (mutabilityError) {
-                    // We may not be able to modify the original error object
-                    throw originalError;
-                }
-            }
-            throw originalError;
-        }
-    }
-    // Implementation of parsing DSL
-    optionInternalRecord(actionORMethodDef, occurrence) {
-        return recordProd.call(this, model.Option, actionORMethodDef, occurrence);
-    }
-    atLeastOneInternalRecord(occurrence, actionORMethodDef) {
-        recordProd.call(this, model.RepetitionMandatory, actionORMethodDef, occurrence);
-    }
-    atLeastOneSepFirstInternalRecord(occurrence, options) {
-        recordProd.call(this, model.RepetitionMandatoryWithSeparator, options, occurrence, HANDLE_SEPARATOR);
-    }
-    manyInternalRecord(occurrence, actionORMethodDef) {
-        recordProd.call(this, model.Repetition, actionORMethodDef, occurrence);
-    }
-    manySepFirstInternalRecord(occurrence, options) {
-        recordProd.call(this, model.RepetitionWithSeparator, options, occurrence, HANDLE_SEPARATOR);
-    }
-    orInternalRecord(altsOrOpts, occurrence) {
-        return recordOrProd.call(this, altsOrOpts, occurrence);
-    }
-    subruleInternalRecord(ruleToCall, occurrence, options) {
-        assertMethodIdxIsValid(occurrence);
-        if (!ruleToCall || has(ruleToCall, "ruleName") === false) {
-            const error = new Error(`<SUBRULE${getIdxSuffix(occurrence)}> argument is invalid` +
-                ` expecting a Parser method reference but got: <${JSON.stringify(ruleToCall)}>` +
-                `\n inside top level rule: <${this.recordingProdStack[0].name}>`);
-            error.KNOWN_RECORDER_ERROR = true;
-            throw error;
-        }
-        const prevProd = last(this.recordingProdStack);
-        const ruleName = ruleToCall.ruleName;
-        const newNoneTerminal = new model.NonTerminal({
-            idx: occurrence,
-            nonTerminalName: ruleName,
-            label: options === null || options === void 0 ? void 0 : options.LABEL,
-            // The resolving of the `referencedRule` property will be done once all the Rule's GASTs have been created
-            referencedRule: undefined,
-        });
-        prevProd.definition.push(newNoneTerminal);
-        return this.outputCst
-            ? RECORDING_PHASE_CSTNODE
-            : RECORDING_NULL_OBJECT;
-    }
-    consumeInternalRecord(tokType, occurrence, options) {
-        assertMethodIdxIsValid(occurrence);
-        if (!tokens.hasShortKeyProperty(tokType)) {
-            const error = new Error(`<CONSUME${getIdxSuffix(occurrence)}> argument is invalid` +
-                ` expecting a TokenType reference but got: <${JSON.stringify(tokType)}>` +
-                `\n inside top level rule: <${this.recordingProdStack[0].name}>`);
-            error.KNOWN_RECORDER_ERROR = true;
-            throw error;
-        }
-        const prevProd = last(this.recordingProdStack);
-        const newNoneTerminal = new model.Terminal({
-            idx: occurrence,
-            terminalType: tokType,
-            label: options === null || options === void 0 ? void 0 : options.LABEL,
-        });
-        prevProd.definition.push(newNoneTerminal);
-        return RECORDING_PHASE_TOKEN;
-    }
-}
-function recordProd(prodConstructor, mainProdArg, occurrence, handleSep = false) {
-    assertMethodIdxIsValid(occurrence);
-    const prevProd = last(this.recordingProdStack);
-    const grammarAction = isFunction(mainProdArg) ? mainProdArg : mainProdArg.DEF;
-    const newProd = new prodConstructor({ definition: [], idx: occurrence });
-    if (handleSep) {
-        newProd.separator = mainProdArg.SEP;
-    }
-    if (has(mainProdArg, "MAX_LOOKAHEAD")) {
-        newProd.maxLookahead = mainProdArg.MAX_LOOKAHEAD;
-    }
-    this.recordingProdStack.push(newProd);
-    grammarAction.call(this);
-    prevProd.definition.push(newProd);
-    this.recordingProdStack.pop();
-    return RECORDING_NULL_OBJECT;
-}
-function recordOrProd(mainProdArg, occurrence) {
-    assertMethodIdxIsValid(occurrence);
-    const prevProd = last(this.recordingProdStack);
-    // Only an array of alternatives
-    const hasOptions = isArray(mainProdArg) === false;
-    const alts = hasOptions === false ? mainProdArg : mainProdArg.DEF;
-    const newOrProd = new model.Alternation({
-        definition: [],
-        idx: occurrence,
-        ignoreAmbiguities: hasOptions && mainProdArg.IGNORE_AMBIGUITIES === true,
-    });
-    if (has(mainProdArg, "MAX_LOOKAHEAD")) {
-        newOrProd.maxLookahead = mainProdArg.MAX_LOOKAHEAD;
-    }
-    const hasPredicates = some(alts, (currAlt) => isFunction(currAlt.GATE));
-    newOrProd.hasPredicates = hasPredicates;
-    prevProd.definition.push(newOrProd);
-    forEach(alts, (currAlt) => {
-        const currAltFlat = new model.Alternative({ definition: [] });
-        newOrProd.definition.push(currAltFlat);
-        if (has(currAlt, "IGNORE_AMBIGUITIES")) {
-            currAltFlat.ignoreAmbiguities = currAlt.IGNORE_AMBIGUITIES; // assumes end user provides the correct config value/type
-        }
-        // **implicit** ignoreAmbiguities due to usage of gate
-        else if (has(currAlt, "GATE")) {
-            currAltFlat.ignoreAmbiguities = true;
-        }
-        this.recordingProdStack.push(currAltFlat);
-        currAlt.ALT.call(this);
-        this.recordingProdStack.pop();
-    });
-    return RECORDING_NULL_OBJECT;
-}
-function getIdxSuffix(idx) {
-    return idx === 0 ? "" : `${idx}`;
-}
-function assertMethodIdxIsValid(idx) {
-    if (idx < 0 || idx > MAX_METHOD_IDX) {
-        const error = new Error(
-        // The stack trace will contain all the needed details
-        `Invalid DSL Method idx value: <${idx}>\n\t` +
-            `Idx value must be a none negative value smaller than ${MAX_METHOD_IDX + 1}`);
-        error.KNOWN_RECORDER_ERROR = true;
-        throw error;
-    }
-}
-
-exports.GastRecorder = GastRecorder;

package/dist/node_modules/.pnpm/chevrotain@11.1.2/node_modules/chevrotain/lib/src/parse/parser/traits/gast_recorder.mjs

@@ -1,302 +0,0 @@
-import { Rule, Option, RepetitionMandatory, RepetitionMandatoryWithSeparator, Repetition, RepetitionWithSeparator, NonTerminal, Terminal, Alternation, Alternative } from '../../../../../../../../@chevrotain_gast@11.1.2/node_modules/@chevrotain/gast/lib/src/model.mjs';
-import { Lexer } from '../../../scan/lexer_public.mjs';
-import { augmentTokenTypes, hasShortKeyProperty } from '../../../scan/tokens.mjs';
-import { createToken, createTokenInstance } from '../../../scan/tokens_public.mjs';
-import { END_OF_FILE } from '../parser.mjs';
-import { BITS_FOR_OCCURRENCE_IDX } from '../../grammar/keys.mjs';
-import has from '../../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/has.mjs';
-import last from '../../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/last.mjs';
-import isFunction from '../../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/isFunction.mjs';
-import some from '../../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/some.mjs';
-import forEach from '../../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/forEach.mjs';
-import isArray from '../../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/isArray.mjs';
-
-const RECORDING_NULL_OBJECT = {
-    description: "This Object indicates the Parser is during Recording Phase",
-};
-Object.freeze(RECORDING_NULL_OBJECT);
-const HANDLE_SEPARATOR = true;
-const MAX_METHOD_IDX = Math.pow(2, BITS_FOR_OCCURRENCE_IDX) - 1;
-const RFT = createToken({ name: "RECORDING_PHASE_TOKEN", pattern: Lexer.NA });
-augmentTokenTypes([RFT]);
-const RECORDING_PHASE_TOKEN = createTokenInstance(RFT, "This IToken indicates the Parser is in Recording Phase\n\t" +
-    "" +
-    "See: https://chevrotain.io/docs/guide/internals.html#grammar-recording for details", 
-// Using "-1" instead of NaN (as in EOF) because an actual number is less likely to
-// cause errors if the output of LA or CONSUME would be (incorrectly) used during the recording phase.
--1, -1, -1, -1, -1, -1);
-Object.freeze(RECORDING_PHASE_TOKEN);
-const RECORDING_PHASE_CSTNODE = {
-    name: "This CSTNode indicates the Parser is in Recording Phase\n\t" +
-        "See: https://chevrotain.io/docs/guide/internals.html#grammar-recording for details",
-    children: {},
-};
-/**
- * This trait handles the creation of the GAST structure for Chevrotain Grammars
- */
-class GastRecorder {
-    initGastRecorder(config) {
-        this.recordingProdStack = [];
-        this.RECORDING_PHASE = false;
-    }
-    enableRecording() {
-        this.RECORDING_PHASE = true;
-        this.TRACE_INIT("Enable Recording", () => {
-            /**
-             * Warning Dark Voodoo Magic upcoming!
-             * We are "replacing" the public parsing DSL methods API
-             * With **new** alternative implementations on the Parser **instance**
-             *
-             * So far this is the only way I've found to avoid performance regressions during parsing time.
-             * - Approx 30% performance regression was measured on Chrome 75 Canary when attempting to replace the "internal"
-             *   implementations directly instead.
-             */
-            for (let i = 0; i < 10; i++) {
-                const idx = i > 0 ? i : "";
-                this[`CONSUME${idx}`] = function (arg1, arg2) {
-                    return this.consumeInternalRecord(arg1, i, arg2);
-                };
-                this[`SUBRULE${idx}`] = function (arg1, arg2) {
-                    return this.subruleInternalRecord(arg1, i, arg2);
-                };
-                this[`OPTION${idx}`] = function (arg1) {
-                    return this.optionInternalRecord(arg1, i);
-                };
-                this[`OR${idx}`] = function (arg1) {
-                    return this.orInternalRecord(arg1, i);
-                };
-                this[`MANY${idx}`] = function (arg1) {
-                    this.manyInternalRecord(i, arg1);
-                };
-                this[`MANY_SEP${idx}`] = function (arg1) {
-                    this.manySepFirstInternalRecord(i, arg1);
-                };
-                this[`AT_LEAST_ONE${idx}`] = function (arg1) {
-                    this.atLeastOneInternalRecord(i, arg1);
-                };
-                this[`AT_LEAST_ONE_SEP${idx}`] = function (arg1) {
-                    this.atLeastOneSepFirstInternalRecord(i, arg1);
-                };
-            }
-            // DSL methods with the idx(suffix) as an argument
-            this[`consume`] = function (idx, arg1, arg2) {
-                return this.consumeInternalRecord(arg1, idx, arg2);
-            };
-            this[`subrule`] = function (idx, arg1, arg2) {
-                return this.subruleInternalRecord(arg1, idx, arg2);
-            };
-            this[`option`] = function (idx, arg1) {
-                return this.optionInternalRecord(arg1, idx);
-            };
-            this[`or`] = function (idx, arg1) {
-                return this.orInternalRecord(arg1, idx);
-            };
-            this[`many`] = function (idx, arg1) {
-                this.manyInternalRecord(idx, arg1);
-            };
-            this[`atLeastOne`] = function (idx, arg1) {
-                this.atLeastOneInternalRecord(idx, arg1);
-            };
-            this.ACTION = this.ACTION_RECORD;
-            this.BACKTRACK = this.BACKTRACK_RECORD;
-            this.LA = this.LA_RECORD;
-        });
-    }
-    disableRecording() {
-        this.RECORDING_PHASE = false;
-        // By deleting these **instance** properties, any future invocation
-        // will be deferred to the original methods on the **prototype** object
-        // This seems to get rid of any incorrect optimizations that V8 may
-        // do during the recording phase.
-        this.TRACE_INIT("Deleting Recording methods", () => {
-            const that = this;
-            for (let i = 0; i < 10; i++) {
-                const idx = i > 0 ? i : "";
-                delete that[`CONSUME${idx}`];
-                delete that[`SUBRULE${idx}`];
-                delete that[`OPTION${idx}`];
-                delete that[`OR${idx}`];
-                delete that[`MANY${idx}`];
-                delete that[`MANY_SEP${idx}`];
-                delete that[`AT_LEAST_ONE${idx}`];
-                delete that[`AT_LEAST_ONE_SEP${idx}`];
-            }
-            delete that[`consume`];
-            delete that[`subrule`];
-            delete that[`option`];
-            delete that[`or`];
-            delete that[`many`];
-            delete that[`atLeastOne`];
-            delete that.ACTION;
-            delete that.BACKTRACK;
-            delete that.LA;
-        });
-    }
-    //   Parser methods are called inside an ACTION?
-    //   Maybe try/catch/finally on ACTIONS while disabling the recorders state changes?
-    // @ts-expect-error -- noop place holder
-    ACTION_RECORD(impl) {
-        // NO-OP during recording
-    }
-    // Executing backtracking logic will break our recording logic assumptions
-    BACKTRACK_RECORD(grammarRule, args) {
-        return () => true;
-    }
-    // LA is part of the official API and may be used for custom lookahead logic
-    // by end users who may forget to wrap it in ACTION or inside a GATE
-    LA_RECORD(howMuch) {
-        // We cannot use the RECORD_PHASE_TOKEN here because someone may depend
-        // On LA return EOF at the end of the input so an infinite loop may occur.
-        return END_OF_FILE;
-    }
-    topLevelRuleRecord(name, def) {
-        try {
-            const newTopLevelRule = new Rule({ definition: [], name: name });
-            newTopLevelRule.name = name;
-            this.recordingProdStack.push(newTopLevelRule);
-            def.call(this);
-            this.recordingProdStack.pop();
-            return newTopLevelRule;
-        }
-        catch (originalError) {
-            if (originalError.KNOWN_RECORDER_ERROR !== true) {
-                try {
-                    originalError.message =
-                        originalError.message +
-                            '\n\t This error was thrown during the "grammar recording phase" For more info see:\n\t' +
-                            "https://chevrotain.io/docs/guide/internals.html#grammar-recording";
-                }
-                catch (mutabilityError) {
-                    // We may not be able to modify the original error object
-                    throw originalError;
-                }
-            }
-            throw originalError;
-        }
-    }
-    // Implementation of parsing DSL
-    optionInternalRecord(actionORMethodDef, occurrence) {
-        return recordProd.call(this, Option, actionORMethodDef, occurrence);
-    }
-    atLeastOneInternalRecord(occurrence, actionORMethodDef) {
-        recordProd.call(this, RepetitionMandatory, actionORMethodDef, occurrence);
-    }
-    atLeastOneSepFirstInternalRecord(occurrence, options) {
-        recordProd.call(this, RepetitionMandatoryWithSeparator, options, occurrence, HANDLE_SEPARATOR);
-    }
-    manyInternalRecord(occurrence, actionORMethodDef) {
-        recordProd.call(this, Repetition, actionORMethodDef, occurrence);
-    }
-    manySepFirstInternalRecord(occurrence, options) {
-        recordProd.call(this, RepetitionWithSeparator, options, occurrence, HANDLE_SEPARATOR);
-    }
-    orInternalRecord(altsOrOpts, occurrence) {
-        return recordOrProd.call(this, altsOrOpts, occurrence);
-    }
-    subruleInternalRecord(ruleToCall, occurrence, options) {
-        assertMethodIdxIsValid(occurrence);
-        if (!ruleToCall || has(ruleToCall, "ruleName") === false) {
-            const error = new Error(`<SUBRULE${getIdxSuffix(occurrence)}> argument is invalid` +
-                ` expecting a Parser method reference but got: <${JSON.stringify(ruleToCall)}>` +
-                `\n inside top level rule: <${this.recordingProdStack[0].name}>`);
-            error.KNOWN_RECORDER_ERROR = true;
-            throw error;
-        }
-        const prevProd = last(this.recordingProdStack);
-        const ruleName = ruleToCall.ruleName;
-        const newNoneTerminal = new NonTerminal({
-            idx: occurrence,
-            nonTerminalName: ruleName,
-            label: options === null || options === void 0 ? void 0 : options.LABEL,
-            // The resolving of the `referencedRule` property will be done once all the Rule's GASTs have been created
-            referencedRule: undefined,
-        });
-        prevProd.definition.push(newNoneTerminal);
-        return this.outputCst
-            ? RECORDING_PHASE_CSTNODE
-            : RECORDING_NULL_OBJECT;
-    }
-    consumeInternalRecord(tokType, occurrence, options) {
-        assertMethodIdxIsValid(occurrence);
-        if (!hasShortKeyProperty(tokType)) {
-            const error = new Error(`<CONSUME${getIdxSuffix(occurrence)}> argument is invalid` +
-                ` expecting a TokenType reference but got: <${JSON.stringify(tokType)}>` +
-                `\n inside top level rule: <${this.recordingProdStack[0].name}>`);
-            error.KNOWN_RECORDER_ERROR = true;
-            throw error;
-        }
-        const prevProd = last(this.recordingProdStack);
-        const newNoneTerminal = new Terminal({
-            idx: occurrence,
-            terminalType: tokType,
-            label: options === null || options === void 0 ? void 0 : options.LABEL,
-        });
-        prevProd.definition.push(newNoneTerminal);
-        return RECORDING_PHASE_TOKEN;
-    }
-}
-function recordProd(prodConstructor, mainProdArg, occurrence, handleSep = false) {
-    assertMethodIdxIsValid(occurrence);
-    const prevProd = last(this.recordingProdStack);
-    const grammarAction = isFunction(mainProdArg) ? mainProdArg : mainProdArg.DEF;
-    const newProd = new prodConstructor({ definition: [], idx: occurrence });
-    if (handleSep) {
-        newProd.separator = mainProdArg.SEP;
-    }
-    if (has(mainProdArg, "MAX_LOOKAHEAD")) {
-        newProd.maxLookahead = mainProdArg.MAX_LOOKAHEAD;
-    }
-    this.recordingProdStack.push(newProd);
-    grammarAction.call(this);
-    prevProd.definition.push(newProd);
-    this.recordingProdStack.pop();
-    return RECORDING_NULL_OBJECT;
-}
-function recordOrProd(mainProdArg, occurrence) {
-    assertMethodIdxIsValid(occurrence);
-    const prevProd = last(this.recordingProdStack);
-    // Only an array of alternatives
-    const hasOptions = isArray(mainProdArg) === false;
-    const alts = hasOptions === false ? mainProdArg : mainProdArg.DEF;
-    const newOrProd = new Alternation({
-        definition: [],
-        idx: occurrence,
-        ignoreAmbiguities: hasOptions && mainProdArg.IGNORE_AMBIGUITIES === true,
-    });
-    if (has(mainProdArg, "MAX_LOOKAHEAD")) {
-        newOrProd.maxLookahead = mainProdArg.MAX_LOOKAHEAD;
-    }
-    const hasPredicates = some(alts, (currAlt) => isFunction(currAlt.GATE));
-    newOrProd.hasPredicates = hasPredicates;
-    prevProd.definition.push(newOrProd);
-    forEach(alts, (currAlt) => {
-        const currAltFlat = new Alternative({ definition: [] });
-        newOrProd.definition.push(currAltFlat);
-        if (has(currAlt, "IGNORE_AMBIGUITIES")) {
-            currAltFlat.ignoreAmbiguities = currAlt.IGNORE_AMBIGUITIES; // assumes end user provides the correct config value/type
-        }
-        // **implicit** ignoreAmbiguities due to usage of gate
-        else if (has(currAlt, "GATE")) {
-            currAltFlat.ignoreAmbiguities = true;
-        }
-        this.recordingProdStack.push(currAltFlat);
-        currAlt.ALT.call(this);
-        this.recordingProdStack.pop();
-    });
-    return RECORDING_NULL_OBJECT;
-}
-function getIdxSuffix(idx) {
-    return idx === 0 ? "" : `${idx}`;
-}
-function assertMethodIdxIsValid(idx) {
-    if (idx < 0 || idx > MAX_METHOD_IDX) {
-        const error = new Error(
-        // The stack trace will contain all the needed details
-        `Invalid DSL Method idx value: <${idx}>\n\t` +
-            `Idx value must be a none negative value smaller than ${MAX_METHOD_IDX + 1}`);
-        error.KNOWN_RECORDER_ERROR = true;
-        throw error;
-    }
-}
-
-export { GastRecorder };