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

package/lib/index.cjs

@@ -1,13 +1,8 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -20,326 +15,139 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// ../../node_modules/rdf-data-factory/lib/BlankNode.js
-var require_BlankNode = __commonJS({
-  "../../node_modules/rdf-data-factory/lib/BlankNode.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.BlankNode = void 0;
-    var BlankNode = class {
-      constructor(value) {
-        this.termType = "BlankNode";
-        this.value = value;
-      }
-      equals(other) {
-        return !!other && other.termType === "BlankNode" && other.value === this.value;
-      }
-    };
-    exports2.BlankNode = BlankNode;
-  }
+// lib/index.ts
+var index_exports = {};
+__export(index_exports, {
+  GeneratorBuilder: () => GeneratorBuilder,
+  LexerBuilder: () => LexerBuilder,
+  ParserBuilder: () => ParserBuilder,
+  createToken: () => createToken2,
+  unCapitalize: () => unCapitalize
 });
+module.exports = __toCommonJS(index_exports);
 
-// ../../node_modules/rdf-data-factory/lib/DefaultGraph.js
-var require_DefaultGraph = __commonJS({
-  "../../node_modules/rdf-data-factory/lib/DefaultGraph.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.DefaultGraph = void 0;
-    var DefaultGraph = class {
-      constructor() {
-        this.termType = "DefaultGraph";
-        this.value = "";
-      }
-      equals(other) {
-        return !!other && other.termType === "DefaultGraph";
+// 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);
       }
     };
-    exports2.DefaultGraph = DefaultGraph;
-    DefaultGraph.INSTANCE = new DefaultGraph();
+    for (const rule of Object.values(rules)) {
+      this[rule.name] = (input, context, args) => {
+        this.setContext(context);
+        return rule.gImpl(selfRef)(input, this.getSafeContext(), args);
+      };
+    }
   }
-});
-
-// ../../node_modules/rdf-data-factory/lib/NamedNode.js
-var require_NamedNode = __commonJS({
-  "../../node_modules/rdf-data-factory/lib/NamedNode.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.NamedNode = void 0;
-    var NamedNode = class {
-      constructor(value) {
-        this.termType = "NamedNode";
-        this.value = value;
-      }
-      equals(other) {
-        return !!other && other.termType === "NamedNode" && other.value === this.value;
-      }
-    };
-    exports2.NamedNode = NamedNode;
+  setContext(context) {
+    this.__context = context;
   }
-});
-
-// ../../node_modules/rdf-data-factory/lib/Literal.js
-var require_Literal = __commonJS({
-  "../../node_modules/rdf-data-factory/lib/Literal.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.Literal = void 0;
-    var NamedNode_1 = require_NamedNode();
-    var Literal = class _Literal {
-      constructor(value, languageOrDatatype) {
-        this.termType = "Literal";
-        this.value = value;
-        if (typeof languageOrDatatype === "string") {
-          this.language = languageOrDatatype;
-          this.datatype = _Literal.RDF_LANGUAGE_STRING;
-          this.direction = "";
-        } else if (languageOrDatatype) {
-          if ("termType" in languageOrDatatype) {
-            this.language = "";
-            this.datatype = languageOrDatatype;
-            this.direction = "";
-          } else {
-            this.language = languageOrDatatype.language;
-            this.datatype = languageOrDatatype.direction ? _Literal.RDF_DIRECTIONAL_LANGUAGE_STRING : _Literal.RDF_LANGUAGE_STRING;
-            this.direction = languageOrDatatype.direction || "";
-          }
-        } else {
-          this.language = "";
-          this.datatype = _Literal.XSD_STRING;
-          this.direction = "";
-        }
-      }
-      equals(other) {
-        return !!other && other.termType === "Literal" && other.value === this.value && other.language === this.language && (other.direction === this.direction || !other.direction && this.direction === "") && this.datatype.equals(other.datatype);
-      }
-    };
-    exports2.Literal = Literal;
-    Literal.RDF_LANGUAGE_STRING = new NamedNode_1.NamedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#langString");
-    Literal.RDF_DIRECTIONAL_LANGUAGE_STRING = new NamedNode_1.NamedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#dirLangString");
-    Literal.XSD_STRING = new NamedNode_1.NamedNode("http://www.w3.org/2001/XMLSchema#string");
+  getSafeContext() {
+    return this.__context;
   }
-});
+};
 
