@traqula/core 0.0.23 → 0.0.24

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

@@ -1,182 +1,180 @@
 "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");
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParserBuilder = void 0;
+const LexerBuilder_js_1 = require("../lexer-builder/LexerBuilder.js");
+const dynamicParser_js_1 = require("./dynamicParser.js");
+/**
+ * Converts a list of ruledefs to a record mapping a name to the corresponding ruledef.
+ */
 function listToRuleDefMap(rules) {
-  const newRules = {};
-  for (const rule of rules) {
-    newRules[rule.name] = rule;
-  }
-  return newRules;
+    const newRules = {};
+    for (const rule of rules) {
+        newRules[rule.name] = rule;
+    }
+    return newRules;
 }
+/**
+ * The grammar builder. This is the core of traqula (besides using the amazing chevrotain framework).
+ * Using the builder you can create a grammar + AST creator.
+ * At any point in time, a parser can be constructed from the added rules.
+ * Constructing a parser will cause a validation which will validate the correctness of the grammar.
+ */
+// This code is wild so other code can be simple.
 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));
+    /**
+     * 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;
     }
-    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`);
+    typePatch() {
+        return this;
     }
-    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`);
-          }
+    /**
+     * 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] !== undefined && 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;
     }
-    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}
+    /**
+     * 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) {
+        // Assume the other grammar is bigger than yours. So start from that one and add this one
+        const otherRules = { ...builder.rules };
+        const myRules = this.rules;
+        for (const rule of Object.values(myRules)) {
+            if (otherRules[rule.name] === undefined) {
+                otherRules[rule.name] = rule;
+            }
+            else {
+                const existingRule = otherRules[rule.name];
+                // If same rule, no issue, move on. Else
+                if (existingRule !== rule) {
+                    const override = overridingRules.find(x => x.name === rule.name);
+                    // If override specified, take override, else, inform user that there is a conflict
+                    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 !== undefined && !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)}^`);
-      }
+            const columnIdx = firstError.token.startColumn;
+            if (columnIdx !== undefined) {
+                messageBuilder.push(`\n${'-'.repeat(columnIdx - 1)}^`);
+            }
+        }
+        messageBuilder.push(`\n${firstError.message}`);
+        throw new Error(messageBuilder.join(''));
     }
-    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);
-          }
+    build({ tokenVocabulary, parserConfig = {}, lexerConfig = {}, queryPreProcessor = s => s, errorHandler, }) {
+        const lexer = LexerBuilder_js_1.LexerBuilder.create().add(...tokenVocabulary).build({
+            positionTracking: 'full',
+            recoveryEnabled: false,
+            ensureOptimizations: true,
+            safeMode: false,
+            skipValidations: true,
+            ...lexerConfig,
+        });
+        // Get the chevrotain parser
+        const parser = this.consume({
+            tokenVocabulary: tokenVocabulary,
+            config: parserConfig,
+        });
+        // Start building a parser that does not pass input using a state, but instead gets it as a function argument.
+        const selfSufficientParser = {};
+        // To do that, we need to create a wrapper for each parser rule.
+        // eslint-disable-next-line ts/no-unnecessary-type-assertion
+        for (const rule of Object.values(this.rules)) {
+            selfSufficientParser[rule.name] = ((input, context, ...args) => {
+                const processedInput = queryPreProcessor(input);
+                const lexResult = lexer.tokenize(processedInput);
+                // This also resets the parser
+                parser.input = lexResult.tokens;
+                parser.setContext(context);
+                const result = parser[rule.name](context, ...args);
+                if (parser.errors.length > 0) {
+                    // Console.log(lexResult);
+                    if (errorHandler) {
+                        errorHandler(parser.errors);
+                    }
+                    else {
+                        this.defaultErrorHandler(processedInput, parser.errors);
+                    }
+                }
+                return result;
+            });
         }
-        return result;
-      });
+        return selfSufficientParser;
+    }
+    consume({ tokenVocabulary, config = {} }) {
+        return new dynamicParser_js_1.DynamicParser(this.rules, tokenVocabulary, config);
     }
-    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
-});
+exports.ParserBuilder = ParserBuilder;
+//# sourceMappingURL=parserBuilder.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parserBuilder.js","sourceRoot":"","sources":["../../../../lib/parser-builder/parserBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import type {\n  ILexerConfig,\n  IParserConfig,\n  IRecognitionException,\n  TokenType,\n  TokenVocabulary,\n  EmbeddedActionsParser,\n} from '@traqula/chevrotain';\nimport { LexerBuilder } from '../lexer-builder/LexerBuilder.js';\nimport type { CheckOverlap } from '../utils.js';\nimport type {\n  ParseMethodsFromRules,\n  ParserFromRules,\n  ParseRuleMap,\n  ParseRulesToObject,\n  ParseNamesFromList,\n} from './builderTypes.js';\nimport { DynamicParser } from './dynamicParser.js';\nimport type { ParserRule } from './ruleDefTypes.js';\n\n/**\n * Converts a list of ruledefs to a record mapping a name to the corresponding ruledef.\n */\nfunction listToRuleDefMap<T extends readonly ParserRule[]>(rules: T): ParseRulesToObject<T> {\n  const newRules: Record<string, ParserRule> = {};\n  for (const rule of rules) {\n    newRules[rule.name] = rule;\n  }\n  return <ParseRulesToObject<T>>newRules;\n}\n\nexport interface ParserBuildArgs {\n  tokenVocabulary: readonly TokenType[];\n  parserConfig?: IParserConfig;\n  lexerConfig?: ILexerConfig;\n  queryPreProcessor?: (input: string) => string;\n  errorHandler?: (errors: IRecognitionException[]) => void;\n}\n\n/**\n * The grammar builder. This is the core of traqula (besides using the amazing chevrotain framework).\n * Using the builder you can create a grammar + AST creator.\n * At any point in time, a parser can be constructed from the added rules.\n * Constructing a parser will cause a validation which will validate the correctness of the grammar.\n */\n// This code is wild so other code can be simple.\nexport class ParserBuilder<Context, Names extends string, RuleDefs extends ParseRuleMap<Names>> {\n  /**\n   * Create a builder from some initial grammar rules or an existing builder.\n   * If a builder is provided, a new copy will be created.\n   */\n  public static create<\n    Rules extends readonly ParserRule[] = readonly ParserRule[],\n    Context = Rules[0] extends ParserRule<infer context> ? context : never,\n    Names extends string = ParseNamesFromList<Rules>,\n    RuleDefs extends ParseRuleMap<Names> = ParseRulesToObject<Rules>,\n  >(\n    start: Rules | ParserBuilder<Context, Names, RuleDefs>,\n  ): ParserBuilder<Context, Names, RuleDefs> {\n    if (Array.isArray(start)) {\n      return <ParserBuilder<Context, Names, RuleDefs>> <unknown> new ParserBuilder(listToRuleDefMap(start));\n    }\n    return new ParserBuilder({ ...(<ParserBuilder<any, any, any>>start).rules });\n  }\n\n  private rules: RuleDefs;\n\n  private constructor(startRules: RuleDefs) {\n    this.rules = startRules;\n  }\n\n  public widenContext<NewContext extends Context>(): ParserBuilder<\n    NewContext,\nNames,\n{[Key in keyof RuleDefs]: Key extends Names ?\n    (RuleDefs[Key] extends ParserRule<any, any, infer RT, infer PT> ? ParserRule<NewContext, Key, RT, PT> : never)\n  : never }\n> {\n    return <any> this;\n  }\n\n  public typePatch<Patch extends {[Key in Names]?: [any] | [any, any[]]}>():\n  ParserBuilder<Context, Names, {[Key in Names]: Key extends keyof Patch ? (\n    Patch[Key] extends [any, any[]] ? ParserRule<Context, Key, Patch[Key][0], Patch[Key][1]> : (\n      // Only one - infer yourself\n      Patch[Key] extends [any] ? (\n        RuleDefs[Key] extends ParserRule<any, any, any, infer Par> ?\n          ParserRule<Context, Key, Patch[Key][0], Par> : never\n      ) : never\n    )\n  ) : (RuleDefs[Key] extends ParserRule<Context, Key> ? RuleDefs[Key] : never) }> {\n    return <any> this;\n  }\n\n  /**\n   * Change the implementation of an existing grammar rule.\n   */\n  public patchRule<U extends Names, RET, ARGS extends any[]>(patch: ParserRule<Context, U, RET, ARGS>):\n  ParserBuilder<Context, Names, {[Key in Names]: Key extends U ?\n    ParserRule<Context, Key, RET, ARGS> :\n      (RuleDefs[Key] extends ParserRule<Context, Key> ? RuleDefs[Key] : never)\n  } > {\n    const self = <ParserBuilder<Context, Names, {[Key in Names]: Key extends U ?\n      ParserRule<Context, Key, RET, ARGS> : (RuleDefs[Key] extends ParserRule<Context, Key> ? RuleDefs[Key] : never) }>>\n      <unknown> this;\n    self.rules[patch.name] = <any> patch;\n    return self;\n  }\n\n  /**\n   * Add a rule to the grammar. If the rule already exists, but the implementation differs, an error will be thrown.\n   */\n  public addRuleRedundant<U extends string, RET, ARGS extends any[]>(rule: ParserRule<Context, U, RET, ARGS>):\n  ParserBuilder<Context, Names | U, {[K in Names | U]: K extends U ?\n    ParserRule<Context, K, RET, ARGS> :\n      (K extends Names ? (RuleDefs[K] extends ParserRule<Context, K> ? RuleDefs[K] : never) : never)\n  }> {\n    const self = <ParserBuilder<Context, Names | U, {[K in Names | U]: K extends U ?\n      ParserRule<Context, K, RET, ARGS> :\n        (K extends Names ? (RuleDefs[K] extends ParserRule<Context, K> ? RuleDefs[K] : never) : never) }>>\n      <unknown> this;\n    const rules = <Record<string, ParserRule<Context>>> self.rules;\n    if (rules[rule.name] !== undefined && rules[rule.name] !== rule) {\n      throw new Error(`Rule ${rule.name} already exists in the builder`);\n    }\n    rules[rule.name] = rule;\n    return self;\n  }\n\n  /**\n   * Add a rule to the grammar. Will raise a typescript error if the rule already exists in the grammar.\n   */\n  public addRule<U extends string, RET, ARGS extends any[]>(\n    rule: CheckOverlap<U, Names, ParserRule<Context, U, RET, ARGS>>,\n  ): ParserBuilder<Context, Names | U, {[K in Names | U]: K extends U ?\n    ParserRule<Context, K, RET, ARGS> :\n      (K extends Names ? (RuleDefs[K] extends ParserRule<Context, K> ? RuleDefs[K] : never) : never) }> {\n    return this.addRuleRedundant(rule);\n  }\n\n  public addMany<U extends readonly ParserRule<Context>[]>(\n    ...rules: CheckOverlap<ParseNamesFromList<U>, Names, U>\n  ): ParserBuilder<\n      Context,\n    Names | ParseNamesFromList<U>,\n    {[K in Names | ParseNamesFromList<U>]:\n      K extends keyof ParseRulesToObject<typeof rules> ? (\n        ParseRulesToObject<typeof rules>[K] extends ParserRule<Context, K> ? ParseRulesToObject<typeof rules>[K] : never\n      ) : (\n        K extends Names ? (RuleDefs[K] extends ParserRule<Context, K> ? RuleDefs[K] : never) : never\n      )\n    }\n    > {\n    this.rules = { ...this.rules, ...listToRuleDefMap(rules) };\n    return <any> <unknown> this;\n  }\n\n  /**\n   * Delete a grammar rule by its name.\n   */\n  public deleteRule<U extends Names>(ruleName: U):\n  ParserBuilder<Context, Exclude<Names, U>, {[K in Exclude<Names, U>]:\n    RuleDefs[K] extends ParserRule<Context, K> ? RuleDefs[K] : never }> {\n    delete this.rules[ruleName];\n    return <ParserBuilder<Context, Exclude<Names, U>, {[K in Exclude<Names, U>]:\n      RuleDefs[K] extends ParserRule<Context, K> ? RuleDefs[K] : never }>>\n      <unknown> this;\n  }\n\n  public getRule<U extends Names>(ruleName: U): RuleDefs[U] extends ParserRule<any, U, infer RT, infer PT> ?\n    ParserRule<Context, U, RT, PT> : never {\n    return <any> this.rules[ruleName];\n  }\n\n  /**\n   * Merge this grammar builder with another.\n   * It is best to merge the bigger grammar with the smaller one.\n   * If the two builders both have a grammar rule with the same name,\n   * no error will be thrown case they map to the same ruledef object.\n   * If they map to a different object, an error will be thrown.\n   * To fix this problem, the overridingRules array should contain a rule with the same conflicting name,\n   * this rule implementation will be used.\n   */\n  public merge<\n    OtherNames extends string,\n    OtherRules extends ParseRuleMap<OtherNames>,\n    OW extends readonly ParserRule<Context>[],\n  >(\n    builder: ParserBuilder<Context, OtherNames, OtherRules>,\n    overridingRules: OW,\n  ):\n    ParserBuilder<\n      Context,\n      Names | OtherNames | ParseNamesFromList<OW>,\n      {[K in Names | OtherNames | ParseNamesFromList<OW>]:\n        K extends keyof ParseRulesToObject<OW> ? (\n          ParseRulesToObject<OW>[K] extends ParserRule<Context, K> ? ParseRulesToObject<OW>[K] : never\n        )\n          : (\n              K extends Names ? (RuleDefs[K] extends ParserRule<Context, K> ? RuleDefs[K] : never)\n                : K extends OtherNames ? (OtherRules[K] extends ParserRule<Context, K> ? OtherRules[K] : never) : never\n            ) }\n    > {\n    // Assume the other grammar is bigger than yours. So start from that one and add this one\n    const otherRules: Record<string, ParserRule<Context>> = { ...builder.rules };\n    const myRules: Record<string, ParserRule<Context>> = this.rules;\n\n    for (const rule of Object.values(myRules)) {\n      if (otherRules[rule.name] === undefined) {\n        otherRules[rule.name] = rule;\n      } else {\n        const existingRule = otherRules[rule.name];\n        // If same rule, no issue, move on. Else\n        if (existingRule !== rule) {\n          const override = overridingRules.find(x => x.name === rule.name);\n          // If override specified, take override, else, inform user that there is a conflict\n          if (override) {\n            otherRules[rule.name] = override;\n          } else {\n            throw new Error(`Rule with name \"${rule.name}\" already exists in the builder, specify an override to resolve conflict`);\n          }\n        }\n      }\n    }\n\n    this.rules = <any> <unknown> otherRules;\n    return <any> <unknown> this;\n  }\n\n  private defaultErrorHandler(input: string, errors: IRecognitionException[]): void {\n    const firstError = errors[0];\n    const messageBuilder: string[] = [ 'Parse error' ];\n    const lineIdx = firstError.token.startLine;\n    if (lineIdx !== undefined && !Number.isNaN(lineIdx)) {\n      const errorLine = input.split('\\n')[lineIdx - 1];\n      messageBuilder.push(` on line ${lineIdx}\n${errorLine}`);\n      const columnIdx = firstError.token.startColumn;\n      if (columnIdx !== undefined) {\n        messageBuilder.push(`\\n${'-'.repeat(columnIdx - 1)}^`);\n      }\n    }\n    messageBuilder.push(`\\n${firstError.message}`);\n    throw new Error(messageBuilder.join(''));\n  }\n\n  public build({\n    tokenVocabulary,\n    parserConfig = {},\n    lexerConfig = {},\n    queryPreProcessor = s => s,\n    errorHandler,\n  }: ParserBuildArgs): ParserFromRules<Context, Names, RuleDefs> {\n    const lexer = LexerBuilder.create().add(...tokenVocabulary).build({\n      positionTracking: 'full',\n      recoveryEnabled: false,\n      ensureOptimizations: true,\n      safeMode: false,\n      skipValidations: true,\n      ...lexerConfig,\n    });\n    // Get the chevrotain parser\n    const parser = this.consume({\n      tokenVocabulary: <TokenType[]> tokenVocabulary,\n      config: parserConfig,\n    });\n    // Start building a parser that does not pass input using a state, but instead gets it as a function argument.\n    const selfSufficientParser: Partial<ParserFromRules<Context, Names, RuleDefs>> = {};\n\n    // To do that, we need to create a wrapper for each parser rule.\n    // eslint-disable-next-line ts/no-unnecessary-type-assertion\n    for (const rule of <ParserRule<Context, Names>[]> Object.values(this.rules)) {\n      selfSufficientParser[rule.name] = <any> ((input: string, context: Context, ...args: unknown[]) => {\n        const processedInput = queryPreProcessor(input);\n        const lexResult = lexer.tokenize(processedInput);\n\n        // This also resets the parser\n        parser.input = lexResult.tokens;\n        parser.setContext(context);\n        const result = parser[rule.name](context, ...args);\n        if (parser.errors.length > 0) {\n          // Console.log(lexResult);\n          if (errorHandler) {\n            errorHandler(parser.errors);\n          } else {\n            this.defaultErrorHandler(processedInput, parser.errors);\n          }\n        }\n        return result;\n      });\n    }\n    return <ParserFromRules<Context, Names, RuleDefs>> selfSufficientParser;\n  }\n\n  private consume({ tokenVocabulary, config = {}}: {\n    tokenVocabulary: TokenVocabulary;\n    config?: IParserConfig;\n  }): EmbeddedActionsParser & ParseMethodsFromRules<Context, Names, RuleDefs> &\n    { setContext: (context: Context) => void } {\n    return <EmbeddedActionsParser & ParseMethodsFromRules<Context, Names, RuleDefs> &\n      { setContext: (context: Context) => void }><unknown> new DynamicParser(this.rules, tokenVocabulary, config);\n  }\n}\n"]}

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

