@traqula/core 0.0.1-alpha.148 → 0.0.1-alpha.9

package/lib/index.cjs

@@ -20,16 +20,349 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // lib/index.ts
 var index_exports = {};
 __export(index_exports, {
-  Builder: () => Builder,
-  CommonIRIs: () => CommonIRIs,
+  CoreFactory: () => CoreFactory,
+  GeneratorBuilder: () => GeneratorBuilder,
   LexerBuilder: () => LexerBuilder,
-  Wildcard: () => Wildcard,
+  ParserBuilder: () => ParserBuilder,
+  RangeArithmetic: () => RangeArithmetic,
+  Transformer: () => Transformer,
   createToken: () => createToken2,
-  resolveIRI: () => resolveIRI,
   unCapitalize: () => unCapitalize
 });
 module.exports = __toCommonJS(index_exports);
 
+// lib/CoreFactory.ts
+var CoreFactory = class {
+  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 first2 = filtered[0];
+    const last2 = filtered.at(-1);
+    return {
+      sourceLocationType: "source",
+      start: this.isLocalized(first2) ? first2.loc.start : first2.startOffset,
+      end: this.isLocalized(last2) ? last2.loc.end : last2.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;
+  }
+};
+
+// lib/generator-builder/dynamicGenerator.ts
+var DynamicGenerator = class {
+  constructor(rules) {
+    this.rules = rules;
+    this.factory = new CoreFactory();
+    this.__context = void 0;
+    this.origSource = "";
+    this.generatedUntil = 0;
+    this.stringBuilder = [];
+    this.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();
+      }
+    };
+    this.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;
+    };
+    this.catchup = (until) => {
+      const start = this.generatedUntil;
+      if (start < until) {
+        this.print(this.origSource.slice(start, until));
+      }
+      this.generatedUntil = Math.max(this.generatedUntil, until);
+    };
+    this.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);
+      }
+    };
+    this.printWord = (...args) => {
+      this.expectsSpace = true;
+      this.print(...args);
+      this.expectsSpace = true;
+    };
+    this.printSpaceLeft = (...args) => {
+      this.expectsSpace = true;
+      this.print(...args);
+    };
+    this.printWords = (...args) => {
+      for (const arg of args) {
+        this.printWord(arg);
+      }
+    };
+    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;
+  }
+};
+
+// lib/generator-builder/generatorBuilder.ts
+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));
+  }
+  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);
+  }
+};
+
 // ../../node_modules/lodash-es/_freeGlobal.js
 var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
 var freeGlobal_default = freeGlobal;
@@ -1395,8 +1728,8 @@ var Promise2 = getNative_default(root_default, "Promise");
 var Promise_default = Promise2;
 
 // ../../node_modules/lodash-es/_Set.js
-var Set = getNative_default(root_default, "Set");
-var Set_default = Set;
+var Set2 = getNative_default(root_default, "Set");
+var Set_default = Set2;
 
 // ../../node_modules/lodash-es/_getTag.js
 var mapTag2 = "[object Map]";
@@ -9248,28 +9581,242 @@ var EmbeddedActionsParser = class extends Parser {
   }
 };
 