-// ../../node_modules/rdf-data-factory/lib/Quad.js
-var require_Quad = __commonJS({
-  "../../node_modules/rdf-data-factory/lib/Quad.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.Quad = void 0;
-    var Quad = class {
-      constructor(subject, predicate, object, graph) {
-        this.termType = "Quad";
-        this.value = "";
-        this.subject = subject;
-        this.predicate = predicate;
-        this.object = object;
-        this.graph = graph;
-      }
-      equals(other) {
-        return !!other && (other.termType === "Quad" || !other.termType) && this.subject.equals(other.subject) && this.predicate.equals(other.predicate) && this.object.equals(other.object) && this.graph.equals(other.graph);
-      }
-    };
-    exports2.Quad = Quad;
+// lib/generator-builder/generatorBuilder.ts
+function listToRuleDefMap(rules) {
+  const newRules = {};
+  for (const rule of rules) {
+    newRules[rule.name] = rule;
   }
-});
-
-// ../../node_modules/rdf-data-factory/lib/Variable.js
-var require_Variable = __commonJS({
-  "../../node_modules/rdf-data-factory/lib/Variable.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.Variable = void 0;
-    var Variable = class {
-      constructor(value) {
-        this.termType = "Variable";
-        this.value = value;
-      }
-      equals(other) {
-        return !!other && other.termType === "Variable" && other.value === this.value;
-      }
-    };
-    exports2.Variable = Variable;
+  return newRules;
+}
+var GeneratorBuilder = class _GeneratorBuilder {
+  static createBuilder(start) {
+    if (start instanceof _GeneratorBuilder) {
+      return new _GeneratorBuilder({ ...start.rules });
+    }
+    return new _GeneratorBuilder(listToRuleDefMap(start));
   }
-});
-
-// ../../node_modules/rdf-data-factory/lib/DataFactory.js
-var require_DataFactory = __commonJS({
-  "../../node_modules/rdf-data-factory/lib/DataFactory.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.DataFactory = void 0;
-    var BlankNode_1 = require_BlankNode();
-    var DefaultGraph_1 = require_DefaultGraph();
-    var Literal_1 = require_Literal();
-    var NamedNode_1 = require_NamedNode();
-    var Quad_1 = require_Quad();
-    var Variable_1 = require_Variable();
-    var dataFactoryCounter = 0;
-    var DataFactory2 = class {
-      constructor(options) {
-        this.blankNodeCounter = 0;
-        options = options || {};
-        this.blankNodePrefix = options.blankNodePrefix || `df_${dataFactoryCounter++}_`;
-      }
-      /**
-       * @param value The IRI for the named node.
-       * @return A new instance of NamedNode.
-       * @see NamedNode
-       */
-      namedNode(value) {
-        return new NamedNode_1.NamedNode(value);
-      }
-      /**
-       * @param value The optional blank node identifier.
-       * @return A new instance of BlankNode.
-       *         If the `value` parameter is undefined a new identifier
-       *         for the blank node is generated for each call.
-       * @see BlankNode
-       */
-      blankNode(value) {
-        return new BlankNode_1.BlankNode(value || `${this.blankNodePrefix}${this.blankNodeCounter++}`);
-      }
-      /**
-       * @param value              The literal value.
-       * @param languageOrDatatype The optional language, datatype, or directional language.
-       *                           If `languageOrDatatype` is a NamedNode,
-       *                           then it is used for the value of `NamedNode.datatype`.
-       *                           If `languageOrDatatype` is a NamedNode, it is used for the value
-       *                           of `NamedNode.language`.
-       *                           Otherwise, it is used as a directional language,
-       *                           from which the language is set to `languageOrDatatype.language`
-       *                           and the direction to `languageOrDatatype.direction`.
-       * @return A new instance of Literal.
-       * @see Literal
-       */
-      literal(value, languageOrDatatype) {
-        return new Literal_1.Literal(value, languageOrDatatype);
-      }
-      /**
-       * This method is optional.
-       * @param value The variable name
-       * @return A new instance of Variable.
-       * @see Variable
-       */
-      variable(value) {
-        return new Variable_1.Variable(value);
-      }
-      /**
-       * @return An instance of DefaultGraph.
-       */
-      defaultGraph() {
-        return DefaultGraph_1.DefaultGraph.INSTANCE;
-      }
-      /**
-       * @param subject   The quad subject term.
-       * @param predicate The quad predicate term.
-       * @param object    The quad object term.
-       * @param graph     The quad graph term.
-       * @return A new instance of Quad.
-       * @see Quad
-       */
-      quad(subject, predicate, object, graph) {
-        return new Quad_1.Quad(subject, predicate, object, graph || this.defaultGraph());
-      }
-      /**
-       * Create a deep copy of the given term using this data factory.
-       * @param original An RDF term.
-       * @return A deep copy of the given term.
-       */
-      fromTerm(original) {
-        switch (original.termType) {
-          case "NamedNode":
-            return this.namedNode(original.value);
-          case "BlankNode":
-            return this.blankNode(original.value);
-          case "Literal":
-            if (original.language) {
-              return this.literal(original.value, original.language);
-            }
-            if (!original.datatype.equals(Literal_1.Literal.XSD_STRING)) {
-              return this.literal(original.value, this.fromTerm(original.datatype));
-            }
-            return this.literal(original.value);
-          case "Variable":
-            return this.variable(original.value);
-          case "DefaultGraph":
-            return this.defaultGraph();
-          case "Quad":
-            return this.quad(this.fromTerm(original.subject), this.fromTerm(original.predicate), this.fromTerm(original.object), this.fromTerm(original.graph));
+  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`);
+          }
         }
       }
-      /**
-       * Create a deep copy of the given quad using this data factory.
-       * @param original An RDF quad.
-       * @return A deep copy of the given quad.
-       */
-      fromQuad(original) {
-        return this.fromTerm(original);
-      }
-      /**
-       * Reset the internal blank node counter.
-       */
-      resetBlankNodeCounter() {
-        this.blankNodeCounter = 0;
-      }
-    };
-    exports2.DataFactory = DataFactory2;
+    }
+    this.rules = otherRules;
+    return this;
   }
-});
-
-// ../../node_modules/rdf-data-factory/index.js
-var require_rdf_data_factory = __commonJS({
-  "../../node_modules/rdf-data-factory/index.js"(exports2) {
-    "use strict";
-    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
-      if (k2 === void 0) k2 = k;
-      var desc = Object.getOwnPropertyDescriptor(m, k);
-      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-        desc = { enumerable: true, get: function() {
-          return m[k];
-        } };
-      }
-      Object.defineProperty(o, k2, desc);
-    } : function(o, m, k, k2) {
-      if (k2 === void 0) k2 = k;
-      o[k2] = m[k];
-    });
-    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
-      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
-    };
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    __exportStar(require_BlankNode(), exports2);
-    __exportStar(require_DataFactory(), exports2);
-    __exportStar(require_DefaultGraph(), exports2);
-    __exportStar(require_Literal(), exports2);
-    __exportStar(require_NamedNode(), exports2);
-    __exportStar(require_Quad(), exports2);
-    __exportStar(require_Variable(), exports2);
+  build() {
+    return new DynamicGenerator(this.rules);
   }
-});
-
-// lib/index.ts
-var index_exports = {};
-__export(index_exports, {
-  Builder: () => Builder,
-  CommonIRIs: () => CommonIRIs,
-  LexerBuilder: () => LexerBuilder,
-  Wildcard: () => Wildcard,
-  createToken: () => createToken2,
-  resolveIRI: () => resolveIRI,
-  unCapitalize: () => unCapitalize
-});
-module.exports = __toCommonJS(index_exports);
+};
 
 // ../../node_modules/lodash-es/_freeGlobal.js
 var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
@@ -1706,8 +1514,8 @@ var Promise2 = getNative_default(root_default, "Promise");
 var Promise_default = Promise2;
 
 // ../../node_modules/lodash-es/_Set.js
-var Set2 = getNative_default(root_default, "Set");
-var Set_default = Set2;
+var Set = getNative_default(root_default, "Set");
+var Set_default = Set;
 
 // ../../node_modules/lodash-es/_getTag.js
 var mapTag2 = "[object Map]";
@@ -9559,29 +9367,235 @@ var EmbeddedActionsParser = class extends Parser {
   }
 };
 
-// lib/grammar-builder/parserBuilder.ts
-var import_rdf_data_factory = __toESM(require_rdf_data_factory(), 1);
-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 with from some initial grammar rules or an existing builder.
+   * 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.
    */
@@ -9609,13 +9623,25 @@ var Builder = class _Builder {
     return this.addRuleRedundant(rule);
   }
   addMany(...rules) {
-    this.rules = { ...this.rules, ...listToRuleDefMap(rules) };
+    this.rules = { ...this.rules, ...listToRuleDefMap2(rules) };
     return this;
   }
+  /**
+   * Delete a grammar rule by its name.
+   */
   deleteRule(ruleName) {
     delete this.rules[ruleName];
     return this;
   }
+  /**
+   * 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 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(builder, overridingRules) {
     const otherRules = { ...builder.rules };
     const myRules = this.rules;
@@ -9637,349 +9663,68 @@ var Builder = class _Builder {
     this.rules = otherRules;
     return this;
   }
-  consumeToParser({ tokenVocabulary, parserConfig = {}, lexerConfig = {} }, context = {}) {
-    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 }, context);
     const selfSufficientParser = {};
     for (const rule of Object.values(this.rules)) {
-      selfSufficientParser[rule.name] = (input, 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);
-        parser.reset();
+      selfSufficientParser[rule.name] = (input, context, arg) => {
+        const processedInput = queryPreProcessor(input);
+        const lexResult = lexer.tokenize(processedInput);
         parser.input = lexResult.tokens;
-        const result = parser[rule.name](arg);
+        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;
       };
     }
     return selfSufficientParser;
   }
-  consume({ tokenVocabulary, config = {} }, context = {}) {
-    const rules = this.rules;
-    class MyParser extends EmbeddedActionsParser {
-      constructor() {
-        super(tokenVocabulary, {
-          // RecoveryEnabled: true,
-          maxLookahead: 2,
-          // SkipValidations: true,
-          ...config
-        });
-        const selfRef = this.getSelfRef();
-        this.initialParseContext = {
-          dataFactory: new import_rdf_data_factory.DataFactory({ blankNodePrefix: "g_" }),
-          baseIRI: void 0,
-          parseMode: /* @__PURE__ */ new Set(),
-          skipValidation: false,
-          ...context,
-          prefixes: context.prefixes ? { ...context.prefixes } : {}
-        };
-        this.runningContext = {
-          ...this.initialParseContext,
-          prefixes: { ...this.initialParseContext.prefixes },
-          parseMode: new Set(this.initialParseContext.parseMode)
-        };
-        const implArgs = {
-          ...selfRef,
-          cache: /* @__PURE__ */ new WeakMap(),
-          context: this.runningContext
-        };
-        for (const rule of Object.values(rules)) {
-          this[rule.name] = this.RULE(rule.name, rule.impl(implArgs));
-        }
-        this.performSelfAnalysis();
-      }
-      reset() {
-        super.reset();
-        Object.assign(this.runningContext, {
-          ...this.initialParseContext
-        });
-        this.runningContext.prefixes = { ...this.initialParseContext.prefixes };
-        this.runningContext.parseMode = new Set(this.initialParseContext.parseMode);
-      }
-      getSelfRef() {
-        const subRuleImpl = (subrule) => {
-          return (cstDef, ...args) => {
-            return subrule(this[cstDef.name], { ARGS: args });
-          };
-        };
-        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();
+  consume({ tokenVocabulary, config = {} }) {
+    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: