@elmethis/core 1.0.0-alpha.146 → 1.0.0-alpha.148

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

@@ -0,0 +1,25 @@
+import { nextPossibleTokensAfter, NextAfterTokenWalker } from "../../grammar/interpreter.mjs";
+import { isUndefined, first } from "lodash-es";
+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 = first(grammarPath.ruleStack);
+    const gastProductions = this.getGAstProductions();
+    const topProduction = gastProductions[topRuleName];
+    const nextPossibleTokenTypes = new NextAfterTokenWalker(topProduction, grammarPath).startWalking();
+    return nextPossibleTokenTypes;
+  }
+}
+export {
+  ContentAssist
+};

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

@@ -0,0 +1,69 @@
+import { isRecognitionException, EarlyExitException, NoViableAltException } from "../../exceptions_public.mjs";
+import { has, clone } from "lodash-es";
+import { getLookaheadPathsForOptionalProd, getLookaheadPathsForOr } from "../../grammar/lookahead.mjs";
+import { DEFAULT_PARSER_CONFIG } from "../parser.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
+};

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

@@ -0,0 +1,270 @@
+import { has, last, isFunction, isArray, some, forEach } from "lodash-es";
+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";
+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
+};

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

@@ -0,0 +1,59 @@
+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
+};

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

@@ -0,0 +1,128 @@
+import { has, forEach } from "lodash-es";
+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";
+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
+};

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

@@ -0,0 +1,38 @@
+import { has } from "lodash-es";
+import { timer } from "../../../../../../../../@chevrotain_utils@11.0.3/node_modules/@chevrotain/utils/lib/src/timer.mjs";
+import { DEFAULT_PARSER_CONFIG } from "../parser.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
+};