-// lib/grammar-builder/parserBuilder.ts
-function listToRuleDefMap(rules) {
+// lib/lexer-builder/LexerBuilder.ts
+var LexerBuilder = class _LexerBuilder {
+  static create(starter) {
+    return new _LexerBuilder(starter);
+  }
+  constructor(starter) {
+    this.tokens = starter?.tokens ? [...starter.tokens] : [];
+  }
+  merge(merge, overwrite = []) {
+    const extraTokens = merge.tokens.filter((token) => {
+      const overwriteToken = overwrite.find((t) => t.name === token.name);
+      if (overwriteToken) {
+        return false;
+      }
+      const match = this.tokens.find((t) => t.name === token.name);
+      if (match) {
+        if (match !== token) {
+          throw new Error(`Token with name ${token.name} already exists. Implementation is different and no overwrite was provided.`);
+        }
+        return false;
+      }
+      return true;
+    });
+    this.tokens.push(...extraTokens);
+    return this;
+  }
+  add(...token) {
+    this.tokens.push(...token);
+    return this;
+  }
+  addBefore(before, ...token) {
+    const index = this.tokens.indexOf(before);
+    if (index === -1) {
+      throw new Error("Token not found");
+    }
+    this.tokens.splice(index, 0, ...token);
+    return this;
+  }
+  moveBeforeOrAfter(beforeOrAfter, before, ...tokens) {
+    const beforeIndex = this.tokens.indexOf(before) + (beforeOrAfter === "before" ? 0 : 1);
+    if (beforeIndex === -1) {
+      throw new Error("BeforeToken not found");
+    }
+    for (const token of tokens) {
+      const tokenIndex = this.tokens.indexOf(token);
+      if (tokenIndex === -1) {
+        throw new Error("Token not found");
+      }
+      this.tokens.splice(tokenIndex, 1);
+      this.tokens.splice(beforeIndex, 0, token);
+    }
+    return this;
+  }
+  /**
+   * @param before token to move rest before
+   * @param tokens tokens to move before the first token
+   */
+  moveBefore(before, ...tokens) {
+    return this.moveBeforeOrAfter("before", before, ...tokens);
+  }
+  moveAfter(after, ...tokens) {
+    return this.moveBeforeOrAfter("after", after, ...tokens);
+  }
+  addAfter(after, ...token) {
+    const index = this.tokens.indexOf(after);
+    if (index === -1) {
+      throw new Error("Token not found");
+    }
+    this.tokens.splice(index + 1, 0, ...token);
+    return this;
+  }
+  delete(...token) {
+    for (const t of token) {
+      const index = this.tokens.indexOf(t);
+      if (index === -1) {
+        throw new Error("Token not found");
+      }
+      this.tokens.splice(index, 1);
+    }
+    return this;
+  }
+  build(lexerConfig) {
+    return new Lexer(this.tokens, {
+      positionTracking: "onlyStart",
+      recoveryEnabled: false,
+      ensureOptimizations: true,
+      // SafeMode: true,
+      // SkipValidations: true,
+      ...lexerConfig
+    });
+  }
+  get tokenVocabulary() {
+    return this.tokens;
+  }
+};
+
+// lib/parser-builder/dynamicParser.ts
+var DynamicParser = class extends EmbeddedActionsParser {
+  setContext(context) {
+    this.context = context;
+  }
+  constructor(rules, tokenVocabulary, config = {}) {
+    super(tokenVocabulary, {
+      // RecoveryEnabled: true,
+      maxLookahead: 2,
+      // SkipValidations: true,
+      ...config
+    });
+    this.context = void 0;
+    const selfRef = this.constructSelfRef();
+    const implArgs = {
+      ...selfRef,
+      cache: /* @__PURE__ */ new WeakMap()
+    };
+    for (const rule of Object.values(rules)) {
+      this[rule.name] = this.RULE(rule.name, rule.impl(implArgs));
+    }
+    this.performSelfAnalysis();
+  }
+  constructSelfRef() {
+    const subRuleImpl = (chevrotainSubrule) => (cstDef, arg) => chevrotainSubrule(this[cstDef.name], { ARGS: [this.context, arg] });
+    return {
+      CONSUME: (tokenType, option) => this.CONSUME(tokenType, option),
+      CONSUME1: (tokenType, option) => this.CONSUME1(tokenType, option),
+      CONSUME2: (tokenType, option) => this.CONSUME2(tokenType, option),
+      CONSUME3: (tokenType, option) => this.CONSUME3(tokenType, option),
+      CONSUME4: (tokenType, option) => this.CONSUME4(tokenType, option),
+      CONSUME5: (tokenType, option) => this.CONSUME5(tokenType, option),
+      CONSUME6: (tokenType, option) => this.CONSUME6(tokenType, option),
+      CONSUME7: (tokenType, option) => this.CONSUME7(tokenType, option),
+      CONSUME8: (tokenType, option) => this.CONSUME8(tokenType, option),
+      CONSUME9: (tokenType, option) => this.CONSUME9(tokenType, option),
+      OPTION: (actionORMethodDef) => this.OPTION(actionORMethodDef),
+      OPTION1: (actionORMethodDef) => this.OPTION1(actionORMethodDef),
+      OPTION2: (actionORMethodDef) => this.OPTION2(actionORMethodDef),
+      OPTION3: (actionORMethodDef) => this.OPTION3(actionORMethodDef),
+      OPTION4: (actionORMethodDef) => this.OPTION4(actionORMethodDef),
+      OPTION5: (actionORMethodDef) => this.OPTION5(actionORMethodDef),
+      OPTION6: (actionORMethodDef) => this.OPTION6(actionORMethodDef),
+      OPTION7: (actionORMethodDef) => this.OPTION7(actionORMethodDef),
+      OPTION8: (actionORMethodDef) => this.OPTION8(actionORMethodDef),
+      OPTION9: (actionORMethodDef) => this.OPTION9(actionORMethodDef),
+      OR: (altsOrOpts) => this.OR(altsOrOpts),
+      OR1: (altsOrOpts) => this.OR1(altsOrOpts),
+      OR2: (altsOrOpts) => this.OR2(altsOrOpts),
+      OR3: (altsOrOpts) => this.OR3(altsOrOpts),
+      OR4: (altsOrOpts) => this.OR4(altsOrOpts),
+      OR5: (altsOrOpts) => this.OR5(altsOrOpts),
+      OR6: (altsOrOpts) => this.OR6(altsOrOpts),
+      OR7: (altsOrOpts) => this.OR7(altsOrOpts),
+      OR8: (altsOrOpts) => this.OR8(altsOrOpts),
+      OR9: (altsOrOpts) => this.OR9(altsOrOpts),
+      MANY: (actionORMethodDef) => this.MANY(actionORMethodDef),
+      MANY1: (actionORMethodDef) => this.MANY1(actionORMethodDef),
+      MANY2: (actionORMethodDef) => this.MANY2(actionORMethodDef),
+      MANY3: (actionORMethodDef) => this.MANY3(actionORMethodDef),
+      MANY4: (actionORMethodDef) => this.MANY4(actionORMethodDef),
+      MANY5: (actionORMethodDef) => this.MANY5(actionORMethodDef),
+      MANY6: (actionORMethodDef) => this.MANY6(actionORMethodDef),
+      MANY7: (actionORMethodDef) => this.MANY7(actionORMethodDef),
+      MANY8: (actionORMethodDef) => this.MANY8(actionORMethodDef),
+      MANY9: (actionORMethodDef) => this.MANY9(actionORMethodDef),
+      MANY_SEP: (options) => this.MANY_SEP(options),
+      MANY_SEP1: (options) => this.MANY_SEP1(options),
+      MANY_SEP2: (options) => this.MANY_SEP2(options),
+      MANY_SEP3: (options) => this.MANY_SEP3(options),
+      MANY_SEP4: (options) => this.MANY_SEP4(options),
+      MANY_SEP5: (options) => this.MANY_SEP5(options),
+      MANY_SEP6: (options) => this.MANY_SEP6(options),
+      MANY_SEP7: (options) => this.MANY_SEP7(options),
+      MANY_SEP8: (options) => this.MANY_SEP8(options),
+      MANY_SEP9: (options) => this.MANY_SEP9(options),
+      AT_LEAST_ONE: (actionORMethodDef) => this.AT_LEAST_ONE(actionORMethodDef),
+      AT_LEAST_ONE1: (actionORMethodDef) => this.AT_LEAST_ONE1(actionORMethodDef),
+      AT_LEAST_ONE2: (actionORMethodDef) => this.AT_LEAST_ONE2(actionORMethodDef),
+      AT_LEAST_ONE3: (actionORMethodDef) => this.AT_LEAST_ONE3(actionORMethodDef),
+      AT_LEAST_ONE4: (actionORMethodDef) => this.AT_LEAST_ONE4(actionORMethodDef),
+      AT_LEAST_ONE5: (actionORMethodDef) => this.AT_LEAST_ONE5(actionORMethodDef),
+      AT_LEAST_ONE6: (actionORMethodDef) => this.AT_LEAST_ONE6(actionORMethodDef),
+      AT_LEAST_ONE7: (actionORMethodDef) => this.AT_LEAST_ONE7(actionORMethodDef),
+      AT_LEAST_ONE8: (actionORMethodDef) => this.AT_LEAST_ONE8(actionORMethodDef),
+      AT_LEAST_ONE9: (actionORMethodDef) => this.AT_LEAST_ONE9(actionORMethodDef),
+      AT_LEAST_ONE_SEP: (options) => this.AT_LEAST_ONE_SEP(options),
+      AT_LEAST_ONE_SEP1: (options) => this.AT_LEAST_ONE_SEP1(options),
+      AT_LEAST_ONE_SEP2: (options) => this.AT_LEAST_ONE_SEP2(options),
+      AT_LEAST_ONE_SEP3: (options) => this.AT_LEAST_ONE_SEP3(options),
+      AT_LEAST_ONE_SEP4: (options) => this.AT_LEAST_ONE_SEP4(options),
+      AT_LEAST_ONE_SEP5: (options) => this.AT_LEAST_ONE_SEP5(options),
+      AT_LEAST_ONE_SEP6: (options) => this.AT_LEAST_ONE_SEP6(options),
+      AT_LEAST_ONE_SEP7: (options) => this.AT_LEAST_ONE_SEP7(options),
+      AT_LEAST_ONE_SEP8: (options) => this.AT_LEAST_ONE_SEP8(options),
+      AT_LEAST_ONE_SEP9: (options) => this.AT_LEAST_ONE_SEP9(options),
+      ACTION: (func) => this.ACTION(func),
+      BACKTRACK: (cstDef, ...args) => this.BACKTRACK(this[cstDef.name], { ARGS: args }),
+      SUBRULE: subRuleImpl((rule, args) => this.SUBRULE(rule, args)),
+      SUBRULE1: subRuleImpl((rule, args) => this.SUBRULE1(rule, args)),
+      SUBRULE2: subRuleImpl((rule, args) => this.SUBRULE2(rule, args)),
+      SUBRULE3: subRuleImpl((rule, args) => this.SUBRULE3(rule, args)),
+      SUBRULE4: subRuleImpl((rule, args) => this.SUBRULE4(rule, args)),
+      SUBRULE5: subRuleImpl((rule, args) => this.SUBRULE5(rule, args)),
+      SUBRULE6: subRuleImpl((rule, args) => this.SUBRULE6(rule, args)),
+      SUBRULE7: subRuleImpl((rule, args) => this.SUBRULE7(rule, args)),
+      SUBRULE8: subRuleImpl((rule, args) => this.SUBRULE8(rule, args)),
+      SUBRULE9: subRuleImpl((rule, args) => this.SUBRULE9(rule, args))
+    };
+  }
+};
+
+// lib/parser-builder/parserBuilder.ts
+function listToRuleDefMap2(rules) {
   const newRules = {};
   for (const rule of rules) {
     newRules[rule.name] = rule;
   }
   return newRules;
 }
-var Builder = class _Builder {
+var ParserBuilder = class _ParserBuilder {
   /**
    * Create a builder from some initial grammar rules or an existing builder.
    * If a builder is provided, a new copy will be created.
    */
-  static createBuilder(start) {
-    if (start instanceof _Builder) {
-      return new _Builder({ ...start.rules });
+  static create(start) {
+    if (start instanceof _ParserBuilder) {
+      return new _ParserBuilder({ ...start.rules });
     }
-    return new _Builder(listToRuleDefMap(start));
+    return new _ParserBuilder(listToRuleDefMap2(start));
   }
   constructor(startRules) {
     this.rules = startRules;
   }
+  widenContext() {
+    return this;
+  }
+  typePatch() {
+    return this;
+  }
   /**
    * Change the implementation of an existing grammar rule.
    */
@@ -9297,7 +9844,7 @@ var Builder = class _Builder {
     return this.addRuleRedundant(rule);
   }
   addMany(...rules) {
-    this.rules = { ...this.rules, ...listToRuleDefMap(rules) };
+    this.rules = { ...this.rules, ...listToRuleDefMap2(rules) };
     return this;
   }
   /**
@@ -9310,9 +9857,11 @@ var Builder = class _Builder {
   /**
    * Merge this grammar builder 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 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.
+   * To fix this problem, the overridingRules array should contain a rule with the same conflicting name,
+   * this rule implementation will be used.
    */
   merge(builder, overridingRules) {
     const otherRules = { ...builder.rules };
@@ -9335,44 +9884,57 @@ var Builder = class _Builder {
     this.rules = otherRules;
     return this;
   }
-  consumeToParser({ tokenVocabulary, parserConfig = {}, lexerConfig = {} }) {
-    const lexer = new Lexer(tokenVocabulary, {
-      positionTracking: "onlyStart",
+  defaultErrorHandler(input, errors) {
+    const firstError = errors[0];
+    const messageBuilder = ["Parse error"];
+    const lineIdx = firstError.token.startLine;
+    if (lineIdx !== void 0) {
+      const errorLine = input.split("\n")[lineIdx - 1];
+      messageBuilder.push(` on line ${lineIdx}
+${errorLine}`);
+      const columnIdx = firstError.token.startColumn;
+      if (columnIdx !== void 0) {
+        messageBuilder.push(`
+${"-".repeat(columnIdx - 1)}^`);
+      }
+    }
+    messageBuilder.push(`
+${firstError.message}`);
+    throw new Error(messageBuilder.join(""));
+  }
+  build({
+    tokenVocabulary,
+    parserConfig = {},
+    lexerConfig = {},
+    queryPreProcessor = (s) => s,
+    errorHandler
+  }) {
+    const lexer = LexerBuilder.create().add(...tokenVocabulary).build({
+      positionTracking: "full",
       recoveryEnabled: false,
       // SafeMode: true,
       // SkipValidations: true,
-      ensureOptimizations: true,
+      // ensureOptimizations: true,
       ...lexerConfig
     });
-    const parser = this.consume({ tokenVocabulary, config: parserConfig });
+    const parser = this.consume({
+      tokenVocabulary,
+      config: parserConfig
+    });
     const selfSufficientParser = {};
     for (const rule of Object.values(this.rules)) {
       selfSufficientParser[rule.name] = (input, context, arg) => {
-        input = input.replaceAll(
-          /\\u([0-9a-fA-F]{4})|\\U([0-9a-fA-F]{8})/gu,
-          (_, unicode4, unicode8) => {
-            if (unicode4) {
-              const charCode2 = Number.parseInt(unicode4, 16);
-              return String.fromCodePoint(charCode2);
-            }
-            const charCode = Number.parseInt(unicode8, 16);
-            if (charCode < 65535) {
-              return String.fromCodePoint(charCode);
-            }
-            const substractedCharCode = charCode - 65536;
-            return String.fromCodePoint(55296 + (substractedCharCode >> 10), 56320 + (substractedCharCode & 1023));
-          }
-        );
-        if (/[\uD800-\uDBFF]([^\uDC00-\uDFFF]|$)/u.test(input)) {
-          throw new Error(`Invalid unicode codepoint of surrogate pair without corresponding codepoint`);
-        }
-        const lexResult = lexer.tokenize(input);
+        const processedInput = queryPreProcessor(input);
+        const lexResult = lexer.tokenize(processedInput);
         parser.input = lexResult.tokens;
         parser.setContext(context);
         const result = parser[rule.name](context, arg);
         if (parser.errors.length > 0) {
-          throw new Error(`Parse error on line ${parser.errors.map((x) => x.token.startLine).join(", ")}
-${parser.errors.map((x) => `${x.token.startLine}: ${x.message}`).join("\n")}`);
+          if (errorHandler) {
+            errorHandler(parser.errors);
+          } else {
+            this.defaultErrorHandler(processedInput, parser.errors);
+          }
         }
         return result;
       };
@@ -9380,292 +9942,139 @@ ${parser.errors.map((x) => `${x.token.startLine}: ${x.message}`).join("\n")}`);
     return selfSufficientParser;
   }
   consume({ tokenVocabulary, config = {} }) {
-    const rules = this.rules;
-    class MyParser extends EmbeddedActionsParser {
-      getSafeContext() {
-        if (this.context === void 0) {
-          throw new Error("context was not correctly set");
-        }
-        return this.context;
-      }
-      setContext(context) {
-        this.context = context;
-      }
-      constructor() {
-        super(tokenVocabulary, {
-          // RecoveryEnabled: true,
-          maxLookahead: 2,
-          // SkipValidations: true,
-          ...config
-        });
-        this.context = void 0;
-        const selfRef = this.getSelfRef();
-        const implArgs = {
-          ...selfRef,
-          cache: /* @__PURE__ */ new WeakMap()
-        };
-        for (const rule of Object.values(rules)) {
-          this[rule.name] = this.RULE(rule.name, rule.impl(implArgs));
-        }
-        this.performSelfAnalysis();
-      }
-      getSelfRef() {
-        const subRuleImpl = (chevrotainSubrule) => {
-          return (cstDef, arg) => {
-            return chevrotainSubrule(this[cstDef.name], { ARGS: [this.context, arg] });
-          };
-        };
-        return {
-          CONSUME: (tokenType, option) => this.CONSUME(tokenType, option),
-          CONSUME1: (tokenType, option) => this.CONSUME1(tokenType, option),
-          CONSUME2: (tokenType, option) => this.CONSUME2(tokenType, option),
-          CONSUME3: (tokenType, option) => this.CONSUME3(tokenType, option),
-          CONSUME4: (tokenType, option) => this.CONSUME4(tokenType, option),
-          CONSUME5: (tokenType, option) => this.CONSUME5(tokenType, option),
-          CONSUME6: (tokenType, option) => this.CONSUME6(tokenType, option),
-          CONSUME7: (tokenType, option) => this.CONSUME7(tokenType, option),
-          CONSUME8: (tokenType, option) => this.CONSUME8(tokenType, option),
-          CONSUME9: (tokenType, option) => this.CONSUME9(tokenType, option),
-          OPTION: (actionORMethodDef) => this.OPTION(actionORMethodDef),
-          OPTION1: (actionORMethodDef) => this.OPTION1(actionORMethodDef),
-          OPTION2: (actionORMethodDef) => this.OPTION2(actionORMethodDef),
-          OPTION3: (actionORMethodDef) => this.OPTION3(actionORMethodDef),
-          OPTION4: (actionORMethodDef) => this.OPTION4(actionORMethodDef),
-          OPTION5: (actionORMethodDef) => this.OPTION5(actionORMethodDef),
-          OPTION6: (actionORMethodDef) => this.OPTION6(actionORMethodDef),
-          OPTION7: (actionORMethodDef) => this.OPTION7(actionORMethodDef),
-          OPTION8: (actionORMethodDef) => this.OPTION8(actionORMethodDef),
-          OPTION9: (actionORMethodDef) => this.OPTION9(actionORMethodDef),
-          OR: (altsOrOpts) => this.OR(altsOrOpts),
-          OR1: (altsOrOpts) => this.OR1(altsOrOpts),
-          OR2: (altsOrOpts) => this.OR2(altsOrOpts),
-          OR3: (altsOrOpts) => this.OR3(altsOrOpts),
-          OR4: (altsOrOpts) => this.OR4(altsOrOpts),
-          OR5: (altsOrOpts) => this.OR5(altsOrOpts),
-          OR6: (altsOrOpts) => this.OR6(altsOrOpts),
-          OR7: (altsOrOpts) => this.OR7(altsOrOpts),
-          OR8: (altsOrOpts) => this.OR8(altsOrOpts),
-          OR9: (altsOrOpts) => this.OR9(altsOrOpts),
-          MANY: (actionORMethodDef) => this.MANY(actionORMethodDef),
-          MANY1: (actionORMethodDef) => this.MANY1(actionORMethodDef),
-          MANY2: (actionORMethodDef) => this.MANY2(actionORMethodDef),
-          MANY3: (actionORMethodDef) => this.MANY3(actionORMethodDef),
-          MANY4: (actionORMethodDef) => this.MANY4(actionORMethodDef),
-          MANY5: (actionORMethodDef) => this.MANY5(actionORMethodDef),
-          MANY6: (actionORMethodDef) => this.MANY6(actionORMethodDef),
-          MANY7: (actionORMethodDef) => this.MANY7(actionORMethodDef),
-          MANY8: (actionORMethodDef) => this.MANY8(actionORMethodDef),
-          MANY9: (actionORMethodDef) => this.MANY9(actionORMethodDef),
-          MANY_SEP: (options) => this.MANY_SEP(options),
-          MANY_SEP1: (options) => this.MANY_SEP1(options),
-          MANY_SEP2: (options) => this.MANY_SEP2(options),
-          MANY_SEP3: (options) => this.MANY_SEP3(options),
-          MANY_SEP4: (options) => this.MANY_SEP4(options),
-          MANY_SEP5: (options) => this.MANY_SEP5(options),
-          MANY_SEP6: (options) => this.MANY_SEP6(options),
-          MANY_SEP7: (options) => this.MANY_SEP7(options),
-          MANY_SEP8: (options) => this.MANY_SEP8(options),
-          MANY_SEP9: (options) => this.MANY_SEP9(options),
-          AT_LEAST_ONE: (actionORMethodDef) => this.AT_LEAST_ONE(actionORMethodDef),
-          AT_LEAST_ONE1: (actionORMethodDef) => this.AT_LEAST_ONE1(actionORMethodDef),
-          AT_LEAST_ONE2: (actionORMethodDef) => this.AT_LEAST_ONE2(actionORMethodDef),
-          AT_LEAST_ONE3: (actionORMethodDef) => this.AT_LEAST_ONE3(actionORMethodDef),
-          AT_LEAST_ONE4: (actionORMethodDef) => this.AT_LEAST_ONE4(actionORMethodDef),
-          AT_LEAST_ONE5: (actionORMethodDef) => this.AT_LEAST_ONE5(actionORMethodDef),
-          AT_LEAST_ONE6: (actionORMethodDef) => this.AT_LEAST_ONE6(actionORMethodDef),
-          AT_LEAST_ONE7: (actionORMethodDef) => this.AT_LEAST_ONE7(actionORMethodDef),
-          AT_LEAST_ONE8: (actionORMethodDef) => this.AT_LEAST_ONE8(actionORMethodDef),
-          AT_LEAST_ONE9: (actionORMethodDef) => this.AT_LEAST_ONE9(actionORMethodDef),
-          AT_LEAST_ONE_SEP: (options) => this.AT_LEAST_ONE_SEP(options),
-          AT_LEAST_ONE_SEP1: (options) => this.AT_LEAST_ONE_SEP1(options),
-          AT_LEAST_ONE_SEP2: (options) => this.AT_LEAST_ONE_SEP2(options),
-          AT_LEAST_ONE_SEP3: (options) => this.AT_LEAST_ONE_SEP3(options),
-          AT_LEAST_ONE_SEP4: (options) => this.AT_LEAST_ONE_SEP4(options),
-          AT_LEAST_ONE_SEP5: (options) => this.AT_LEAST_ONE_SEP5(options),
-          AT_LEAST_ONE_SEP6: (options) => this.AT_LEAST_ONE_SEP6(options),
-          AT_LEAST_ONE_SEP7: (options) => this.AT_LEAST_ONE_SEP7(options),
-          AT_LEAST_ONE_SEP8: (options) => this.AT_LEAST_ONE_SEP8(options),
-          AT_LEAST_ONE_SEP9: (options) => this.AT_LEAST_ONE_SEP9(options),
-          ACTION: (func) => this.ACTION(func),
-          BACKTRACK: (cstDef, ...args) => {
-            try {
-              return this.BACKTRACK(this[cstDef.name], { ARGS: args });
-            } catch (error) {
-              throw error;
-            }
-          },
-          SUBRULE: subRuleImpl((rule, args) => this.SUBRULE(rule, args)),
-          SUBRULE1: subRuleImpl((rule, args) => this.SUBRULE1(rule, args)),
-          SUBRULE2: subRuleImpl((rule, args) => this.SUBRULE2(rule, args)),
-          SUBRULE3: subRuleImpl((rule, args) => this.SUBRULE3(rule, args)),
-          SUBRULE4: subRuleImpl((rule, args) => this.SUBRULE4(rule, args)),
-          SUBRULE5: subRuleImpl((rule, args) => this.SUBRULE5(rule, args)),
-          SUBRULE6: subRuleImpl((rule, args) => this.SUBRULE6(rule, args)),
-          SUBRULE7: subRuleImpl((rule, args) => this.SUBRULE7(rule, args)),
-          SUBRULE8: subRuleImpl((rule, args) => this.SUBRULE8(rule, args)),
-          SUBRULE9: subRuleImpl((rule, args) => this.SUBRULE9(rule, args))
-        };
-      }
-    }
-    return new MyParser();
+    return new DynamicParser(this.rules, tokenVocabulary, config);
   }
 };
 
-// lib/grammar-helpers/utils.ts
-var CommonIRIs = /* @__PURE__ */ ((CommonIRIs2) => {
-  CommonIRIs2["BOOLEAN"] = "http://www.w3.org/2001/XMLSchema#boolean";
-  CommonIRIs2["INTEGER"] = "http://www.w3.org/2001/XMLSchema#integer";
-  CommonIRIs2["DECIMAL"] = "http://www.w3.org/2001/XMLSchema#decimal";
-  CommonIRIs2["DOUBLE"] = "http://www.w3.org/2001/XMLSchema#double";
-  CommonIRIs2["FIRST"] = "http://www.w3.org/1999/02/22-rdf-syntax-ns#first";
-  CommonIRIs2["REST"] = "http://www.w3.org/1999/02/22-rdf-syntax-ns#rest";
-  CommonIRIs2["NIL"] = "http://www.w3.org/1999/02/22-rdf-syntax-ns#nil";
-  CommonIRIs2["TYPE"] = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";
-  CommonIRIs2["REIFIES"] = "http://www.w3.org/1999/02/22-rdf-syntax-ns#reifies";
-  return CommonIRIs2;
-})(CommonIRIs || {});
+// lib/utils.ts
 function unCapitalize(str) {
   return str.charAt(0).toLowerCase() + str.slice(1);
 }
-function resolveIRI(iri, base) {
-  if (/^[a-z][\d+.a-z-]*:/iu.test(iri)) {
-    return iri;
-  }
-  if (!base) {
-    throw new Error(`Cannot resolve relative IRI ${iri} because no base IRI was set.`);
-  }
-  switch (iri[0]) {
-    // An empty relative IRI indicates the base IRI
-    case void 0:
-      return base;
-    // Resolve relative fragment IRIs against the base IRI
-    case "#":
-      return base + iri;
-    // Resolve relative query string IRIs by replacing the query string
-    case "?":
-      return base.replace(/(?:\?.*)?$/u, iri);
-    // Resolve root relative IRIs at the root of the base IRI
-    case "/":
-      const baseMatch = base.match(/^(?:[a-z]+:\/*)?[^\/]*/);
-      if (!baseMatch) {
-        throw new Error(`Could not determine relative IRI using base: ${base}`);
-      }
-      const baseRoot = baseMatch[0];
-      return baseRoot + iri;
-    // Resolve all other IRIs at the base IRI's path
-    default:
-      const basePath = base.replace(/[^\/:]*$/, "");
-      return basePath + iri;
-  }
+function createToken2(config) {
+  return createToken(config);
 }
 
-// lib/lexer-builder/LexerBuilder.ts
-var LexerBuilder = class _LexerBuilder {
-  static create(starter) {
-    return new _LexerBuilder(starter);
-  }
-  constructor(starter) {
-    this.tokens = starter?.tokens ? [...starter.tokens] : [];
+// lib/RangeArithmetic.ts
+var RangeArithmetic = class _RangeArithmetic {
+  constructor(start, end) {
+    this.ranges = [];
+    this.initRange = _RangeArithmetic.validate(start, end);
+    this.ranges.push(this.initRange);
   }
-  get(index) {
-    return this.tokens[index];
+  static validate(...range) {
+    const [start, end] = range;
+    if (start >= end) {
+      throw new Error("Invalid range");
+    }
+    return range;
   }
-  merge(merge, overwrite = []) {
-    const extraTokens = merge.tokens.filter((token) => {
-      const overwriteToken = overwrite.find((t) => t.name === token.name);
-      if (overwriteToken) {
-        return false;
+  static substractRange(included, ...range) {
+    const [sMinus, eMinus] = _RangeArithmetic.validate(...range);
+    return included.flatMap(([sCur, eCur]) => {
+      if (sCur < sMinus && eMinus < eCur) {
+        return [[sCur, sMinus], [eMinus, eCur]];
       }
-      const match = this.tokens.find((t) => t.name === token.name);
-      if (match) {
-        if (match !== token) {
-          throw new Error(`Token with name ${token.name} already exists. Implementation is different and no overwrite was provided.`);
-        }
-        return false;
+      if (sMinus <= sCur && sCur < eMinus && eMinus < eCur) {
+        return [[eMinus, eCur]];
       }
-      return true;
+      if (sCur < sMinus && sMinus < eCur && eCur <= eMinus) {
+        return [[sCur, sMinus]];
+      }
+      if (sMinus <= sCur && eCur <= eMinus) {
+        return [];
+      }
+      return [[sCur, eCur]];
     });
-    this.tokens.push(...extraTokens);
-    return this;
   }
-  add(...token) {
-    this.tokens.push(...token);
+  subtract(...range) {
+    this.ranges = _RangeArithmetic.substractRange(this.ranges, ...range);
     return this;
   }
-  addBefore(before, ...token) {
-    const index = this.tokens.indexOf(before);
-    if (index === -1) {
-      throw new Error("Token not found");
+  negate() {
+    let iter = [this.initRange];
+    for (const range of this.ranges) {
+      iter = _RangeArithmetic.substractRange(iter, ...range);
     }
-    this.tokens.splice(index, 0, ...token);
+    this.ranges = iter;
     return this;
   }
-  moveBeforeOrAfter(beforeOrAfter, before, ...tokens) {
-    const beforeIndex = this.tokens.indexOf(before) + (beforeOrAfter === "before" ? 0 : 1);
-    if (beforeIndex === -1) {
-      throw new Error("BeforeToken not found");
+  projection(...range) {
+    const [sProj, eProj] = range;
+    if (sProj >= eProj) {
+      return [];
     }
-    for (const token of tokens) {
-      const tokenIndex = this.tokens.indexOf(token);
-      if (tokenIndex === -1) {
-        throw new Error("Token not found");
+    return this.ranges.flatMap(([sCur, eCur]) => {
+      if (sCur < sProj && eProj < eCur) {
+        return [[sProj, eProj]];
       }
-      this.tokens.splice(tokenIndex, 1);
-      this.tokens.splice(beforeIndex, 0, token);
-    }
-    return this;
-  }
-  moveBefore(before, ...tokens) {
-    return this.moveBeforeOrAfter("before", before, ...tokens);
-  }
-  moveAfter(after, ...tokens) {
-    return this.moveBeforeOrAfter("after", after, ...tokens);
+      if (sProj <= sCur && eCur <= eProj) {
+        return [[sCur, eCur]];
+      }
+      if (sProj <= sCur && sCur < eProj && eProj < eCur) {
+        return [[sCur, eProj]];
+      }
+      if (sCur < sProj && sProj < eCur && eCur < eProj) {
+        return [[sProj, eCur]];
+      }
+      return [];
+    });
   }
-  addAfter(after, ...token) {
-    const index = this.tokens.indexOf(after);
-    if (index === -1) {
-      throw new Error("Token not found");
+};
+
+// lib/Transformer.ts
+var Transformer = class {
+  transformNode(curObject, searchType, patch) {
+    const copy = { ...curObject };
+    for (const [key, value] of Object.entries(copy)) {
+      copy[key] = this.safeObjectVisit(value, (obj) => this.transformNode(obj, searchType, patch));
     }
-    this.tokens.splice(index + 1, 0, ...token);
-    return this;
+    if (copy.type === searchType) {
+      return patch(copy);
+    }
+    return copy;
   }
-  delete(...token) {
-    for (const t of token) {
-      const index = this.tokens.indexOf(t);
-      if (index === -1) {
-        throw new Error("Token not found");
-      }
-      this.tokens.splice(index, 1);
+  transformNodeSpecific(curObject, searchType, searchSubType, patch) {
+    const copy = { ...curObject };
+    for (const [key, value] of Object.entries(copy)) {
+      copy[key] = this.safeObjectVisit(value, (obj) => this.transformNodeSpecific(obj, searchType, searchSubType, patch));
     }
-    return this;
+    if (copy.type === searchType && copy.subType === searchSubType) {
+      return patch(copy);
+    }
+    return copy;
   }
-  build() {
-    return this.tokens;
+  visitObjects(curObject, visitor) {
+    for (const value of Object.values(curObject)) {
+      this.safeObjectVisit(value, (obj) => this.visitObjects(obj, visitor));
+    }
   }
-};
-
-// lib/lexer-helper/utils.ts
-function createToken2(config) {
-  return createToken(config);
-}
-
-// lib/Wildcard.ts
-var Wildcard = class {
-  constructor() {
-    this.value = "*";
-    this.termType = "Wildcard";
-    return WILDCARD ?? this;
+  visitNode(curObject, searchType, visitor) {
+    for (const value of Object.values(curObject)) {
+      this.safeObjectVisit(value, (obj) => this.visitNode(obj, searchType, visitor));
+    }
+    if (curObject.type === searchType) {
+      visitor(curObject);
+    }
   }
-  equals(other) {
-    return Boolean(other && this.termType === other.termType);
+  visitNodeSpecific(curObject, searchType, searchSubType, visitor) {
+    for (const value of Object.values(curObject)) {
+      this.safeObjectVisit(value, (obj) => this.visitNodeSpecific(obj, searchType, searchSubType, visitor));
+    }
+    const cast = curObject;
+    if (cast.type === searchType && cast.subType === searchSubType) {
+      visitor(curObject);
+    }
   }
-  toJSON() {
-    const { value, ...rest } = this;
-    return rest;
+  safeObjectVisit(value, mapper) {
+    if (value && typeof value === "object") {
+      if (Array.isArray(value)) {
+        return value.map((x) => this.safeObjectVisit(x, mapper));
+      }
+      return mapper(value);
+    }
+    return value;
   }
 };
-var WILDCARD;
-WILDCARD = new Wildcard();
 /*! Bundled license information:
 
 lodash-es/lodash.js: