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

@@ -1,555 +0,0 @@
-'use strict';
-
-var keys = require('../../grammar/keys.js');
-var exceptions_public = require('../../exceptions_public.js');
-var lookahead = require('../../grammar/lookahead.js');
-var interpreter = require('../../grammar/interpreter.js');
-var parser = require('../parser.js');
-var recoverable = require('./recoverable.js');
-var tokens_public = require('../../../scan/tokens_public.js');
-var tokens = require('../../../scan/tokens.js');
-var has = require('../../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/has.js');
-var isArray = require('../../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/isArray.js');
-var isEmpty = require('../../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/isEmpty.js');
-var reduce = require('../../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/reduce.js');
-var every = require('../../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/every.js');
-var flatten = require('../../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/flatten.js');
-var values = require('../../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/values.js');
-var uniq = require('../../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/uniq.js');
-var isObject = require('../../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/isObject.js');
-var clone = require('../../../../../../../../lodash-es@4.17.23/node_modules/lodash-es/clone.js');
-
-/**
- * This trait is responsible for the runtime parsing engine
- * Used by the official API (recognizer_api.ts)
- */
-class RecognizerEngine {
-    initRecognizerEngine(tokenVocabulary, config) {
-        this.className = this.constructor.name;
-        // TODO: would using an ES6 Map or plain object be faster (CST building scenario)
-        this.shortRuleNameToFull = {};
-        this.fullRuleNameToShort = {};
-        this.ruleShortNameIdx = 256;
-        this.tokenMatcher = tokens.tokenStructuredMatcherNoCategories;
-        this.subruleIdx = 0;
-        this.definedRulesNames = [];
-        this.tokensMap = {};
-        this.isBackTrackingStack = [];
-        this.RULE_STACK = [];
-        this.RULE_OCCURRENCE_STACK = [];
-        this.gastProductionsCache = {};
-        if (has(config, "serializedGrammar")) {
-            throw Error("The Parser's configuration can no longer contain a <serializedGrammar> property.\n" +
-                "\tSee: https://chevrotain.io/docs/changes/BREAKING_CHANGES.html#_6-0-0\n" +
-                "\tFor Further details.");
-        }
-        if (isArray(tokenVocabulary)) {
-            // This only checks for Token vocabularies provided as arrays.
-            // That is good enough because the main objective is to detect users of pre-V4.0 APIs
-            // rather than all edge cases of empty Token vocabularies.
-            if (isEmpty(tokenVocabulary)) {
-                throw Error("A Token Vocabulary cannot be empty.\n" +
-                    "\tNote that the first argument for the parser constructor\n" +
-                    "\tis no longer a Token vector (since v4.0).");
-            }
-            if (typeof tokenVocabulary[0].startOffset === "number") {
-                throw Error("The Parser constructor no longer accepts a token vector as the first argument.\n" +
-                    "\tSee: https://chevrotain.io/docs/changes/BREAKING_CHANGES.html#_4-0-0\n" +
-                    "\tFor Further details.");
-            }
-        }
-        if (isArray(tokenVocabulary)) {
-            this.tokensMap = reduce(tokenVocabulary, (acc, tokType) => {
-                acc[tokType.name] = tokType;
-                return acc;
-            }, {});
-        }
-        else if (has(tokenVocabulary, "modes") &&
-            every(flatten(values(tokenVocabulary.modes)), tokens.isTokenType)) {
-            const allTokenTypes = flatten(values(tokenVocabulary.modes));
-            const uniqueTokens = uniq(allTokenTypes);
-            this.tokensMap = reduce(uniqueTokens, (acc, tokType) => {
-                acc[tokType.name] = tokType;
-                return acc;
-            }, {});
-        }
-        else if (isObject(tokenVocabulary)) {
-            this.tokensMap = clone(tokenVocabulary);
-        }
-        else {
-            throw new Error("<tokensDictionary> argument must be An Array of Token constructors," +
-                " A dictionary of Token constructors or an IMultiModeLexerDefinition");
-        }
-        // always add EOF to the tokenNames -> constructors map. it is useful to assure all the input has been
-        // parsed with a clear error message ("expecting EOF but found ...")
-        this.tokensMap["EOF"] = tokens_public.EOF;
-        const allTokenTypes = has(tokenVocabulary, "modes")
-            ? flatten(values(tokenVocabulary.modes))
-            : values(tokenVocabulary);
-        const noTokenCategoriesUsed = every(allTokenTypes, (tokenConstructor) => isEmpty(tokenConstructor.categoryMatches));
-        this.tokenMatcher = noTokenCategoriesUsed
-            ? tokens.tokenStructuredMatcherNoCategories
-            : tokens.tokenStructuredMatcher;
-        // Because ES2015+ syntax should be supported for creating Token classes
-        // We cannot assume that the Token classes were created using the "extendToken" utilities
-        // Therefore we must augment the Token classes both on Lexer initialization and on Parser initialization
-        tokens.augmentTokenTypes(values(this.tokensMap));
-    }
-    defineRule(ruleName, impl, config) {
-        if (this.selfAnalysisDone) {
-            throw Error(`Grammar rule <${ruleName}> may not be defined after the 'performSelfAnalysis' method has been called'\n` +
-                `Make sure that all grammar rule definitions are done before 'performSelfAnalysis' is called.`);
-        }
-        const resyncEnabled = has(config, "resyncEnabled")
-            ? config.resyncEnabled // assumes end user provides the correct config value/type
-            : parser.DEFAULT_RULE_CONFIG.resyncEnabled;
-        const recoveryValueFunc = has(config, "recoveryValueFunc")
-            ? config.recoveryValueFunc // assumes end user provides the correct config value/type
-            : parser.DEFAULT_RULE_CONFIG.recoveryValueFunc;
-        // performance optimization: Use small integers as keys for the longer human readable "full" rule names.
-        // this greatly improves Map access time (as much as 8% for some performance benchmarks).
-        const shortName = this.ruleShortNameIdx << (keys.BITS_FOR_METHOD_TYPE + keys.BITS_FOR_OCCURRENCE_IDX);
-        this.ruleShortNameIdx++;
-        this.shortRuleNameToFull[shortName] = ruleName;
-        this.fullRuleNameToShort[ruleName] = shortName;
-        let invokeRuleWithTry;
-        // Micro optimization, only check the condition **once** on rule definition
-        // instead of **every single** rule invocation.
-        if (this.outputCst === true) {
-            invokeRuleWithTry = function invokeRuleWithTry(...args) {
-                try {
-                    this.ruleInvocationStateUpdate(shortName, ruleName, this.subruleIdx);
-                    impl.apply(this, args);
-                    const cst = this.CST_STACK[this.CST_STACK.length - 1];
-                    this.cstPostRule(cst);
-                    return cst;
-                }
-                catch (e) {
-                    return this.invokeRuleCatch(e, resyncEnabled, recoveryValueFunc);
-                }
-                finally {
-                    this.ruleFinallyStateUpdate();
-                }
-            };
-        }
-        else {
-            invokeRuleWithTry = function invokeRuleWithTryCst(...args) {
-                try {
-                    this.ruleInvocationStateUpdate(shortName, ruleName, this.subruleIdx);
-                    return impl.apply(this, args);
-                }
-                catch (e) {
-                    return this.invokeRuleCatch(e, resyncEnabled, recoveryValueFunc);
-                }
-                finally {
-                    this.ruleFinallyStateUpdate();
-                }
-            };
-        }
-        const wrappedGrammarRule = Object.assign(invokeRuleWithTry, { ruleName, originalGrammarAction: impl });
-        return wrappedGrammarRule;
-    }
-    invokeRuleCatch(e, resyncEnabledConfig, recoveryValueFunc) {
-        const isFirstInvokedRule = this.RULE_STACK.length === 1;
-        // note the reSync is always enabled for the first rule invocation, because we must always be able to
-        // reSync with EOF and just output some INVALID ParseTree
-        // during backtracking reSync recovery is disabled, otherwise we can't be certain the backtracking
-        // path is really the most valid one
-        const reSyncEnabled = resyncEnabledConfig && !this.isBackTracking() && this.recoveryEnabled;
-        if (exceptions_public.isRecognitionException(e)) {
-            const recogError = e;
-            if (reSyncEnabled) {
-                const reSyncTokType = this.findReSyncTokenType();
-                if (this.isInCurrentRuleReSyncSet(reSyncTokType)) {
-                    recogError.resyncedTokens = this.reSyncTo(reSyncTokType);
-                    if (this.outputCst) {
-                        const partialCstResult = this.CST_STACK[this.CST_STACK.length - 1];
-                        partialCstResult.recoveredNode = true;
-                        return partialCstResult;
-                    }
-                    else {
-                        return recoveryValueFunc(e);
-                    }
-                }
-                else {
-                    if (this.outputCst) {
-                        const partialCstResult = this.CST_STACK[this.CST_STACK.length - 1];
-                        partialCstResult.recoveredNode = true;
-                        recogError.partialCstResult = partialCstResult;
-                    }
-                    // to be handled Further up the call stack
-                    throw recogError;
-                }
-            }
-            else if (isFirstInvokedRule) {
-                // otherwise a Redundant input error will be created as well and we cannot guarantee that this is indeed the case
-                this.moveToTerminatedState();
-                // the parser should never throw one of its own errors outside its flow.
-                // even if error recovery is disabled
-                return recoveryValueFunc(e);
-            }
-            else {
-                // to be recovered Further up the call stack
-                throw recogError;
-            }
-        }
-        else {
-            // some other Error type which we don't know how to handle (for example a built in JavaScript Error)
-            throw e;
-        }
-    }
-    // Implementation of parsing DSL
-    optionInternal(actionORMethodDef, occurrence) {
-        const key = this.getKeyForAutomaticLookahead(keys.OPTION_IDX, occurrence);
-        return this.optionInternalLogic(actionORMethodDef, occurrence, key);
-    }
-    optionInternalLogic(actionORMethodDef, occurrence, key) {
-        let lookAheadFunc = this.getLaFuncFromCache(key);
-        let action;
-        if (typeof actionORMethodDef !== "function") {
-            action = actionORMethodDef.DEF;
-            const predicate = actionORMethodDef.GATE;
-            // predicate present
-            if (predicate !== undefined) {
-                const orgLookaheadFunction = lookAheadFunc;
-                lookAheadFunc = () => {
-                    return predicate.call(this) && orgLookaheadFunction.call(this);
-                };
-            }
-        }
-        else {
-            action = actionORMethodDef;
-        }
-        if (lookAheadFunc.call(this) === true) {
-            return action.call(this);
-        }
-        return undefined;
-    }
-    atLeastOneInternal(prodOccurrence, actionORMethodDef) {
-        const laKey = this.getKeyForAutomaticLookahead(keys.AT_LEAST_ONE_IDX, prodOccurrence);
-        return this.atLeastOneInternalLogic(prodOccurrence, actionORMethodDef, laKey);
-    }
-    atLeastOneInternalLogic(prodOccurrence, actionORMethodDef, key) {
-        let lookAheadFunc = this.getLaFuncFromCache(key);
-        let action;
-        if (typeof actionORMethodDef !== "function") {
-            action = actionORMethodDef.DEF;
-            const predicate = actionORMethodDef.GATE;
-            // predicate present
-            if (predicate !== undefined) {
-                const orgLookaheadFunction = lookAheadFunc;
-                lookAheadFunc = () => {
-                    return predicate.call(this) && orgLookaheadFunction.call(this);
-                };
-            }
-        }
-        else {
-            action = actionORMethodDef;
-        }
-        if (lookAheadFunc.call(this) === true) {
-            let notStuck = this.doSingleRepetition(action);
-            while (lookAheadFunc.call(this) === true &&
-                notStuck === true) {
-                notStuck = this.doSingleRepetition(action);
-            }
-        }
-        else {
-            throw this.raiseEarlyExitException(prodOccurrence, lookahead.PROD_TYPE.REPETITION_MANDATORY, actionORMethodDef.ERR_MSG);
-        }
-        // note that while it may seem that this can cause an error because by using a recursive call to
-        // AT_LEAST_ONE we change the grammar to AT_LEAST_TWO, AT_LEAST_THREE ... , the possible recursive call
-        // from the tryInRepetitionRecovery(...) will only happen IFF there really are TWO/THREE/.... items.
-        // Performance optimization: "attemptInRepetitionRecovery" will be defined as NOOP unless recovery is enabled
-        this.attemptInRepetitionRecovery(this.atLeastOneInternal, [prodOccurrence, actionORMethodDef], lookAheadFunc, keys.AT_LEAST_ONE_IDX, prodOccurrence, interpreter.NextTerminalAfterAtLeastOneWalker);
-    }
-    atLeastOneSepFirstInternal(prodOccurrence, options) {
-        const laKey = this.getKeyForAutomaticLookahead(keys.AT_LEAST_ONE_SEP_IDX, prodOccurrence);
-        this.atLeastOneSepFirstInternalLogic(prodOccurrence, options, laKey);
-    }
-    atLeastOneSepFirstInternalLogic(prodOccurrence, options, key) {
-        const action = options.DEF;
-        const separator = options.SEP;
-        const firstIterationLookaheadFunc = this.getLaFuncFromCache(key);
-        // 1st iteration
-        if (firstIterationLookaheadFunc.call(this) === true) {
-            action.call(this);
-            //  TODO: Optimization can move this function construction into "attemptInRepetitionRecovery"
-            //  because it is only needed in error recovery scenarios.
-            const separatorLookAheadFunc = () => {
-                return this.tokenMatcher(this.LA(1), separator);
-            };
-            // 2nd..nth iterations
-            while (this.tokenMatcher(this.LA(1), separator) === true) {
-                // note that this CONSUME will never enter recovery because
-                // the separatorLookAheadFunc checks that the separator really does exist.
-                this.CONSUME(separator);
-                // No need for checking infinite loop here due to consuming the separator.
-                action.call(this);
-            }
-            // Performance optimization: "attemptInRepetitionRecovery" will be defined as NOOP unless recovery is enabled
-            this.attemptInRepetitionRecovery(this.repetitionSepSecondInternal, [
-                prodOccurrence,
-                separator,
-                separatorLookAheadFunc,
-                action,
-                interpreter.NextTerminalAfterAtLeastOneSepWalker,
-            ], separatorLookAheadFunc, keys.AT_LEAST_ONE_SEP_IDX, prodOccurrence, interpreter.NextTerminalAfterAtLeastOneSepWalker);
-        }
-        else {
-            throw this.raiseEarlyExitException(prodOccurrence, lookahead.PROD_TYPE.REPETITION_MANDATORY_WITH_SEPARATOR, options.ERR_MSG);
-        }
-    }
-    manyInternal(prodOccurrence, actionORMethodDef) {
-        const laKey = this.getKeyForAutomaticLookahead(keys.MANY_IDX, prodOccurrence);
-        return this.manyInternalLogic(prodOccurrence, actionORMethodDef, laKey);
-    }
-    manyInternalLogic(prodOccurrence, actionORMethodDef, key) {
-        let lookaheadFunction = this.getLaFuncFromCache(key);
-        let action;
-        if (typeof actionORMethodDef !== "function") {
-            action = actionORMethodDef.DEF;
-            const predicate = actionORMethodDef.GATE;
-            // predicate present
-            if (predicate !== undefined) {
-                const orgLookaheadFunction = lookaheadFunction;
-                lookaheadFunction = () => {
-                    return predicate.call(this) && orgLookaheadFunction.call(this);
-                };
-            }
-        }
-        else {
-            action = actionORMethodDef;
-        }
-        let notStuck = true;
-        while (lookaheadFunction.call(this) === true && notStuck === true) {
-            notStuck = this.doSingleRepetition(action);
-        }
-        // Performance optimization: "attemptInRepetitionRecovery" will be defined as NOOP unless recovery is enabled
-        this.attemptInRepetitionRecovery(this.manyInternal, [prodOccurrence, actionORMethodDef], lookaheadFunction, keys.MANY_IDX, prodOccurrence, interpreter.NextTerminalAfterManyWalker, 
-        // The notStuck parameter is only relevant when "attemptInRepetitionRecovery"
-        // is invoked from manyInternal, in the MANY_SEP case and AT_LEAST_ONE[_SEP]
-        // An infinite loop cannot occur as:
-        // - Either the lookahead is guaranteed to consume something (Single Token Separator)
-        // - AT_LEAST_ONE by definition is guaranteed to consume something (or error out).
-        notStuck);
-    }
-    manySepFirstInternal(prodOccurrence, options) {
-        const laKey = this.getKeyForAutomaticLookahead(keys.MANY_SEP_IDX, prodOccurrence);
-        this.manySepFirstInternalLogic(prodOccurrence, options, laKey);
-    }
-    manySepFirstInternalLogic(prodOccurrence, options, key) {
-        const action = options.DEF;
-        const separator = options.SEP;
-        const firstIterationLaFunc = this.getLaFuncFromCache(key);
-        // 1st iteration
-        if (firstIterationLaFunc.call(this) === true) {
-            action.call(this);
-            const separatorLookAheadFunc = () => {
-                return this.tokenMatcher(this.LA(1), separator);
-            };
-            // 2nd..nth iterations
-            while (this.tokenMatcher(this.LA(1), separator) === true) {
-                // note that this CONSUME will never enter recovery because
-                // the separatorLookAheadFunc checks that the separator really does exist.
-                this.CONSUME(separator);
-                // No need for checking infinite loop here due to consuming the separator.
-                action.call(this);
-            }
-            // Performance optimization: "attemptInRepetitionRecovery" will be defined as NOOP unless recovery is enabled
-            this.attemptInRepetitionRecovery(this.repetitionSepSecondInternal, [
-                prodOccurrence,
-                separator,
-                separatorLookAheadFunc,
-                action,
-                interpreter.NextTerminalAfterManySepWalker,
-            ], separatorLookAheadFunc, keys.MANY_SEP_IDX, prodOccurrence, interpreter.NextTerminalAfterManySepWalker);
-        }
-    }
-    repetitionSepSecondInternal(prodOccurrence, separator, separatorLookAheadFunc, action, nextTerminalAfterWalker) {
-        while (separatorLookAheadFunc()) {
-            // note that this CONSUME will never enter recovery because
-            // the separatorLookAheadFunc checks that the separator really does exist.
-            this.CONSUME(separator);
-            action.call(this);
-        }
-        // we can only arrive to this function after an error
-        // has occurred (hence the name 'second') so the following
-        // IF will always be entered, its possible to remove it...
-        // however it is kept to avoid confusion and be consistent.
-        // Performance optimization: "attemptInRepetitionRecovery" will be defined as NOOP unless recovery is enabled
-        /* istanbul ignore else */
-        this.attemptInRepetitionRecovery(this.repetitionSepSecondInternal, [
-            prodOccurrence,
-            separator,
-            separatorLookAheadFunc,
-            action,
-            nextTerminalAfterWalker,
-        ], separatorLookAheadFunc, keys.AT_LEAST_ONE_SEP_IDX, prodOccurrence, nextTerminalAfterWalker);
-    }
-    doSingleRepetition(action) {
-        const beforeIteration = this.getLexerPosition();
-        action.call(this);
-        const afterIteration = this.getLexerPosition();
-        // This boolean will indicate if this repetition progressed
-        // or if we are "stuck" (potential infinite loop in the repetition).
-        return afterIteration > beforeIteration;
-    }
-    orInternal(altsOrOpts, occurrence) {
-        const laKey = this.getKeyForAutomaticLookahead(keys.OR_IDX, occurrence);
-        const alts = isArray(altsOrOpts) ? altsOrOpts : altsOrOpts.DEF;
-        const laFunc = this.getLaFuncFromCache(laKey);
-        const altIdxToTake = laFunc.call(this, alts);
-        if (altIdxToTake !== undefined) {
-            const chosenAlternative = alts[altIdxToTake];
-            return chosenAlternative.ALT.call(this);
-        }
-        this.raiseNoAltException(occurrence, altsOrOpts.ERR_MSG);
-    }
-    ruleFinallyStateUpdate() {
-        this.RULE_STACK.pop();
-        this.RULE_OCCURRENCE_STACK.pop();
-        // NOOP when cst is disabled
-        this.cstFinallyStateUpdate();
-        if (this.RULE_STACK.length === 0 && this.isAtEndOfInput() === false) {
-            const firstRedundantTok = this.LA(1);
-            const errMsg = this.errorMessageProvider.buildNotAllInputParsedMessage({
-                firstRedundant: firstRedundantTok,
-                ruleName: this.getCurrRuleFullName(),
-            });
-            this.SAVE_ERROR(new exceptions_public.NotAllInputParsedException(errMsg, firstRedundantTok));
-        }
-    }
-    subruleInternal(ruleToCall, idx, options) {
-        let ruleResult;
-        try {
-            const args = options !== undefined ? options.ARGS : undefined;
-            this.subruleIdx = idx;
-            ruleResult = ruleToCall.apply(this, args);
-            this.cstPostNonTerminal(ruleResult, options !== undefined && options.LABEL !== undefined
-                ? options.LABEL
-                : ruleToCall.ruleName);
-            return ruleResult;
-        }
-        catch (e) {
-            throw this.subruleInternalError(e, options, ruleToCall.ruleName);
-        }
-    }
-    subruleInternalError(e, options, ruleName) {
-        if (exceptions_public.isRecognitionException(e) && e.partialCstResult !== undefined) {
-            this.cstPostNonTerminal(e.partialCstResult, options !== undefined && options.LABEL !== undefined
-                ? options.LABEL
-                : ruleName);
-            delete e.partialCstResult;
-        }
-        throw e;
-    }
-    consumeInternal(tokType, idx, options) {
-        let consumedToken;
-        try {
-            const nextToken = this.LA(1);
-            if (this.tokenMatcher(nextToken, tokType) === true) {
-                this.consumeToken();
-                consumedToken = nextToken;
-            }
-            else {
-                this.consumeInternalError(tokType, nextToken, options);
-            }
-        }
-        catch (eFromConsumption) {
-            consumedToken = this.consumeInternalRecovery(tokType, idx, eFromConsumption);
-        }
-        this.cstPostTerminal(options !== undefined && options.LABEL !== undefined
-            ? options.LABEL
-            : tokType.name, consumedToken);
-        return consumedToken;
-    }
-    consumeInternalError(tokType, nextToken, options) {
-        let msg;
-        const previousToken = this.LA(0);
-        if (options !== undefined && options.ERR_MSG) {
-            msg = options.ERR_MSG;
-        }
-        else {
-            msg = this.errorMessageProvider.buildMismatchTokenMessage({
-                expected: tokType,
-                actual: nextToken,
-                previous: previousToken,
-                ruleName: this.getCurrRuleFullName(),
-            });
-        }
-        throw this.SAVE_ERROR(new exceptions_public.MismatchedTokenException(msg, nextToken, previousToken));
-    }
-    consumeInternalRecovery(tokType, idx, eFromConsumption) {
-        // no recovery allowed during backtracking, otherwise backtracking may recover invalid syntax and accept it
-        // but the original syntax could have been parsed successfully without any backtracking + recovery
-        if (this.recoveryEnabled &&
-            // TODO: more robust checking of the exception type. Perhaps Typescript extending expressions?
-            eFromConsumption.name === "MismatchedTokenException" &&
-            !this.isBackTracking()) {
-            const follows = this.getFollowsForInRuleRecovery(tokType, idx);
-            try {
-                return this.tryInRuleRecovery(tokType, follows);
-            }
-            catch (eFromInRuleRecovery) {
-                if (eFromInRuleRecovery.name === recoverable.IN_RULE_RECOVERY_EXCEPTION) {
-                    // failed in RuleRecovery.
-                    // throw the original error in order to trigger reSync error recovery
-                    throw eFromConsumption;
-                }
-                else {
-                    throw eFromInRuleRecovery;
-                }
-            }
-        }
-        else {
-            throw eFromConsumption;
-        }
-    }
-    saveRecogState() {
-        // errors is a getter which will clone the errors array
-        const savedErrors = this.errors;
-        const savedRuleStack = clone(this.RULE_STACK);
-        return {
-            errors: savedErrors,
-            lexerState: this.exportLexerState(),
-            RULE_STACK: savedRuleStack,
-            CST_STACK: this.CST_STACK,
-        };
-    }
-    reloadRecogState(newState) {
-        this.errors = newState.errors;
-        this.importLexerState(newState.lexerState);
-        this.RULE_STACK = newState.RULE_STACK;
-    }
-    ruleInvocationStateUpdate(shortName, fullName, idxInCallingRule) {
-        this.RULE_OCCURRENCE_STACK.push(idxInCallingRule);
-        this.RULE_STACK.push(shortName);
-        // NOOP when cst is disabled
-        this.cstInvocationStateUpdate(fullName);
-    }
-    isBackTracking() {
-        return this.isBackTrackingStack.length !== 0;
-    }
-    getCurrRuleFullName() {
-        const shortName = this.getLastExplicitRuleShortName();
-        return this.shortRuleNameToFull[shortName];
-    }
-    shortRuleNameToFullName(shortName) {
-        return this.shortRuleNameToFull[shortName];
-    }
-    isAtEndOfInput() {
-        return this.tokenMatcher(this.LA(1), tokens_public.EOF);
-    }
-    reset() {
-        this.resetLexerState();
-        this.subruleIdx = 0;
-        this.isBackTrackingStack = [];
-        this.errors = [];
-        this.RULE_STACK = [];
-        // TODO: extract a specific reset for TreeBuilder trait
-        this.CST_STACK = [];
-        this.RULE_OCCURRENCE_STACK = [];
-    }
-}
-
-exports.RecognizerEngine = RecognizerEngine;