@@ -1,16 +1,3 @@
 "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);
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ruleDefTypes.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ruleDefTypes.js","sourceRoot":"","sources":["../../../../lib/parser-builder/ruleDefTypes.ts"],"names":[],"mappings":"","sourcesContent":["import type {\n  AtLeastOneSepMethodOpts,\n  DSLMethodOpts,\n  DSLMethodOptsWithErr,\n  GrammarAction,\n  IOrAlt,\n  ManySepMethodOpts,\n  OrMethodOpts,\n  ConsumeMethodOpts,\n  IToken,\n  TokenType,\n} from '@traqula/chevrotain';\n\n/**\n * Get the return-type of a RuleDef\n */\nexport type RuleDefReturn<T extends ParserRule> = T extends ParserRule<any, string, infer Ret> ? Ret : never;\n\n/**\n * Type used to declare grammar rules.\n */\nexport type ParserRule<\n  /**\n   * Context object available in rule implementation.\n   */\n  Context = any,\n  /**\n   * Name of grammar rule, should be a strict subtype of string like 'myGrammarRule'.\n   */\n  NameType extends string = string,\n  /**\n   * Type that will be returned after a correct parse of this rule.\n   * This type will be the return type of calling SUBRULE with this grammar rule.\n   */\n  ReturnType = unknown,\n  /**\n   * Function arguments that can be given to convey the state of the current parse operation.\n   */\n  ParamType extends any[] = any[],\n> = {\n  name: NameType;\n  impl: (def: ImplArgs) => (context: Context, ...params: ParamType) => ReturnType;\n};\n\n/**\n * Type expected by grammar rules in the main `impl` function.\n */\nexport interface ImplArgs extends CstDef {\n  cache: WeakMap<ParserRule, unknown>;\n}\n\n/**\n * Type definition used by {@link CstDef.SUBRULE} and family.\n */\ntype SubRuleFunc = <T extends string, U = unknown, ARGS extends any[] = any>(\n  cstDef: ParserRule<any, T, U, ARGS>,\n  ...argument: ARGS\n) => U;\n/**\n * Type definition used by {@link CstDef.BACKTRACK}.\n */\ntype BacktrackFunc = <T extends string, U = unknown, ARGS extends any[] = any>(\n  cstDef: ParserRule<any, T, U, ARGS>,\n  ...argument: ARGS\n) => () => boolean;\n\n/**\n * Mainly a repetition of the functions exposed by the {@link EmbeddedActionsParser},\n * with some small adjustments that allow for the API changes made by traqula.\n * Specifically changes are made to the {@link CstDef.SUBRULE} (and family) interface,\n * and to the {@link CstDef.BACKTRACK} interface.\n */\nexport interface CstDef {\n  /**\n   *\n   * A Parsing DSL method use to consume a single Token.\n   * In EBNF terms this is equivalent to a Terminal.\n   *\n   * A Token will be consumed, IFF the next token in the token vector matches `tokType`.\n   * otherwise the parser may attempt to perform error recovery (if enabled).\n   *\n   * The index in the method name indicates the unique occurrence of a terminal consumption\n   * inside a the top level rule. What this means is that if a terminal appears\n   * more than once in a single rule, each appearance must have a **different** index.\n   *\n   * For example:\n   * ```\n   *   this.RULE(\"qualifiedName\", () => {\n   *   this.CONSUME1(Identifier);\n   *     this.MANY(() => {\n   *       this.CONSUME1(Dot);\n   *       // here we use CONSUME2 because the terminal\n   *       // 'Identifier' has already appeared previously in the\n   *       // the rule 'parseQualifiedName'\n   *       this.CONSUME2(Identifier);\n   *     });\n   *   })\n   * ```\n   *\n   * - See more details on the [unique suffixes requirement](http://chevrotain.io/docs/FAQ.html#NUMERICAL_SUFFIXES).\n   *\n   * @param tokType - The Type of the token to be consumed.\n   * @param options - optional properties to modify the behavior of CONSUME.\n   */\n  CONSUME: (tokType: TokenType, options?: ConsumeMethodOpts) => IToken;\n  CONSUME1: (tokType: TokenType, options?: ConsumeMethodOpts) => IToken;\n  CONSUME2: (tokType: TokenType, options?: ConsumeMethodOpts) => IToken;\n  CONSUME3: (tokType: TokenType, options?: ConsumeMethodOpts) => IToken;\n  CONSUME4: (tokType: TokenType, options?: ConsumeMethodOpts) => IToken;\n  CONSUME5: (tokType: TokenType, options?: ConsumeMethodOpts) => IToken;\n  CONSUME6: (tokType: TokenType, options?: ConsumeMethodOpts) => IToken;\n  CONSUME7: (tokType: TokenType, options?: ConsumeMethodOpts) => IToken;\n  CONSUME8: (tokType: TokenType, options?: ConsumeMethodOpts) => IToken;\n  CONSUME9: (tokType: TokenType, options?: ConsumeMethodOpts) => IToken;\n  /**\n   * Parsing DSL Method that Indicates an Optional production.\n   * in EBNF notation this is equivalent to: \"[...]\".\n   *\n   * Note that there are two syntax forms:\n   * - Passing the grammar action directly:\n   *   ```\n   *     this.OPTION(() => {\n   *       this.CONSUME(Digit)}\n   *     );\n   *   ```\n   *\n   * - using an \"options\" object:\n   *   ```\n   *     this.OPTION({\n   *       GATE:predicateFunc,\n   *       DEF: () => {\n   *         this.CONSUME(Digit)\n   *     }});\n   *   ```\n   *\n   * The optional 'GATE' property in \"options\" object form can be used to add constraints\n   * to invoking the grammar action.\n   *\n   * As in CONSUME the index in the method name indicates the occurrence\n   * of the optional production in it's top rule.\n   *\n   * @param  actionORMethodDef - The grammar action to optionally invoke once\n   *                             or an \"OPTIONS\" object describing the grammar action and optional properties.\n   *\n   * @returns The `GrammarAction` return value (OUT) if the optional syntax is encountered\n   *          or `undefined` if not.\n   */\n  OPTION: <OUT>(\n    actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT>,\n  ) => OUT | undefined;\n  OPTION1: <OUT>(\n    actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT>,\n  ) => OUT | undefined;\n  OPTION2: <OUT>(\n    actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT>,\n  ) => OUT | undefined;\n  OPTION3: <OUT>(\n    actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT>,\n  ) => OUT | undefined;\n  OPTION4: <OUT>(\n    actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT>,\n  ) => OUT | undefined;\n  OPTION5: <OUT>(\n    actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT>,\n  ) => OUT | undefined;\n  OPTION6: <OUT>(\n    actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT>,\n  ) => OUT | undefined;\n  OPTION7: <OUT>(\n    actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT>,\n  ) => OUT | undefined;\n  OPTION8: <OUT>(\n    actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT>,\n  ) => OUT | undefined;\n  OPTION9: <OUT>(\n    actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT>,\n  ) => OUT | undefined;\n  /**\n   * Parsing DSL method that indicates a choice between a set of alternatives must be made.\n   * This is equivalent to an EBNF alternation (A | B | C | D ...), except\n   * that the alternatives are ordered like in a PEG grammar.\n   * This means that the **first** matching alternative is always chosen.\n   *\n   * There are several forms for the inner alternatives array:\n   *\n   * - Passing alternatives array directly:\n   *   ```\n   *     this.OR([\n   *       { ALT:() => { this.CONSUME(One) }},\n   *       { ALT:() => { this.CONSUME(Two) }},\n   *       { ALT:() => { this.CONSUME(Three) }}\n   *     ])\n   *   ```\n   *\n   * - Passing alternative array directly with predicates (GATE):\n   *   ```\n   *     this.OR([\n   *       { GATE: predicateFunc1, ALT:() => { this.CONSUME(One) }},\n   *       { GATE: predicateFuncX, ALT:() => { this.CONSUME(Two) }},\n   *       { GATE: predicateFuncX, ALT:() => { this.CONSUME(Three) }}\n   *     ])\n   *   ```\n   *\n   * - These syntax forms can also be mixed:\n   *   ```\n   *     this.OR([\n   *       {\n   *         GATE: predicateFunc1,\n   *         ALT:() => { this.CONSUME(One) }\n   *       },\n   *       { ALT:() => { this.CONSUME(Two) }},\n   *       { ALT:() => { this.CONSUME(Three) }}\n   *     ])\n   *   ```\n   *\n   * - Additionally an \"options\" object may be used:\n   *   ```\n   *     this.OR({\n   *       DEF:[\n   *         { ALT:() => { this.CONSUME(One) }},\n   *         { ALT:() => { this.CONSUME(Two) }},\n   *         { ALT:() => { this.CONSUME(Three) }}\n   *       ],\n   *       // OPTIONAL property\n   *       ERR_MSG: \"A Number\"\n   *     })\n   *   ```\n   *\n   * The 'predicateFuncX' in the long form can be used to add constraints to choosing the alternative.\n   *\n   * As in CONSUME the index in the method name indicates the occurrence\n   * of the alternation production in it's top rule.\n   *\n   * @param altsOrOpts - A set of alternatives or an \"OPTIONS\" object describing the alternatives\n   * and optional properties.\n   *\n   * @returns The result of invoking the chosen alternative.\n   */\n  OR: <T>(altsOrOpts: IOrAlt<T>[] | OrMethodOpts<T>) => T;\n  OR1: <T>(altsOrOpts: IOrAlt<T>[] | OrMethodOpts<T>) => T;\n  OR2: <T>(altsOrOpts: IOrAlt<T>[] | OrMethodOpts<T>) => T;\n  OR3: <T>(altsOrOpts: IOrAlt<T>[] | OrMethodOpts<T>) => T;\n  OR4: <T>(altsOrOpts: IOrAlt<T>[] | OrMethodOpts<T>) => T;\n  OR5: <T>(altsOrOpts: IOrAlt<T>[] | OrMethodOpts<T>) => T;\n  OR6: <T>(altsOrOpts: IOrAlt<T>[] | OrMethodOpts<T>) => T;\n  OR7: <T>(altsOrOpts: IOrAlt<T>[] | OrMethodOpts<T>) => T;\n  OR8: <T>(altsOrOpts: IOrAlt<T>[] | OrMethodOpts<T>) => T;\n  OR9: <T>(altsOrOpts: IOrAlt<T>[] | OrMethodOpts<T>) => T;\n  /**\n   * Parsing DSL method, that indicates a repetition of zero or more.\n   * This is equivalent to EBNF repetition \\{...\\}.\n   *\n   * Note that there are two syntax forms:\n   * - Passing the grammar action directly:\n   *   ```\n   *     this.MANY(() => {\n   *       this.CONSUME(Comma)\n   *       this.CONSUME(Digit)\n   *      })\n   *   ```\n   *\n   * - using an \"options\" object:\n   *   ```\n   *     this.MANY({\n   *       GATE: predicateFunc,\n   *       DEF: () => {\n   *              this.CONSUME(Comma)\n   *              this.CONSUME(Digit)\n   *            }\n   *     });\n   *   ```\n   *\n   * The optional 'GATE' property in \"options\" object form can be used to add constraints\n   * to invoking the grammar action.\n   *\n   * As in CONSUME the index in the method name indicates the occurrence\n   * of the repetition production in it's top rule.\n   *\n   * @param actionORMethodDef - The grammar action to optionally invoke multiple times\n   *                             or an \"OPTIONS\" object describing the grammar action and optional properties.\n   *\n   */\n  MANY: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any>,\n  ) => void;\n  MANY1: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any>,\n  ) => void;\n  MANY2: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any>,\n  ) => void;\n  MANY3: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any>,\n  ) => void;\n  MANY4: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any>,\n  ) => void;\n  MANY5: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any>,\n  ) => void;\n  MANY6: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any>,\n  ) => void;\n  MANY7: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any>,\n  ) => void;\n  MANY8: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any>,\n  ) => void;\n  MANY9: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any>,\n  ) => void;\n  /**\n   * Parsing DSL method, that indicates a repetition of zero or more with a separator\n   * Token between the repetitions.\n   *\n   * Example:\n   *\n   * ```\n   *     this.MANY_SEP({\n   *         SEP:Comma,\n   *         DEF: () => {\n   *             this.CONSUME(Number};\n   *             // ...\n   *         })\n   * ```\n   *\n   * Note that because this DSL method always requires more than one argument the options object is always required\n   * and it is not possible to use a shorter form like in the MANY DSL method.\n   *\n   * Note that for the purposes of deciding on whether or not another iteration exists\n   * Only a single Token is examined (The separator). Therefore if the grammar being implemented is\n   * so \"crazy\" to require multiple tokens to identify an item separator please use the more basic DSL methods\n   * to implement it.\n   *\n   * As in CONSUME the index in the method name indicates the occurrence\n   * of the repetition production in it's top rule.\n   *\n   * @param options - An object defining the grammar of each iteration and the separator between iterations\n   *\n   */\n  MANY_SEP: (options: ManySepMethodOpts<any>) => void;\n  MANY_SEP1: (options: ManySepMethodOpts<any>) => void;\n  MANY_SEP2: (options: ManySepMethodOpts<any>) => void;\n  MANY_SEP3: (options: ManySepMethodOpts<any>) => void;\n  MANY_SEP4: (options: ManySepMethodOpts<any>) => void;\n  MANY_SEP5: (options: ManySepMethodOpts<any>) => void;\n  MANY_SEP6: (options: ManySepMethodOpts<any>) => void;\n  MANY_SEP7: (options: ManySepMethodOpts<any>) => void;\n  MANY_SEP8: (options: ManySepMethodOpts<any>) => void;\n  MANY_SEP9: (options: ManySepMethodOpts<any>) => void;\n  /**\n   * Convenience method, same as MANY but the repetition is of one or more.\n   * failing to match at least one repetition will result in a parsing error and\n   * cause a parsing error.\n   *\n   * @see MANY\n   *\n   * @param actionORMethodDef  - The grammar action to optionally invoke multiple times\n   *                             or an \"OPTIONS\" object describing the grammar action and optional properties.\n   *\n   */\n  AT_LEAST_ONE: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any>,\n  ) => void;\n  AT_LEAST_ONE1: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any>,\n  ) => void;\n  AT_LEAST_ONE2: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any>,\n  ) => void;\n  AT_LEAST_ONE3: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any>,\n  ) => void;\n  AT_LEAST_ONE4: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any>,\n  ) => void;\n  AT_LEAST_ONE5: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any>,\n  ) => void;\n  AT_LEAST_ONE6: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any>,\n  ) => void;\n  AT_LEAST_ONE7: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any>,\n  ) => void;\n  AT_LEAST_ONE8: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any>,\n  ) => void;\n  AT_LEAST_ONE9: (\n    actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any>,\n  ) => void;\n  /**\n   * Convenience method, same as MANY_SEP but the repetition is of one or more.\n   * failing to match at least one repetition will result in a parsing error and\n   * cause the parser to attempt error recovery.\n   *\n   * Note that an additional optional property ERR_MSG can be used to provide custom error messages.\n   *\n   * @see MANY_SEP\n   *\n   * @param options - An object defining the grammar of each iteration and the separator between iterations\n   *\n   * @return ISeparatedIterationResult<OUT>\n   */\n  AT_LEAST_ONE_SEP: (options: AtLeastOneSepMethodOpts<any>) => void;\n  AT_LEAST_ONE_SEP1: (options: AtLeastOneSepMethodOpts<any>) => void;\n  AT_LEAST_ONE_SEP2: (options: AtLeastOneSepMethodOpts<any>) => void;\n  AT_LEAST_ONE_SEP3: (options: AtLeastOneSepMethodOpts<any>) => void;\n  AT_LEAST_ONE_SEP4: (options: AtLeastOneSepMethodOpts<any>) => void;\n  AT_LEAST_ONE_SEP5: (options: AtLeastOneSepMethodOpts<any>) => void;\n  AT_LEAST_ONE_SEP6: (options: AtLeastOneSepMethodOpts<any>) => void;\n  AT_LEAST_ONE_SEP7: (options: AtLeastOneSepMethodOpts<any>) => void;\n  AT_LEAST_ONE_SEP8: (options: AtLeastOneSepMethodOpts<any>) => void;\n  AT_LEAST_ONE_SEP9: (options: AtLeastOneSepMethodOpts<any>) => void;\n  /**\n   * Perform an action that is only executed during actual parsing and not during parser initialization.\n   * (When a lot of this secretly return null)\n   * @param impl\n   * @constructor\n   */\n  ACTION: <T>(impl: () => T) => T;\n  BACKTRACK: BacktrackFunc;\n  SUBRULE: SubRuleFunc;\n  SUBRULE1: SubRuleFunc;\n  SUBRULE2: SubRuleFunc;\n  SUBRULE3: SubRuleFunc;\n  SUBRULE4: SubRuleFunc;\n  SUBRULE5: SubRuleFunc;\n  SUBRULE6: SubRuleFunc;\n  SUBRULE7: SubRuleFunc;\n  SUBRULE8: SubRuleFunc;\n  SUBRULE9: SubRuleFunc;\n}\n"]}