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

package/lib/index.cjs

@@ -20,16 +20,135 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // lib/index.ts
 var index_exports = {};
 __export(index_exports, {
-  Builder: () => Builder,
-  CommonIRIs: () => CommonIRIs,
+  GeneratorBuilder: () => GeneratorBuilder,
   LexerBuilder: () => LexerBuilder,
-  Wildcard: () => Wildcard,
+  ParserBuilder: () => ParserBuilder,
   createToken: () => createToken2,
-  resolveIRI: () => resolveIRI,
   unCapitalize: () => unCapitalize
 });
 module.exports = __toCommonJS(index_exports);
 
+// lib/generator-builder/dynamicGenerator.ts
+var DynamicGenerator = class {
+  constructor(rules) {
+    this.__context = void 0;
+    const selfRef = {
+      SUBRULE: (cstDef, input, arg) => {
+        const def = rules[cstDef.name];
+        if (!def) {
+          throw new Error(`Rule ${cstDef.name} not found`);
+        }
+        return def.gImpl(selfRef)(input, this.getSafeContext(), arg);
+      }
+    };
+    for (const rule of Object.values(rules)) {
+      this[rule.name] = (input, context, args) => {
+        this.setContext(context);
+        return rule.gImpl(selfRef)(input, this.getSafeContext(), args);
+      };
+    }
+  }
+  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 createBuilder(start) {
+    if (start instanceof _GeneratorBuilder) {
+      return new _GeneratorBuilder({ ...start.rules });
+    }
+    return new _GeneratorBuilder(listToRuleDefMap(start));
+  }
+  constructor(startRules) {
+    this.rules = startRules;
+  }
+  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;
@@ -9248,28 +9367,235 @@ 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;
+  }
+  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,
+      // SafeMode: true,
+      // SkipValidations: true,
+      ensureOptimizations: 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 });
+    if (start instanceof _ParserBuilder) {
+      return new _ParserBuilder({ ...start.rules });
     }
-    return new _Builder(listToRuleDefMap(start));
+    return new _ParserBuilder(listToRuleDefMap2(start));
   }
   constructor(startRules) {
     this.rules = startRules;
   }
+  typePatch() {
+    return this;
+  }
   /**
    * Change the implementation of an existing grammar rule.
    */
@@ -9297,7 +9623,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 +9636,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 +9663,50 @@ var Builder = class _Builder {
     this.rules = otherRules;
     return this;
   }
-  consumeToParser({ tokenVocabulary, parserConfig = {}, lexerConfig = {} }) {
-    const lexer = new Lexer(tokenVocabulary, {
-      positionTracking: "onlyStart",
-      recoveryEnabled: false,
-      // SafeMode: true,
-      // SkipValidations: true,
-      ensureOptimizations: true,
-      ...lexerConfig
+  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(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 +9714,17 @@ ${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;
-  }
-}
-
-// lib/lexer-builder/LexerBuilder.ts
-var LexerBuilder = class _LexerBuilder {
-  static create(starter) {
-    return new _LexerBuilder(starter);
-  }
-  constructor(starter) {
-    this.tokens = starter?.tokens ? [...starter.tokens] : [];
-  }
-  get(index) {
-    return this.tokens[index];
-  }
-  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;
-  }
-  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() {
-    return this.tokens;
-  }
-};
-
-// 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;
-  }
-  equals(other) {
-    return Boolean(other && this.termType === other.termType);
-  }
-  toJSON() {
-    const { value, ...rest } = this;
-    return rest;
-  }
-};
-var WILDCARD;
-WILDCARD = new Wildcard();
 /*! Bundled license information:
 
 lodash-es/lodash.js: