@elmethis/core 1.0.0-alpha.149 → 1.0.0-alpha.150

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

@@ -1,25 +0,0 @@
-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

@@ -1,69 +0,0 @@
-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

@@ -1,270 +0,0 @@
-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

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

@@ -1,128 +0,0 @@
-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

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