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

package/lib/{grammar-builder → parser-builder}/ruleDefTypes.d.ts

@@ -3,11 +3,11 @@ import type { ConsumeMethodOpts, IToken, TokenType } from 'chevrotain';
 /**
  * Get the return-type of a RuleDef
  */
-export type RuleDefReturn<T extends RuleDef> = T extends RuleDef<any, string, infer Ret> ? Ret : never;
+export type RuleDefReturn<T extends ParserRule> = T extends ParserRule<any, string, infer Ret> ? Ret : never;
 /**
  * Type used to declare grammar rules.
  */
-export type RuleDef<
+export type ParserRule<
 /**
  * Context object available in rule implementation.
  */
@@ -32,16 +32,16 @@ ParamType = any> = {
  * Type expected by grammar rules in the main `impl` function.
  */
 export interface ImplArgs extends CstDef {
-    cache: WeakMap<RuleDef, unknown>;
+    cache: WeakMap<ParserRule, unknown>;
 }
 /**
  * Type definition used by {@link CstDef.SUBRULE} and family.
  */
-type SubRuleFunc = <T extends string, U = unknown, ARGS = any>(cstDef: RuleDef<any, T, U, ARGS>, argument: ARGS) => U;
+type SubRuleFunc = <T extends string, U = unknown, ARGS = any>(cstDef: ParserRule<any, T, U, ARGS>, argument: ARGS) => U;
 /**
  * Type definition used by {@link CstDef.BACKTRACK}.
  */
-type BacktrackFunc = <T extends string, U = unknown, ARGS = any>(cstDef: RuleDef<any, T, U, ARGS>, argument: ARGS) => () => boolean;
+type BacktrackFunc = <T extends string, U = unknown, ARGS = any>(cstDef: ParserRule<any, T, U, ARGS>, argument: ARGS) => () => boolean;
 /**
  * Mainly a repetition of the functions exposed by the {@link EmbeddedActionsParser},
  * with some small adjustments that allow for the API changes made by traqula.

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

@@ -0,0 +1 @@
+{"version":3,"file":"ruleDefTypes.js","sourceRoot":"","sources":["ruleDefTypes.ts"],"names":[],"mappings":"","sourcesContent":["import type {\n  AtLeastOneSepMethodOpts,\n  DSLMethodOpts,\n  DSLMethodOptsWithErr,\n  GrammarAction,\n  IOrAlt,\n  ManySepMethodOpts,\n  OrMethodOpts,\n} from '@chevrotain/types';\nimport type { ConsumeMethodOpts, IToken, TokenType } from '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 = 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 = 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 = 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  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"]}

package/lib/utils.d.ts

@@ -0,0 +1,17 @@
+import type { ITokenConfig, TokenType } from '@chevrotain/types';
+/**
+ * Check whether the first two types overlap, if no, return the 3th argument, else the 4th.
+ */
+export type CheckOverlap<T, U, V, W = never> = T & U extends never ? V : W;
+export declare function unCapitalize<T extends string>(str: T): Uncapitalize<T>;
+export type NamedToken<Name extends string> = TokenType & {
+    name: Name;
+};
+export declare function createToken<Name extends string>(config: ITokenConfig & {
+    name: Name;
+}): NamedToken<Name>;
+export type Patch<T extends object, Patch extends {
+    [Key in keyof T]?: any;
+}> = {
+    [Key in keyof T]: Key extends keyof Patch ? Patch[Key] : T[Key];
+};

package/lib/utils.js

@@ -0,0 +1,8 @@
+import { createToken as chevcT } from 'chevrotain';
+export function unCapitalize(str) {
+    return (str.charAt(0).toLowerCase() + str.slice(1));
+}
+export function createToken(config) {
+    return chevcT(config);
+}
+//# sourceMappingURL=utils.js.map

package/lib/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,IAAI,MAAM,EAAE,MAAM,YAAY,CAAC;AAOnD,MAAM,UAAU,YAAY,CAAmB,GAAM;IACnD,OAAyB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AACxE,CAAC;AAID,MAAM,UAAU,WAAW,CAAsB,MAAqC;IACpF,OAAoC,MAAM,CAAC,MAAM,CAAC,CAAC;AACrD,CAAC","sourcesContent":["import type { ITokenConfig, TokenType } from '@chevrotain/types';\nimport { createToken as chevcT } from 'chevrotain';\n\n/**\n * Check whether the first two types overlap, if no, return the 3th argument, else the 4th.\n */\nexport type CheckOverlap<T, U, V, W = never> = T & U extends never ? V : W;\n\nexport function unCapitalize<T extends string>(str: T): Uncapitalize<T> {\n  return <Uncapitalize<T>> (str.charAt(0).toLowerCase() + str.slice(1));\n}\n\nexport type NamedToken<Name extends string> = TokenType & { name: Name };\n\nexport function createToken<Name extends string>(config: ITokenConfig & { name: Name }): NamedToken<Name> {\n  return <TokenType & { name: Name }> chevcT(config);\n}\n\nexport type Patch<T extends object, Patch extends {[Key in keyof T ]?: any }> =\n  {[Key in keyof T]: Key extends keyof Patch ? Patch[Key] : T[Key] };\n"]}

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@traqula/core",
-  "version": "0.0.1-alpha.148+1455821",
-  "description": "Core components of TRAQULA",
+  "type": "module",
+  "version": "0.0.1-alpha.176+9400dc5",
+  "description": "Core components of Traqula",
   "lsd:module": true,
   "license": "MIT",
   "repository": {
@@ -13,19 +14,18 @@
     "url": "https://github.com/comunica/traqula/issues"
   },
   "sideEffects": false,
-  "type": "module",
-  "main": "lib/index.js",
   "exports": {
     "import": "./lib/index.js",
     "require": "./lib/index.cjs"
   },
+  "main": "lib/index.js",
   "publishConfig": {
     "access": "public"
   },
   "files": [
+    "lib/**/*.cjs",
     "lib/**/*.d.ts",
     "lib/**/*.js",
-    "lib/**/*.cjs",
     "lib/**/*.js.map"
   ],
   "engines": {
@@ -43,5 +43,5 @@
   "devDependencies": {
     "@chevrotain/types": "^11.0.3"
   },
-  "gitHead": "14558218b5c59739a791015d2bfbb466c5da9e62"
+  "gitHead": "9400dc5f8bda1d8c2b3d1f4cf56b308995744ba0"
 }

package/lib/Wildcard.d.ts

@@ -1,9 +0,0 @@
-export declare class Wildcard {
-    value: "*";
-    termType: "Wildcard";
-    constructor();
-    equals(other: {
-        termType: unknown;
-    } | undefined | null): boolean;
-    toJSON(): object;
-}

package/lib/Wildcard.js

@@ -1,19 +0,0 @@
-export class Wildcard {
-    constructor() {
-        this.value = '*';
-        this.termType = 'Wildcard';
-        // eslint-disable-next-line no-constructor-return
-        return WILDCARD ?? this;
-    }
-    equals(other) {
-        return Boolean(other && (this.termType === other.termType));
-    }
-    toJSON() {
-        // eslint-disable-next-line unused-imports/no-unused-vars
-        const { value, ...rest } = this;
-        return rest;
-    }
-}
-let WILDCARD;
-WILDCARD = new Wildcard();
-//# sourceMappingURL=Wildcard.js.map

package/lib/Wildcard.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Wildcard.js","sourceRoot":"","sources":["Wildcard.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,QAAQ;IAGnB;QAFO,UAAK,GAAW,GAAG,CAAC;QACpB,aAAQ,GAAW,UAAU,CAAC;QAEnC,iDAAiD;QACjD,OAAO,QAAQ,IAAI,IAAI,CAAC;IAC1B,CAAC;IAEM,MAAM,CAAC,KAA+C;QAC3D,OAAO,OAAO,CAAC,KAAK,IAAI,CAAC,IAAI,CAAC,QAAQ,KAAK,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC;IAC9D,CAAC;IAEM,MAAM;QACX,yDAAyD;QACzD,MAAM,EAAE,KAAK,EAAE,GAAG,IAAI,EAAE,GAAG,IAAI,CAAC;QAChC,OAAO,IAAI,CAAC;IACd,CAAC;CACF;AAED,IAAI,QAA8B,CAAC;AACnC,QAAQ,GAAG,IAAI,QAAQ,EAAE,CAAC","sourcesContent":["export class Wildcard {\n  public value = <const> '*';\n  public termType = <const> 'Wildcard';\n  public constructor() {\n    // eslint-disable-next-line no-constructor-return\n    return WILDCARD ?? this;\n  }\n\n  public equals(other: { termType: unknown } | undefined | null): boolean {\n    return Boolean(other && (this.termType === other.termType));\n  }\n\n  public toJSON(): object {\n    // eslint-disable-next-line unused-imports/no-unused-vars\n    const { value, ...rest } = this;\n    return rest;\n  }\n}\n\nlet WILDCARD: Wildcard | undefined;\nWILDCARD = new Wildcard();\n"]}

package/lib/grammar-builder/builderTypes.d.ts

@@ -1,28 +0,0 @@
-import type { ParserMethod } from 'chevrotain';
-import type { RuleDef } from './ruleDefTypes';
-/**
- * Get union-type of names used in list of ruledefs.
- */
-export type RuleNamesFromList<T extends readonly RuleDef[]> = T[number]['name'];
-/**
- * Convert a list of ruledefs to a record that maps each rule name to its definition.
- */
-export type RuleDefMap<RuleNames extends string> = {
-    [Key in RuleNames]: RuleDef<any, Key>;
-};
-/**
- * Check whether the first two types overlap, if yes, return the 3th argument, else the 4th.
- */
-export type CheckOverlap<T, U, V, W = never> = T & U extends never ? V : W;
-/**
- * Convert a list of RuleDefs to a Record with the name of the RuleDef as the key, matching the RuleDefMap type.
- */
-export type RuleListToObject<T extends readonly RuleDef[], Names extends string = RuleNamesFromList<T>, Agg extends Record<string, RuleDef> = Record<never, never>> = T extends readonly [infer First, ...infer Rest] ? (First extends RuleDef ? (Rest extends readonly RuleDef[] ? (RuleListToObject<Rest, Names, {
-    [K in keyof Agg | First['name']]: K extends First['name'] ? First : Agg[K];
-}>) : never) : never) : RuleDefMap<Names> & Agg;
-export type ParserFromRules<Context, Names extends string, RuleDefs extends RuleDefMap<Names>> = {
-    [K in Names]: RuleDefs[K] extends RuleDef<Context, K, infer RET, infer ARGS> ? (input: string, context: Context, args: ARGS) => RET : never;
-};
-export type ParseMethodsFromRules<Context, Names extends string, RuleDefs extends RuleDefMap<Names>> = {
-    [K in Names]: RuleDefs[K] extends RuleDef<Context, K, infer RET, infer ARGS> ? ParserMethod<[Context, ARGS], RET> : never;
-};

package/lib/grammar-builder/builderTypes.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"builderTypes.js","sourceRoot":"","sources":["builderTypes.ts"],"names":[],"mappings":"","sourcesContent":["import type { ParserMethod } from 'chevrotain';\nimport type {RuleDef} from './ruleDefTypes';\n\n/**\n * Get union-type of names used in list of ruledefs.\n */\nexport type RuleNamesFromList<T extends readonly RuleDef[]> = T[number]['name'];\n\n/**\n * Convert a list of ruledefs to a record that maps each rule name to its definition.\n */\nexport type RuleDefMap<RuleNames extends string> = {[Key in RuleNames]: RuleDef<any, Key> };\n\n/**\n * Check whether the first two types overlap, if yes, return the 3th argument, else the 4th.\n */\nexport type CheckOverlap<T, U, V, W = never> = T & U extends never ? V : W;\n\n/**\n * Convert a list of RuleDefs to a Record with the name of the RuleDef as the key, matching the RuleDefMap type.\n */\nexport type RuleListToObject<\n  T extends readonly RuleDef[],\n  Names extends string = RuleNamesFromList<T>,\n  Agg extends Record<string, RuleDef> = Record<never, never>,\n> = T extends readonly [infer First, ...infer Rest] ? (\n  First extends RuleDef ? (\n    Rest extends readonly RuleDef[] ? (\n      RuleListToObject<Rest, Names, {[K in keyof Agg | First['name']]: K extends First['name'] ? First : Agg[K] }>\n    ) : never\n  ) : never\n) : RuleDefMap<Names> & Agg;\n\nexport type ParserFromRules<Context, Names extends string, RuleDefs extends RuleDefMap<Names>> = {\n  [K in Names]: RuleDefs[K] extends RuleDef<Context, K, infer RET, infer ARGS> ? (input: string, context: Context, args: ARGS) => RET : never\n};\n\nexport type ParseMethodsFromRules<Context, Names extends string, RuleDefs extends RuleDefMap<Names>> = {\n  [K in Names]: RuleDefs[K] extends RuleDef<Context, K, infer RET, infer ARGS> ? ParserMethod<[Context, ARGS], RET> : never\n};\n"]}

package/lib/grammar-builder/parserBuilder.d.ts

@@ -1,68 +0,0 @@
-import { ILexerConfig, IParserConfig } from '@chevrotain/types';
-import type { TokenType, TokenVocabulary } from 'chevrotain';
-import { EmbeddedActionsParser } from 'chevrotain';
-import type { CheckOverlap, ParseMethodsFromRules, ParserFromRules, RuleDefMap, RuleListToObject, RuleNamesFromList } from './builderTypes';
-import type { RuleDef } from './ruleDefTypes';
-/**
- * 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.
- */
-export declare class Builder<Context, Names extends string, RuleDefs extends RuleDefMap<Names>> {
-    /**
-     * 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<Rules extends readonly RuleDef[] = readonly RuleDef[], Context = Rules[0] extends RuleDef<infer context> ? context : never, Names extends string = RuleNamesFromList<Rules>, RuleDefs extends RuleDefMap<Names> = RuleListToObject<Rules>>(start: Rules | Builder<Context, Names, RuleDefs>): Builder<Context, Names, RuleDefs>;
-    private rules;
-    private constructor();
-    /**
-     * Change the implementation of an existing grammar rule.
-     */
-    patchRule<U extends Names, RET, ARGS>(patch: RuleDef<Context, U, RET, ARGS>): Builder<Context, Names, {
-        [Key in Names]: Key extends U ? RuleDef<Context, Key, RET, ARGS> : (RuleDefs[Key] extends RuleDef<Context, Key> ? RuleDefs[Key] : never);
-    }>;
-    /**
-     * Add a rule to the grammar. If the rule already exists, but the implementation differs, an error will be thrown.
-     */
-    addRuleRedundant<U extends string, RET, ARGS>(rule: RuleDef<Context, U, RET, ARGS>): Builder<Context, Names | U, {
-        [K in Names | U]: K extends U ? RuleDef<Context, K, RET, ARGS> : (K extends Names ? (RuleDefs[K] extends RuleDef<Context, K> ? RuleDefs[K] : never) : never);
-    }>;
-    /**
-     * Add a rule to the grammar. Will raise a typescript error if the rule already exists in the grammar.
-     */
-    addRule<U extends string, RET, ARGS>(rule: CheckOverlap<U, Names, RuleDef<Context, U, RET, ARGS>>): Builder<Context, Names | U, {
-        [K in Names | U]: K extends U ? RuleDef<Context, K, RET, ARGS> : (K extends Names ? (RuleDefs[K] extends RuleDef<Context, K> ? RuleDefs[K] : never) : never);
-    }>;
-    addMany<U extends readonly RuleDef<Context>[]>(...rules: CheckOverlap<RuleNamesFromList<U>, Names, U>): Builder<Context, Names | RuleNamesFromList<U>, {
-        [K in Names | RuleNamesFromList<U>]: K extends keyof RuleListToObject<typeof rules> ? (RuleListToObject<typeof rules>[K] extends RuleDef<Context, K> ? RuleListToObject<typeof rules>[K] : never) : (K extends Names ? (RuleDefs[K] extends RuleDef<Context, K> ? RuleDefs[K] : never) : never);
-    }>;
-    /**
-     * Delete a grammar rule by its name.
-     */
-    deleteRule<U extends Names>(ruleName: U): Builder<Context, Exclude<Names, U>, {
-        [K in Exclude<Names, U>]: RuleDefs[K] extends RuleDef<Context, K> ? RuleDefs[K] : never;
-    }>;
-    /**
-     * 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<OtherNames extends string, OtherRules extends RuleDefMap<OtherNames>, OW extends readonly RuleDef<Context>[]>(builder: Builder<Context, OtherNames, OtherRules>, overridingRules: OW): Builder<Context, Names | OtherNames | RuleNamesFromList<OW>, {
-        [K in Names | OtherNames | RuleNamesFromList<OW>]: K extends keyof RuleListToObject<OW> ? (RuleListToObject<OW>[K] extends RuleDef<Context, K> ? RuleListToObject<OW>[K] : never) : (K extends Names ? (RuleDefs[K] extends RuleDef<Context, K> ? RuleDefs[K] : never) : K extends OtherNames ? (OtherRules[K] extends RuleDef<Context, K> ? OtherRules[K] : never) : never);
-    }>;
-    consumeToParser({ tokenVocabulary, parserConfig, lexerConfig }: {
-        tokenVocabulary: TokenType[];
-        parserConfig?: IParserConfig;
-        lexerConfig?: ILexerConfig;
-    }): ParserFromRules<Context, Names, RuleDefs>;
-    consume({ tokenVocabulary, config }: {
-        tokenVocabulary: TokenVocabulary;
-        config?: IParserConfig;
-    }): EmbeddedActionsParser & ParseMethodsFromRules<Context, Names, RuleDefs> & {
-        setContext: (context: Context) => void;
-    };
-}

package/lib/grammar-builder/parserBuilder.js

@@ -1,283 +0,0 @@
-import { EmbeddedActionsParser, Lexer } from 'chevrotain';
-/**
- * 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;
-}
-/**
- * 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.
-export class 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 });
-        }
-        return new Builder(listToRuleDefMap(start));
-    }
-    constructor(startRules) {
-        this.rules = startRules;
-    }
-    /**
-     * 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;
-    }
-    /**
-     * 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) {
-        // 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;
-    }
-    consumeToParser({ tokenVocabulary, parserConfig = {}, lexerConfig = {} }) {
-        const lexer = new Lexer(tokenVocabulary, {
-            positionTracking: 'onlyStart',
-            recoveryEnabled: false,
-            // SafeMode: true,
-            // SkipValidations: true,
-            ensureOptimizations: true,
-            ...lexerConfig,
-        });
-        // get the chevrotain parser
-        const parser = this.consume({ 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.
-        for (const rule of Object.values(this.rules)) {
-            selfSufficientParser[rule.name] = ((input, context, arg) => {
-                // Transform input in accordance to 19.2
-                input = input.replaceAll(/\\u([0-9a-fA-F]{4})|\\U([0-9a-fA-F]{8})/gu, (_, unicode4, unicode8) => {
-                    if (unicode4) {
-                        const charCode = Number.parseInt(unicode4, 16);
-                        return String.fromCodePoint(charCode);
-                    }
-                    const charCode = Number.parseInt(unicode8, 16);
-                    if (charCode < 0xFFFF) {
-                        return String.fromCodePoint(charCode);
-                    }
-                    const substractedCharCode = charCode - 0x10000;
-                    return String.fromCodePoint(0xD800 + (substractedCharCode >> 10), 0xDC00 + (substractedCharCode & 0x3FF));
-                });
-                // Test for invalid unicode surrogate pairs
-                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);
-                // This also resets the parser
-                parser.input = lexResult.tokens;
-                parser.setContext(context);
-                const result = parser[rule.name](context, arg);
-                if (parser.errors.length > 0) {
-                    // Console.log(lexResult.tokens);
-                    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')}`);
-                }
-                return result;
-            });
-        }
-        return selfSufficientParser;
-    }
-    consume({ tokenVocabulary, config = {} }) {
-        const rules = this.rules;
-        class MyParser extends EmbeddedActionsParser {
-            getSafeContext() {
-                if (this.context === undefined) {
-                    throw new Error('context was not correctly set');
-                }
-                return this.context;
-            }
-            setContext(context) {
-                this.context = context;
-            }
-            constructor() {
-                super(tokenVocabulary, {
-                    // RecoveryEnabled: true,
-                    maxLookahead: 2,
-                    // SkipValidations: true,
-                    ...config,
-                });
-                this.context = undefined;
-                const selfRef = this.getSelfRef();
-                const implArgs = {
-                    ...selfRef,
-                    cache: new WeakMap(),
-                };
-                for (const rule of Object.values(rules)) {
-                    this[rule.name] = this.RULE(rule.name, rule.impl(implArgs));
-                }
-                this.performSelfAnalysis();
-            }
-            getSelfRef() {
-                const subRuleImpl = (chevrotainSubrule) => {
-                    return ((cstDef, arg) => {
-                        return chevrotainSubrule(this[cstDef.name], { ARGS: [this.context, arg] });
-                    });
-                };
-                return {
-                    CONSUME: (tokenType, option) => this.CONSUME(tokenType, option),
-                    CONSUME1: (tokenType, option) => this.CONSUME1(tokenType, option),
-                    CONSUME2: (tokenType, option) => this.CONSUME2(tokenType, option),
-                    CONSUME3: (tokenType, option) => this.CONSUME3(tokenType, option),
-                    CONSUME4: (tokenType, option) => this.CONSUME4(tokenType, option),
-                    CONSUME5: (tokenType, option) => this.CONSUME5(tokenType, option),
-                    CONSUME6: (tokenType, option) => this.CONSUME6(tokenType, option),
-                    CONSUME7: (tokenType, option) => this.CONSUME7(tokenType, option),
-                    CONSUME8: (tokenType, option) => this.CONSUME8(tokenType, option),
-                    CONSUME9: (tokenType, option) => this.CONSUME9(tokenType, option),
-                    OPTION: actionORMethodDef => this.OPTION(actionORMethodDef),
-                    OPTION1: actionORMethodDef => this.OPTION1(actionORMethodDef),
-                    OPTION2: actionORMethodDef => this.OPTION2(actionORMethodDef),
-                    OPTION3: actionORMethodDef => this.OPTION3(actionORMethodDef),
-                    OPTION4: actionORMethodDef => this.OPTION4(actionORMethodDef),
-                    OPTION5: actionORMethodDef => this.OPTION5(actionORMethodDef),
-                    OPTION6: actionORMethodDef => this.OPTION6(actionORMethodDef),
-                    OPTION7: actionORMethodDef => this.OPTION7(actionORMethodDef),
-                    OPTION8: actionORMethodDef => this.OPTION8(actionORMethodDef),
-                    OPTION9: actionORMethodDef => this.OPTION9(actionORMethodDef),
-                    OR: altsOrOpts => this.OR(altsOrOpts),
-                    OR1: altsOrOpts => this.OR1(altsOrOpts),
-                    OR2: altsOrOpts => this.OR2(altsOrOpts),
-                    OR3: altsOrOpts => this.OR3(altsOrOpts),
-                    OR4: altsOrOpts => this.OR4(altsOrOpts),
-                    OR5: altsOrOpts => this.OR5(altsOrOpts),
-                    OR6: altsOrOpts => this.OR6(altsOrOpts),
-                    OR7: altsOrOpts => this.OR7(altsOrOpts),
-                    OR8: altsOrOpts => this.OR8(altsOrOpts),
-                    OR9: altsOrOpts => this.OR9(altsOrOpts),
-                    MANY: actionORMethodDef => this.MANY(actionORMethodDef),
-                    MANY1: actionORMethodDef => this.MANY1(actionORMethodDef),
-                    MANY2: actionORMethodDef => this.MANY2(actionORMethodDef),
-                    MANY3: actionORMethodDef => this.MANY3(actionORMethodDef),
-                    MANY4: actionORMethodDef => this.MANY4(actionORMethodDef),
-                    MANY5: actionORMethodDef => this.MANY5(actionORMethodDef),
-                    MANY6: actionORMethodDef => this.MANY6(actionORMethodDef),
-                    MANY7: actionORMethodDef => this.MANY7(actionORMethodDef),
-                    MANY8: actionORMethodDef => this.MANY8(actionORMethodDef),
-                    MANY9: actionORMethodDef => this.MANY9(actionORMethodDef),
-                    MANY_SEP: options => this.MANY_SEP(options),
-                    MANY_SEP1: options => this.MANY_SEP1(options),
-                    MANY_SEP2: options => this.MANY_SEP2(options),
-                    MANY_SEP3: options => this.MANY_SEP3(options),
-                    MANY_SEP4: options => this.MANY_SEP4(options),
-                    MANY_SEP5: options => this.MANY_SEP5(options),
-                    MANY_SEP6: options => this.MANY_SEP6(options),
-                    MANY_SEP7: options => this.MANY_SEP7(options),
-                    MANY_SEP8: options => this.MANY_SEP8(options),
-                    MANY_SEP9: options => this.MANY_SEP9(options),
-                    AT_LEAST_ONE: actionORMethodDef => this.AT_LEAST_ONE(actionORMethodDef),
-                    AT_LEAST_ONE1: actionORMethodDef => this.AT_LEAST_ONE1(actionORMethodDef),
-                    AT_LEAST_ONE2: actionORMethodDef => this.AT_LEAST_ONE2(actionORMethodDef),
-                    AT_LEAST_ONE3: actionORMethodDef => this.AT_LEAST_ONE3(actionORMethodDef),
-                    AT_LEAST_ONE4: actionORMethodDef => this.AT_LEAST_ONE4(actionORMethodDef),
-                    AT_LEAST_ONE5: actionORMethodDef => this.AT_LEAST_ONE5(actionORMethodDef),
-                    AT_LEAST_ONE6: actionORMethodDef => this.AT_LEAST_ONE6(actionORMethodDef),
-                    AT_LEAST_ONE7: actionORMethodDef => this.AT_LEAST_ONE7(actionORMethodDef),
-                    AT_LEAST_ONE8: actionORMethodDef => this.AT_LEAST_ONE8(actionORMethodDef),
-                    AT_LEAST_ONE9: actionORMethodDef => this.AT_LEAST_ONE9(actionORMethodDef),
-                    AT_LEAST_ONE_SEP: options => this.AT_LEAST_ONE_SEP(options),
-                    AT_LEAST_ONE_SEP1: options => this.AT_LEAST_ONE_SEP1(options),
-                    AT_LEAST_ONE_SEP2: options => this.AT_LEAST_ONE_SEP2(options),
-                    AT_LEAST_ONE_SEP3: options => this.AT_LEAST_ONE_SEP3(options),
-                    AT_LEAST_ONE_SEP4: options => this.AT_LEAST_ONE_SEP4(options),
-                    AT_LEAST_ONE_SEP5: options => this.AT_LEAST_ONE_SEP5(options),
-                    AT_LEAST_ONE_SEP6: options => this.AT_LEAST_ONE_SEP6(options),
-                    AT_LEAST_ONE_SEP7: options => this.AT_LEAST_ONE_SEP7(options),
-                    AT_LEAST_ONE_SEP8: options => this.AT_LEAST_ONE_SEP8(options),
-                    AT_LEAST_ONE_SEP9: options => this.AT_LEAST_ONE_SEP9(options),
-                    ACTION: func => this.ACTION(func),
-                    BACKTRACK: (cstDef, ...args) => {
-                        try {
-                            return this.BACKTRACK(this[cstDef.name], { ARGS: args });
-                        }
-                        catch (error) {
-                            throw error;
-                        }
-                    },
-                    SUBRULE: subRuleImpl((rule, args) => this.SUBRULE(rule, args)),
-                    SUBRULE1: subRuleImpl((rule, args) => this.SUBRULE1(rule, args)),
-                    SUBRULE2: subRuleImpl((rule, args) => this.SUBRULE2(rule, args)),
-                    SUBRULE3: subRuleImpl((rule, args) => this.SUBRULE3(rule, args)),
-                    SUBRULE4: subRuleImpl((rule, args) => this.SUBRULE4(rule, args)),
-                    SUBRULE5: subRuleImpl((rule, args) => this.SUBRULE5(rule, args)),
-                    SUBRULE6: subRuleImpl((rule, args) => this.SUBRULE6(rule, args)),
-                    SUBRULE7: subRuleImpl((rule, args) => this.SUBRULE7(rule, args)),
-                    SUBRULE8: subRuleImpl((rule, args) => this.SUBRULE8(rule, args)),
-                    SUBRULE9: subRuleImpl((rule, args) => this.SUBRULE9(rule, args)),
-                };
-            }
-        }
-        return new MyParser();
-    }
-}
-//# sourceMappingURL=parserBuilder.js.map