@traqula/core 0.0.21 → 0.0.23

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

@@ -0,0 +1,55 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dynamicIndirected_exports = {};
+__export(dynamicIndirected_exports, {
+  DynamicIndirect: () => DynamicIndirect
+});
+module.exports = __toCommonJS(dynamicIndirected_exports);
+class DynamicIndirect {
+  rules;
+  __context = void 0;
+  constructor(rules) {
+    this.rules = rules;
+    for (const rule of Object.values(rules)) {
+      this[rule.name] = ((context, ...args) => {
+        this.setContext(context);
+        return this.subrule(rule, ...args);
+      });
+    }
+  }
+  setContext(context) {
+    this.__context = context;
+  }
+  getSafeContext() {
+    return this.__context;
+  }
+  subrule = (cstDef, ...args) => {
+    const def = this.rules[cstDef.name];
+    if (!def) {
+      throw new Error(`Rule ${cstDef.name} not found`);
+    }
+    return def.fun({
+      SUBRULE: this.subrule
+    })(this.getSafeContext(), ...args);
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DynamicIndirect
+});

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

@@ -0,0 +1,34 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var helpers_exports = {};
+__export(helpers_exports, {
+  listToIndirectionMap: () => listToIndirectionMap
+});
+module.exports = __toCommonJS(helpers_exports);
+function listToIndirectionMap(rules) {
+  const newRules = {};
+  for (const rule of rules) {
+    newRules[rule.name] = rule;
+  }
+  return newRules;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  listToIndirectionMap
+});

package/dist/cjs/lib/lexer-builder/LexerBuilder.js

@@ -0,0 +1,123 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var LexerBuilder_exports = {};
+__export(LexerBuilder_exports, {
+  LexerBuilder: () => LexerBuilder
+});
+module.exports = __toCommonJS(LexerBuilder_exports);
+var import_chevrotain = require("@traqula/chevrotain");
+class LexerBuilder {
+  tokens;
+  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 import_chevrotain.Lexer(this.tokens, {
+      positionTracking: "onlyStart",
+      recoveryEnabled: false,
+      ensureOptimizations: true,
+      // SafeMode: true,
+      // SkipValidations: true,
+      ...lexerConfig
+    });
+  }
+  get tokenVocabulary() {
+    return this.tokens;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LexerBuilder
+});

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

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

package/dist/cjs/lib/parser-builder/dynamicParser.js

@@ -0,0 +1,139 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dynamicParser_exports = {};
+__export(dynamicParser_exports, {
+  DynamicParser: () => DynamicParser
+});
+module.exports = __toCommonJS(dynamicParser_exports);
+var import_chevrotain = require("@traqula/chevrotain");
+class DynamicParser extends import_chevrotain.EmbeddedActionsParser {
+  context;
+  setContext(context) {
+    this.context = context;
+  }
+  constructor(rules, tokenVocabulary, config = {}) {
+    super(tokenVocabulary, {
+      // RecoveryEnabled: true,
+      maxLookahead: 1,
+      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))
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DynamicParser
+});

package/dist/cjs/lib/parser-builder/parserBuilder.js

@@ -0,0 +1,182 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var parserBuilder_exports = {};
+__export(parserBuilder_exports, {
+  ParserBuilder: () => ParserBuilder
+});
+module.exports = __toCommonJS(parserBuilder_exports);
+var import_LexerBuilder = require("../lexer-builder/LexerBuilder.js");
+var import_dynamicParser = require("./dynamicParser.js");
+function listToRuleDefMap(rules) {
+  const newRules = {};
+  for (const rule of rules) {
+    newRules[rule.name] = rule;
+  }
+  return newRules;
+}
+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 create(start) {
+    if (Array.isArray(start)) {
+      return new ParserBuilder(listToRuleDefMap(start));
+    }
+    return new ParserBuilder({ ...start.rules });
+  }
+  rules;
+  constructor(startRules) {
+    this.rules = startRules;
+  }
+  widenContext() {
+    return this;
+  }
+  typePatch() {
+    return this;
+  }
+  /**
+   * Change the implementation of an existing grammar rule.
+   */
+  patchRule(patch) {
+    const self = this;
+    self.rules[patch.name] = patch;
+    return self;
+  }
+  /**
+   * Add a rule to the grammar. If the rule already exists, but the implementation differs, an error will be thrown.
+   */
+  addRuleRedundant(rule) {
+    const self = this;
+    const rules = self.rules;
+    if (rules[rule.name] !== void 0 && rules[rule.name] !== rule) {
+      throw new Error(`Rule ${rule.name} already exists in the builder`);
+    }
+    rules[rule.name] = rule;
+    return self;
+  }
+  /**
+   * Add a rule to the grammar. Will raise a typescript error if the rule already exists in the grammar.
+   */
+  addRule(rule) {
+    return this.addRuleRedundant(rule);
+  }
+  addMany(...rules) {
+    this.rules = { ...this.rules, ...listToRuleDefMap(rules) };
+    return this;
+  }
+  /**
+   * Delete a grammar rule by its name.
+   */
+  deleteRule(ruleName) {
+    delete this.rules[ruleName];
+    return this;
+  }
+  getRule(ruleName) {
+    return this.rules[ruleName];
+  }
+  /**
+   * Merge this grammar 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;
+    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 builder, specify an override to resolve conflict`);
+          }
+        }
+      }
+    }
+    this.rules = otherRules;
+    return this;
+  }
+  defaultErrorHandler(input, errors) {
+    const firstError = errors[0];
+    const messageBuilder = ["Parse error"];
+    const lineIdx = firstError.token.startLine;
+    if (lineIdx !== void 0 && !Number.isNaN(lineIdx)) {
+      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 = import_LexerBuilder.LexerBuilder.create().add(...tokenVocabulary).build({
+      positionTracking: "full",
+      recoveryEnabled: false,
+      ensureOptimizations: true,
+      safeMode: false,
+      skipValidations: true,
+      ...lexerConfig
+    });
+    const parser = this.consume({
+      tokenVocabulary,
+      config: parserConfig
+    });
+    const selfSufficientParser = {};
+    for (const rule of Object.values(this.rules)) {
+      selfSufficientParser[rule.name] = ((input, context, ...args) => {
+        const processedInput = queryPreProcessor(input);
+        const lexResult = lexer.tokenize(processedInput);
+        parser.input = lexResult.tokens;
+        parser.setContext(context);
+        const result = parser[rule.name](context, ...args);
+        if (parser.errors.length > 0) {
+          if (errorHandler) {
+            errorHandler(parser.errors);
+          } else {
+            this.defaultErrorHandler(processedInput, parser.errors);
+          }
+        }
+        return result;
+      });
+    }
+    return selfSufficientParser;
+  }
+  consume({ tokenVocabulary, config = {} }) {
+    return new import_dynamicParser.DynamicParser(this.rules, tokenVocabulary, config);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ParserBuilder
+});

package/dist/cjs/lib/parser-builder/ruleDefTypes.js

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