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/parser.mjs

@@ -0,0 +1,187 @@
+import { toFastProperties } from "../../../../../../../@chevrotain_utils@11.0.3/node_modules/@chevrotain/utils/lib/src/to-fast-properties.mjs";
+import { computeAllProdsFollows } from "../grammar/follow.mjs";
+import { createTokenInstance, EOF } from "../../scan/tokens_public.mjs";
+import { defaultParserErrorProvider, defaultGrammarValidatorErrorProvider } from "../errors_public.mjs";
+import { resolveGrammar, validateGrammar } from "../grammar/gast/gast_resolver_public.mjs";
+import { Recoverable } from "./traits/recoverable.mjs";
+import { LooksAhead } from "./traits/looksahead.mjs";
+import { TreeBuilder } from "./traits/tree_builder.mjs";
+import { LexerAdapter } from "./traits/lexer_adapter.mjs";
+import { RecognizerApi } from "./traits/recognizer_api.mjs";
+import { RecognizerEngine } from "./traits/recognizer_engine.mjs";
+import { ErrorHandler } from "./traits/error_handler.mjs";
+import { ContentAssist } from "./traits/context_assist.mjs";
+import { GastRecorder } from "./traits/gast_recorder.mjs";
+import { PerformanceTracer } from "./traits/perf_tracer.mjs";
+import { applyMixins } from "./utils/apply_mixins.mjs";
+import { validateLookahead } from "../grammar/checks.mjs";
+import clone from "../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/clone.mjs";
+import forEach from "../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/forEach.mjs";
+import values from "../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/values.mjs";
+import isEmpty from "../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/isEmpty.mjs";
+import map from "../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/map.mjs";
+import has from "../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/has.mjs";
+const END_OF_FILE = createTokenInstance(EOF, "", NaN, NaN, NaN, NaN, NaN, NaN);
+Object.freeze(END_OF_FILE);
+const DEFAULT_PARSER_CONFIG = Object.freeze({
+  recoveryEnabled: false,
+  maxLookahead: 3,
+  dynamicTokensEnabled: false,
+  outputCst: true,
+  errorMessageProvider: defaultParserErrorProvider,
+  nodeLocationTracking: "none",
+  traceInitPerf: false,
+  skipValidations: false
+});
+const DEFAULT_RULE_CONFIG = Object.freeze({
+  recoveryValueFunc: () => void 0,
+  resyncEnabled: true
+});
+var ParserDefinitionErrorType;
+(function(ParserDefinitionErrorType2) {
+  ParserDefinitionErrorType2[ParserDefinitionErrorType2["INVALID_RULE_NAME"] = 0] = "INVALID_RULE_NAME";
+  ParserDefinitionErrorType2[ParserDefinitionErrorType2["DUPLICATE_RULE_NAME"] = 1] = "DUPLICATE_RULE_NAME";
+  ParserDefinitionErrorType2[ParserDefinitionErrorType2["INVALID_RULE_OVERRIDE"] = 2] = "INVALID_RULE_OVERRIDE";
+  ParserDefinitionErrorType2[ParserDefinitionErrorType2["DUPLICATE_PRODUCTIONS"] = 3] = "DUPLICATE_PRODUCTIONS";
+  ParserDefinitionErrorType2[ParserDefinitionErrorType2["UNRESOLVED_SUBRULE_REF"] = 4] = "UNRESOLVED_SUBRULE_REF";
+  ParserDefinitionErrorType2[ParserDefinitionErrorType2["LEFT_RECURSION"] = 5] = "LEFT_RECURSION";
+  ParserDefinitionErrorType2[ParserDefinitionErrorType2["NONE_LAST_EMPTY_ALT"] = 6] = "NONE_LAST_EMPTY_ALT";
+  ParserDefinitionErrorType2[ParserDefinitionErrorType2["AMBIGUOUS_ALTS"] = 7] = "AMBIGUOUS_ALTS";
+  ParserDefinitionErrorType2[ParserDefinitionErrorType2["CONFLICT_TOKENS_RULES_NAMESPACE"] = 8] = "CONFLICT_TOKENS_RULES_NAMESPACE";
+  ParserDefinitionErrorType2[ParserDefinitionErrorType2["INVALID_TOKEN_NAME"] = 9] = "INVALID_TOKEN_NAME";
+  ParserDefinitionErrorType2[ParserDefinitionErrorType2["NO_NON_EMPTY_LOOKAHEAD"] = 10] = "NO_NON_EMPTY_LOOKAHEAD";
+  ParserDefinitionErrorType2[ParserDefinitionErrorType2["AMBIGUOUS_PREFIX_ALTS"] = 11] = "AMBIGUOUS_PREFIX_ALTS";
+  ParserDefinitionErrorType2[ParserDefinitionErrorType2["TOO_MANY_ALTS"] = 12] = "TOO_MANY_ALTS";
+  ParserDefinitionErrorType2[ParserDefinitionErrorType2["CUSTOM_LOOKAHEAD_VALIDATION"] = 13] = "CUSTOM_LOOKAHEAD_VALIDATION";
+})(ParserDefinitionErrorType || (ParserDefinitionErrorType = {}));
+function EMPTY_ALT(value = void 0) {
+  return function() {
+    return value;
+  };
+}
+class Parser {
+  /**
+   *  @deprecated use the **instance** method with the same name instead
+   */
+  static performSelfAnalysis(parserInstance) {
+    throw Error("The **static** `performSelfAnalysis` method has been deprecated.	\nUse the **instance** method with the same name instead.");
+  }
+  performSelfAnalysis() {
+    this.TRACE_INIT("performSelfAnalysis", () => {
+      let defErrorsMsgs;
+      this.selfAnalysisDone = true;
+      const className = this.className;
+      this.TRACE_INIT("toFastProps", () => {
+        toFastProperties(this);
+      });
+      this.TRACE_INIT("Grammar Recording", () => {
+        try {
+          this.enableRecording();
+          forEach(this.definedRulesNames, (currRuleName) => {
+            const wrappedRule = this[currRuleName];
+            const originalGrammarAction = wrappedRule["originalGrammarAction"];
+            let recordedRuleGast;
+            this.TRACE_INIT(`${currRuleName} Rule`, () => {
+              recordedRuleGast = this.topLevelRuleRecord(currRuleName, originalGrammarAction);
+            });
+            this.gastProductionsCache[currRuleName] = recordedRuleGast;
+          });
+        } finally {
+          this.disableRecording();
+        }
+      });
+      let resolverErrors = [];
+      this.TRACE_INIT("Grammar Resolving", () => {
+        resolverErrors = resolveGrammar({
+          rules: values(this.gastProductionsCache)
+        });
+        this.definitionErrors = this.definitionErrors.concat(resolverErrors);
+      });
+      this.TRACE_INIT("Grammar Validations", () => {
+        if (isEmpty(resolverErrors) && this.skipValidations === false) {
+          const validationErrors = validateGrammar({
+            rules: values(this.gastProductionsCache),
+            tokenTypes: values(this.tokensMap),
+            errMsgProvider: defaultGrammarValidatorErrorProvider,
+            grammarName: className
+          });
+          const lookaheadValidationErrors = validateLookahead({
+            lookaheadStrategy: this.lookaheadStrategy,
+            rules: values(this.gastProductionsCache),
+            tokenTypes: values(this.tokensMap),
+            grammarName: className
+          });
+          this.definitionErrors = this.definitionErrors.concat(validationErrors, lookaheadValidationErrors);
+        }
+      });
+      if (isEmpty(this.definitionErrors)) {
+        if (this.recoveryEnabled) {
+          this.TRACE_INIT("computeAllProdsFollows", () => {
+            const allFollows = computeAllProdsFollows(values(this.gastProductionsCache));
+            this.resyncFollows = allFollows;
+          });
+        }
+        this.TRACE_INIT("ComputeLookaheadFunctions", () => {
+          var _a, _b;
+          (_b = (_a = this.lookaheadStrategy).initialize) === null || _b === void 0 ? void 0 : _b.call(_a, {
+            rules: values(this.gastProductionsCache)
+          });
+          this.preComputeLookaheadFunctions(values(this.gastProductionsCache));
+        });
+      }
+      if (!Parser.DEFER_DEFINITION_ERRORS_HANDLING && !isEmpty(this.definitionErrors)) {
+        defErrorsMsgs = map(this.definitionErrors, (defError) => defError.message);
+        throw new Error(`Parser Definition Errors detected:
+ ${defErrorsMsgs.join("\n-------------------------------\n")}`);
+      }
+    });
+  }
+  constructor(tokenVocabulary, config) {
+    this.definitionErrors = [];
+    this.selfAnalysisDone = false;
+    const that = this;
+    that.initErrorHandler(config);
+    that.initLexerAdapter();
+    that.initLooksAhead(config);
+    that.initRecognizerEngine(tokenVocabulary, config);
+    that.initRecoverable(config);
+    that.initTreeBuilder(config);
+    that.initContentAssist();
+    that.initGastRecorder(config);
+    that.initPerformanceTracer(config);
+    if (has(config, "ignoredIssues")) {
+      throw new Error("The <ignoredIssues> IParserConfig property has been deprecated.\n	Please use the <IGNORE_AMBIGUITIES> flag on the relevant DSL method instead.\n	See: https://chevrotain.io/docs/guide/resolving_grammar_errors.html#IGNORING_AMBIGUITIES\n	For further details.");
+    }
+    this.skipValidations = has(config, "skipValidations") ? config.skipValidations : DEFAULT_PARSER_CONFIG.skipValidations;
+  }
+}
+Parser.DEFER_DEFINITION_ERRORS_HANDLING = false;
+applyMixins(Parser, [
+  Recoverable,
+  LooksAhead,
+  TreeBuilder,
+  LexerAdapter,
+  RecognizerEngine,
+  RecognizerApi,
+  ErrorHandler,
+  ContentAssist,
+  GastRecorder,
+  PerformanceTracer
+]);
+class EmbeddedActionsParser extends Parser {
+  constructor(tokenVocabulary, config = DEFAULT_PARSER_CONFIG) {
+    const configClone = clone(config);
+    configClone.outputCst = false;
+    super(tokenVocabulary, configClone);
+  }
+}
+export {
+  DEFAULT_PARSER_CONFIG,
+  DEFAULT_RULE_CONFIG,
+  EMPTY_ALT,
+  END_OF_FILE,
+  EmbeddedActionsParser,
+  Parser,
+  ParserDefinitionErrorType
+};
+//# sourceMappingURL=parser.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parser.mjs","sources":["../../../../../../../../../../../../node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/parser/parser.js"],"sourcesContent":["import { clone, forEach, has, isEmpty, map, values } from \"lodash-es\";\nimport { toFastProperties } from \"@chevrotain/utils\";\nimport { computeAllProdsFollows } from \"../grammar/follow.js\";\nimport { createTokenInstance, EOF } from \"../../scan/tokens_public.js\";\nimport { defaultGrammarValidatorErrorProvider, defaultParserErrorProvider, } from \"../errors_public.js\";\nimport { resolveGrammar, validateGrammar, } from \"../grammar/gast/gast_resolver_public.js\";\nimport { Recoverable } from \"./traits/recoverable.js\";\nimport { LooksAhead } from \"./traits/looksahead.js\";\nimport { TreeBuilder } from \"./traits/tree_builder.js\";\nimport { LexerAdapter } from \"./traits/lexer_adapter.js\";\nimport { RecognizerApi } from \"./traits/recognizer_api.js\";\nimport { RecognizerEngine } from \"./traits/recognizer_engine.js\";\nimport { ErrorHandler } from \"./traits/error_handler.js\";\nimport { ContentAssist } from \"./traits/context_assist.js\";\nimport { GastRecorder } from \"./traits/gast_recorder.js\";\nimport { PerformanceTracer } from \"./traits/perf_tracer.js\";\nimport { applyMixins } from \"./utils/apply_mixins.js\";\nimport { validateLookahead } from \"../grammar/checks.js\";\nexport const END_OF_FILE = createTokenInstance(EOF, \"\", NaN, NaN, NaN, NaN, NaN, NaN);\nObject.freeze(END_OF_FILE);\nexport const DEFAULT_PARSER_CONFIG = Object.freeze({\n    recoveryEnabled: false,\n    maxLookahead: 3,\n    dynamicTokensEnabled: false,\n    outputCst: true,\n    errorMessageProvider: defaultParserErrorProvider,\n    nodeLocationTracking: \"none\",\n    traceInitPerf: false,\n    skipValidations: false,\n});\nexport const DEFAULT_RULE_CONFIG = Object.freeze({\n    recoveryValueFunc: () => undefined,\n    resyncEnabled: true,\n});\nexport var ParserDefinitionErrorType;\n(function (ParserDefinitionErrorType) {\n    ParserDefinitionErrorType[ParserDefinitionErrorType[\"INVALID_RULE_NAME\"] = 0] = \"INVALID_RULE_NAME\";\n    ParserDefinitionErrorType[ParserDefinitionErrorType[\"DUPLICATE_RULE_NAME\"] = 1] = \"DUPLICATE_RULE_NAME\";\n    ParserDefinitionErrorType[ParserDefinitionErrorType[\"INVALID_RULE_OVERRIDE\"] = 2] = \"INVALID_RULE_OVERRIDE\";\n    ParserDefinitionErrorType[ParserDefinitionErrorType[\"DUPLICATE_PRODUCTIONS\"] = 3] = \"DUPLICATE_PRODUCTIONS\";\n    ParserDefinitionErrorType[ParserDefinitionErrorType[\"UNRESOLVED_SUBRULE_REF\"] = 4] = \"UNRESOLVED_SUBRULE_REF\";\n    ParserDefinitionErrorType[ParserDefinitionErrorType[\"LEFT_RECURSION\"] = 5] = \"LEFT_RECURSION\";\n    ParserDefinitionErrorType[ParserDefinitionErrorType[\"NONE_LAST_EMPTY_ALT\"] = 6] = \"NONE_LAST_EMPTY_ALT\";\n    ParserDefinitionErrorType[ParserDefinitionErrorType[\"AMBIGUOUS_ALTS\"] = 7] = \"AMBIGUOUS_ALTS\";\n    ParserDefinitionErrorType[ParserDefinitionErrorType[\"CONFLICT_TOKENS_RULES_NAMESPACE\"] = 8] = \"CONFLICT_TOKENS_RULES_NAMESPACE\";\n    ParserDefinitionErrorType[ParserDefinitionErrorType[\"INVALID_TOKEN_NAME\"] = 9] = \"INVALID_TOKEN_NAME\";\n    ParserDefinitionErrorType[ParserDefinitionErrorType[\"NO_NON_EMPTY_LOOKAHEAD\"] = 10] = \"NO_NON_EMPTY_LOOKAHEAD\";\n    ParserDefinitionErrorType[ParserDefinitionErrorType[\"AMBIGUOUS_PREFIX_ALTS\"] = 11] = \"AMBIGUOUS_PREFIX_ALTS\";\n    ParserDefinitionErrorType[ParserDefinitionErrorType[\"TOO_MANY_ALTS\"] = 12] = \"TOO_MANY_ALTS\";\n    ParserDefinitionErrorType[ParserDefinitionErrorType[\"CUSTOM_LOOKAHEAD_VALIDATION\"] = 13] = \"CUSTOM_LOOKAHEAD_VALIDATION\";\n})(ParserDefinitionErrorType || (ParserDefinitionErrorType = {}));\nexport function EMPTY_ALT(value = undefined) {\n    return function () {\n        return value;\n    };\n}\nexport class Parser {\n    /**\n     *  @deprecated use the **instance** method with the same name instead\n     */\n    static performSelfAnalysis(parserInstance) {\n        throw Error(\"The **static** `performSelfAnalysis` method has been deprecated.\" +\n            \"\\t\\nUse the **instance** method with the same name instead.\");\n    }\n    performSelfAnalysis() {\n        this.TRACE_INIT(\"performSelfAnalysis\", () => {\n            let defErrorsMsgs;\n            this.selfAnalysisDone = true;\n            const className = this.className;\n            this.TRACE_INIT(\"toFastProps\", () => {\n                // Without this voodoo magic the parser would be x3-x4 slower\n                // It seems it is better to invoke `toFastProperties` **before**\n                // Any manipulations of the `this` object done during the recording phase.\n                toFastProperties(this);\n            });\n            this.TRACE_INIT(\"Grammar Recording\", () => {\n                try {\n                    this.enableRecording();\n                    // Building the GAST\n                    forEach(this.definedRulesNames, (currRuleName) => {\n                        const wrappedRule = this[currRuleName];\n                        const originalGrammarAction = wrappedRule[\"originalGrammarAction\"];\n                        let recordedRuleGast;\n                        this.TRACE_INIT(`${currRuleName} Rule`, () => {\n                            recordedRuleGast = this.topLevelRuleRecord(currRuleName, originalGrammarAction);\n                        });\n                        this.gastProductionsCache[currRuleName] = recordedRuleGast;\n                    });\n                }\n                finally {\n                    this.disableRecording();\n                }\n            });\n            let resolverErrors = [];\n            this.TRACE_INIT(\"Grammar Resolving\", () => {\n                resolverErrors = resolveGrammar({\n                    rules: values(this.gastProductionsCache),\n                });\n                this.definitionErrors = this.definitionErrors.concat(resolverErrors);\n            });\n            this.TRACE_INIT(\"Grammar Validations\", () => {\n                // only perform additional grammar validations IFF no resolving errors have occurred.\n                // as unresolved grammar may lead to unhandled runtime exceptions in the follow up validations.\n                if (isEmpty(resolverErrors) && this.skipValidations === false) {\n                    const validationErrors = validateGrammar({\n                        rules: values(this.gastProductionsCache),\n                        tokenTypes: values(this.tokensMap),\n                        errMsgProvider: defaultGrammarValidatorErrorProvider,\n                        grammarName: className,\n                    });\n                    const lookaheadValidationErrors = validateLookahead({\n                        lookaheadStrategy: this.lookaheadStrategy,\n                        rules: values(this.gastProductionsCache),\n                        tokenTypes: values(this.tokensMap),\n                        grammarName: className,\n                    });\n                    this.definitionErrors = this.definitionErrors.concat(validationErrors, lookaheadValidationErrors);\n                }\n            });\n            // this analysis may fail if the grammar is not perfectly valid\n            if (isEmpty(this.definitionErrors)) {\n                // The results of these computations are not needed unless error recovery is enabled.\n                if (this.recoveryEnabled) {\n                    this.TRACE_INIT(\"computeAllProdsFollows\", () => {\n                        const allFollows = computeAllProdsFollows(values(this.gastProductionsCache));\n                        this.resyncFollows = allFollows;\n                    });\n                }\n                this.TRACE_INIT(\"ComputeLookaheadFunctions\", () => {\n                    var _a, _b;\n                    (_b = (_a = this.lookaheadStrategy).initialize) === null || _b === void 0 ? void 0 : _b.call(_a, {\n                        rules: values(this.gastProductionsCache),\n                    });\n                    this.preComputeLookaheadFunctions(values(this.gastProductionsCache));\n                });\n            }\n            if (!Parser.DEFER_DEFINITION_ERRORS_HANDLING &&\n                !isEmpty(this.definitionErrors)) {\n                defErrorsMsgs = map(this.definitionErrors, (defError) => defError.message);\n                throw new Error(`Parser Definition Errors detected:\\n ${defErrorsMsgs.join(\"\\n-------------------------------\\n\")}`);\n            }\n        });\n    }\n    constructor(tokenVocabulary, config) {\n        this.definitionErrors = [];\n        this.selfAnalysisDone = false;\n        const that = this;\n        that.initErrorHandler(config);\n        that.initLexerAdapter();\n        that.initLooksAhead(config);\n        that.initRecognizerEngine(tokenVocabulary, config);\n        that.initRecoverable(config);\n        that.initTreeBuilder(config);\n        that.initContentAssist();\n        that.initGastRecorder(config);\n        that.initPerformanceTracer(config);\n        if (has(config, \"ignoredIssues\")) {\n            throw new Error(\"The <ignoredIssues> IParserConfig property has been deprecated.\\n\\t\" +\n                \"Please use the <IGNORE_AMBIGUITIES> flag on the relevant DSL method instead.\\n\\t\" +\n                \"See: https://chevrotain.io/docs/guide/resolving_grammar_errors.html#IGNORING_AMBIGUITIES\\n\\t\" +\n                \"For further details.\");\n        }\n        this.skipValidations = has(config, \"skipValidations\")\n            ? config.skipValidations // casting assumes the end user passing the correct type\n            : DEFAULT_PARSER_CONFIG.skipValidations;\n    }\n}\n// Set this flag to true if you don't want the Parser to throw error when problems in it's definition are detected.\n// (normally during the parser's constructor).\n// This is a design time flag, it will not affect the runtime error handling of the parser, just design time errors,\n// for example: duplicate rule names, referencing an unresolved subrule, ect...\n// This flag should not be enabled during normal usage, it is used in special situations, for example when\n// needing to display the parser definition errors in some GUI(online playground).\nParser.DEFER_DEFINITION_ERRORS_HANDLING = false;\napplyMixins(Parser, [\n    Recoverable,\n    LooksAhead,\n    TreeBuilder,\n    LexerAdapter,\n    RecognizerEngine,\n    RecognizerApi,\n    ErrorHandler,\n    ContentAssist,\n    GastRecorder,\n    PerformanceTracer,\n]);\nexport class CstParser extends Parser {\n    constructor(tokenVocabulary, config = DEFAULT_PARSER_CONFIG) {\n        const configClone = clone(config);\n        configClone.outputCst = true;\n        super(tokenVocabulary, configClone);\n    }\n}\nexport class EmbeddedActionsParser extends Parser {\n    constructor(tokenVocabulary, config = DEFAULT_PARSER_CONFIG) {\n        const configClone = clone(config);\n        configClone.outputCst = false;\n        super(tokenVocabulary, configClone);\n    }\n}\n//# sourceMappingURL=parser.js.map"],"names":["ParserDefinitionErrorType"],"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/context_assist.mjs

@@ -0,0 +1,27 @@
+import { nextPossibleTokensAfter, NextAfterTokenWalker } from "../../grammar/interpreter.mjs";
+import isUndefined from "../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/isUndefined.mjs";
+import head from "../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/head.mjs";
+class ContentAssist {
+  initContentAssist() {
+  }
+  computeContentAssist(startRuleName, precedingInput) {
+    const startRuleGast = this.gastProductionsCache[startRuleName];
+    if (isUndefined(startRuleGast)) {
+      throw Error(`Rule ->${startRuleName}<- does not exist in this grammar.`);
+    }
+    return nextPossibleTokensAfter([startRuleGast], precedingInput, this.tokenMatcher, this.maxLookahead);
+  }
+  // TODO: should this be a member method or a utility? it does not have any state or usage of 'this'...
+  // TODO: should this be more explicitly part of the public API?
+  getNextPossibleTokenTypes(grammarPath) {
+    const topRuleName = head(grammarPath.ruleStack);
+    const gastProductions = this.getGAstProductions();
+    const topProduction = gastProductions[topRuleName];
+    const nextPossibleTokenTypes = new NextAfterTokenWalker(topProduction, grammarPath).startWalking();
+    return nextPossibleTokenTypes;
+  }
+}
+export {
+  ContentAssist
+};
+//# sourceMappingURL=context_assist.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"context_assist.mjs","sources":["../../../../../../../../../../../../../node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/parser/traits/context_assist.js"],"sourcesContent":["import { NextAfterTokenWalker, nextPossibleTokensAfter, } from \"../../grammar/interpreter.js\";\nimport { first, isUndefined } from \"lodash-es\";\nexport class ContentAssist {\n    initContentAssist() { }\n    computeContentAssist(startRuleName, precedingInput) {\n        const startRuleGast = this.gastProductionsCache[startRuleName];\n        if (isUndefined(startRuleGast)) {\n            throw Error(`Rule ->${startRuleName}<- does not exist in this grammar.`);\n        }\n        return nextPossibleTokensAfter([startRuleGast], precedingInput, this.tokenMatcher, this.maxLookahead);\n    }\n    // TODO: should this be a member method or a utility? it does not have any state or usage of 'this'...\n    // TODO: should this be more explicitly part of the public API?\n    getNextPossibleTokenTypes(grammarPath) {\n        const topRuleName = first(grammarPath.ruleStack);\n        const gastProductions = this.getGAstProductions();\n        const topProduction = gastProductions[topRuleName];\n        const nextPossibleTokenTypes = new NextAfterTokenWalker(topProduction, grammarPath).startWalking();\n        return nextPossibleTokenTypes;\n    }\n}\n//# sourceMappingURL=context_assist.js.map"],"names":["first"],"mappings":";;;AAEO,MAAM,cAAc;AAAA,EACvB,oBAAoB;AAAA,EAAE;AAAA,EACtB,qBAAqB,eAAe,gBAAgB;AAChD,UAAM,gBAAgB,KAAK,qBAAqB,aAAa;AAC7D,QAAI,YAAY,aAAa,GAAG;AAC5B,YAAM,MAAM,UAAU,aAAa,oCAAoC;AAAA,IAC3E;AACA,WAAO,wBAAwB,CAAC,aAAa,GAAG,gBAAgB,KAAK,cAAc,KAAK,YAAY;AAAA,EACxG;AAAA;AAAA;AAAA,EAGA,0BAA0B,aAAa;AACnC,UAAM,cAAcA,KAAM,YAAY,SAAS;AAC/C,UAAM,kBAAkB,KAAK,mBAAkB;AAC/C,UAAM,gBAAgB,gBAAgB,WAAW;AACjD,UAAM,yBAAyB,IAAI,qBAAqB,eAAe,WAAW,EAAE,aAAY;AAChG,WAAO;AAAA,EACX;AACJ;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,71 @@
+import { isRecognitionException, EarlyExitException, NoViableAltException } from "../../exceptions_public.mjs";
+import { getLookaheadPathsForOptionalProd, getLookaheadPathsForOr } from "../../grammar/lookahead.mjs";
+import { DEFAULT_PARSER_CONFIG } from "../parser.mjs";
+import has from "../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/has.mjs";
+import clone from "../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/clone.mjs";
+class ErrorHandler {
+  initErrorHandler(config) {
+    this._errors = [];
+    this.errorMessageProvider = has(config, "errorMessageProvider") ? config.errorMessageProvider : DEFAULT_PARSER_CONFIG.errorMessageProvider;
+  }
+  SAVE_ERROR(error) {
+    if (isRecognitionException(error)) {
+      error.context = {
+        ruleStack: this.getHumanReadableRuleStack(),
+        ruleOccurrenceStack: clone(this.RULE_OCCURRENCE_STACK)
+      };
+      this._errors.push(error);
+      return error;
+    } else {
+      throw Error("Trying to save an Error which is not a RecognitionException");
+    }
+  }
+  get errors() {
+    return clone(this._errors);
+  }
+  set errors(newErrors) {
+    this._errors = newErrors;
+  }
+  // TODO: consider caching the error message computed information
+  raiseEarlyExitException(occurrence, prodType, userDefinedErrMsg) {
+    const ruleName = this.getCurrRuleFullName();
+    const ruleGrammar = this.getGAstProductions()[ruleName];
+    const lookAheadPathsPerAlternative = getLookaheadPathsForOptionalProd(occurrence, ruleGrammar, prodType, this.maxLookahead);
+    const insideProdPaths = lookAheadPathsPerAlternative[0];
+    const actualTokens = [];
+    for (let i = 1; i <= this.maxLookahead; i++) {
+      actualTokens.push(this.LA(i));
+    }
+    const msg = this.errorMessageProvider.buildEarlyExitMessage({
+      expectedIterationPaths: insideProdPaths,
+      actual: actualTokens,
+      previous: this.LA(0),
+      customUserDescription: userDefinedErrMsg,
+      ruleName
+    });
+    throw this.SAVE_ERROR(new EarlyExitException(msg, this.LA(1), this.LA(0)));
+  }
+  // TODO: consider caching the error message computed information
+  raiseNoAltException(occurrence, errMsgTypes) {
+    const ruleName = this.getCurrRuleFullName();
+    const ruleGrammar = this.getGAstProductions()[ruleName];
+    const lookAheadPathsPerAlternative = getLookaheadPathsForOr(occurrence, ruleGrammar, this.maxLookahead);
+    const actualTokens = [];
+    for (let i = 1; i <= this.maxLookahead; i++) {
+      actualTokens.push(this.LA(i));
+    }
+    const previousToken = this.LA(0);
+    const errMsg = this.errorMessageProvider.buildNoViableAltMessage({
+      expectedPathsPerAlt: lookAheadPathsPerAlternative,
+      actual: actualTokens,
+      previous: previousToken,
+      customUserDescription: errMsgTypes,
+      ruleName: this.getCurrRuleFullName()
+    });
+    throw this.SAVE_ERROR(new NoViableAltException(errMsg, this.LA(1), previousToken));
+  }
+}
+export {
+  ErrorHandler
+};
+//# sourceMappingURL=error_handler.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"error_handler.mjs","sources":["../../../../../../../../../../../../../node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/parser/traits/error_handler.js"],"sourcesContent":["import { EarlyExitException, isRecognitionException, NoViableAltException, } from \"../../exceptions_public.js\";\nimport { clone, has } from \"lodash-es\";\nimport { getLookaheadPathsForOptionalProd, getLookaheadPathsForOr, } from \"../../grammar/lookahead.js\";\nimport { DEFAULT_PARSER_CONFIG } from \"../parser.js\";\n/**\n * Trait responsible for runtime parsing errors.\n */\nexport class ErrorHandler {\n    initErrorHandler(config) {\n        this._errors = [];\n        this.errorMessageProvider = has(config, \"errorMessageProvider\")\n            ? config.errorMessageProvider // assumes end user provides the correct config value/type\n            : DEFAULT_PARSER_CONFIG.errorMessageProvider;\n    }\n    SAVE_ERROR(error) {\n        if (isRecognitionException(error)) {\n            error.context = {\n                ruleStack: this.getHumanReadableRuleStack(),\n                ruleOccurrenceStack: clone(this.RULE_OCCURRENCE_STACK),\n            };\n            this._errors.push(error);\n            return error;\n        }\n        else {\n            throw Error(\"Trying to save an Error which is not a RecognitionException\");\n        }\n    }\n    get errors() {\n        return clone(this._errors);\n    }\n    set errors(newErrors) {\n        this._errors = newErrors;\n    }\n    // TODO: consider caching the error message computed information\n    raiseEarlyExitException(occurrence, prodType, userDefinedErrMsg) {\n        const ruleName = this.getCurrRuleFullName();\n        const ruleGrammar = this.getGAstProductions()[ruleName];\n        const lookAheadPathsPerAlternative = getLookaheadPathsForOptionalProd(occurrence, ruleGrammar, prodType, this.maxLookahead);\n        const insideProdPaths = lookAheadPathsPerAlternative[0];\n        const actualTokens = [];\n        for (let i = 1; i <= this.maxLookahead; i++) {\n            actualTokens.push(this.LA(i));\n        }\n        const msg = this.errorMessageProvider.buildEarlyExitMessage({\n            expectedIterationPaths: insideProdPaths,\n            actual: actualTokens,\n            previous: this.LA(0),\n            customUserDescription: userDefinedErrMsg,\n            ruleName: ruleName,\n        });\n        throw this.SAVE_ERROR(new EarlyExitException(msg, this.LA(1), this.LA(0)));\n    }\n    // TODO: consider caching the error message computed information\n    raiseNoAltException(occurrence, errMsgTypes) {\n        const ruleName = this.getCurrRuleFullName();\n        const ruleGrammar = this.getGAstProductions()[ruleName];\n        // TODO: getLookaheadPathsForOr can be slow for large enough maxLookahead and certain grammars, consider caching ?\n        const lookAheadPathsPerAlternative = getLookaheadPathsForOr(occurrence, ruleGrammar, this.maxLookahead);\n        const actualTokens = [];\n        for (let i = 1; i <= this.maxLookahead; i++) {\n            actualTokens.push(this.LA(i));\n        }\n        const previousToken = this.LA(0);\n        const errMsg = this.errorMessageProvider.buildNoViableAltMessage({\n            expectedPathsPerAlt: lookAheadPathsPerAlternative,\n            actual: actualTokens,\n            previous: previousToken,\n            customUserDescription: errMsgTypes,\n            ruleName: this.getCurrRuleFullName(),\n        });\n        throw this.SAVE_ERROR(new NoViableAltException(errMsg, this.LA(1), previousToken));\n    }\n}\n//# sourceMappingURL=error_handler.js.map"],"names":[],"mappings":";;;;;AAOO,MAAM,aAAa;AAAA,EACtB,iBAAiB,QAAQ;AACrB,SAAK,UAAU,CAAA;AACf,SAAK,uBAAuB,IAAI,QAAQ,sBAAsB,IACxD,OAAO,uBACP,sBAAsB;AAAA,EAChC;AAAA,EACA,WAAW,OAAO;AACd,QAAI,uBAAuB,KAAK,GAAG;AAC/B,YAAM,UAAU;AAAA,QACZ,WAAW,KAAK,0BAAyB;AAAA,QACzC,qBAAqB,MAAM,KAAK,qBAAqB;AAAA,MACrE;AACY,WAAK,QAAQ,KAAK,KAAK;AACvB,aAAO;AAAA,IACX,OACK;AACD,YAAM,MAAM,6DAA6D;AAAA,IAC7E;AAAA,EACJ;AAAA,EACA,IAAI,SAAS;AACT,WAAO,MAAM,KAAK,OAAO;AAAA,EAC7B;AAAA,EACA,IAAI,OAAO,WAAW;AAClB,SAAK,UAAU;AAAA,EACnB;AAAA;AAAA,EAEA,wBAAwB,YAAY,UAAU,mBAAmB;AAC7D,UAAM,WAAW,KAAK,oBAAmB;AACzC,UAAM,cAAc,KAAK,mBAAkB,EAAG,QAAQ;AACtD,UAAM,+BAA+B,iCAAiC,YAAY,aAAa,UAAU,KAAK,YAAY;AAC1H,UAAM,kBAAkB,6BAA6B,CAAC;AACtD,UAAM,eAAe,CAAA;AACrB,aAAS,IAAI,GAAG,KAAK,KAAK,cAAc,KAAK;AACzC,mBAAa,KAAK,KAAK,GAAG,CAAC,CAAC;AAAA,IAChC;AACA,UAAM,MAAM,KAAK,qBAAqB,sBAAsB;AAAA,MACxD,wBAAwB;AAAA,MACxB,QAAQ;AAAA,MACR,UAAU,KAAK,GAAG,CAAC;AAAA,MACnB,uBAAuB;AAAA,MACvB;AAAA,IACZ,CAAS;AACD,UAAM,KAAK,WAAW,IAAI,mBAAmB,KAAK,KAAK,GAAG,CAAC,GAAG,KAAK,GAAG,CAAC,CAAC,CAAC;AAAA,EAC7E;AAAA;AAAA,EAEA,oBAAoB,YAAY,aAAa;AACzC,UAAM,WAAW,KAAK,oBAAmB;AACzC,UAAM,cAAc,KAAK,mBAAkB,EAAG,QAAQ;AAEtD,UAAM,+BAA+B,uBAAuB,YAAY,aAAa,KAAK,YAAY;AACtG,UAAM,eAAe,CAAA;AACrB,aAAS,IAAI,GAAG,KAAK,KAAK,cAAc,KAAK;AACzC,mBAAa,KAAK,KAAK,GAAG,CAAC,CAAC;AAAA,IAChC;AACA,UAAM,gBAAgB,KAAK,GAAG,CAAC;AAC/B,UAAM,SAAS,KAAK,qBAAqB,wBAAwB;AAAA,MAC7D,qBAAqB;AAAA,MACrB,QAAQ;AAAA,MACR,UAAU;AAAA,MACV,uBAAuB;AAAA,MACvB,UAAU,KAAK,oBAAmB;AAAA,IAC9C,CAAS;AACD,UAAM,KAAK,WAAW,IAAI,qBAAqB,QAAQ,KAAK,GAAG,CAAC,GAAG,aAAa,CAAC;AAAA,EACrF;AACJ;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,276 @@
+import { Rule, Option, RepetitionMandatory, RepetitionMandatoryWithSeparator, Repetition, RepetitionWithSeparator, NonTerminal, Terminal, Alternation, Alternative } from "../../../../../../../../@chevrotain_gast@11.0.3/node_modules/@chevrotain/gast/lib/src/model.mjs";
+import { Lexer } from "../../../scan/lexer_public.mjs";
+import { augmentTokenTypes, hasShortKeyProperty } from "../../../scan/tokens.mjs";
+import { createToken, createTokenInstance } from "../../../scan/tokens_public.mjs";
+import { END_OF_FILE } from "../parser.mjs";
+import { BITS_FOR_OCCURRENCE_IDX } from "../../grammar/keys.mjs";
+import has from "../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/has.mjs";
+import last from "../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/last.mjs";
+import isFunction from "../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/isFunction.mjs";
+import some from "../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/some.mjs";
+import forEach from "../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/forEach.mjs";
+import isArray from "../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/isArray.mjs";
+const RECORDING_NULL_OBJECT = {
+  description: "This Object indicates the Parser is during Recording Phase"
+};
+Object.freeze(RECORDING_NULL_OBJECT);
+const HANDLE_SEPARATOR = true;
+const MAX_METHOD_IDX = Math.pow(2, BITS_FOR_OCCURRENCE_IDX) - 1;
+const RFT = createToken({ name: "RECORDING_PHASE_TOKEN", pattern: Lexer.NA });
+augmentTokenTypes([RFT]);
+const RECORDING_PHASE_TOKEN = createTokenInstance(
+  RFT,
+  "This IToken indicates the Parser is in Recording Phase\n	See: https://chevrotain.io/docs/guide/internals.html#grammar-recording for details",
+  // Using "-1" instead of NaN (as in EOF) because an actual number is less likely to
+  // cause errors if the output of LA or CONSUME would be (incorrectly) used during the recording phase.
+  -1,
+  -1,
+  -1,
+  -1,
+  -1,
+  -1
+);
+Object.freeze(RECORDING_PHASE_TOKEN);
+const RECORDING_PHASE_CSTNODE = {
+  name: "This CSTNode indicates the Parser is in Recording Phase\n	See: https://chevrotain.io/docs/guide/internals.html#grammar-recording for details",
+  children: {}
+};
+class GastRecorder {
+  initGastRecorder(config) {
+    this.recordingProdStack = [];
+    this.RECORDING_PHASE = false;
+  }
+  enableRecording() {
+    this.RECORDING_PHASE = true;
+    this.TRACE_INIT("Enable Recording", () => {
+      for (let i = 0; i < 10; i++) {
+        const idx = i > 0 ? i : "";
+        this[`CONSUME${idx}`] = function(arg1, arg2) {
+          return this.consumeInternalRecord(arg1, i, arg2);
+        };
+        this[`SUBRULE${idx}`] = function(arg1, arg2) {
+          return this.subruleInternalRecord(arg1, i, arg2);
+        };
+        this[`OPTION${idx}`] = function(arg1) {
+          return this.optionInternalRecord(arg1, i);
+        };
+        this[`OR${idx}`] = function(arg1) {
+          return this.orInternalRecord(arg1, i);
+        };
+        this[`MANY${idx}`] = function(arg1) {
+          this.manyInternalRecord(i, arg1);
+        };
+        this[`MANY_SEP${idx}`] = function(arg1) {
+          this.manySepFirstInternalRecord(i, arg1);
+        };
+        this[`AT_LEAST_ONE${idx}`] = function(arg1) {
+          this.atLeastOneInternalRecord(i, arg1);
+        };
+        this[`AT_LEAST_ONE_SEP${idx}`] = function(arg1) {
+          this.atLeastOneSepFirstInternalRecord(i, arg1);
+        };
+      }
+      this[`consume`] = function(idx, arg1, arg2) {
+        return this.consumeInternalRecord(arg1, idx, arg2);
+      };
+      this[`subrule`] = function(idx, arg1, arg2) {
+        return this.subruleInternalRecord(arg1, idx, arg2);
+      };
+      this[`option`] = function(idx, arg1) {
+        return this.optionInternalRecord(arg1, idx);
+      };
+      this[`or`] = function(idx, arg1) {
+        return this.orInternalRecord(arg1, idx);
+      };
+      this[`many`] = function(idx, arg1) {
+        this.manyInternalRecord(idx, arg1);
+      };
+      this[`atLeastOne`] = function(idx, arg1) {
+        this.atLeastOneInternalRecord(idx, arg1);
+      };
+      this.ACTION = this.ACTION_RECORD;
+      this.BACKTRACK = this.BACKTRACK_RECORD;
+      this.LA = this.LA_RECORD;
+    });
+  }
+  disableRecording() {
+    this.RECORDING_PHASE = false;
+    this.TRACE_INIT("Deleting Recording methods", () => {
+      const that = this;
+      for (let i = 0; i < 10; i++) {
+        const idx = i > 0 ? i : "";
+        delete that[`CONSUME${idx}`];
+        delete that[`SUBRULE${idx}`];
+        delete that[`OPTION${idx}`];
+        delete that[`OR${idx}`];
+        delete that[`MANY${idx}`];
+        delete that[`MANY_SEP${idx}`];
+        delete that[`AT_LEAST_ONE${idx}`];
+        delete that[`AT_LEAST_ONE_SEP${idx}`];
+      }
+      delete that[`consume`];
+      delete that[`subrule`];
+      delete that[`option`];
+      delete that[`or`];
+      delete that[`many`];
+      delete that[`atLeastOne`];
+      delete that.ACTION;
+      delete that.BACKTRACK;
+      delete that.LA;
+    });
+  }
+  //   Parser methods are called inside an ACTION?
+  //   Maybe try/catch/finally on ACTIONS while disabling the recorders state changes?
+  // @ts-expect-error -- noop place holder
+  ACTION_RECORD(impl) {
+  }
+  // Executing backtracking logic will break our recording logic assumptions
+  BACKTRACK_RECORD(grammarRule, args) {
+    return () => true;
+  }
+  // LA is part of the official API and may be used for custom lookahead logic
+  // by end users who may forget to wrap it in ACTION or inside a GATE
+  LA_RECORD(howMuch) {
+    return END_OF_FILE;
+  }
+  topLevelRuleRecord(name, def) {
+    try {
+      const newTopLevelRule = new Rule({ definition: [], name });
+      newTopLevelRule.name = name;
+      this.recordingProdStack.push(newTopLevelRule);
+      def.call(this);
+      this.recordingProdStack.pop();
+      return newTopLevelRule;
+    } catch (originalError) {
+      if (originalError.KNOWN_RECORDER_ERROR !== true) {
+        try {
+          originalError.message = originalError.message + '\n	 This error was thrown during the "grammar recording phase" For more info see:\n	https://chevrotain.io/docs/guide/internals.html#grammar-recording';
+        } catch (mutabilityError) {
+          throw originalError;
+        }
+      }
+      throw originalError;
+    }
+  }
+  // Implementation of parsing DSL
+  optionInternalRecord(actionORMethodDef, occurrence) {
+    return recordProd.call(this, Option, actionORMethodDef, occurrence);
+  }
+  atLeastOneInternalRecord(occurrence, actionORMethodDef) {
+    recordProd.call(this, RepetitionMandatory, actionORMethodDef, occurrence);
+  }
+  atLeastOneSepFirstInternalRecord(occurrence, options) {
+    recordProd.call(this, RepetitionMandatoryWithSeparator, options, occurrence, HANDLE_SEPARATOR);
+  }
+  manyInternalRecord(occurrence, actionORMethodDef) {
+    recordProd.call(this, Repetition, actionORMethodDef, occurrence);
+  }
+  manySepFirstInternalRecord(occurrence, options) {
+    recordProd.call(this, RepetitionWithSeparator, options, occurrence, HANDLE_SEPARATOR);
+  }
+  orInternalRecord(altsOrOpts, occurrence) {
+    return recordOrProd.call(this, altsOrOpts, occurrence);
+  }
+  subruleInternalRecord(ruleToCall, occurrence, options) {
+    assertMethodIdxIsValid(occurrence);
+    if (!ruleToCall || has(ruleToCall, "ruleName") === false) {
+      const error = new Error(`<SUBRULE${getIdxSuffix(occurrence)}> argument is invalid expecting a Parser method reference but got: <${JSON.stringify(ruleToCall)}>
+ inside top level rule: <${this.recordingProdStack[0].name}>`);
+      error.KNOWN_RECORDER_ERROR = true;
+      throw error;
+    }
+    const prevProd = last(this.recordingProdStack);
+    const ruleName = ruleToCall.ruleName;
+    const newNoneTerminal = new NonTerminal({
+      idx: occurrence,
+      nonTerminalName: ruleName,
+      label: options === null || options === void 0 ? void 0 : options.LABEL,
+      // The resolving of the `referencedRule` property will be done once all the Rule's GASTs have been created
+      referencedRule: void 0
+    });
+    prevProd.definition.push(newNoneTerminal);
+    return this.outputCst ? RECORDING_PHASE_CSTNODE : RECORDING_NULL_OBJECT;
+  }
+  consumeInternalRecord(tokType, occurrence, options) {
+    assertMethodIdxIsValid(occurrence);
+    if (!hasShortKeyProperty(tokType)) {
+      const error = new Error(`<CONSUME${getIdxSuffix(occurrence)}> argument is invalid expecting a TokenType reference but got: <${JSON.stringify(tokType)}>
+ inside top level rule: <${this.recordingProdStack[0].name}>`);
+      error.KNOWN_RECORDER_ERROR = true;
+      throw error;
+    }
+    const prevProd = last(this.recordingProdStack);
+    const newNoneTerminal = new Terminal({
+      idx: occurrence,
+      terminalType: tokType,
+      label: options === null || options === void 0 ? void 0 : options.LABEL
+    });
+    prevProd.definition.push(newNoneTerminal);
+    return RECORDING_PHASE_TOKEN;
+  }
+}
+function recordProd(prodConstructor, mainProdArg, occurrence, handleSep = false) {
+  assertMethodIdxIsValid(occurrence);
+  const prevProd = last(this.recordingProdStack);
+  const grammarAction = isFunction(mainProdArg) ? mainProdArg : mainProdArg.DEF;
+  const newProd = new prodConstructor({ definition: [], idx: occurrence });
+  if (handleSep) {
+    newProd.separator = mainProdArg.SEP;
+  }
+  if (has(mainProdArg, "MAX_LOOKAHEAD")) {
+    newProd.maxLookahead = mainProdArg.MAX_LOOKAHEAD;
+  }
+  this.recordingProdStack.push(newProd);
+  grammarAction.call(this);
+  prevProd.definition.push(newProd);
+  this.recordingProdStack.pop();
+  return RECORDING_NULL_OBJECT;
+}
+function recordOrProd(mainProdArg, occurrence) {
+  assertMethodIdxIsValid(occurrence);
+  const prevProd = last(this.recordingProdStack);
+  const hasOptions = isArray(mainProdArg) === false;
+  const alts = hasOptions === false ? mainProdArg : mainProdArg.DEF;
+  const newOrProd = new Alternation({
+    definition: [],
+    idx: occurrence,
+    ignoreAmbiguities: hasOptions && mainProdArg.IGNORE_AMBIGUITIES === true
+  });
+  if (has(mainProdArg, "MAX_LOOKAHEAD")) {
+    newOrProd.maxLookahead = mainProdArg.MAX_LOOKAHEAD;
+  }
+  const hasPredicates = some(alts, (currAlt) => isFunction(currAlt.GATE));
+  newOrProd.hasPredicates = hasPredicates;
+  prevProd.definition.push(newOrProd);
+  forEach(alts, (currAlt) => {
+    const currAltFlat = new Alternative({ definition: [] });
+    newOrProd.definition.push(currAltFlat);
+    if (has(currAlt, "IGNORE_AMBIGUITIES")) {
+      currAltFlat.ignoreAmbiguities = currAlt.IGNORE_AMBIGUITIES;
+    } else if (has(currAlt, "GATE")) {
+      currAltFlat.ignoreAmbiguities = true;
+    }
+    this.recordingProdStack.push(currAltFlat);
+    currAlt.ALT.call(this);
+    this.recordingProdStack.pop();
+  });
+  return RECORDING_NULL_OBJECT;
+}
+function getIdxSuffix(idx) {
+  return idx === 0 ? "" : `${idx}`;
+}
+function assertMethodIdxIsValid(idx) {
+  if (idx < 0 || idx > MAX_METHOD_IDX) {
+    const error = new Error(
+      // The stack trace will contain all the needed details
+      `Invalid DSL Method idx value: <${idx}>
+	Idx value must be a none negative value smaller than ${MAX_METHOD_IDX + 1}`
+    );
+    error.KNOWN_RECORDER_ERROR = true;
+    throw error;
+  }
+}
+export {
+  GastRecorder
+};
+//# sourceMappingURL=gast_recorder.mjs.map