@traqula/core 0.0.21 → 0.0.22

package/dist/cjs/lib/AstCoreFactory.js

@@ -0,0 +1,152 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var AstCoreFactory_exports = {};
+__export(AstCoreFactory_exports, {
+  AstCoreFactory: () => AstCoreFactory
+});
+module.exports = __toCommonJS(AstCoreFactory_exports);
+class AstCoreFactory {
+  wrap(val, loc) {
+    return { val, loc };
+  }
+  isLocalized(obj) {
+    return typeof obj === "object" && obj !== null && "loc" in obj && typeof obj.loc === "object" && obj.loc !== null && "sourceLocationType" in obj.loc;
+  }
+  sourceLocation(...elements) {
+    const pureElements = elements.filter((x) => x !== void 0);
+    if (pureElements.length === 0) {
+      return this.sourceLocationNoMaterialize();
+    }
+    const filtered = pureElements.filter((element) => !this.isLocalized(element) || this.isSourceLocationSource(element.loc) || this.isSourceLocationStringReplace(element.loc) || this.isSourceLocationNodeReplace(element.loc));
+    if (filtered.length === 0) {
+      return this.gen();
+    }
+    const first = filtered.at(0);
+    const last = filtered.at(-1);
+    return {
+      sourceLocationType: "source",
+      start: this.isLocalized(first) ? first.loc.start : first.startOffset,
+      end: this.isLocalized(last) ? last.loc.end : last.endOffset + 1
+    };
+  }
+  sourceLocationNoMaterialize() {
+    return { sourceLocationType: "noMaterialize" };
+  }
+  /**
+   * Returns a copy of the argument that is not materialized
+   */
+  dematerialized(arg) {
+    return { ...arg, loc: this.sourceLocationNoMaterialize() };
+  }
+  safeObjectTransform(value, mapper) {
+    if (value && typeof value === "object") {
+      if (Array.isArray(value)) {
+        return value.map((x) => this.safeObjectTransform(x, mapper));
+      }
+      return mapper(value);
+    }
+    return value;
+  }
+  forcedAutoGenTree(obj) {
+    const copy = { ...obj };
+    for (const [key, value] of Object.entries(copy)) {
+      copy[key] = this.safeObjectTransform(value, (obj2) => this.forcedAutoGenTree(obj2));
+    }
+    if (this.isLocalized(copy)) {
+      copy.loc = this.gen();
+    }
+    return copy;
+  }
+  forceMaterialized(arg) {
+    if (this.isSourceLocationNoMaterialize(arg.loc)) {
+      return this.forcedAutoGenTree(arg);
+    }
+    return { ...arg };
+  }
+  isSourceLocation(loc) {
+    return "sourceLocationType" in loc;
+  }
+  sourceLocationSource(start, end) {
+    return {
+      sourceLocationType: "source",
+      start,
+      end
+    };
+  }
+  gen() {
+    return { sourceLocationType: "autoGenerate" };
+  }
+  isSourceLocationSource(loc) {
+    return this.isSourceLocation(loc) && loc.sourceLocationType === "source";
+  }
+  isSourceLocationStringReplace(loc) {
+    return this.isSourceLocation(loc) && loc.sourceLocationType === "stringReplace";
+  }
+  sourceLocationNodeReplaceUnsafe(loc) {
+    if (this.isSourceLocationSource(loc)) {
+      return this.sourceLocationNodeReplace(loc);
+    }
+    throw new Error("not possible");
+  }
+  sourceLocationNodeReplace(startOrLoc, end) {
+    let starting;
+    let ending;
+    if (typeof startOrLoc === "number") {
+      starting = startOrLoc;
+      ending = end;
+    } else {
+      starting = startOrLoc.start;
+      ending = startOrLoc.end;
+    }
+    return {
+      sourceLocationType: "nodeReplace",
+      start: starting,
+      end: ending
+    };
+  }
+  isSourceLocationNodeReplace(loc) {
+    return this.isSourceLocation(loc) && loc.sourceLocationType === "nodeReplace";
+  }
+  isSourceLocationNodeAutoGenerate(loc) {
+    return this.isSourceLocation(loc) && loc.sourceLocationType === "autoGenerate";
+  }
+  nodeShouldPrint(node) {
+    return this.isSourceLocationNodeReplace(node.loc) || this.isSourceLocationNodeAutoGenerate(node.loc);
+  }
+  printFilter(node, callback) {
+    if (this.nodeShouldPrint(node)) {
+      callback();
+    }
+  }
+  isSourceLocationNoMaterialize(loc) {
+    return this.isSourceLocation(loc) && loc.sourceLocationType === "noMaterialize";
+  }
+  isOfType(obj, type) {
+    const casted = obj;
+    return casted.type === type;
+  }
+  isOfSubType(obj, type, subType) {
+    const temp = obj;
+    return temp.type === type && temp.subType === subType;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AstCoreFactory
+});

package/dist/cjs/lib/generator-builder/builderTypes.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var builderTypes_exports = {};
+module.exports = __toCommonJS(builderTypes_exports);

package/dist/cjs/lib/generator-builder/dynamicGenerator.js

@@ -0,0 +1,207 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dynamicGenerator_exports = {};
+__export(dynamicGenerator_exports, {
+  DynamicGenerator: () => DynamicGenerator
+});
+module.exports = __toCommonJS(dynamicGenerator_exports);
+var import_AstCoreFactory = require("../AstCoreFactory.js");
+var import_utils = require("../utils.js");
+class DynamicGenerator {
+  rules;
+  factory = new import_AstCoreFactory.AstCoreFactory();
+  __context = void 0;
+  origSource = "";
+  generatedUntil = 0;
+  toEnsure = [];
+  /**
+   * Should not contain empty strings
+   * @protected
+   */
+  stringBuilder = [];
+  constructor(rules) {
+    this.rules = rules;
+    for (const rule of Object.values(rules)) {
+      this[rule.name] = ((input, context, args) => {
+        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,
+      ENSURE: this.ensure,
+      ENSURE_EITHER: this.ensureEither,
+      NEW_LINE: this.newLine,
+      HANDLE_LOC: this.handleLoc,
+      CATCHUP: this.catchup,
+      PRINT_WORD: this.printWord,
+      PRINT_WORDS: this.printWords,
+      PRINT_ON_EMPTY: this.printOnEmpty,
+      PRINT_ON_OWN_LINE: this.printOnOwnLine
+    })(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);
+  };
+  handeEnsured(toPrint) {
+    for (const callBack of this.toEnsure) {
+      callBack(toPrint);
+    }
+    this.toEnsure.length = 0;
+  }
+  print = (...args) => {
+    const joined = args.join("");
+    this.handeEnsured(joined);
+    this.stringBuilder.push(joined);
+  };
+  doesEndWith(subsStr) {
+    const len = subsStr.length;
+    let temp = "";
+    while (temp.length < len && this.stringBuilder.length > 0) {
+      temp = this.stringBuilder.pop() + temp;
+    }
+    this.stringBuilder.push(temp);
+    return temp.endsWith(subsStr);
+  }
+  ensure = (...args) => {
+    const toEnsure = args.join("");
+    if (!this.doesEndWith(toEnsure)) {
+      this.toEnsure.push((willPrint) => {
+        if (!willPrint.startsWith(toEnsure) && !this.doesEndWith(toEnsure)) {
+          this.stringBuilder.push(toEnsure);
+        }
+      });
+    }
+  };
+  ensureEither = (...args) => {
+    if (args.length === 1) {
+      this.ensure(...args);
+    } else if (args.length > 1 && // Not already matched?
+    !args.some((subStr) => this.doesEndWith(subStr))) {
+      this.toEnsure.push((willPrint) => {
+        if (!args.some((subStr) => willPrint.startsWith(subStr)) && !args.some((subStr) => this.doesEndWith(subStr))) {
+          this.stringBuilder.push(args[0]);
+        }
+      });
+    }
+  };
+  pruneEndingBlanks() {
+    let temp = "";
+    while (/^[ \t]*$/u.test(temp) && this.stringBuilder.length > 0) {
+      temp = this.stringBuilder.pop() + temp;
+    }
+    this.print(temp.trimEnd());
+  }
+  newLine = (arg) => {
+    const indentation = this.getSafeContext()[import_utils.traqulaIndentation] ?? 0;
+    if (indentation === -1) {
+      return;
+    }
+    const force = arg?.force ?? false;
+    this.pruneEndingBlanks();
+    if (force) {
+      this.print("\n", " ".repeat(indentation));
+    } else {
+      let temp = "";
+      while (!temp.includes("\n") && this.stringBuilder.length > 0) {
+        temp = this.stringBuilder.pop() + temp;
+      }
+      if (/\n[ \t]*$/u.test(temp)) {
+        temp = temp.replace(/\n[ \t]*$/u, `
+${" ".repeat(indentation)}`);
+        this.print(temp);
+      } else {
+        this.print(temp, "\n", " ".repeat(indentation));
+      }
+    }
+  };
+  printWord = (...args) => {
+    this.ensureEither(" ", "\n");
+    this.print(...args);
+    this.ensureEither(" ", "\n");
+  };
+  printWords = (...args) => {
+    for (const arg of args) {
+      this.printWord(arg);
+    }
+  };
+  printOnEmpty = (...args) => {
+    this.newLine();
+    this.print(...args);
+  };
+  printOnOwnLine = (...args) => {
+    this.newLine();
+    this.print(...args);
+    this.newLine();
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DynamicGenerator
+});

package/dist/cjs/lib/generator-builder/generatorBuilder.js

@@ -0,0 +1,126 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var generatorBuilder_exports = {};
+__export(generatorBuilder_exports, {
+  GeneratorBuilder: () => GeneratorBuilder
+});
+module.exports = __toCommonJS(generatorBuilder_exports);
+var import_dynamicGenerator = require("./dynamicGenerator.js");
+function listToRuleDefMap(rules) {
+  const newRules = {};
+  for (const rule of rules) {
+    newRules[rule.name] = rule;
+  }
+  return newRules;
+}
+class GeneratorBuilder {
+  static create(start) {
+    if (Array.isArray(start)) {
+      return new GeneratorBuilder(listToRuleDefMap(start));
+    }
+    return new GeneratorBuilder({ ...start.rules });
+  }
+  rules;
+  constructor(startRules) {
+    this.rules = startRules;
+  }
+  widenContext() {
+    return this;
+  }
+  typePatch() {
+    return this;
+  }
+  /**
+   * Change the implementation of an existing generator rule.
+   */
+  patchRule(patch) {
+    const self = this;
+    self.rules[patch.name] = patch;
+    return self;
+  }
+  /**
+   * Add a rule to the grammar. If the rule already exists, but the implementation differs, an error will be thrown.
+   */
+  addRuleRedundant(rule) {
+    const self = this;
+    const rules = self.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 self;
+  }
+  /**
+   * 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;
+  }
+  getRule(ruleName) {
+    return this.rules[ruleName];
+  }
+  /**
+   * 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 import_dynamicGenerator.DynamicGenerator(this.rules);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GeneratorBuilder
+});

package/dist/cjs/lib/generator-builder/generatorTypes.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var generatorTypes_exports = {};
+module.exports = __toCommonJS(generatorTypes_exports);

package/dist/cjs/lib/index.js

@@ -0,0 +1,59 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var lib_exports = {};
+__export(lib_exports, {
+  TransformerObject: () => import_TransformerObject.TransformerObject,
+  TransformerSubTyped: () => import_TransformerSubTyped.TransformerSubTyped,
+  TransformerTyped: () => import_TransformerTyped.TransformerTyped
+});
+module.exports = __toCommonJS(lib_exports);
+__reExport(lib_exports, require("./generator-builder/builderTypes.js"), module.exports);
+__reExport(lib_exports, require("./generator-builder/generatorBuilder.js"), module.exports);
+__reExport(lib_exports, require("./generator-builder/generatorTypes.js"), module.exports);
+__reExport(lib_exports, require("./indirection-builder/helpers.js"), module.exports);
+__reExport(lib_exports, require("./indirection-builder/IndirBuilder.js"), module.exports);
+__reExport(lib_exports, require("./lexer-builder/LexerBuilder.js"), module.exports);
+__reExport(lib_exports, require("./parser-builder/builderTypes.js"), module.exports);
+__reExport(lib_exports, require("./parser-builder/parserBuilder.js"), module.exports);
+__reExport(lib_exports, require("./parser-builder/ruleDefTypes.js"), module.exports);
+__reExport(lib_exports, require("./utils.js"), module.exports);
+__reExport(lib_exports, require("./AstCoreFactory.js"), module.exports);
+__reExport(lib_exports, require("./types.js"), module.exports);
+var import_TransformerObject = require("./transformers/TransformerObject.js");
+var import_TransformerTyped = require("./transformers/TransformerTyped.js");
+var import_TransformerSubTyped = require("./transformers/TransformerSubTyped.js");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TransformerObject,
+  TransformerSubTyped,
+  TransformerTyped,
+  ...require("./generator-builder/builderTypes.js"),
+  ...require("./generator-builder/generatorBuilder.js"),
+  ...require("./generator-builder/generatorTypes.js"),
+  ...require("./indirection-builder/helpers.js"),
+  ...require("./indirection-builder/IndirBuilder.js"),
+  ...require("./lexer-builder/LexerBuilder.js"),
+  ...require("./parser-builder/builderTypes.js"),
+  ...require("./parser-builder/parserBuilder.js"),
+  ...require("./parser-builder/ruleDefTypes.js"),
+  ...require("./utils.js"),
+  ...require("./AstCoreFactory.js"),
+  ...require("./types.js")
+});

package/dist/cjs/lib/indirection-builder/IndirBuilder.js

@@ -0,0 +1,90 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var IndirBuilder_exports = {};
+__export(IndirBuilder_exports, {
+  IndirBuilder: () => IndirBuilder
+});
+module.exports = __toCommonJS(IndirBuilder_exports);
+var import_dynamicIndirected = require("./dynamicIndirected.js");
+var import_helpers = require("./helpers.js");
+class IndirBuilder {
+  static create(start) {
+    if (Array.isArray(start)) {
+      return new IndirBuilder((0, import_helpers.listToIndirectionMap)(start));
+    }
+    return new IndirBuilder({ ...start.rules });
+  }
+  rules;
+  constructor(startRules) {
+    this.rules = startRules;
+  }
+  widenContext() {
+    return this;
+  }
+  typePatch() {
+    return this;
+  }
+  /**
+   * Change the implementation of an existing indirection.
+   */
+  patchRule(patch) {
+    const self = this;
+    self.rules[patch.name] = patch;
+    return self;
+  }
+  /**
+   * Add an indirection function. If the rule already exists, but the implementation differs, an error will be thrown.
+   */
+  addRuleRedundant(rule) {
+    const self = this;
+    const rules = self.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 self;
+  }
+  /**
+   * 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, ...(0, import_helpers.listToIndirectionMap)(rules) };
+    return this;
+  }
+  /**
+   * Delete a grammar rule by its name.
+   */
+  deleteRule(ruleName) {
+    delete this.rules[ruleName];
+    return this;
+  }
+  getRule(ruleName) {
+    return this.rules[ruleName];
+  }
+  build() {
+    return new import_dynamicIndirected.DynamicIndirect(this.rules);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  IndirBuilder
+});