qidian-vue-ui 1.1.50 → 1.1.51

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

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

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

@@ -0,0 +1,60 @@
+import { END_OF_FILE } from "../parser.mjs";
+class LexerAdapter {
+  initLexerAdapter() {
+    this.tokVector = [];
+    this.tokVectorLength = 0;
+    this.currIdx = -1;
+  }
+  set input(newInput) {
+    if (this.selfAnalysisDone !== true) {
+      throw Error(`Missing <performSelfAnalysis> invocation at the end of the Parser's constructor.`);
+    }
+    this.reset();
+    this.tokVector = newInput;
+    this.tokVectorLength = newInput.length;
+  }
+  get input() {
+    return this.tokVector;
+  }
+  // skips a token and returns the next token
+  SKIP_TOKEN() {
+    if (this.currIdx <= this.tokVector.length - 2) {
+      this.consumeToken();
+      return this.LA(1);
+    } else {
+      return END_OF_FILE;
+    }
+  }
+  // Lexer (accessing Token vector) related methods which can be overridden to implement lazy lexers
+  // or lexers dependent on parser context.
+  LA(howMuch) {
+    const soughtIdx = this.currIdx + howMuch;
+    if (soughtIdx < 0 || this.tokVectorLength <= soughtIdx) {
+      return END_OF_FILE;
+    } else {
+      return this.tokVector[soughtIdx];
+    }
+  }
+  consumeToken() {
+    this.currIdx++;
+  }
+  exportLexerState() {
+    return this.currIdx;
+  }
+  importLexerState(newState) {
+    this.currIdx = newState;
+  }
+  resetLexerState() {
+    this.currIdx = -1;
+  }
+  moveToTerminatedState() {
+    this.currIdx = this.tokVector.length - 1;
+  }
+  getLexerPosition() {
+    return this.exportLexerState();
+  }
+}
+export {
+  LexerAdapter
+};
+//# sourceMappingURL=lexer_adapter.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lexer_adapter.mjs","sources":["../../../../../../../../../../../../../node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/parser/traits/lexer_adapter.js"],"sourcesContent":["import { END_OF_FILE } from \"../parser.js\";\n/**\n * Trait responsible abstracting over the interaction with Lexer output (Token vector).\n *\n * This could be generalized to support other kinds of lexers, e.g.\n * - Just in Time Lexing / Lexer-Less parsing.\n * - Streaming Lexer.\n */\nexport class LexerAdapter {\n    initLexerAdapter() {\n        this.tokVector = [];\n        this.tokVectorLength = 0;\n        this.currIdx = -1;\n    }\n    set input(newInput) {\n        // @ts-ignore - `this parameter` not supported in setters/getters\n        //   - https://www.typescriptlang.org/docs/handbook/functions.html#this-parameters\n        if (this.selfAnalysisDone !== true) {\n            throw Error(`Missing <performSelfAnalysis> invocation at the end of the Parser's constructor.`);\n        }\n        // @ts-ignore - `this parameter` not supported in setters/getters\n        //   - https://www.typescriptlang.org/docs/handbook/functions.html#this-parameters\n        this.reset();\n        this.tokVector = newInput;\n        this.tokVectorLength = newInput.length;\n    }\n    get input() {\n        return this.tokVector;\n    }\n    // skips a token and returns the next token\n    SKIP_TOKEN() {\n        if (this.currIdx <= this.tokVector.length - 2) {\n            this.consumeToken();\n            return this.LA(1);\n        }\n        else {\n            return END_OF_FILE;\n        }\n    }\n    // Lexer (accessing Token vector) related methods which can be overridden to implement lazy lexers\n    // or lexers dependent on parser context.\n    LA(howMuch) {\n        const soughtIdx = this.currIdx + howMuch;\n        if (soughtIdx < 0 || this.tokVectorLength <= soughtIdx) {\n            return END_OF_FILE;\n        }\n        else {\n            return this.tokVector[soughtIdx];\n        }\n    }\n    consumeToken() {\n        this.currIdx++;\n    }\n    exportLexerState() {\n        return this.currIdx;\n    }\n    importLexerState(newState) {\n        this.currIdx = newState;\n    }\n    resetLexerState() {\n        this.currIdx = -1;\n    }\n    moveToTerminatedState() {\n        this.currIdx = this.tokVector.length - 1;\n    }\n    getLexerPosition() {\n        return this.exportLexerState();\n    }\n}\n//# sourceMappingURL=lexer_adapter.js.map"],"names":[],"mappings":";AAQO,MAAM,aAAa;AAAA,EACtB,mBAAmB;AACf,SAAK,YAAY,CAAA;AACjB,SAAK,kBAAkB;AACvB,SAAK,UAAU;AAAA,EACnB;AAAA,EACA,IAAI,MAAM,UAAU;AAGhB,QAAI,KAAK,qBAAqB,MAAM;AAChC,YAAM,MAAM,kFAAkF;AAAA,IAClG;AAGA,SAAK,MAAK;AACV,SAAK,YAAY;AACjB,SAAK,kBAAkB,SAAS;AAAA,EACpC;AAAA,EACA,IAAI,QAAQ;AACR,WAAO,KAAK;AAAA,EAChB;AAAA;AAAA,EAEA,aAAa;AACT,QAAI,KAAK,WAAW,KAAK,UAAU,SAAS,GAAG;AAC3C,WAAK,aAAY;AACjB,aAAO,KAAK,GAAG,CAAC;AAAA,IACpB,OACK;AACD,aAAO;AAAA,IACX;AAAA,EACJ;AAAA;AAAA;AAAA,EAGA,GAAG,SAAS;AACR,UAAM,YAAY,KAAK,UAAU;AACjC,QAAI,YAAY,KAAK,KAAK,mBAAmB,WAAW;AACpD,aAAO;AAAA,IACX,OACK;AACD,aAAO,KAAK,UAAU,SAAS;AAAA,IACnC;AAAA,EACJ;AAAA,EACA,eAAe;AACX,SAAK;AAAA,EACT;AAAA,EACA,mBAAmB;AACf,WAAO,KAAK;AAAA,EAChB;AAAA,EACA,iBAAiB,UAAU;AACvB,SAAK,UAAU;AAAA,EACnB;AAAA,EACA,kBAAkB;AACd,SAAK,UAAU;AAAA,EACnB;AAAA,EACA,wBAAwB;AACpB,SAAK,UAAU,KAAK,UAAU,SAAS;AAAA,EAC3C;AAAA,EACA,mBAAmB;AACf,WAAO,KAAK,iBAAgB;AAAA,EAChC;AACJ;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,130 @@
+import { DEFAULT_PARSER_CONFIG } from "../parser.mjs";
+import { getKeyForAutomaticLookahead, OR_IDX, MANY_IDX, OPTION_IDX, AT_LEAST_ONE_IDX, AT_LEAST_ONE_SEP_IDX, MANY_SEP_IDX } from "../../grammar/keys.mjs";
+import { GAstVisitor } from "../../../../../../../../@chevrotain_gast@11.0.3/node_modules/@chevrotain/gast/lib/src/visitor.mjs";
+import { getProductionDslName } from "../../../../../../../../@chevrotain_gast@11.0.3/node_modules/@chevrotain/gast/lib/src/helpers.mjs";
+import { LLkLookaheadStrategy } from "../../grammar/llk_lookahead.mjs";
+import has from "../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/has.mjs";
+import forEach from "../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/forEach.mjs";
+class LooksAhead {
+  initLooksAhead(config) {
+    this.dynamicTokensEnabled = has(config, "dynamicTokensEnabled") ? config.dynamicTokensEnabled : DEFAULT_PARSER_CONFIG.dynamicTokensEnabled;
+    this.maxLookahead = has(config, "maxLookahead") ? config.maxLookahead : DEFAULT_PARSER_CONFIG.maxLookahead;
+    this.lookaheadStrategy = has(config, "lookaheadStrategy") ? config.lookaheadStrategy : new LLkLookaheadStrategy({ maxLookahead: this.maxLookahead });
+    this.lookAheadFuncsCache = /* @__PURE__ */ new Map();
+  }
+  preComputeLookaheadFunctions(rules) {
+    forEach(rules, (currRule) => {
+      this.TRACE_INIT(`${currRule.name} Rule Lookahead`, () => {
+        const { alternation, repetition, option, repetitionMandatory, repetitionMandatoryWithSeparator, repetitionWithSeparator } = collectMethods(currRule);
+        forEach(alternation, (currProd) => {
+          const prodIdx = currProd.idx === 0 ? "" : currProd.idx;
+          this.TRACE_INIT(`${getProductionDslName(currProd)}${prodIdx}`, () => {
+            const laFunc = this.lookaheadStrategy.buildLookaheadForAlternation({
+              prodOccurrence: currProd.idx,
+              rule: currRule,
+              maxLookahead: currProd.maxLookahead || this.maxLookahead,
+              hasPredicates: currProd.hasPredicates,
+              dynamicTokensEnabled: this.dynamicTokensEnabled
+            });
+            const key = getKeyForAutomaticLookahead(this.fullRuleNameToShort[currRule.name], OR_IDX, currProd.idx);
+            this.setLaFuncCache(key, laFunc);
+          });
+        });
+        forEach(repetition, (currProd) => {
+          this.computeLookaheadFunc(currRule, currProd.idx, MANY_IDX, "Repetition", currProd.maxLookahead, getProductionDslName(currProd));
+        });
+        forEach(option, (currProd) => {
+          this.computeLookaheadFunc(currRule, currProd.idx, OPTION_IDX, "Option", currProd.maxLookahead, getProductionDslName(currProd));
+        });
+        forEach(repetitionMandatory, (currProd) => {
+          this.computeLookaheadFunc(currRule, currProd.idx, AT_LEAST_ONE_IDX, "RepetitionMandatory", currProd.maxLookahead, getProductionDslName(currProd));
+        });
+        forEach(repetitionMandatoryWithSeparator, (currProd) => {
+          this.computeLookaheadFunc(currRule, currProd.idx, AT_LEAST_ONE_SEP_IDX, "RepetitionMandatoryWithSeparator", currProd.maxLookahead, getProductionDslName(currProd));
+        });
+        forEach(repetitionWithSeparator, (currProd) => {
+          this.computeLookaheadFunc(currRule, currProd.idx, MANY_SEP_IDX, "RepetitionWithSeparator", currProd.maxLookahead, getProductionDslName(currProd));
+        });
+      });
+    });
+  }
+  computeLookaheadFunc(rule, prodOccurrence, prodKey, prodType, prodMaxLookahead, dslMethodName) {
+    this.TRACE_INIT(`${dslMethodName}${prodOccurrence === 0 ? "" : prodOccurrence}`, () => {
+      const laFunc = this.lookaheadStrategy.buildLookaheadForOptional({
+        prodOccurrence,
+        rule,
+        maxLookahead: prodMaxLookahead || this.maxLookahead,
+        dynamicTokensEnabled: this.dynamicTokensEnabled,
+        prodType
+      });
+      const key = getKeyForAutomaticLookahead(this.fullRuleNameToShort[rule.name], prodKey, prodOccurrence);
+      this.setLaFuncCache(key, laFunc);
+    });
+  }
+  // this actually returns a number, but it is always used as a string (object prop key)
+  getKeyForAutomaticLookahead(dslMethodIdx, occurrence) {
+    const currRuleShortName = this.getLastExplicitRuleShortName();
+    return getKeyForAutomaticLookahead(currRuleShortName, dslMethodIdx, occurrence);
+  }
+  getLaFuncFromCache(key) {
+    return this.lookAheadFuncsCache.get(key);
+  }
+  /* istanbul ignore next */
+  setLaFuncCache(key, value) {
+    this.lookAheadFuncsCache.set(key, value);
+  }
+}
+class DslMethodsCollectorVisitor extends GAstVisitor {
+  constructor() {
+    super(...arguments);
+    this.dslMethods = {
+      option: [],
+      alternation: [],
+      repetition: [],
+      repetitionWithSeparator: [],
+      repetitionMandatory: [],
+      repetitionMandatoryWithSeparator: []
+    };
+  }
+  reset() {
+    this.dslMethods = {
+      option: [],
+      alternation: [],
+      repetition: [],
+      repetitionWithSeparator: [],
+      repetitionMandatory: [],
+      repetitionMandatoryWithSeparator: []
+    };
+  }
+  visitOption(option) {
+    this.dslMethods.option.push(option);
+  }
+  visitRepetitionWithSeparator(manySep) {
+    this.dslMethods.repetitionWithSeparator.push(manySep);
+  }
+  visitRepetitionMandatory(atLeastOne) {
+    this.dslMethods.repetitionMandatory.push(atLeastOne);
+  }
+  visitRepetitionMandatoryWithSeparator(atLeastOneSep) {
+    this.dslMethods.repetitionMandatoryWithSeparator.push(atLeastOneSep);
+  }
+  visitRepetition(many) {
+    this.dslMethods.repetition.push(many);
+  }
+  visitAlternation(or) {
+    this.dslMethods.alternation.push(or);
+  }
+}
+const collectorVisitor = new DslMethodsCollectorVisitor();
+function collectMethods(rule) {
+  collectorVisitor.reset();
+  rule.accept(collectorVisitor);
+  const dslMethods = collectorVisitor.dslMethods;
+  collectorVisitor.reset();
+  return dslMethods;
+}
+export {
+  LooksAhead,
+  collectMethods
+};
+//# sourceMappingURL=looksahead.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"looksahead.mjs","sources":["../../../../../../../../../../../../../node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/parser/traits/looksahead.js"],"sourcesContent":["import { forEach, has } from \"lodash-es\";\nimport { DEFAULT_PARSER_CONFIG } from \"../parser.js\";\nimport { AT_LEAST_ONE_IDX, AT_LEAST_ONE_SEP_IDX, getKeyForAutomaticLookahead, MANY_IDX, MANY_SEP_IDX, OPTION_IDX, OR_IDX, } from \"../../grammar/keys.js\";\nimport { GAstVisitor, getProductionDslName, } from \"@chevrotain/gast\";\nimport { LLkLookaheadStrategy } from \"../../grammar/llk_lookahead.js\";\n/**\n * Trait responsible for the lookahead related utilities and optimizations.\n */\nexport class LooksAhead {\n    initLooksAhead(config) {\n        this.dynamicTokensEnabled = has(config, \"dynamicTokensEnabled\")\n            ? config.dynamicTokensEnabled // assumes end user provides the correct config value/type\n            : DEFAULT_PARSER_CONFIG.dynamicTokensEnabled;\n        this.maxLookahead = has(config, \"maxLookahead\")\n            ? config.maxLookahead // assumes end user provides the correct config value/type\n            : DEFAULT_PARSER_CONFIG.maxLookahead;\n        this.lookaheadStrategy = has(config, \"lookaheadStrategy\")\n            ? config.lookaheadStrategy // assumes end user provides the correct config value/type\n            : new LLkLookaheadStrategy({ maxLookahead: this.maxLookahead });\n        this.lookAheadFuncsCache = new Map();\n    }\n    preComputeLookaheadFunctions(rules) {\n        forEach(rules, (currRule) => {\n            this.TRACE_INIT(`${currRule.name} Rule Lookahead`, () => {\n                const { alternation, repetition, option, repetitionMandatory, repetitionMandatoryWithSeparator, repetitionWithSeparator, } = collectMethods(currRule);\n                forEach(alternation, (currProd) => {\n                    const prodIdx = currProd.idx === 0 ? \"\" : currProd.idx;\n                    this.TRACE_INIT(`${getProductionDslName(currProd)}${prodIdx}`, () => {\n                        const laFunc = this.lookaheadStrategy.buildLookaheadForAlternation({\n                            prodOccurrence: currProd.idx,\n                            rule: currRule,\n                            maxLookahead: currProd.maxLookahead || this.maxLookahead,\n                            hasPredicates: currProd.hasPredicates,\n                            dynamicTokensEnabled: this.dynamicTokensEnabled,\n                        });\n                        const key = getKeyForAutomaticLookahead(this.fullRuleNameToShort[currRule.name], OR_IDX, currProd.idx);\n                        this.setLaFuncCache(key, laFunc);\n                    });\n                });\n                forEach(repetition, (currProd) => {\n                    this.computeLookaheadFunc(currRule, currProd.idx, MANY_IDX, \"Repetition\", currProd.maxLookahead, getProductionDslName(currProd));\n                });\n                forEach(option, (currProd) => {\n                    this.computeLookaheadFunc(currRule, currProd.idx, OPTION_IDX, \"Option\", currProd.maxLookahead, getProductionDslName(currProd));\n                });\n                forEach(repetitionMandatory, (currProd) => {\n                    this.computeLookaheadFunc(currRule, currProd.idx, AT_LEAST_ONE_IDX, \"RepetitionMandatory\", currProd.maxLookahead, getProductionDslName(currProd));\n                });\n                forEach(repetitionMandatoryWithSeparator, (currProd) => {\n                    this.computeLookaheadFunc(currRule, currProd.idx, AT_LEAST_ONE_SEP_IDX, \"RepetitionMandatoryWithSeparator\", currProd.maxLookahead, getProductionDslName(currProd));\n                });\n                forEach(repetitionWithSeparator, (currProd) => {\n                    this.computeLookaheadFunc(currRule, currProd.idx, MANY_SEP_IDX, \"RepetitionWithSeparator\", currProd.maxLookahead, getProductionDslName(currProd));\n                });\n            });\n        });\n    }\n    computeLookaheadFunc(rule, prodOccurrence, prodKey, prodType, prodMaxLookahead, dslMethodName) {\n        this.TRACE_INIT(`${dslMethodName}${prodOccurrence === 0 ? \"\" : prodOccurrence}`, () => {\n            const laFunc = this.lookaheadStrategy.buildLookaheadForOptional({\n                prodOccurrence,\n                rule,\n                maxLookahead: prodMaxLookahead || this.maxLookahead,\n                dynamicTokensEnabled: this.dynamicTokensEnabled,\n                prodType,\n            });\n            const key = getKeyForAutomaticLookahead(this.fullRuleNameToShort[rule.name], prodKey, prodOccurrence);\n            this.setLaFuncCache(key, laFunc);\n        });\n    }\n    // this actually returns a number, but it is always used as a string (object prop key)\n    getKeyForAutomaticLookahead(dslMethodIdx, occurrence) {\n        const currRuleShortName = this.getLastExplicitRuleShortName();\n        return getKeyForAutomaticLookahead(currRuleShortName, dslMethodIdx, occurrence);\n    }\n    getLaFuncFromCache(key) {\n        return this.lookAheadFuncsCache.get(key);\n    }\n    /* istanbul ignore next */\n    setLaFuncCache(key, value) {\n        this.lookAheadFuncsCache.set(key, value);\n    }\n}\nclass DslMethodsCollectorVisitor extends GAstVisitor {\n    constructor() {\n        super(...arguments);\n        this.dslMethods = {\n            option: [],\n            alternation: [],\n            repetition: [],\n            repetitionWithSeparator: [],\n            repetitionMandatory: [],\n            repetitionMandatoryWithSeparator: [],\n        };\n    }\n    reset() {\n        this.dslMethods = {\n            option: [],\n            alternation: [],\n            repetition: [],\n            repetitionWithSeparator: [],\n            repetitionMandatory: [],\n            repetitionMandatoryWithSeparator: [],\n        };\n    }\n    visitOption(option) {\n        this.dslMethods.option.push(option);\n    }\n    visitRepetitionWithSeparator(manySep) {\n        this.dslMethods.repetitionWithSeparator.push(manySep);\n    }\n    visitRepetitionMandatory(atLeastOne) {\n        this.dslMethods.repetitionMandatory.push(atLeastOne);\n    }\n    visitRepetitionMandatoryWithSeparator(atLeastOneSep) {\n        this.dslMethods.repetitionMandatoryWithSeparator.push(atLeastOneSep);\n    }\n    visitRepetition(many) {\n        this.dslMethods.repetition.push(many);\n    }\n    visitAlternation(or) {\n        this.dslMethods.alternation.push(or);\n    }\n}\nconst collectorVisitor = new DslMethodsCollectorVisitor();\nexport function collectMethods(rule) {\n    collectorVisitor.reset();\n    rule.accept(collectorVisitor);\n    const dslMethods = collectorVisitor.dslMethods;\n    // avoid uncleaned references\n    collectorVisitor.reset();\n    return dslMethods;\n}\n//# sourceMappingURL=looksahead.js.map"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

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

@@ -0,0 +1,39 @@
+import { timer } from "../../../../../../../../@chevrotain_utils@11.0.3/node_modules/@chevrotain/utils/lib/src/timer.mjs";
+import { DEFAULT_PARSER_CONFIG } from "../parser.mjs";
+import has from "../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/has.mjs";
+class PerformanceTracer {
+  initPerformanceTracer(config) {
+    if (has(config, "traceInitPerf")) {
+      const userTraceInitPerf = config.traceInitPerf;
+      const traceIsNumber = typeof userTraceInitPerf === "number";
+      this.traceInitMaxIdent = traceIsNumber ? userTraceInitPerf : Infinity;
+      this.traceInitPerf = traceIsNumber ? userTraceInitPerf > 0 : userTraceInitPerf;
+    } else {
+      this.traceInitMaxIdent = 0;
+      this.traceInitPerf = DEFAULT_PARSER_CONFIG.traceInitPerf;
+    }
+    this.traceInitIndent = -1;
+  }
+  TRACE_INIT(phaseDesc, phaseImpl) {
+    if (this.traceInitPerf === true) {
+      this.traceInitIndent++;
+      const indent = new Array(this.traceInitIndent + 1).join("	");
+      if (this.traceInitIndent < this.traceInitMaxIdent) {
+        console.log(`${indent}--> <${phaseDesc}>`);
+      }
+      const { time, value } = timer(phaseImpl);
+      const traceMethod = time > 10 ? console.warn : console.log;
+      if (this.traceInitIndent < this.traceInitMaxIdent) {
+        traceMethod(`${indent}<-- <${phaseDesc}> time: ${time}ms`);
+      }
+      this.traceInitIndent--;
+      return value;
+    } else {
+      return phaseImpl();
+    }
+  }
+}
+export {
+  PerformanceTracer
+};
+//# sourceMappingURL=perf_tracer.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"perf_tracer.mjs","sources":["../../../../../../../../../../../../../node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/parser/traits/perf_tracer.js"],"sourcesContent":["import { has } from \"lodash-es\";\nimport { timer } from \"@chevrotain/utils\";\nimport { DEFAULT_PARSER_CONFIG } from \"../parser.js\";\n/**\n * Trait responsible for runtime parsing errors.\n */\nexport class PerformanceTracer {\n    initPerformanceTracer(config) {\n        if (has(config, \"traceInitPerf\")) {\n            const userTraceInitPerf = config.traceInitPerf;\n            const traceIsNumber = typeof userTraceInitPerf === \"number\";\n            this.traceInitMaxIdent = traceIsNumber\n                ? userTraceInitPerf\n                : Infinity;\n            this.traceInitPerf = traceIsNumber\n                ? userTraceInitPerf > 0\n                : userTraceInitPerf; // assumes end user provides the correct config value/type\n        }\n        else {\n            this.traceInitMaxIdent = 0;\n            this.traceInitPerf = DEFAULT_PARSER_CONFIG.traceInitPerf;\n        }\n        this.traceInitIndent = -1;\n    }\n    TRACE_INIT(phaseDesc, phaseImpl) {\n        // No need to optimize this using NOOP pattern because\n        // It is not called in a hot spot...\n        if (this.traceInitPerf === true) {\n            this.traceInitIndent++;\n            const indent = new Array(this.traceInitIndent + 1).join(\"\\t\");\n            if (this.traceInitIndent < this.traceInitMaxIdent) {\n                console.log(`${indent}--> <${phaseDesc}>`);\n            }\n            const { time, value } = timer(phaseImpl);\n            /* istanbul ignore next - Difficult to reproduce specific performance behavior (>10ms) in tests */\n            const traceMethod = time > 10 ? console.warn : console.log;\n            if (this.traceInitIndent < this.traceInitMaxIdent) {\n                traceMethod(`${indent}<-- <${phaseDesc}> time: ${time}ms`);\n            }\n            this.traceInitIndent--;\n            return value;\n        }\n        else {\n            return phaseImpl();\n        }\n    }\n}\n//# sourceMappingURL=perf_tracer.js.map"],"names":[],"mappings":";;;AAMO,MAAM,kBAAkB;AAAA,EAC3B,sBAAsB,QAAQ;AAC1B,QAAI,IAAI,QAAQ,eAAe,GAAG;AAC9B,YAAM,oBAAoB,OAAO;AACjC,YAAM,gBAAgB,OAAO,sBAAsB;AACnD,WAAK,oBAAoB,gBACnB,oBACA;AACN,WAAK,gBAAgB,gBACf,oBAAoB,IACpB;AAAA,IACV,OACK;AACD,WAAK,oBAAoB;AACzB,WAAK,gBAAgB,sBAAsB;AAAA,IAC/C;AACA,SAAK,kBAAkB;AAAA,EAC3B;AAAA,EACA,WAAW,WAAW,WAAW;AAG7B,QAAI,KAAK,kBAAkB,MAAM;AAC7B,WAAK;AACL,YAAM,SAAS,IAAI,MAAM,KAAK,kBAAkB,CAAC,EAAE,KAAK,GAAI;AAC5D,UAAI,KAAK,kBAAkB,KAAK,mBAAmB;AAC/C,gBAAQ,IAAI,GAAG,MAAM,QAAQ,SAAS,GAAG;AAAA,MAC7C;AACA,YAAM,EAAE,MAAM,UAAU,MAAM,SAAS;AAEvC,YAAM,cAAc,OAAO,KAAK,QAAQ,OAAO,QAAQ;AACvD,UAAI,KAAK,kBAAkB,KAAK,mBAAmB;AAC/C,oBAAY,GAAG,MAAM,QAAQ,SAAS,WAAW,IAAI,IAAI;AAAA,MAC7D;AACA,WAAK;AACL,aAAO;AAAA,IACX,OACK;AACD,aAAO,UAAS;AAAA,IACpB;AAAA,EACJ;AACJ;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,325 @@
+import { isRecognitionException } from "../../exceptions_public.mjs";
+import { DEFAULT_RULE_CONFIG, ParserDefinitionErrorType } from "../parser.mjs";
+import { defaultGrammarValidatorErrorProvider } from "../../errors_public.mjs";
+import { validateRuleIsOverridden } from "../../grammar/checks.mjs";
+import { serializeGrammar } from "../../../../../../../../@chevrotain_gast@11.0.3/node_modules/@chevrotain/gast/lib/src/model.mjs";
+import includes from "../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/includes.mjs";
+import values from "../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/values.mjs";
+class RecognizerApi {
+  ACTION(impl) {
+    return impl.call(this);
+  }
+  consume(idx, tokType, options) {
+    return this.consumeInternal(tokType, idx, options);
+  }
+  subrule(idx, ruleToCall, options) {
+    return this.subruleInternal(ruleToCall, idx, options);
+  }
+  option(idx, actionORMethodDef) {
+    return this.optionInternal(actionORMethodDef, idx);
+  }
+  or(idx, altsOrOpts) {
+    return this.orInternal(altsOrOpts, idx);
+  }
+  many(idx, actionORMethodDef) {
+    return this.manyInternal(idx, actionORMethodDef);
+  }
+  atLeastOne(idx, actionORMethodDef) {
+    return this.atLeastOneInternal(idx, actionORMethodDef);
+  }
+  CONSUME(tokType, options) {
+    return this.consumeInternal(tokType, 0, options);
+  }
+  CONSUME1(tokType, options) {
+    return this.consumeInternal(tokType, 1, options);
+  }
+  CONSUME2(tokType, options) {
+    return this.consumeInternal(tokType, 2, options);
+  }
+  CONSUME3(tokType, options) {
+    return this.consumeInternal(tokType, 3, options);
+  }
+  CONSUME4(tokType, options) {
+    return this.consumeInternal(tokType, 4, options);
+  }
+  CONSUME5(tokType, options) {
+    return this.consumeInternal(tokType, 5, options);
+  }
+  CONSUME6(tokType, options) {
+    return this.consumeInternal(tokType, 6, options);
+  }
+  CONSUME7(tokType, options) {
+    return this.consumeInternal(tokType, 7, options);
+  }
+  CONSUME8(tokType, options) {
+    return this.consumeInternal(tokType, 8, options);
+  }
+  CONSUME9(tokType, options) {
+    return this.consumeInternal(tokType, 9, options);
+  }
+  SUBRULE(ruleToCall, options) {
+    return this.subruleInternal(ruleToCall, 0, options);
+  }
+  SUBRULE1(ruleToCall, options) {
+    return this.subruleInternal(ruleToCall, 1, options);
+  }
+  SUBRULE2(ruleToCall, options) {
+    return this.subruleInternal(ruleToCall, 2, options);
+  }
+  SUBRULE3(ruleToCall, options) {
+    return this.subruleInternal(ruleToCall, 3, options);
+  }
+  SUBRULE4(ruleToCall, options) {
+    return this.subruleInternal(ruleToCall, 4, options);
+  }
+  SUBRULE5(ruleToCall, options) {
+    return this.subruleInternal(ruleToCall, 5, options);
+  }
+  SUBRULE6(ruleToCall, options) {
+    return this.subruleInternal(ruleToCall, 6, options);
+  }
+  SUBRULE7(ruleToCall, options) {
+    return this.subruleInternal(ruleToCall, 7, options);
+  }
+  SUBRULE8(ruleToCall, options) {
+    return this.subruleInternal(ruleToCall, 8, options);
+  }
+  SUBRULE9(ruleToCall, options) {
+    return this.subruleInternal(ruleToCall, 9, options);
+  }
+  OPTION(actionORMethodDef) {
+    return this.optionInternal(actionORMethodDef, 0);
+  }
+  OPTION1(actionORMethodDef) {
+    return this.optionInternal(actionORMethodDef, 1);
+  }
+  OPTION2(actionORMethodDef) {
+    return this.optionInternal(actionORMethodDef, 2);
+  }
+  OPTION3(actionORMethodDef) {
+    return this.optionInternal(actionORMethodDef, 3);
+  }
+  OPTION4(actionORMethodDef) {
+    return this.optionInternal(actionORMethodDef, 4);
+  }
+  OPTION5(actionORMethodDef) {
+    return this.optionInternal(actionORMethodDef, 5);
+  }
+  OPTION6(actionORMethodDef) {
+    return this.optionInternal(actionORMethodDef, 6);
+  }
+  OPTION7(actionORMethodDef) {
+    return this.optionInternal(actionORMethodDef, 7);
+  }
+  OPTION8(actionORMethodDef) {
+    return this.optionInternal(actionORMethodDef, 8);
+  }
+  OPTION9(actionORMethodDef) {
+    return this.optionInternal(actionORMethodDef, 9);
+  }
+  OR(altsOrOpts) {
+    return this.orInternal(altsOrOpts, 0);
+  }
+  OR1(altsOrOpts) {
+    return this.orInternal(altsOrOpts, 1);
+  }
+  OR2(altsOrOpts) {
+    return this.orInternal(altsOrOpts, 2);
+  }
+  OR3(altsOrOpts) {
+    return this.orInternal(altsOrOpts, 3);
+  }
+  OR4(altsOrOpts) {
+    return this.orInternal(altsOrOpts, 4);
+  }
+  OR5(altsOrOpts) {
+    return this.orInternal(altsOrOpts, 5);
+  }
+  OR6(altsOrOpts) {
+    return this.orInternal(altsOrOpts, 6);
+  }
+  OR7(altsOrOpts) {
+    return this.orInternal(altsOrOpts, 7);
+  }
+  OR8(altsOrOpts) {
+    return this.orInternal(altsOrOpts, 8);
+  }
+  OR9(altsOrOpts) {
+    return this.orInternal(altsOrOpts, 9);
+  }
+  MANY(actionORMethodDef) {
+    this.manyInternal(0, actionORMethodDef);
+  }
+  MANY1(actionORMethodDef) {
+    this.manyInternal(1, actionORMethodDef);
+  }
+  MANY2(actionORMethodDef) {
+    this.manyInternal(2, actionORMethodDef);
+  }
+  MANY3(actionORMethodDef) {
+    this.manyInternal(3, actionORMethodDef);
+  }
+  MANY4(actionORMethodDef) {
+    this.manyInternal(4, actionORMethodDef);
+  }
+  MANY5(actionORMethodDef) {
+    this.manyInternal(5, actionORMethodDef);
+  }
+  MANY6(actionORMethodDef) {
+    this.manyInternal(6, actionORMethodDef);
+  }
+  MANY7(actionORMethodDef) {
+    this.manyInternal(7, actionORMethodDef);
+  }
+  MANY8(actionORMethodDef) {
+    this.manyInternal(8, actionORMethodDef);
+  }
+  MANY9(actionORMethodDef) {
+    this.manyInternal(9, actionORMethodDef);
+  }
+  MANY_SEP(options) {
+    this.manySepFirstInternal(0, options);
+  }
+  MANY_SEP1(options) {
+    this.manySepFirstInternal(1, options);
+  }
+  MANY_SEP2(options) {
+    this.manySepFirstInternal(2, options);
+  }
+  MANY_SEP3(options) {
+    this.manySepFirstInternal(3, options);
+  }
+  MANY_SEP4(options) {
+    this.manySepFirstInternal(4, options);
+  }
+  MANY_SEP5(options) {
+    this.manySepFirstInternal(5, options);
+  }
+  MANY_SEP6(options) {
+    this.manySepFirstInternal(6, options);
+  }
+  MANY_SEP7(options) {
+    this.manySepFirstInternal(7, options);
+  }
+  MANY_SEP8(options) {
+    this.manySepFirstInternal(8, options);
+  }
+  MANY_SEP9(options) {
+    this.manySepFirstInternal(9, options);
+  }
+  AT_LEAST_ONE(actionORMethodDef) {
+    this.atLeastOneInternal(0, actionORMethodDef);
+  }
+  AT_LEAST_ONE1(actionORMethodDef) {
+    return this.atLeastOneInternal(1, actionORMethodDef);
+  }
+  AT_LEAST_ONE2(actionORMethodDef) {
+    this.atLeastOneInternal(2, actionORMethodDef);
+  }
+  AT_LEAST_ONE3(actionORMethodDef) {
+    this.atLeastOneInternal(3, actionORMethodDef);
+  }
+  AT_LEAST_ONE4(actionORMethodDef) {
+    this.atLeastOneInternal(4, actionORMethodDef);
+  }
+  AT_LEAST_ONE5(actionORMethodDef) {
+    this.atLeastOneInternal(5, actionORMethodDef);
+  }
+  AT_LEAST_ONE6(actionORMethodDef) {
+    this.atLeastOneInternal(6, actionORMethodDef);
+  }
+  AT_LEAST_ONE7(actionORMethodDef) {
+    this.atLeastOneInternal(7, actionORMethodDef);
+  }
+  AT_LEAST_ONE8(actionORMethodDef) {
+    this.atLeastOneInternal(8, actionORMethodDef);
+  }
+  AT_LEAST_ONE9(actionORMethodDef) {
+    this.atLeastOneInternal(9, actionORMethodDef);
+  }
+  AT_LEAST_ONE_SEP(options) {
+    this.atLeastOneSepFirstInternal(0, options);
+  }
+  AT_LEAST_ONE_SEP1(options) {
+    this.atLeastOneSepFirstInternal(1, options);
+  }
+  AT_LEAST_ONE_SEP2(options) {
+    this.atLeastOneSepFirstInternal(2, options);
+  }
+  AT_LEAST_ONE_SEP3(options) {
+    this.atLeastOneSepFirstInternal(3, options);
+  }
+  AT_LEAST_ONE_SEP4(options) {
+    this.atLeastOneSepFirstInternal(4, options);
+  }
+  AT_LEAST_ONE_SEP5(options) {
+    this.atLeastOneSepFirstInternal(5, options);
+  }
+  AT_LEAST_ONE_SEP6(options) {
+    this.atLeastOneSepFirstInternal(6, options);
+  }
+  AT_LEAST_ONE_SEP7(options) {
+    this.atLeastOneSepFirstInternal(7, options);
+  }
+  AT_LEAST_ONE_SEP8(options) {
+    this.atLeastOneSepFirstInternal(8, options);
+  }
+  AT_LEAST_ONE_SEP9(options) {
+    this.atLeastOneSepFirstInternal(9, options);
+  }
+  RULE(name, implementation, config = DEFAULT_RULE_CONFIG) {
+    if (includes(this.definedRulesNames, name)) {
+      const errMsg = defaultGrammarValidatorErrorProvider.buildDuplicateRuleNameError({
+        topLevelRule: name,
+        grammarName: this.className
+      });
+      const error = {
+        message: errMsg,
+        type: ParserDefinitionErrorType.DUPLICATE_RULE_NAME,
+        ruleName: name
+      };
+      this.definitionErrors.push(error);
+    }
+    this.definedRulesNames.push(name);
+    const ruleImplementation = this.defineRule(name, implementation, config);
+    this[name] = ruleImplementation;
+    return ruleImplementation;
+  }
+  OVERRIDE_RULE(name, impl, config = DEFAULT_RULE_CONFIG) {
+    const ruleErrors = validateRuleIsOverridden(name, this.definedRulesNames, this.className);
+    this.definitionErrors = this.definitionErrors.concat(ruleErrors);
+    const ruleImplementation = this.defineRule(name, impl, config);
+    this[name] = ruleImplementation;
+    return ruleImplementation;
+  }
+  BACKTRACK(grammarRule, args) {
+    return function() {
+      this.isBackTrackingStack.push(1);
+      const orgState = this.saveRecogState();
+      try {
+        grammarRule.apply(this, args);
+        return true;
+      } catch (e) {
+        if (isRecognitionException(e)) {
+          return false;
+        } else {
+          throw e;
+        }
+      } finally {
+        this.reloadRecogState(orgState);
+        this.isBackTrackingStack.pop();
+      }
+    };
+  }
+  // GAST export APIs
+  getGAstProductions() {
+    return this.gastProductionsCache;
+  }
+  getSerializedGastProductions() {
+    return serializeGrammar(values(this.gastProductionsCache));
+  }
+}
+export {
+  RecognizerApi
+};
+//# sourceMappingURL=recognizer_api.mjs.map