@traqula/core 0.0.15 → 0.0.17

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,313 +161,6 @@ 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;
-  }
-  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);
-    } 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);
-    }
-  };
-};
-
-// lib/generator-builder/generatorBuilder.js
-function listToRuleDefMap(rules) {
-  const newRules = {};
-  for (const rule of rules) {
-    newRules[rule.name] = rule;
-  }
-  return newRules;
-}
-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;
-  }
-  /**
-   * Change the implementation of an existing generator rule.
-   */
-  patchRule(patch) {
-    const self2 = this;
-    self2.rules[patch.name] = patch;
-    return self2;
-  }
-  /**
-   * 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;
-  }
-  /**
-   * 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, ...listToRuleDefMap(rules) };
-    return this;
-  }
-  /**
-   * 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;
@@ -9630,58 +9324,413 @@ var Parser = class _Parser {
             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));
-        });
+        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;
+  }
+  return newRules;
+}
+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;
+  }
+  /**
+   * Change the implementation of an existing generator rule.
+   */
+  patchRule(patch) {
+    const self2 = this;
+    self2.rules[patch.name] = patch;
+    return self2;
+  }
+  /**
+   * 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;
+  }
+  /**
+   * 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, ...listToRuleDefMap(rules) };
+    return this;
+  }
+  /**
+   * 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`);
+          }
+        }
       }
-      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")}`);
-      }
-    });
+    }
+    this.rules = otherRules;
+    return this;
   }
-  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.");
+  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);
+      });
     }
-    this.skipValidations = has_default(config, "skipValidations") ? config.skipValidations : DEFAULT_PARSER_CONFIG.skipValidations;
   }
+  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);
+  };
 };
-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/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);
   }
 };
 
@@ -10047,16 +10096,13 @@ ${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 {
+  clone(obj) {
+    const newObj = Object.create(Object.getPrototypeOf(obj));
+    Object.defineProperties(newObj, Object.getOwnPropertyDescriptors(obj));
+    return newObj;
+  }
   safeObjectVisit(value, mapper) {
     if (value && typeof value === "object") {
       if (Array.isArray(value)) {
@@ -10066,104 +10112,213 @@ var TransformerType = class {
     }
     return value;
   }
-  transformNode(curObject, nodeCallBacks) {
-    let continueCheck;
-    let transformation;
-    const casted = curObject;
-    if (casted.type) {
-      continueCheck = nodeCallBacks[casted.type]?.continue;
-      transformation = nodeCallBacks[casted.type]?.transform;
-    }
-    let shouldContinue = true;
-    if (continueCheck) {
-      shouldContinue = continueCheck(curObject);
-    }
-    if (!shouldContinue) {
-      return curObject;
-    }
-    const copy = { ...curObject };
-    for (const [key, value] of Object.entries(copy)) {
-      copy[key] = this.safeObjectVisit(value, (obj) => this.transformNode(obj, nodeCallBacks));
-    }
-    if (transformation) {
-      return transformation(copy);
-    }
-    return copy;
+  /**
+   * Recursively transforms all objects that are not arrays. Mapper is called on deeper objects first.
+   * @param startObject object to start iterating from
+   * @param mapper mapper to transform the various objects - argument is a copy of the original
+   * @param preVisitor callback that is evaluated before iterating deeper.
+   *   If continues is false, we do not iterate deeper, current object is still mapped. - default: true
+   *   If shortcut is true, we do not iterate deeper, nor do we branch out, this mapper will be the last one called.
+   *    - Default false
+   */
+  transformObject(startObject, mapper, preVisitor = () => ({})) {
+    let didShortCut = false;
+    const recurse = (curObject) => {
+      const copy = this.clone(curObject);
+      const context = preVisitor(copy);
+      didShortCut = context.shortcut ?? false;
+      const continues = context.continue ?? true;
+      if (continues && !didShortCut) {
+        for (const [key, value] of Object.entries(copy)) {
+          if (didShortCut) {
+            return copy;
+          }
+          copy[key] = this.safeObjectVisit(value, (obj) => recurse(obj));
+        }
+      }
+      return mapper(copy);
+    };
+    return recurse(startObject);
   }
