@traqula/core 0.0.15 → 0.0.16

package/lib/index.cjs

@@ -20,7 +20,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // lib/index.ts
 var index_exports = {};
 __export(index_exports, {
-  CoreFactory: () => CoreFactory,
+  AstCoreFactory: () => AstCoreFactory,
   GeneratorBuilder: () => GeneratorBuilder,
   IndirBuilder: () => IndirBuilder,
   LexerBuilder: () => LexerBuilder,
@@ -29,12 +29,13 @@ __export(index_exports, {
   TransformerType: () => TransformerType,
   createToken: () => createToken2,
   listToIndirectionMap: () => listToIndirectionMap,
+  traqulaIndentation: () => traqulaIndentation,
   unCapitalize: () => unCapitalize
 });
 module.exports = __toCommonJS(index_exports);
 
-// lib/CoreFactory.js
-var CoreFactory = class {
+// lib/AstCoreFactory.js
+var AstCoreFactory = class {
   wrap(val, loc) {
     return { val, loc };
   }
@@ -160,421 +161,114 @@ var CoreFactory = class {
   }
 };
 
-// lib/generator-builder/dynamicGenerator.js
-var DynamicGenerator = class {
-  rules;
-  factory = new CoreFactory();
-  __context = void 0;
-  origSource = "";
-  generatedUntil = 0;
-  expectsSpace;
-  stringBuilder = [];
-  constructor(rules) {
-    this.rules = rules;
-    for (const rule of Object.values(rules)) {
-      this[rule.name] = ((input, context, args) => {
-        this.expectsSpace = false;
-        this.stringBuilder.length = 0;
-        this.origSource = context.origSource;
-        this.generatedUntil = context?.offset ?? 0;
-        this.setContext(context);
-        this.subrule(rule, input, args);
-        this.catchup(this.origSource.length);
-        return this.stringBuilder.join("");
-      });
-    }
-  }
-  setContext(context) {
-    this.__context = context;
-  }
-  getSafeContext() {
-    return this.__context;
+// ../../node_modules/lodash-es/_freeGlobal.js
+var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+var freeGlobal_default = freeGlobal;
+
+// ../../node_modules/lodash-es/_root.js
+var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+var root = freeGlobal_default || freeSelf || Function("return this")();
+var root_default = root;
+
+// ../../node_modules/lodash-es/_Symbol.js
+var Symbol2 = root_default.Symbol;
+var Symbol_default = Symbol2;
+
+// ../../node_modules/lodash-es/_getRawTag.js
+var objectProto = Object.prototype;
+var hasOwnProperty = objectProto.hasOwnProperty;
+var nativeObjectToString = objectProto.toString;
+var symToStringTag = Symbol_default ? Symbol_default.toStringTag : void 0;
+function getRawTag(value) {
+  var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
+  try {
+    value[symToStringTag] = void 0;
+    var unmasked = true;
+  } catch (e) {
   }
-  subrule = (cstDef, ast, ...arg) => {
-    const def = this.rules[cstDef.name];
-    if (!def) {
-      throw new Error(`Rule ${cstDef.name} not found`);
-    }
-    const generate = () => def.gImpl({
-      SUBRULE: this.subrule,
-      PRINT: this.print,
-      PRINT_SPACE_LEFT: this.printSpaceLeft,
-      PRINT_WORD: this.printWord,
-      PRINT_WORDS: this.printWords,
-      CATCHUP: this.catchup,
-      HANDLE_LOC: this.handleLoc
-    })(ast, this.getSafeContext(), ...arg);
-    if (this.factory.isLocalized(ast)) {
-      this.handleLoc(ast, generate);
+  var result = nativeObjectToString.call(value);
+  if (unmasked) {
+    if (isOwn) {
+      value[symToStringTag] = tag;
     } else {
-      generate();
-    }
-  };
-  handleLoc = (localized, handle) => {
-    if (this.factory.isSourceLocationNoMaterialize(localized.loc)) {
-      return;
-    }
-    if (this.factory.isSourceLocationStringReplace(localized.loc)) {
-      this.catchup(localized.loc.start);
-      this.print(localized.loc.newSource);
-      this.generatedUntil = localized.loc.end;
-      return;
-    }
-    if (this.factory.isSourceLocationNodeReplace(localized.loc)) {
-      this.catchup(localized.loc.start);
-      this.generatedUntil = localized.loc.end;
-    }
-    if (this.factory.isSourceLocationSource(localized.loc)) {
-      this.catchup(localized.loc.start);
-    }
-    const ret = handle();
-    if (this.factory.isSourceLocationSource(localized.loc)) {
-      this.catchup(localized.loc.end);
-    }
-    return ret;
-  };
-  catchup = (until) => {
-    const start = this.generatedUntil;
-    if (start < until) {
-      this.print(this.origSource.slice(start, until));
-    }
-    this.generatedUntil = Math.max(this.generatedUntil, until);
-  };
-  print = (...args) => {
-    const pureArgs = args.filter((x) => x.length > 0);
-    if (pureArgs.length > 0) {
-      const [head2, ...tail] = pureArgs;
-      if (this.expectsSpace) {
-        this.expectsSpace = false;
-        const blanks = /* @__PURE__ */ new Set(["\n", " ", "	"]);
-        if (this.stringBuilder.length > 0 && !(blanks.has(head2[0]) || blanks.has(this.stringBuilder.at(-1).at(-1)))) {
-          this.stringBuilder.push(" ");
-        }
-      }
-      this.stringBuilder.push(head2);
-      this.stringBuilder.push(...tail);
-    }
-  };
-  printWord = (...args) => {
-    this.expectsSpace = true;
-    this.print(...args);
-    this.expectsSpace = true;
-  };
-  printSpaceLeft = (...args) => {
-    this.expectsSpace = true;
-    this.print(...args);
-  };
-  printWords = (...args) => {
-    for (const arg of args) {
-      this.printWord(arg);
+      delete value[symToStringTag];
     }
-  };
-};
-
-// lib/generator-builder/generatorBuilder.js
-function listToRuleDefMap(rules) {
-  const newRules = {};
-  for (const rule of rules) {
-    newRules[rule.name] = rule;
   }
-  return newRules;
+  return result;
 }
-var GeneratorBuilder = class _GeneratorBuilder {
-  static create(start) {
-    if (start instanceof _GeneratorBuilder) {
-      return new _GeneratorBuilder({ ...start.rules });
-    }
-    return new _GeneratorBuilder(listToRuleDefMap(start));
-  }
-  rules;
-  constructor(startRules) {
-    this.rules = startRules;
-  }
-  widenContext() {
-    return this;
-  }
-  typePatch() {
-    return this;
+var getRawTag_default = getRawTag;
+
+// ../../node_modules/lodash-es/_objectToString.js
+var objectProto2 = Object.prototype;
+var nativeObjectToString2 = objectProto2.toString;
+function objectToString(value) {
+  return nativeObjectToString2.call(value);
+}
+var objectToString_default = objectToString;
+
+// ../../node_modules/lodash-es/_baseGetTag.js
+var nullTag = "[object Null]";
+var undefinedTag = "[object Undefined]";
+var symToStringTag2 = Symbol_default ? Symbol_default.toStringTag : void 0;
+function baseGetTag(value) {
+  if (value == null) {
+    return value === void 0 ? undefinedTag : nullTag;
   }
-  /**
-   * Change the implementation of an existing generator rule.
-   */
-  patchRule(patch) {
-    const self2 = this;
-    self2.rules[patch.name] = patch;
-    return self2;
+  return symToStringTag2 && symToStringTag2 in Object(value) ? getRawTag_default(value) : objectToString_default(value);
+}
+var baseGetTag_default = baseGetTag;
+
+// ../../node_modules/lodash-es/isObjectLike.js
+function isObjectLike(value) {
+  return value != null && typeof value == "object";
+}
+var isObjectLike_default = isObjectLike;
+
+// ../../node_modules/lodash-es/isSymbol.js
+var symbolTag = "[object Symbol]";
+function isSymbol(value) {
+  return typeof value == "symbol" || isObjectLike_default(value) && baseGetTag_default(value) == symbolTag;
+}
+var isSymbol_default = isSymbol;
+
+// ../../node_modules/lodash-es/_arrayMap.js
+function arrayMap(array, iteratee) {
+  var index = -1, length = array == null ? 0 : array.length, result = Array(length);
+  while (++index < length) {
+    result[index] = iteratee(array[index], index, array);
   }
-  /**
-   * Add a rule to the grammar. If the rule already exists, but the implementation differs, an error will be thrown.
-   */
-  addRuleRedundant(rule) {
-    const self2 = this;
-    const rules = self2.rules;
-    if (rules[rule.name] !== void 0 && rules[rule.name] !== rule) {
-      throw new Error(`Rule ${rule.name} already exists in the GeneratorBuilder`);
-    }
-    rules[rule.name] = rule;
-    return self2;
+  return result;
+}
+var arrayMap_default = arrayMap;
+
+// ../../node_modules/lodash-es/isArray.js
+var isArray = Array.isArray;
+var isArray_default = isArray;
+
+// ../../node_modules/lodash-es/_baseToString.js
+var INFINITY = 1 / 0;
+var symbolProto = Symbol_default ? Symbol_default.prototype : void 0;
+var symbolToString = symbolProto ? symbolProto.toString : void 0;
+function baseToString(value) {
+  if (typeof value == "string") {
+    return value;
   }
-  /**
-   * Add a rule to the grammar. Will raise a typescript error if the rule already exists in the grammar.
-   */
-  addRule(rule) {
-    return this.addRuleRedundant(rule);
+  if (isArray_default(value)) {
+    return arrayMap_default(value, baseToString) + "";
   }
-  addMany(...rules) {
-    this.rules = { ...this.rules, ...listToRuleDefMap(rules) };
-    return this;
+  if (isSymbol_default(value)) {
+    return symbolToString ? symbolToString.call(value) : "";
   }
-  /**
-   * Delete a grammar rule by its name.
-   */
-  deleteRule(ruleName) {
-    delete this.rules[ruleName];
-    return this;
-  }
-  /**
-   * Merge this grammar GeneratorBuilder with another.
-   * It is best to merge the bigger grammar with the smaller one.
-   * If the two builders both have a grammar rule with the same name,
-   * no error will be thrown case they map to the same ruledef object.
-   * If they map to a different object, an error will be thrown.
-   * To fix this problem, the overridingRules array should contain a rule with the same conflicting name,
-   * this rule implementation will be used.
-   */
-  merge(GeneratorBuilder2, overridingRules) {
-    const otherRules = { ...GeneratorBuilder2.rules };
-    const myRules = this.rules;
-    for (const rule of Object.values(myRules)) {
-      if (otherRules[rule.name] === void 0) {
-        otherRules[rule.name] = rule;
-      } else {
-        const existingRule = otherRules[rule.name];
-        if (existingRule !== rule) {
-          const override = overridingRules.find((x) => x.name === rule.name);
-          if (override) {
-            otherRules[rule.name] = override;
-          } else {
-            throw new Error(`Rule with name "${rule.name}" already exists in the GeneratorBuilder, specify an override to resolve conflict`);
-          }
-        }
-      }
-    }
-    this.rules = otherRules;
-    return this;
-  }
-  build() {
-    return new DynamicGenerator(this.rules);
-  }
-};
-
-// lib/indirection-builder/helpers.js
-function listToIndirectionMap(rules) {
-  const newRules = {};
-  for (const rule of rules) {
-    newRules[rule.name] = rule;
-  }
-  return newRules;
-}
-
-// lib/indirection-builder/dynamicIndirected.js
-var DynamicIndirect = class {
-  rules;
-  __context = void 0;
-  constructor(rules) {
-    this.rules = rules;
-    for (const rule of Object.values(rules)) {
-      this[rule.name] = ((context, ...args) => {
-        this.setContext(context);
-        return this.subrule(rule, ...args);
-      });
-    }
-  }
-  setContext(context) {
-    this.__context = context;
-  }
-  getSafeContext() {
-    return this.__context;
-  }
-  subrule = (cstDef, ...args) => {
-    const def = this.rules[cstDef.name];
-    if (!def) {
-      throw new Error(`Rule ${cstDef.name} not found`);
-    }
-    return def.fun({
-      SUBRULE: this.subrule
-    })(this.getSafeContext(), ...args);
-  };
-};
-
-// lib/indirection-builder/IndirBuilder.js
-var IndirBuilder = class _IndirBuilder {
-  static create(start) {
-    if (start instanceof _IndirBuilder) {
-      return new _IndirBuilder({ ...start.rules });
-    }
-    return new _IndirBuilder(listToIndirectionMap(start));
-  }
-  rules;
-  constructor(startRules) {
-    this.rules = startRules;
-  }
-  widenContext() {
-    return this;
-  }
-  typePatch() {
-    return this;
-  }
-  /**
-   * Change the implementation of an existing indirection.
-   */
-  patchRule(patch) {
-    const self2 = this;
-    self2.rules[patch.name] = patch;
-    return self2;
-  }
-  /**
-   * Add an indirection function. If the rule already exists, but the implementation differs, an error will be thrown.
-   */
-  addRuleRedundant(rule) {
-    const self2 = this;
-    const rules = self2.rules;
-    if (rules[rule.name] !== void 0 && rules[rule.name] !== rule) {
-      throw new Error(`Function ${rule.name} already exists in the builder`);
-    }
-    rules[rule.name] = rule;
-    return self2;
-  }
-  /**
-   * Add a rule to the grammar. Will raise a typescript error if the rule already exists in the grammar.
-   */
-  addRule(rule) {
-    return this.addRuleRedundant(rule);
-  }
-  addMany(...rules) {
-    this.rules = { ...this.rules, ...listToIndirectionMap(rules) };
-    return this;
-  }
-  /**
-   * Delete a grammar rule by its name.
-   */
-  deleteRule(ruleName) {
-    delete this.rules[ruleName];
-    return this;
-  }
-  build() {
-    return new DynamicIndirect(this.rules);
-  }
-};
-
-// ../../node_modules/lodash-es/_freeGlobal.js
-var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
-var freeGlobal_default = freeGlobal;
-
-// ../../node_modules/lodash-es/_root.js
-var freeSelf = typeof self == "object" && self && self.Object === Object && self;
-var root = freeGlobal_default || freeSelf || Function("return this")();
-var root_default = root;
-
-// ../../node_modules/lodash-es/_Symbol.js
-var Symbol2 = root_default.Symbol;
-var Symbol_default = Symbol2;
-
-// ../../node_modules/lodash-es/_getRawTag.js
-var objectProto = Object.prototype;
-var hasOwnProperty = objectProto.hasOwnProperty;
-var nativeObjectToString = objectProto.toString;
-var symToStringTag = Symbol_default ? Symbol_default.toStringTag : void 0;
-function getRawTag(value) {
-  var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
-  try {
-    value[symToStringTag] = void 0;
-    var unmasked = true;
-  } catch (e) {
-  }
-  var result = nativeObjectToString.call(value);
-  if (unmasked) {
-    if (isOwn) {
-      value[symToStringTag] = tag;
-    } else {
-      delete value[symToStringTag];
-    }
-  }
-  return result;
-}
-var getRawTag_default = getRawTag;
-
-// ../../node_modules/lodash-es/_objectToString.js
-var objectProto2 = Object.prototype;
-var nativeObjectToString2 = objectProto2.toString;
-function objectToString(value) {
-  return nativeObjectToString2.call(value);
-}
-var objectToString_default = objectToString;
-
-// ../../node_modules/lodash-es/_baseGetTag.js
-var nullTag = "[object Null]";
-var undefinedTag = "[object Undefined]";
-var symToStringTag2 = Symbol_default ? Symbol_default.toStringTag : void 0;
-function baseGetTag(value) {
-  if (value == null) {
-    return value === void 0 ? undefinedTag : nullTag;
-  }
-  return symToStringTag2 && symToStringTag2 in Object(value) ? getRawTag_default(value) : objectToString_default(value);
-}
-var baseGetTag_default = baseGetTag;
-
-// ../../node_modules/lodash-es/isObjectLike.js
-function isObjectLike(value) {
-  return value != null && typeof value == "object";
-}
-var isObjectLike_default = isObjectLike;
-
-// ../../node_modules/lodash-es/isSymbol.js
-var symbolTag = "[object Symbol]";
-function isSymbol(value) {
-  return typeof value == "symbol" || isObjectLike_default(value) && baseGetTag_default(value) == symbolTag;
-}
-var isSymbol_default = isSymbol;
-
-// ../../node_modules/lodash-es/_arrayMap.js
-function arrayMap(array, iteratee) {
-  var index = -1, length = array == null ? 0 : array.length, result = Array(length);
-  while (++index < length) {
-    result[index] = iteratee(array[index], index, array);
-  }
-  return result;
-}
-var arrayMap_default = arrayMap;
-
-// ../../node_modules/lodash-es/isArray.js
-var isArray = Array.isArray;
-var isArray_default = isArray;
-
-// ../../node_modules/lodash-es/_baseToString.js
-var INFINITY = 1 / 0;
-var symbolProto = Symbol_default ? Symbol_default.prototype : void 0;
-var symbolToString = symbolProto ? symbolProto.toString : void 0;
-function baseToString(value) {
-  if (typeof value == "string") {
-    return value;
-  }
-  if (isArray_default(value)) {
-    return arrayMap_default(value, baseToString) + "";
-  }
-  if (isSymbol_default(value)) {
-    return symbolToString ? symbolToString.call(value) : "";
-  }
-  var result = value + "";
-  return result == "0" && 1 / value == -INFINITY ? "-0" : result;
-}
-var baseToString_default = baseToString;
-
-// ../../node_modules/lodash-es/_trimmedEndIndex.js
-var reWhitespace = /\s/;
-function trimmedEndIndex(string) {
-  var index = string.length;
-  while (index-- && reWhitespace.test(string.charAt(index))) {
+  var result = value + "";
+  return result == "0" && 1 / value == -INFINITY ? "-0" : result;
+}
+var baseToString_default = baseToString;
+
+// ../../node_modules/lodash-es/_trimmedEndIndex.js
+var reWhitespace = /\s/;
+function trimmedEndIndex(string) {
+  var index = string.length;
+  while (index-- && reWhitespace.test(string.charAt(index))) {
   }
   return index;
 }
@@ -9360,328 +9054,683 @@ var GastRecorder = class {
           throw originalError;
         }
       }
-      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_default(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_default(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_default(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_default(this.recordingProdStack);
+  const grammarAction = isFunction_default(mainProdArg) ? mainProdArg : mainProdArg.DEF;
+  const newProd = new prodConstructor({ definition: [], idx: occurrence });
+  if (handleSep) {
+    newProd.separator = mainProdArg.SEP;
+  }
+  if (has_default(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_default(this.recordingProdStack);
+  const hasOptions = isArray_default(mainProdArg) === false;
+  const alts = hasOptions === false ? mainProdArg : mainProdArg.DEF;
+  const newOrProd = new Alternation({
+    definition: [],
+    idx: occurrence,
+    ignoreAmbiguities: hasOptions && mainProdArg.IGNORE_AMBIGUITIES === true
+  });
+  if (has_default(mainProdArg, "MAX_LOOKAHEAD")) {
+    newOrProd.maxLookahead = mainProdArg.MAX_LOOKAHEAD;
+  }
+  const hasPredicates = some_default(alts, (currAlt) => isFunction_default(currAlt.GATE));
+  newOrProd.hasPredicates = hasPredicates;
+  prevProd.definition.push(newOrProd);
+  forEach_default(alts, (currAlt) => {
+    const currAltFlat = new Alternative({ definition: [] });
+    newOrProd.definition.push(currAltFlat);
+    if (has_default(currAlt, "IGNORE_AMBIGUITIES")) {
+      currAltFlat.ignoreAmbiguities = currAlt.IGNORE_AMBIGUITIES;
+    } else if (has_default(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;
+  }
+}
+
+// ../../node_modules/chevrotain/lib/src/parse/parser/traits/perf_tracer.js
+var PerformanceTracer = class {
+  initPerformanceTracer(config) {
+    if (has_default(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();
+    }
+  }
+};
+
+// ../../node_modules/chevrotain/lib/src/parse/parser/utils/apply_mixins.js
+function applyMixins(derivedCtor, baseCtors) {
+  baseCtors.forEach((baseCtor) => {
+    const baseProto = baseCtor.prototype;
+    Object.getOwnPropertyNames(baseProto).forEach((propName) => {
+      if (propName === "constructor") {
+        return;
+      }
+      const basePropDescriptor = Object.getOwnPropertyDescriptor(baseProto, propName);
+      if (basePropDescriptor && (basePropDescriptor.get || basePropDescriptor.set)) {
+        Object.defineProperty(derivedCtor.prototype, propName, basePropDescriptor);
+      } else {
+        derivedCtor.prototype[propName] = baseCtor.prototype[propName];
+      }
+    });
+  });
+}
+
+// ../../node_modules/chevrotain/lib/src/parse/parser/parser.js
+var END_OF_FILE = createTokenInstance(EOF, "", NaN, NaN, NaN, NaN, NaN, NaN);
+Object.freeze(END_OF_FILE);
+var DEFAULT_PARSER_CONFIG = Object.freeze({
+  recoveryEnabled: false,
+  maxLookahead: 3,
+  dynamicTokensEnabled: false,
+  outputCst: true,
+  errorMessageProvider: defaultParserErrorProvider,
+  nodeLocationTracking: "none",
+  traceInitPerf: false,
+  skipValidations: false
+});
+var 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 = {}));
+var Parser = 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_default(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 = resolveGrammar2({
+          rules: values_default(this.gastProductionsCache)
+        });
+        this.definitionErrors = this.definitionErrors.concat(resolverErrors);
+      });
+      this.TRACE_INIT("Grammar Validations", () => {
+        if (isEmpty_default(resolverErrors) && this.skipValidations === false) {
+          const validationErrors = validateGrammar2({
+            rules: values_default(this.gastProductionsCache),
+            tokenTypes: values_default(this.tokensMap),
+            errMsgProvider: defaultGrammarValidatorErrorProvider,
+            grammarName: className
+          });
+          const lookaheadValidationErrors = validateLookahead({
+            lookaheadStrategy: this.lookaheadStrategy,
+            rules: values_default(this.gastProductionsCache),
+            tokenTypes: values_default(this.tokensMap),
+            grammarName: className
+          });
+          this.definitionErrors = this.definitionErrors.concat(validationErrors, lookaheadValidationErrors);
+        }
+      });
+      if (isEmpty_default(this.definitionErrors)) {
+        if (this.recoveryEnabled) {
+          this.TRACE_INIT("computeAllProdsFollows", () => {
+            const allFollows = computeAllProdsFollows(values_default(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_default(this.gastProductionsCache)
+          });
+          this.preComputeLookaheadFunctions(values_default(this.gastProductionsCache));
+        });
+      }
+      if (!_Parser.DEFER_DEFINITION_ERRORS_HANDLING && !isEmpty_default(this.definitionErrors)) {
+        defErrorsMsgs = map_default(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_default(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_default(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
+]);
+var EmbeddedActionsParser = class extends Parser {
+  constructor(tokenVocabulary, config = DEFAULT_PARSER_CONFIG) {
+    const configClone = clone_default(config);
+    configClone.outputCst = false;
+    super(tokenVocabulary, configClone);
+  }
+};
+
+// lib/utils.js
+function unCapitalize(str) {
+  return str.charAt(0).toLowerCase() + str.slice(1);
+}
+function createToken2(config) {
+  return createToken(config);
+}
+var traqulaIndentation = "When you use this string, you expect traqula to handle indentation after every newline";
+
+// lib/generator-builder/dynamicGenerator.js
+var DynamicGenerator = class {
+  rules;
+  factory = new AstCoreFactory();
+  __context = void 0;
+  origSource = "";
+  generatedUntil = 0;
+  expectsSpace;
+  stringBuilder = [];
+  constructor(rules) {
+    this.rules = rules;
+    for (const rule of Object.values(rules)) {
+      this[rule.name] = ((input, context, args) => {
+        this.expectsSpace = false;
+        this.stringBuilder.length = 0;
+        this.origSource = context.origSource;
+        this.generatedUntil = context?.offset ?? 0;
+        this.setContext(context);
+        this.subrule(rule, input, args);
+        this.catchup(this.origSource.length);
+        return this.stringBuilder.join("");
+      });
+    }
+  }
+  setContext(context) {
+    this.__context = context;
+  }
+  getSafeContext() {
+    return this.__context;
+  }
+  subrule = (cstDef, ast, ...arg) => {
+    const def = this.rules[cstDef.name];
+    if (!def) {
+      throw new Error(`Rule ${cstDef.name} not found`);
+    }
+    const generate = () => def.gImpl({
+      SUBRULE: this.subrule,
+      PRINT: this.print,
+      PRINT_SPACE_LEFT: this.printSpaceLeft,
+      PRINT_WORD: this.printWord,
+      PRINT_WORDS: this.printWords,
+      PRINT_ON_EMPTY: this.printOnEmpty,
+      CATCHUP: this.catchup,
+      HANDLE_LOC: this.handleLoc
+    })(ast, this.getSafeContext(), ...arg);
+    if (this.factory.isLocalized(ast)) {
+      this.handleLoc(ast, generate);
+    } else {
+      generate();
+    }
+  };
+  handleLoc = (localized, handle) => {
+    if (this.factory.isSourceLocationNoMaterialize(localized.loc)) {
+      return;
+    }
+    if (this.factory.isSourceLocationStringReplace(localized.loc)) {
+      this.catchup(localized.loc.start);
+      this.print(localized.loc.newSource);
+      this.generatedUntil = localized.loc.end;
+      return;
+    }
+    if (this.factory.isSourceLocationNodeReplace(localized.loc)) {
+      this.catchup(localized.loc.start);
+      this.generatedUntil = localized.loc.end;
+    }
+    if (this.factory.isSourceLocationSource(localized.loc)) {
+      this.catchup(localized.loc.start);
+    }
+    const ret = handle();
+    if (this.factory.isSourceLocationSource(localized.loc)) {
+      this.catchup(localized.loc.end);
+    }
+    return ret;
+  };
+  catchup = (until) => {
+    const start = this.generatedUntil;
+    if (start < until) {
+      this.print(this.origSource.slice(start, until));
+    }
+    this.generatedUntil = Math.max(this.generatedUntil, until);
+  };
+  print = (...args) => {
+    const pureArgs = args.filter((x) => x.length > 0);
+    if (pureArgs.length > 0) {
+      const head2 = pureArgs[0];
+      if (this.expectsSpace) {
+        this.expectsSpace = false;
+        const blanks = /* @__PURE__ */ new Set(["\n", " ", "	"]);
+        if (this.stringBuilder.length > 0 && !(blanks.has(head2[0]) || blanks.has(this.stringBuilder.at(-1).at(-1)))) {
+          this.stringBuilder.push(" ");
+        }
+      }
+      const context = this.getSafeContext();
+      if (context[traqulaIndentation] && typeof context[traqulaIndentation] === "number") {
+        const indent = context[traqulaIndentation];
+        for (const str of pureArgs) {
+          const [noNl, ...postNl] = str.split("\n");
+          this.stringBuilder.push(noNl);
+          for (const subStr of postNl.map((line) => line.trimStart())) {
+            this.stringBuilder.push("\n", " ".repeat(indent));
+            if (subStr.length > 0) {
+              this.stringBuilder.push(subStr);
+            }
+          }
+        }
+      } else {
+        this.stringBuilder.push(...pureArgs);
+      }
     }
+  };
+  printWord = (...args) => {
+    this.expectsSpace = true;
+    this.print(...args);
+    this.expectsSpace = true;
+  };
+  printSpaceLeft = (...args) => {
+    this.expectsSpace = true;
+    this.print(...args);
+  };
+  printWords = (...args) => {
+    for (const arg of args) {
+      this.printWord(arg);
+    }
+  };
+  printOnEmpty = (...args) => {
+    let counter = this.stringBuilder.length - 1;
+    let onEmpty = true;
+    const isEmptyTest = /^[ \t\n]*$/u;
+    while (counter >= 0 && onEmpty) {
+      const cur = this.stringBuilder[counter];
+      const indexOfNl = cur.lastIndexOf("\n");
+      if (indexOfNl >= 0) {
+        onEmpty = isEmptyTest.test(cur.slice(indexOfNl));
+        if (onEmpty) {
+          const newVal = cur.slice(0, indexOfNl);
+          if (newVal) {
+            this.stringBuilder[counter] = cur.slice(0, indexOfNl);
+          } else {
+            this.stringBuilder.splice(counter, 1);
+          }
+        }
+        break;
+      }
+      onEmpty = isEmptyTest.test(cur);
+      counter--;
+    }
+    this.print("\n", ...args);
+  };
+};
+
+// lib/generator-builder/generatorBuilder.js
+function listToRuleDefMap(rules) {
+  const newRules = {};
+  for (const rule of rules) {
+    newRules[rule.name] = rule;
   }
-  // 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);
+  return newRules;
+}
+var GeneratorBuilder = class _GeneratorBuilder {
+  static create(start) {
+    if (start instanceof _GeneratorBuilder) {
+      return new _GeneratorBuilder({ ...start.rules });
+    }
+    return new _GeneratorBuilder(listToRuleDefMap(start));
   }
-  manyInternalRecord(occurrence, actionORMethodDef) {
-    recordProd.call(this, Repetition, actionORMethodDef, occurrence);
+  rules;
+  constructor(startRules) {
+    this.rules = startRules;
   }
-  manySepFirstInternalRecord(occurrence, options) {
-    recordProd.call(this, RepetitionWithSeparator, options, occurrence, HANDLE_SEPARATOR);
+  widenContext() {
+    return this;
   }
-  orInternalRecord(altsOrOpts, occurrence) {
-    return recordOrProd.call(this, altsOrOpts, occurrence);
+  typePatch() {
+    return this;
   }
-  subruleInternalRecord(ruleToCall, occurrence, options) {
-    assertMethodIdxIsValid(occurrence);
-    if (!ruleToCall || has_default(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_default(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;
+  /**
+   * Change the implementation of an existing generator rule.
+   */
+  patchRule(patch) {
+    const self2 = this;
+    self2.rules[patch.name] = patch;
+    return self2;
   }
-  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;
+  /**
+   * Add a rule to the grammar. If the rule already exists, but the implementation differs, an error will be thrown.
+   */
+  addRuleRedundant(rule) {
+    const self2 = this;
+    const rules = self2.rules;
+    if (rules[rule.name] !== void 0 && rules[rule.name] !== rule) {
+      throw new Error(`Rule ${rule.name} already exists in the GeneratorBuilder`);
     }
-    const prevProd = last_default(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_default(this.recordingProdStack);
-  const grammarAction = isFunction_default(mainProdArg) ? mainProdArg : mainProdArg.DEF;
-  const newProd = new prodConstructor({ definition: [], idx: occurrence });
-  if (handleSep) {
-    newProd.separator = mainProdArg.SEP;
-  }
-  if (has_default(mainProdArg, "MAX_LOOKAHEAD")) {
-    newProd.maxLookahead = mainProdArg.MAX_LOOKAHEAD;
+    rules[rule.name] = rule;
+    return self2;
   }
-  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_default(this.recordingProdStack);
-  const hasOptions = isArray_default(mainProdArg) === false;
-  const alts = hasOptions === false ? mainProdArg : mainProdArg.DEF;
-  const newOrProd = new Alternation({
-    definition: [],
-    idx: occurrence,
-    ignoreAmbiguities: hasOptions && mainProdArg.IGNORE_AMBIGUITIES === true
-  });
-  if (has_default(mainProdArg, "MAX_LOOKAHEAD")) {
-    newOrProd.maxLookahead = mainProdArg.MAX_LOOKAHEAD;
+  /**
+   * Add a rule to the grammar. Will raise a typescript error if the rule already exists in the grammar.
+   */
+  addRule(rule) {
+    return this.addRuleRedundant(rule);
   }
-  const hasPredicates = some_default(alts, (currAlt) => isFunction_default(currAlt.GATE));
-  newOrProd.hasPredicates = hasPredicates;
-  prevProd.definition.push(newOrProd);
-  forEach_default(alts, (currAlt) => {
-    const currAltFlat = new Alternative({ definition: [] });
-    newOrProd.definition.push(currAltFlat);
-    if (has_default(currAlt, "IGNORE_AMBIGUITIES")) {
-      currAltFlat.ignoreAmbiguities = currAlt.IGNORE_AMBIGUITIES;
-    } else if (has_default(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;
+  addMany(...rules) {
+    this.rules = { ...this.rules, ...listToRuleDefMap(rules) };
+    return this;
   }
-}
-
-// ../../node_modules/chevrotain/lib/src/parse/parser/traits/perf_tracer.js
-var PerformanceTracer = class {
-  initPerformanceTracer(config) {
-    if (has_default(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;
+  /**
+   * Delete a grammar rule by its name.
+   */
+  deleteRule(ruleName) {
+    delete this.rules[ruleName];
+    return this;
   }
-  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`);
+  /**
+   * Merge this grammar GeneratorBuilder with another.
+   * It is best to merge the bigger grammar with the smaller one.
+   * If the two builders both have a grammar rule with the same name,
+   * no error will be thrown case they map to the same ruledef object.
+   * If they map to a different object, an error will be thrown.
+   * To fix this problem, the overridingRules array should contain a rule with the same conflicting name,
+   * this rule implementation will be used.
+   */
+  merge(GeneratorBuilder2, overridingRules) {
+    const otherRules = { ...GeneratorBuilder2.rules };
+    const myRules = this.rules;
+    for (const rule of Object.values(myRules)) {
+      if (otherRules[rule.name] === void 0) {
+        otherRules[rule.name] = rule;
+      } else {
+        const existingRule = otherRules[rule.name];
+        if (existingRule !== rule) {
+          const override = overridingRules.find((x) => x.name === rule.name);
+          if (override) {
+            otherRules[rule.name] = override;
+          } else {
+            throw new Error(`Rule with name "${rule.name}" already exists in the GeneratorBuilder, specify an override to resolve conflict`);
+          }
+        }
       }
-      this.traceInitIndent--;
-      return value;
-    } else {
-      return phaseImpl();
     }
+    this.rules = otherRules;
+    return this;
+  }
+  build() {
+    return new DynamicGenerator(this.rules);
   }
 };
 
-// ../../node_modules/chevrotain/lib/src/parse/parser/utils/apply_mixins.js
-function applyMixins(derivedCtor, baseCtors) {
-  baseCtors.forEach((baseCtor) => {
-    const baseProto = baseCtor.prototype;
-    Object.getOwnPropertyNames(baseProto).forEach((propName) => {
-      if (propName === "constructor") {
-        return;
-      }
-      const basePropDescriptor = Object.getOwnPropertyDescriptor(baseProto, propName);
-      if (basePropDescriptor && (basePropDescriptor.get || basePropDescriptor.set)) {
-        Object.defineProperty(derivedCtor.prototype, propName, basePropDescriptor);
-      } else {
-        derivedCtor.prototype[propName] = baseCtor.prototype[propName];
-      }
-    });
-  });
+// lib/indirection-builder/helpers.js
+function listToIndirectionMap(rules) {
+  const newRules = {};
+  for (const rule of rules) {
+    newRules[rule.name] = rule;
+  }
+  return newRules;
 }
 
-// ../../node_modules/chevrotain/lib/src/parse/parser/parser.js
-var END_OF_FILE = createTokenInstance(EOF, "", NaN, NaN, NaN, NaN, NaN, NaN);
-Object.freeze(END_OF_FILE);
-var DEFAULT_PARSER_CONFIG = Object.freeze({
-  recoveryEnabled: false,
-  maxLookahead: 3,
-  dynamicTokensEnabled: false,
-  outputCst: true,
-  errorMessageProvider: defaultParserErrorProvider,
-  nodeLocationTracking: "none",
-  traceInitPerf: false,
-  skipValidations: false
-});
-var 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 = {}));
-var Parser = class _Parser {
+// lib/indirection-builder/dynamicIndirected.js
+var DynamicIndirect = class {
+  rules;
+  __context = void 0;
+  constructor(rules) {
+    this.rules = rules;
+    for (const rule of Object.values(rules)) {
+      this[rule.name] = ((context, ...args) => {
+        this.setContext(context);
+        return this.subrule(rule, ...args);
+      });
+    }
+  }
+  setContext(context) {
+    this.__context = context;
+  }
+  getSafeContext() {
+    return this.__context;
+  }
+  subrule = (cstDef, ...args) => {
+    const def = this.rules[cstDef.name];
+    if (!def) {
+      throw new Error(`Rule ${cstDef.name} not found`);
+    }
+    return def.fun({
+      SUBRULE: this.subrule
+    })(this.getSafeContext(), ...args);
+  };
+};
+
+// lib/indirection-builder/IndirBuilder.js
+var IndirBuilder = class _IndirBuilder {
+  static create(start) {
+    if (start instanceof _IndirBuilder) {
+      return new _IndirBuilder({ ...start.rules });
+    }
+    return new _IndirBuilder(listToIndirectionMap(start));
+  }
+  rules;
+  constructor(startRules) {
+    this.rules = startRules;
+  }
+  widenContext() {
+    return this;
+  }
+  typePatch() {
+    return this;
+  }
   /**
-   *  @deprecated use the **instance** method with the same name instead
+   * Change the implementation of an existing indirection.
    */
-  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_default(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 = resolveGrammar2({
-          rules: values_default(this.gastProductionsCache)
-        });
-        this.definitionErrors = this.definitionErrors.concat(resolverErrors);
-      });
-      this.TRACE_INIT("Grammar Validations", () => {
-        if (isEmpty_default(resolverErrors) && this.skipValidations === false) {
-          const validationErrors = validateGrammar2({
-            rules: values_default(this.gastProductionsCache),
-            tokenTypes: values_default(this.tokensMap),
-            errMsgProvider: defaultGrammarValidatorErrorProvider,
-            grammarName: className
-          });
-          const lookaheadValidationErrors = validateLookahead({
-            lookaheadStrategy: this.lookaheadStrategy,
-            rules: values_default(this.gastProductionsCache),
-            tokenTypes: values_default(this.tokensMap),
-            grammarName: className
-          });
-          this.definitionErrors = this.definitionErrors.concat(validationErrors, lookaheadValidationErrors);
-        }
-      });
-      if (isEmpty_default(this.definitionErrors)) {
-        if (this.recoveryEnabled) {
-          this.TRACE_INIT("computeAllProdsFollows", () => {
-            const allFollows = computeAllProdsFollows(values_default(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_default(this.gastProductionsCache)
-          });
-          this.preComputeLookaheadFunctions(values_default(this.gastProductionsCache));
-        });
-      }
-      if (!_Parser.DEFER_DEFINITION_ERRORS_HANDLING && !isEmpty_default(this.definitionErrors)) {
-        defErrorsMsgs = map_default(this.definitionErrors, (defError) => defError.message);
-        throw new Error(`Parser Definition Errors detected:
- ${defErrorsMsgs.join("\n-------------------------------\n")}`);
-      }
-    });
+  patchRule(patch) {
+    const self2 = this;
+    self2.rules[patch.name] = patch;
+    return self2;
   }
-  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_default(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.");
+  /**
+   * Add an indirection function. If the rule already exists, but the implementation differs, an error will be thrown.
+   */
+  addRuleRedundant(rule) {
+    const self2 = this;
+    const rules = self2.rules;
+    if (rules[rule.name] !== void 0 && rules[rule.name] !== rule) {
+      throw new Error(`Function ${rule.name} already exists in the builder`);
     }
-    this.skipValidations = has_default(config, "skipValidations") ? config.skipValidations : DEFAULT_PARSER_CONFIG.skipValidations;
+    rules[rule.name] = rule;
+    return self2;
   }
-};
-Parser.DEFER_DEFINITION_ERRORS_HANDLING = false;
-applyMixins(Parser, [
-  Recoverable,
-  LooksAhead,
-  TreeBuilder,
-  LexerAdapter,
-  RecognizerEngine,
-  RecognizerApi,
-  ErrorHandler,
-  ContentAssist,
-  GastRecorder,
-  PerformanceTracer
-]);
-var EmbeddedActionsParser = class extends Parser {
-  constructor(tokenVocabulary, config = DEFAULT_PARSER_CONFIG) {
-    const configClone = clone_default(config);
-    configClone.outputCst = false;
-    super(tokenVocabulary, configClone);
+  /**
+   * Add a rule to the grammar. Will raise a typescript error if the rule already exists in the grammar.
+   */
+  addRule(rule) {
+    return this.addRuleRedundant(rule);
+  }
+  addMany(...rules) {
+    this.rules = { ...this.rules, ...listToIndirectionMap(rules) };
+    return this;
+  }
+  /**
+   * Delete a grammar rule by its name.
+   */
+  deleteRule(ruleName) {
+    delete this.rules[ruleName];
+    return this;
+  }
+  build() {
+    return new DynamicIndirect(this.rules);
   }
 };
 
@@ -10047,14 +10096,6 @@ ${firstError.message}`);
   }
 };
 
-// lib/utils.js
-function unCapitalize(str) {
-  return str.charAt(0).toLowerCase() + str.slice(1);
-}
-function createToken2(config) {
-  return createToken(config);
-}
-
 // lib/Transformers.js
 var TransformerType = class {
   safeObjectVisit(value, mapper) {