@windrun-huaiin/third-ui 7.0.0 → 7.1.0

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

@@ -0,0 +1,555 @@
+'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.21/node_modules/lodash-es/has.js');
+var isArray = require('../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/isArray.js');
+var isEmpty = require('../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/isEmpty.js');
+var reduce = require('../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/reduce.js');
+var every = require('../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/every.js');
+var flatten = require('../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/flatten.js');
+var values = require('../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/values.js');
+var uniq = require('../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/uniq.js');
+var isObject = require('../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/isObject.js');
+var clone = require('../../../../../../../../lodash-es@4.17.21/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;