-  visitNode(curObject, nodeCallBacks) {
-    let callback;
-    const casted = curObject;
-    if (casted.type) {
-      callback = nodeCallBacks[casted.type];
-    }
-    let shouldIterate = true;
-    if (callback) {
-      shouldIterate = callback(curObject);
-    }
-    if (shouldIterate) {
-      for (const value of Object.values(curObject)) {
-        this.safeObjectVisit(value, (obj) => this.visitNode(obj, nodeCallBacks));
+  /**
+   * Visitor that visits all objects. Visits deeper objects first.
+   */
+  visitObject(startObject, visitor, preVisitor = () => ({})) {
+    let didShortCut = false;
+    const recurse = (curObject) => {
+      const context = preVisitor(curObject);
+      didShortCut = context.shortcut ?? false;
+      const continues = context.continue ?? true;
+      if (continues && !didShortCut) {
+        for (const value of Object.values(curObject)) {
+          if (didShortCut) {
+            return;
+          }
+          this.safeObjectVisit(value, (obj) => recurse(obj));
+        }
       }
-    }
+      visitor(curObject);
+    };
+    recurse(startObject);
+  }
+  transformNode(startObject, nodeCallBacks) {
+    const transformWrapper = (curObject) => {
+      const casted = curObject;
+      if (casted.type) {
+        const ogFunc = nodeCallBacks[casted.type]?.transform;
+        if (ogFunc) {
+          return ogFunc(casted);
+        }
+      }
+      return curObject;
+    };
+    const preTransformWrapper = (curObject) => {
+      const casted = curObject;
+      if (casted.type) {
+        const ogFunc = nodeCallBacks[casted.type]?.preVisitor;
+        if (ogFunc) {
+          return ogFunc(casted);
+        }
+      }
+      return {};
+    };
+    return this.transformObject(startObject, transformWrapper, preTransformWrapper);
+  }
+  visitNode(startObject, nodeCallBacks) {
+    const visitWrapper = (curObject) => {
+      const casted = curObject;
+      if (casted.type) {
+        const ogFunc = nodeCallBacks[casted.type]?.visitor;
+        if (ogFunc) {
+          ogFunc(casted);
+        }
+      }
+    };
+    const preVisitWrapper = (curObject) => {
+      const casted = curObject;
+      if (casted.type) {
+        const ogFunc = nodeCallBacks[casted.type]?.preVisitor;
+        if (ogFunc) {
+          return ogFunc(casted);
+        }
+      }
+      return {};
+    };
+    this.visitObject(startObject, visitWrapper, preVisitWrapper);
+  }
+  traverseNodes(currentNode, traverse) {
+    let didShortCut = false;
+    const recurse = (curNode) => {
+      const traverser = traverse[curNode.type];
+      if (traverser) {
+        const { next, shortcut } = traverser(curNode);
+        didShortCut = shortcut ?? false;
+        if (!didShortCut) {
+          for (const node of next ?? []) {
+            if (didShortCut) {
+              return;
+            }
+            recurse(node);
+          }
+        }
+      }
+    };
+    recurse(currentNode);
   }
 };
 var TransformerSubType = class extends TransformerType {
-  // Public visitObjects(curObject: object, visitor: (current: object) => void): void {
-  //   for (const value of Object.values(curObject)) {
-  //     this.safeObjectVisit(value, obj => this.visitObjects(obj, visitor));
-  //   }
-  // }
-  transformNodeSpecific(curObject, nodeCallBacks, nodeSpecificCallBacks = {}) {
-    let continueCheck;
-    let transformation;
-    const casted = curObject;
-    if (casted.type && casted.subType) {
-      const specific = nodeSpecificCallBacks[casted.type];
-      if (specific) {
-        continueCheck = specific[casted.subType]?.continue;
-        transformation = specific[casted.subType]?.transform;
-      }
-    }
-    let shouldContinue = true;
-    if (continueCheck) {
-      shouldContinue = continueCheck(curObject);
-    }
-    if (!shouldContinue) {
-      return curObject;
-    }
-    const copy = { ...curObject };
-    for (const [key, value] of Object.entries(copy)) {
-      copy[key] = this.safeObjectVisit(value, (obj) => this.transformNodeSpecific(obj, nodeCallBacks, nodeSpecificCallBacks));
-    }
-    if (transformation) {
-      return transformation(copy);
-    }
-    return copy;
+  transformNodeSpecific(startObject, nodeCallBacks, nodeSpecificCallBacks) {
+    const transformWrapper = (curObject) => {
+      let ogTransform;
+      const casted = curObject;
+      if (casted.type && casted.subType) {
+        const specific = nodeSpecificCallBacks[casted.type];
+        if (specific) {
+          ogTransform = specific[casted.subType]?.transform;
+        }
+        if (!ogTransform) {
+          ogTransform = nodeCallBacks[casted.type]?.transform;
+        }
+      }
+      return ogTransform ? ogTransform(casted) : curObject;
+    };
+    const preVisitWrapper = (curObject) => {
+      let ogPreVisit;
+      const casted = curObject;
+      if (casted.type && casted.subType) {
+        const specific = nodeSpecificCallBacks[casted.type];
+        if (specific) {
+          ogPreVisit = specific[casted.subType]?.preVisitor;
+        }
+        if (!ogPreVisit) {
+          ogPreVisit = nodeCallBacks[casted.type]?.preVisitor;
+        }
+      }
+      return ogPreVisit ? ogPreVisit(casted) : curObject;
+    };
+    return this.transformObject(startObject, transformWrapper, preVisitWrapper);
   }
   /**
    * When both nodeCallBack and NodeSpecific callBack are matched, will only look at nodeSpecifCallback
    */
-  visitNodeSpecific(curObject, nodeCallBacks, nodeSpecificCallBacks = {}) {
-    let callback;
-    const casted = curObject;
-    if (casted.type && casted.subType) {
-      const specific = nodeSpecificCallBacks[casted.type];
-      if (specific) {
-        callback = specific[casted.subType];
+  visitNodeSpecific(startObject, nodeCallBacks, nodeSpecificCallBacks) {
+    const visitWrapper = (curObject) => {
+      let ogTransform;
+      const casted = curObject;
+      if (casted.type && casted.subType) {
+        const specific = nodeSpecificCallBacks[casted.type];
+        if (specific) {
+          ogTransform = specific[casted.subType]?.visitor;
+        }
+        if (!ogTransform) {
+          ogTransform = nodeCallBacks[casted.type]?.visitor;
+        }
       }
-    }
-    if (!callback && casted.type) {
-      callback = nodeCallBacks[curObject.type];
-    }
-    let shouldIterate = true;
-    if (callback) {
-      shouldIterate = callback(curObject) ?? true;
-    }
-    if (shouldIterate) {
-      for (const value of Object.values(curObject)) {
-        this.safeObjectVisit(value, (obj) => this.visitNodeSpecific(obj, nodeCallBacks, nodeSpecificCallBacks));
+      if (ogTransform) {
+        ogTransform(casted);
       }
-    }
+    };
+    const preVisitWrapper = (curObject) => {
+      let ogPreVisit;
+      const casted = curObject;
+      if (casted.type && casted.subType) {
+        const specific = nodeSpecificCallBacks[casted.type];
+        if (specific) {
+          ogPreVisit = specific[casted.subType]?.preVisitor;
+        }
+        if (!ogPreVisit) {
+          ogPreVisit = nodeCallBacks[casted.type]?.preVisitor;
+        }
+      }
+      return ogPreVisit ? ogPreVisit(casted) : curObject;
+    };
+    this.visitObject(startObject, visitWrapper, preVisitWrapper);
+  }
+  traverseSubNodes(currentNode, traverseNode, traverseSubNode) {
+    let didShortCut = false;
+    const recurse = (curNode) => {
+      let traverser;
+      const subObj = traverseSubNode[curNode.type];
+      if (subObj) {
+        traverser = subObj[curNode.subType];
+      }
+      if (!traverser) {
+        traverser = traverseNode[curNode.type];
+      }
+      if (traverser) {
+        const { next, shortcut } = traverser(curNode);
+        didShortCut = shortcut ?? false;
+        if (!didShortCut) {
+          for (const node of next ?? []) {
+            if (didShortCut) {
+              return;
+            }
+            recurse(node);
+          }
+        }
+      }
+    };
+    recurse(currentNode);
   }
 };
 /*! Bundled license information: