qidian-vue-ui 1.1.49 → 1.1.51

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

@@ -0,0 +1 @@
+{"version":3,"file":"recognizer_api.mjs","sources":["../../../../../../../../../../../../../node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/parser/traits/recognizer_api.js"],"sourcesContent":["import { includes, values } from \"lodash-es\";\nimport { isRecognitionException } from \"../../exceptions_public.js\";\nimport { DEFAULT_RULE_CONFIG, ParserDefinitionErrorType } from \"../parser.js\";\nimport { defaultGrammarValidatorErrorProvider } from \"../../errors_public.js\";\nimport { validateRuleIsOverridden } from \"../../grammar/checks.js\";\nimport { serializeGrammar } from \"@chevrotain/gast\";\n/**\n * This trait is responsible for implementing the public API\n * for defining Chevrotain parsers, i.e:\n * - CONSUME\n * - RULE\n * - OPTION\n * - ...\n */\nexport class RecognizerApi {\n    ACTION(impl) {\n        return impl.call(this);\n    }\n    consume(idx, tokType, options) {\n        return this.consumeInternal(tokType, idx, options);\n    }\n    subrule(idx, ruleToCall, options) {\n        return this.subruleInternal(ruleToCall, idx, options);\n    }\n    option(idx, actionORMethodDef) {\n        return this.optionInternal(actionORMethodDef, idx);\n    }\n    or(idx, altsOrOpts) {\n        return this.orInternal(altsOrOpts, idx);\n    }\n    many(idx, actionORMethodDef) {\n        return this.manyInternal(idx, actionORMethodDef);\n    }\n    atLeastOne(idx, actionORMethodDef) {\n        return this.atLeastOneInternal(idx, actionORMethodDef);\n    }\n    CONSUME(tokType, options) {\n        return this.consumeInternal(tokType, 0, options);\n    }\n    CONSUME1(tokType, options) {\n        return this.consumeInternal(tokType, 1, options);\n    }\n    CONSUME2(tokType, options) {\n        return this.consumeInternal(tokType, 2, options);\n    }\n    CONSUME3(tokType, options) {\n        return this.consumeInternal(tokType, 3, options);\n    }\n    CONSUME4(tokType, options) {\n        return this.consumeInternal(tokType, 4, options);\n    }\n    CONSUME5(tokType, options) {\n        return this.consumeInternal(tokType, 5, options);\n    }\n    CONSUME6(tokType, options) {\n        return this.consumeInternal(tokType, 6, options);\n    }\n    CONSUME7(tokType, options) {\n        return this.consumeInternal(tokType, 7, options);\n    }\n    CONSUME8(tokType, options) {\n        return this.consumeInternal(tokType, 8, options);\n    }\n    CONSUME9(tokType, options) {\n        return this.consumeInternal(tokType, 9, options);\n    }\n    SUBRULE(ruleToCall, options) {\n        return this.subruleInternal(ruleToCall, 0, options);\n    }\n    SUBRULE1(ruleToCall, options) {\n        return this.subruleInternal(ruleToCall, 1, options);\n    }\n    SUBRULE2(ruleToCall, options) {\n        return this.subruleInternal(ruleToCall, 2, options);\n    }\n    SUBRULE3(ruleToCall, options) {\n        return this.subruleInternal(ruleToCall, 3, options);\n    }\n    SUBRULE4(ruleToCall, options) {\n        return this.subruleInternal(ruleToCall, 4, options);\n    }\n    SUBRULE5(ruleToCall, options) {\n        return this.subruleInternal(ruleToCall, 5, options);\n    }\n    SUBRULE6(ruleToCall, options) {\n        return this.subruleInternal(ruleToCall, 6, options);\n    }\n    SUBRULE7(ruleToCall, options) {\n        return this.subruleInternal(ruleToCall, 7, options);\n    }\n    SUBRULE8(ruleToCall, options) {\n        return this.subruleInternal(ruleToCall, 8, options);\n    }\n    SUBRULE9(ruleToCall, options) {\n        return this.subruleInternal(ruleToCall, 9, options);\n    }\n    OPTION(actionORMethodDef) {\n        return this.optionInternal(actionORMethodDef, 0);\n    }\n    OPTION1(actionORMethodDef) {\n        return this.optionInternal(actionORMethodDef, 1);\n    }\n    OPTION2(actionORMethodDef) {\n        return this.optionInternal(actionORMethodDef, 2);\n    }\n    OPTION3(actionORMethodDef) {\n        return this.optionInternal(actionORMethodDef, 3);\n    }\n    OPTION4(actionORMethodDef) {\n        return this.optionInternal(actionORMethodDef, 4);\n    }\n    OPTION5(actionORMethodDef) {\n        return this.optionInternal(actionORMethodDef, 5);\n    }\n    OPTION6(actionORMethodDef) {\n        return this.optionInternal(actionORMethodDef, 6);\n    }\n    OPTION7(actionORMethodDef) {\n        return this.optionInternal(actionORMethodDef, 7);\n    }\n    OPTION8(actionORMethodDef) {\n        return this.optionInternal(actionORMethodDef, 8);\n    }\n    OPTION9(actionORMethodDef) {\n        return this.optionInternal(actionORMethodDef, 9);\n    }\n    OR(altsOrOpts) {\n        return this.orInternal(altsOrOpts, 0);\n    }\n    OR1(altsOrOpts) {\n        return this.orInternal(altsOrOpts, 1);\n    }\n    OR2(altsOrOpts) {\n        return this.orInternal(altsOrOpts, 2);\n    }\n    OR3(altsOrOpts) {\n        return this.orInternal(altsOrOpts, 3);\n    }\n    OR4(altsOrOpts) {\n        return this.orInternal(altsOrOpts, 4);\n    }\n    OR5(altsOrOpts) {\n        return this.orInternal(altsOrOpts, 5);\n    }\n    OR6(altsOrOpts) {\n        return this.orInternal(altsOrOpts, 6);\n    }\n    OR7(altsOrOpts) {\n        return this.orInternal(altsOrOpts, 7);\n    }\n    OR8(altsOrOpts) {\n        return this.orInternal(altsOrOpts, 8);\n    }\n    OR9(altsOrOpts) {\n        return this.orInternal(altsOrOpts, 9);\n    }\n    MANY(actionORMethodDef) {\n        this.manyInternal(0, actionORMethodDef);\n    }\n    MANY1(actionORMethodDef) {\n        this.manyInternal(1, actionORMethodDef);\n    }\n    MANY2(actionORMethodDef) {\n        this.manyInternal(2, actionORMethodDef);\n    }\n    MANY3(actionORMethodDef) {\n        this.manyInternal(3, actionORMethodDef);\n    }\n    MANY4(actionORMethodDef) {\n        this.manyInternal(4, actionORMethodDef);\n    }\n    MANY5(actionORMethodDef) {\n        this.manyInternal(5, actionORMethodDef);\n    }\n    MANY6(actionORMethodDef) {\n        this.manyInternal(6, actionORMethodDef);\n    }\n    MANY7(actionORMethodDef) {\n        this.manyInternal(7, actionORMethodDef);\n    }\n    MANY8(actionORMethodDef) {\n        this.manyInternal(8, actionORMethodDef);\n    }\n    MANY9(actionORMethodDef) {\n        this.manyInternal(9, actionORMethodDef);\n    }\n    MANY_SEP(options) {\n        this.manySepFirstInternal(0, options);\n    }\n    MANY_SEP1(options) {\n        this.manySepFirstInternal(1, options);\n    }\n    MANY_SEP2(options) {\n        this.manySepFirstInternal(2, options);\n    }\n    MANY_SEP3(options) {\n        this.manySepFirstInternal(3, options);\n    }\n    MANY_SEP4(options) {\n        this.manySepFirstInternal(4, options);\n    }\n    MANY_SEP5(options) {\n        this.manySepFirstInternal(5, options);\n    }\n    MANY_SEP6(options) {\n        this.manySepFirstInternal(6, options);\n    }\n    MANY_SEP7(options) {\n        this.manySepFirstInternal(7, options);\n    }\n    MANY_SEP8(options) {\n        this.manySepFirstInternal(8, options);\n    }\n    MANY_SEP9(options) {\n        this.manySepFirstInternal(9, options);\n    }\n    AT_LEAST_ONE(actionORMethodDef) {\n        this.atLeastOneInternal(0, actionORMethodDef);\n    }\n    AT_LEAST_ONE1(actionORMethodDef) {\n        return this.atLeastOneInternal(1, actionORMethodDef);\n    }\n    AT_LEAST_ONE2(actionORMethodDef) {\n        this.atLeastOneInternal(2, actionORMethodDef);\n    }\n    AT_LEAST_ONE3(actionORMethodDef) {\n        this.atLeastOneInternal(3, actionORMethodDef);\n    }\n    AT_LEAST_ONE4(actionORMethodDef) {\n        this.atLeastOneInternal(4, actionORMethodDef);\n    }\n    AT_LEAST_ONE5(actionORMethodDef) {\n        this.atLeastOneInternal(5, actionORMethodDef);\n    }\n    AT_LEAST_ONE6(actionORMethodDef) {\n        this.atLeastOneInternal(6, actionORMethodDef);\n    }\n    AT_LEAST_ONE7(actionORMethodDef) {\n        this.atLeastOneInternal(7, actionORMethodDef);\n    }\n    AT_LEAST_ONE8(actionORMethodDef) {\n        this.atLeastOneInternal(8, actionORMethodDef);\n    }\n    AT_LEAST_ONE9(actionORMethodDef) {\n        this.atLeastOneInternal(9, actionORMethodDef);\n    }\n    AT_LEAST_ONE_SEP(options) {\n        this.atLeastOneSepFirstInternal(0, options);\n    }\n    AT_LEAST_ONE_SEP1(options) {\n        this.atLeastOneSepFirstInternal(1, options);\n    }\n    AT_LEAST_ONE_SEP2(options) {\n        this.atLeastOneSepFirstInternal(2, options);\n    }\n    AT_LEAST_ONE_SEP3(options) {\n        this.atLeastOneSepFirstInternal(3, options);\n    }\n    AT_LEAST_ONE_SEP4(options) {\n        this.atLeastOneSepFirstInternal(4, options);\n    }\n    AT_LEAST_ONE_SEP5(options) {\n        this.atLeastOneSepFirstInternal(5, options);\n    }\n    AT_LEAST_ONE_SEP6(options) {\n        this.atLeastOneSepFirstInternal(6, options);\n    }\n    AT_LEAST_ONE_SEP7(options) {\n        this.atLeastOneSepFirstInternal(7, options);\n    }\n    AT_LEAST_ONE_SEP8(options) {\n        this.atLeastOneSepFirstInternal(8, options);\n    }\n    AT_LEAST_ONE_SEP9(options) {\n        this.atLeastOneSepFirstInternal(9, options);\n    }\n    RULE(name, implementation, config = DEFAULT_RULE_CONFIG) {\n        if (includes(this.definedRulesNames, name)) {\n            const errMsg = defaultGrammarValidatorErrorProvider.buildDuplicateRuleNameError({\n                topLevelRule: name,\n                grammarName: this.className,\n            });\n            const error = {\n                message: errMsg,\n                type: ParserDefinitionErrorType.DUPLICATE_RULE_NAME,\n                ruleName: name,\n            };\n            this.definitionErrors.push(error);\n        }\n        this.definedRulesNames.push(name);\n        const ruleImplementation = this.defineRule(name, implementation, config);\n        this[name] = ruleImplementation;\n        return ruleImplementation;\n    }\n    OVERRIDE_RULE(name, impl, config = DEFAULT_RULE_CONFIG) {\n        const ruleErrors = validateRuleIsOverridden(name, this.definedRulesNames, this.className);\n        this.definitionErrors = this.definitionErrors.concat(ruleErrors);\n        const ruleImplementation = this.defineRule(name, impl, config);\n        this[name] = ruleImplementation;\n        return ruleImplementation;\n    }\n    BACKTRACK(grammarRule, args) {\n        return function () {\n            // save org state\n            this.isBackTrackingStack.push(1);\n            const orgState = this.saveRecogState();\n            try {\n                grammarRule.apply(this, args);\n                // if no exception was thrown we have succeed parsing the rule.\n                return true;\n            }\n            catch (e) {\n                if (isRecognitionException(e)) {\n                    return false;\n                }\n                else {\n                    throw e;\n                }\n            }\n            finally {\n                this.reloadRecogState(orgState);\n                this.isBackTrackingStack.pop();\n            }\n        };\n    }\n    // GAST export APIs\n    getGAstProductions() {\n        return this.gastProductionsCache;\n    }\n    getSerializedGastProductions() {\n        return serializeGrammar(values(this.gastProductionsCache));\n    }\n}\n//# sourceMappingURL=recognizer_api.js.map"],"names":[],"mappings":";;;;;;;AAcO,MAAM,cAAc;AAAA,EACvB,OAAO,MAAM;AACT,WAAO,KAAK,KAAK,IAAI;AAAA,EACzB;AAAA,EACA,QAAQ,KAAK,SAAS,SAAS;AAC3B,WAAO,KAAK,gBAAgB,SAAS,KAAK,OAAO;AAAA,EACrD;AAAA,EACA,QAAQ,KAAK,YAAY,SAAS;AAC9B,WAAO,KAAK,gBAAgB,YAAY,KAAK,OAAO;AAAA,EACxD;AAAA,EACA,OAAO,KAAK,mBAAmB;AAC3B,WAAO,KAAK,eAAe,mBAAmB,GAAG;AAAA,EACrD;AAAA,EACA,GAAG,KAAK,YAAY;AAChB,WAAO,KAAK,WAAW,YAAY,GAAG;AAAA,EAC1C;AAAA,EACA,KAAK,KAAK,mBAAmB;AACzB,WAAO,KAAK,aAAa,KAAK,iBAAiB;AAAA,EACnD;AAAA,EACA,WAAW,KAAK,mBAAmB;AAC/B,WAAO,KAAK,mBAAmB,KAAK,iBAAiB;AAAA,EACzD;AAAA,EACA,QAAQ,SAAS,SAAS;AACtB,WAAO,KAAK,gBAAgB,SAAS,GAAG,OAAO;AAAA,EACnD;AAAA,EACA,SAAS,SAAS,SAAS;AACvB,WAAO,KAAK,gBAAgB,SAAS,GAAG,OAAO;AAAA,EACnD;AAAA,EACA,SAAS,SAAS,SAAS;AACvB,WAAO,KAAK,gBAAgB,SAAS,GAAG,OAAO;AAAA,EACnD;AAAA,EACA,SAAS,SAAS,SAAS;AACvB,WAAO,KAAK,gBAAgB,SAAS,GAAG,OAAO;AAAA,EACnD;AAAA,EACA,SAAS,SAAS,SAAS;AACvB,WAAO,KAAK,gBAAgB,SAAS,GAAG,OAAO;AAAA,EACnD;AAAA,EACA,SAAS,SAAS,SAAS;AACvB,WAAO,KAAK,gBAAgB,SAAS,GAAG,OAAO;AAAA,EACnD;AAAA,EACA,SAAS,SAAS,SAAS;AACvB,WAAO,KAAK,gBAAgB,SAAS,GAAG,OAAO;AAAA,EACnD;AAAA,EACA,SAAS,SAAS,SAAS;AACvB,WAAO,KAAK,gBAAgB,SAAS,GAAG,OAAO;AAAA,EACnD;AAAA,EACA,SAAS,SAAS,SAAS;AACvB,WAAO,KAAK,gBAAgB,SAAS,GAAG,OAAO;AAAA,EACnD;AAAA,EACA,SAAS,SAAS,SAAS;AACvB,WAAO,KAAK,gBAAgB,SAAS,GAAG,OAAO;AAAA,EACnD;AAAA,EACA,QAAQ,YAAY,SAAS;AACzB,WAAO,KAAK,gBAAgB,YAAY,GAAG,OAAO;AAAA,EACtD;AAAA,EACA,SAAS,YAAY,SAAS;AAC1B,WAAO,KAAK,gBAAgB,YAAY,GAAG,OAAO;AAAA,EACtD;AAAA,EACA,SAAS,YAAY,SAAS;AAC1B,WAAO,KAAK,gBAAgB,YAAY,GAAG,OAAO;AAAA,EACtD;AAAA,EACA,SAAS,YAAY,SAAS;AAC1B,WAAO,KAAK,gBAAgB,YAAY,GAAG,OAAO;AAAA,EACtD;AAAA,EACA,SAAS,YAAY,SAAS;AAC1B,WAAO,KAAK,gBAAgB,YAAY,GAAG,OAAO;AAAA,EACtD;AAAA,EACA,SAAS,YAAY,SAAS;AAC1B,WAAO,KAAK,gBAAgB,YAAY,GAAG,OAAO;AAAA,EACtD;AAAA,EACA,SAAS,YAAY,SAAS;AAC1B,WAAO,KAAK,gBAAgB,YAAY,GAAG,OAAO;AAAA,EACtD;AAAA,EACA,SAAS,YAAY,SAAS;AAC1B,WAAO,KAAK,gBAAgB,YAAY,GAAG,OAAO;AAAA,EACtD;AAAA,EACA,SAAS,YAAY,SAAS;AAC1B,WAAO,KAAK,gBAAgB,YAAY,GAAG,OAAO;AAAA,EACtD;AAAA,EACA,SAAS,YAAY,SAAS;AAC1B,WAAO,KAAK,gBAAgB,YAAY,GAAG,OAAO;AAAA,EACtD;AAAA,EACA,OAAO,mBAAmB;AACtB,WAAO,KAAK,eAAe,mBAAmB,CAAC;AAAA,EACnD;AAAA,EACA,QAAQ,mBAAmB;AACvB,WAAO,KAAK,eAAe,mBAAmB,CAAC;AAAA,EACnD;AAAA,EACA,QAAQ,mBAAmB;AACvB,WAAO,KAAK,eAAe,mBAAmB,CAAC;AAAA,EACnD;AAAA,EACA,QAAQ,mBAAmB;AACvB,WAAO,KAAK,eAAe,mBAAmB,CAAC;AAAA,EACnD;AAAA,EACA,QAAQ,mBAAmB;AACvB,WAAO,KAAK,eAAe,mBAAmB,CAAC;AAAA,EACnD;AAAA,EACA,QAAQ,mBAAmB;AACvB,WAAO,KAAK,eAAe,mBAAmB,CAAC;AAAA,EACnD;AAAA,EACA,QAAQ,mBAAmB;AACvB,WAAO,KAAK,eAAe,mBAAmB,CAAC;AAAA,EACnD;AAAA,EACA,QAAQ,mBAAmB;AACvB,WAAO,KAAK,eAAe,mBAAmB,CAAC;AAAA,EACnD;AAAA,EACA,QAAQ,mBAAmB;AACvB,WAAO,KAAK,eAAe,mBAAmB,CAAC;AAAA,EACnD;AAAA,EACA,QAAQ,mBAAmB;AACvB,WAAO,KAAK,eAAe,mBAAmB,CAAC;AAAA,EACnD;AAAA,EACA,GAAG,YAAY;AACX,WAAO,KAAK,WAAW,YAAY,CAAC;AAAA,EACxC;AAAA,EACA,IAAI,YAAY;AACZ,WAAO,KAAK,WAAW,YAAY,CAAC;AAAA,EACxC;AAAA,EACA,IAAI,YAAY;AACZ,WAAO,KAAK,WAAW,YAAY,CAAC;AAAA,EACxC;AAAA,EACA,IAAI,YAAY;AACZ,WAAO,KAAK,WAAW,YAAY,CAAC;AAAA,EACxC;AAAA,EACA,IAAI,YAAY;AACZ,WAAO,KAAK,WAAW,YAAY,CAAC;AAAA,EACxC;AAAA,EACA,IAAI,YAAY;AACZ,WAAO,KAAK,WAAW,YAAY,CAAC;AAAA,EACxC;AAAA,EACA,IAAI,YAAY;AACZ,WAAO,KAAK,WAAW,YAAY,CAAC;AAAA,EACxC;AAAA,EACA,IAAI,YAAY;AACZ,WAAO,KAAK,WAAW,YAAY,CAAC;AAAA,EACxC;AAAA,EACA,IAAI,YAAY;AACZ,WAAO,KAAK,WAAW,YAAY,CAAC;AAAA,EACxC;AAAA,EACA,IAAI,YAAY;AACZ,WAAO,KAAK,WAAW,YAAY,CAAC;AAAA,EACxC;AAAA,EACA,KAAK,mBAAmB;AACpB,SAAK,aAAa,GAAG,iBAAiB;AAAA,EAC1C;AAAA,EACA,MAAM,mBAAmB;AACrB,SAAK,aAAa,GAAG,iBAAiB;AAAA,EAC1C;AAAA,EACA,MAAM,mBAAmB;AACrB,SAAK,aAAa,GAAG,iBAAiB;AAAA,EAC1C;AAAA,EACA,MAAM,mBAAmB;AACrB,SAAK,aAAa,GAAG,iBAAiB;AAAA,EAC1C;AAAA,EACA,MAAM,mBAAmB;AACrB,SAAK,aAAa,GAAG,iBAAiB;AAAA,EAC1C;AAAA,EACA,MAAM,mBAAmB;AACrB,SAAK,aAAa,GAAG,iBAAiB;AAAA,EAC1C;AAAA,EACA,MAAM,mBAAmB;AACrB,SAAK,aAAa,GAAG,iBAAiB;AAAA,EAC1C;AAAA,EACA,MAAM,mBAAmB;AACrB,SAAK,aAAa,GAAG,iBAAiB;AAAA,EAC1C;AAAA,EACA,MAAM,mBAAmB;AACrB,SAAK,aAAa,GAAG,iBAAiB;AAAA,EAC1C;AAAA,EACA,MAAM,mBAAmB;AACrB,SAAK,aAAa,GAAG,iBAAiB;AAAA,EAC1C;AAAA,EACA,SAAS,SAAS;AACd,SAAK,qBAAqB,GAAG,OAAO;AAAA,EACxC;AAAA,EACA,UAAU,SAAS;AACf,SAAK,qBAAqB,GAAG,OAAO;AAAA,EACxC;AAAA,EACA,UAAU,SAAS;AACf,SAAK,qBAAqB,GAAG,OAAO;AAAA,EACxC;AAAA,EACA,UAAU,SAAS;AACf,SAAK,qBAAqB,GAAG,OAAO;AAAA,EACxC;AAAA,EACA,UAAU,SAAS;AACf,SAAK,qBAAqB,GAAG,OAAO;AAAA,EACxC;AAAA,EACA,UAAU,SAAS;AACf,SAAK,qBAAqB,GAAG,OAAO;AAAA,EACxC;AAAA,EACA,UAAU,SAAS;AACf,SAAK,qBAAqB,GAAG,OAAO;AAAA,EACxC;AAAA,EACA,UAAU,SAAS;AACf,SAAK,qBAAqB,GAAG,OAAO;AAAA,EACxC;AAAA,EACA,UAAU,SAAS;AACf,SAAK,qBAAqB,GAAG,OAAO;AAAA,EACxC;AAAA,EACA,UAAU,SAAS;AACf,SAAK,qBAAqB,GAAG,OAAO;AAAA,EACxC;AAAA,EACA,aAAa,mBAAmB;AAC5B,SAAK,mBAAmB,GAAG,iBAAiB;AAAA,EAChD;AAAA,EACA,cAAc,mBAAmB;AAC7B,WAAO,KAAK,mBAAmB,GAAG,iBAAiB;AAAA,EACvD;AAAA,EACA,cAAc,mBAAmB;AAC7B,SAAK,mBAAmB,GAAG,iBAAiB;AAAA,EAChD;AAAA,EACA,cAAc,mBAAmB;AAC7B,SAAK,mBAAmB,GAAG,iBAAiB;AAAA,EAChD;AAAA,EACA,cAAc,mBAAmB;AAC7B,SAAK,mBAAmB,GAAG,iBAAiB;AAAA,EAChD;AAAA,EACA,cAAc,mBAAmB;AAC7B,SAAK,mBAAmB,GAAG,iBAAiB;AAAA,EAChD;AAAA,EACA,cAAc,mBAAmB;AAC7B,SAAK,mBAAmB,GAAG,iBAAiB;AAAA,EAChD;AAAA,EACA,cAAc,mBAAmB;AAC7B,SAAK,mBAAmB,GAAG,iBAAiB;AAAA,EAChD;AAAA,EACA,cAAc,mBAAmB;AAC7B,SAAK,mBAAmB,GAAG,iBAAiB;AAAA,EAChD;AAAA,EACA,cAAc,mBAAmB;AAC7B,SAAK,mBAAmB,GAAG,iBAAiB;AAAA,EAChD;AAAA,EACA,iBAAiB,SAAS;AACtB,SAAK,2BAA2B,GAAG,OAAO;AAAA,EAC9C;AAAA,EACA,kBAAkB,SAAS;AACvB,SAAK,2BAA2B,GAAG,OAAO;AAAA,EAC9C;AAAA,EACA,kBAAkB,SAAS;AACvB,SAAK,2BAA2B,GAAG,OAAO;AAAA,EAC9C;AAAA,EACA,kBAAkB,SAAS;AACvB,SAAK,2BAA2B,GAAG,OAAO;AAAA,EAC9C;AAAA,EACA,kBAAkB,SAAS;AACvB,SAAK,2BAA2B,GAAG,OAAO;AAAA,EAC9C;AAAA,EACA,kBAAkB,SAAS;AACvB,SAAK,2BAA2B,GAAG,OAAO;AAAA,EAC9C;AAAA,EACA,kBAAkB,SAAS;AACvB,SAAK,2BAA2B,GAAG,OAAO;AAAA,EAC9C;AAAA,EACA,kBAAkB,SAAS;AACvB,SAAK,2BAA2B,GAAG,OAAO;AAAA,EAC9C;AAAA,EACA,kBAAkB,SAAS;AACvB,SAAK,2BAA2B,GAAG,OAAO;AAAA,EAC9C;AAAA,EACA,kBAAkB,SAAS;AACvB,SAAK,2BAA2B,GAAG,OAAO;AAAA,EAC9C;AAAA,EACA,KAAK,MAAM,gBAAgB,SAAS,qBAAqB;AACrD,QAAI,SAAS,KAAK,mBAAmB,IAAI,GAAG;AACxC,YAAM,SAAS,qCAAqC,4BAA4B;AAAA,QAC5E,cAAc;AAAA,QACd,aAAa,KAAK;AAAA,MAClC,CAAa;AACD,YAAM,QAAQ;AAAA,QACV,SAAS;AAAA,QACT,MAAM,0BAA0B;AAAA,QAChC,UAAU;AAAA,MAC1B;AACY,WAAK,iBAAiB,KAAK,KAAK;AAAA,IACpC;AACA,SAAK,kBAAkB,KAAK,IAAI;AAChC,UAAM,qBAAqB,KAAK,WAAW,MAAM,gBAAgB,MAAM;AACvE,SAAK,IAAI,IAAI;AACb,WAAO;AAAA,EACX;AAAA,EACA,cAAc,MAAM,MAAM,SAAS,qBAAqB;AACpD,UAAM,aAAa,yBAAyB,MAAM,KAAK,mBAAmB,KAAK,SAAS;AACxF,SAAK,mBAAmB,KAAK,iBAAiB,OAAO,UAAU;AAC/D,UAAM,qBAAqB,KAAK,WAAW,MAAM,MAAM,MAAM;AAC7D,SAAK,IAAI,IAAI;AACb,WAAO;AAAA,EACX;AAAA,EACA,UAAU,aAAa,MAAM;AACzB,WAAO,WAAY;AAEf,WAAK,oBAAoB,KAAK,CAAC;AAC/B,YAAM,WAAW,KAAK,eAAc;AACpC,UAAI;AACA,oBAAY,MAAM,MAAM,IAAI;AAE5B,eAAO;AAAA,MACX,SACO,GAAG;AACN,YAAI,uBAAuB,CAAC,GAAG;AAC3B,iBAAO;AAAA,QACX,OACK;AACD,gBAAM;AAAA,QACV;AAAA,MACJ,UACZ;AACgB,aAAK,iBAAiB,QAAQ;AAC9B,aAAK,oBAAoB,IAAG;AAAA,MAChC;AAAA,IACJ;AAAA,EACJ;AAAA;AAAA,EAEA,qBAAqB;AACjB,WAAO,KAAK;AAAA,EAChB;AAAA,EACA,+BAA+B;AAC3B,WAAO,iBAAiB,OAAO,KAAK,oBAAoB,CAAC;AAAA,EAC7D;AACJ;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,444 @@
+import { BITS_FOR_METHOD_TYPE, BITS_FOR_OCCURRENCE_IDX, OPTION_IDX, AT_LEAST_ONE_IDX, AT_LEAST_ONE_SEP_IDX, MANY_IDX, MANY_SEP_IDX, OR_IDX } from "../../grammar/keys.mjs";
+import { isRecognitionException, NotAllInputParsedException, MismatchedTokenException } from "../../exceptions_public.mjs";
+import { PROD_TYPE } from "../../grammar/lookahead.mjs";
+import { NextTerminalAfterAtLeastOneWalker, NextTerminalAfterAtLeastOneSepWalker, NextTerminalAfterManyWalker, NextTerminalAfterManySepWalker } from "../../grammar/interpreter.mjs";
+import { DEFAULT_RULE_CONFIG } from "../parser.mjs";
+import { IN_RULE_RECOVERY_EXCEPTION } from "./recoverable.mjs";
+import { EOF } from "../../../scan/tokens_public.mjs";
+import { tokenStructuredMatcherNoCategories, isTokenType, tokenStructuredMatcher, augmentTokenTypes } from "../../../scan/tokens.mjs";
+import has from "../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/has.mjs";
+import isArray from "../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/isArray.mjs";
+import isEmpty from "../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/isEmpty.mjs";
+import reduce from "../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/reduce.mjs";
+import every from "../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/every.mjs";
+import flatten from "../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/flatten.mjs";
+import values from "../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/values.mjs";
+import uniq from "../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/uniq.mjs";
+import isObject from "../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/isObject.mjs";
+import clone from "../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/clone.mjs";
+class RecognizerEngine {
+  initRecognizerEngine(tokenVocabulary, config) {
+    this.className = this.constructor.name;
+    this.shortRuleNameToFull = {};
+    this.fullRuleNameToShort = {};
+    this.ruleShortNameIdx = 256;
+    this.tokenMatcher = 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	See: https://chevrotain.io/docs/changes/BREAKING_CHANGES.html#_6-0-0\n	For Further details.");
+    }
+    if (isArray(tokenVocabulary)) {
+      if (isEmpty(tokenVocabulary)) {
+        throw Error("A Token Vocabulary cannot be empty.\n	Note that the first argument for the parser constructor\n	is 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	See: https://chevrotain.io/docs/changes/BREAKING_CHANGES.html#_4-0-0\n	For 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)), isTokenType)) {
+      const allTokenTypes2 = flatten(values(tokenVocabulary.modes));
+      const uniqueTokens = uniq(allTokenTypes2);
+      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");
+    }
+    this.tokensMap["EOF"] = EOF;
+    const allTokenTypes = has(tokenVocabulary, "modes") ? flatten(values(tokenVocabulary.modes)) : values(tokenVocabulary);
+    const noTokenCategoriesUsed = every(allTokenTypes, (tokenConstructor) => isEmpty(tokenConstructor.categoryMatches));
+    this.tokenMatcher = noTokenCategoriesUsed ? tokenStructuredMatcherNoCategories : tokenStructuredMatcher;
+    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'
+Make sure that all grammar rule definitions are done before 'performSelfAnalysis' is called.`);
+    }
+    const resyncEnabled = has(config, "resyncEnabled") ? config.resyncEnabled : DEFAULT_RULE_CONFIG.resyncEnabled;
+    const recoveryValueFunc = has(config, "recoveryValueFunc") ? config.recoveryValueFunc : DEFAULT_RULE_CONFIG.recoveryValueFunc;
+    const shortName = this.ruleShortNameIdx << BITS_FOR_METHOD_TYPE + BITS_FOR_OCCURRENCE_IDX;
+    this.ruleShortNameIdx++;
+    this.shortRuleNameToFull[shortName] = ruleName;
+    this.fullRuleNameToShort[ruleName] = shortName;
+    let invokeRuleWithTry;
+    if (this.outputCst === true) {
+      invokeRuleWithTry = function invokeRuleWithTry2(...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;
+    const reSyncEnabled = resyncEnabledConfig && !this.isBackTracking() && this.recoveryEnabled;
+    if (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;
+          }
+          throw recogError;
+        }
+      } else if (isFirstInvokedRule) {
+        this.moveToTerminatedState();
+        return recoveryValueFunc(e);
+      } else {
+        throw recogError;
+      }
+    } else {
+      throw e;
+    }
+  }
+  // Implementation of parsing DSL
+  optionInternal(actionORMethodDef, occurrence) {
+    const key = this.getKeyForAutomaticLookahead(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;
+      if (predicate !== void 0) {
+        const orgLookaheadFunction = lookAheadFunc;
+        lookAheadFunc = () => {
+          return predicate.call(this) && orgLookaheadFunction.call(this);
+        };
+      }
+    } else {
+      action = actionORMethodDef;
+    }
+    if (lookAheadFunc.call(this) === true) {
+      return action.call(this);
+    }
+    return void 0;
+  }
+  atLeastOneInternal(prodOccurrence, actionORMethodDef) {
+    const laKey = this.getKeyForAutomaticLookahead(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;
+      if (predicate !== void 0) {
+        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, PROD_TYPE.REPETITION_MANDATORY, actionORMethodDef.ERR_MSG);
+    }
+    this.attemptInRepetitionRecovery(this.atLeastOneInternal, [prodOccurrence, actionORMethodDef], lookAheadFunc, AT_LEAST_ONE_IDX, prodOccurrence, NextTerminalAfterAtLeastOneWalker);
+  }
+  atLeastOneSepFirstInternal(prodOccurrence, options) {
+    const laKey = this.getKeyForAutomaticLookahead(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);
+    if (firstIterationLookaheadFunc.call(this) === true) {
+      action.call(this);
+      const separatorLookAheadFunc = () => {
+        return this.tokenMatcher(this.LA(1), separator);
+      };
+      while (this.tokenMatcher(this.LA(1), separator) === true) {
+        this.CONSUME(separator);
+        action.call(this);
+      }
+      this.attemptInRepetitionRecovery(this.repetitionSepSecondInternal, [
+        prodOccurrence,
+        separator,
+        separatorLookAheadFunc,
+        action,
+        NextTerminalAfterAtLeastOneSepWalker
+      ], separatorLookAheadFunc, AT_LEAST_ONE_SEP_IDX, prodOccurrence, NextTerminalAfterAtLeastOneSepWalker);
+    } else {
+      throw this.raiseEarlyExitException(prodOccurrence, PROD_TYPE.REPETITION_MANDATORY_WITH_SEPARATOR, options.ERR_MSG);
+    }
+  }
+  manyInternal(prodOccurrence, actionORMethodDef) {
+    const laKey = this.getKeyForAutomaticLookahead(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;
+      if (predicate !== void 0) {
+        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);
+    }
+    this.attemptInRepetitionRecovery(
+      this.manyInternal,
+      [prodOccurrence, actionORMethodDef],
+      lookaheadFunction,
+      MANY_IDX,
+      prodOccurrence,
+      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(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);
+    if (firstIterationLaFunc.call(this) === true) {
+      action.call(this);
+      const separatorLookAheadFunc = () => {
+        return this.tokenMatcher(this.LA(1), separator);
+      };
+      while (this.tokenMatcher(this.LA(1), separator) === true) {
+        this.CONSUME(separator);
+        action.call(this);
+      }
+      this.attemptInRepetitionRecovery(this.repetitionSepSecondInternal, [
+        prodOccurrence,
+        separator,
+        separatorLookAheadFunc,
+        action,
+        NextTerminalAfterManySepWalker
+      ], separatorLookAheadFunc, MANY_SEP_IDX, prodOccurrence, NextTerminalAfterManySepWalker);
+    }
+  }
+  repetitionSepSecondInternal(prodOccurrence, separator, separatorLookAheadFunc, action, nextTerminalAfterWalker) {
+    while (separatorLookAheadFunc()) {
+      this.CONSUME(separator);
+      action.call(this);
+    }
+    this.attemptInRepetitionRecovery(this.repetitionSepSecondInternal, [
+      prodOccurrence,
+      separator,
+      separatorLookAheadFunc,
+      action,
+      nextTerminalAfterWalker
+    ], separatorLookAheadFunc, AT_LEAST_ONE_SEP_IDX, prodOccurrence, nextTerminalAfterWalker);
+  }
+  doSingleRepetition(action) {
+    const beforeIteration = this.getLexerPosition();
+    action.call(this);
+    const afterIteration = this.getLexerPosition();
+    return afterIteration > beforeIteration;
+  }
+  orInternal(altsOrOpts, occurrence) {
+    const laKey = this.getKeyForAutomaticLookahead(OR_IDX, occurrence);
+    const alts = isArray(altsOrOpts) ? altsOrOpts : altsOrOpts.DEF;
+    const laFunc = this.getLaFuncFromCache(laKey);
+    const altIdxToTake = laFunc.call(this, alts);
+    if (altIdxToTake !== void 0) {
+      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();
+    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 NotAllInputParsedException(errMsg, firstRedundantTok));
+    }
+  }
+  subruleInternal(ruleToCall, idx, options) {
+    let ruleResult;
+    try {
+      const args = options !== void 0 ? options.ARGS : void 0;
+      this.subruleIdx = idx;
+      ruleResult = ruleToCall.apply(this, args);
+      this.cstPostNonTerminal(ruleResult, options !== void 0 && options.LABEL !== void 0 ? options.LABEL : ruleToCall.ruleName);
+      return ruleResult;
+    } catch (e) {
+      throw this.subruleInternalError(e, options, ruleToCall.ruleName);
+    }
+  }
+  subruleInternalError(e, options, ruleName) {
+    if (isRecognitionException(e) && e.partialCstResult !== void 0) {
+      this.cstPostNonTerminal(e.partialCstResult, options !== void 0 && options.LABEL !== void 0 ? 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 !== void 0 && options.LABEL !== void 0 ? options.LABEL : tokType.name, consumedToken);
+    return consumedToken;
+  }
+  consumeInternalError(tokType, nextToken, options) {
+    let msg;
+    const previousToken = this.LA(0);
+    if (options !== void 0 && 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 MismatchedTokenException(msg, nextToken, previousToken));
+  }
+  consumeInternalRecovery(tokType, idx, eFromConsumption) {
+    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 === IN_RULE_RECOVERY_EXCEPTION) {
+          throw eFromConsumption;
+        } else {
+          throw eFromInRuleRecovery;
+        }
+      }
+    } else {
+      throw eFromConsumption;
+    }
+  }
+  saveRecogState() {
+    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);
+    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), EOF);
+  }
+  reset() {
+    this.resetLexerState();
+    this.subruleIdx = 0;
+    this.isBackTrackingStack = [];
+    this.errors = [];
+    this.RULE_STACK = [];
+    this.CST_STACK = [];
+    this.RULE_OCCURRENCE_STACK = [];
+  }
+}
+export {
+  RecognizerEngine
+};
+//# sourceMappingURL=recognizer_engine.mjs.map

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

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