@traqula/core 0.0.1-alpha.176 → 0.0.1

package/lib/indirection-builder/IndirBuilder.d.ts

@@ -0,0 +1,43 @@
+import type { ParseNamesFromList } from '../parser-builder/builderTypes';
+import type { CheckOverlap } from '../utils';
+import type { IndirDef, IndirectionMap, IndirectObjFromIndirDefs, ParseIndirsToObject } from './helpers';
+export declare class IndirBuilder<Context, Names extends string, RuleDefs extends IndirectionMap<Names>> {
+    static create<Context, Names extends string, RuleDefs extends IndirectionMap<Names>>(args: IndirBuilder<Context, Names, RuleDefs>): IndirBuilder<Context, Names, RuleDefs>;
+    static create<Rules extends readonly IndirDef[] = readonly IndirDef[], Context = Rules[0] extends IndirDef<infer context> ? context : never, Names extends string = ParseNamesFromList<Rules>, RuleDefs extends IndirectionMap<Names> = ParseIndirsToObject<Rules>>(rules: Rules): IndirBuilder<Context, Names, RuleDefs>;
+    private rules;
+    private constructor();
+    widenContext<NewContext extends Context>(): IndirBuilder<NewContext, Names, RuleDefs>;
+    typePatch<Patch extends {
+        [Key in Names]?: any;
+    }>(): IndirBuilder<Context, Names, {
+        [Key in Names]: Key extends keyof Patch ? (IndirDef<Context, Key, Patch[Key][0], Patch[Key][1]>) : (RuleDefs[Key] extends IndirDef<Context, Key> ? RuleDefs[Key] : never);
+    }>;
+    /**
+     * Change the implementation of an existing indirection.
+     */
+    patchRule<U extends Names, RET, ARGS extends any[]>(patch: IndirDef<Context, U, RET, ARGS>): IndirBuilder<Context, Names, {
+        [Key in Names]: Key extends U ? IndirDef<Context, Key, RET, ARGS> : (RuleDefs[Key] extends IndirDef<Context, Key> ? RuleDefs[Key] : never);
+    }>;
+    /**
+     * Add an indirection function. If the rule already exists, but the implementation differs, an error will be thrown.
+     */
+    addRuleRedundant<U extends string, RET, ARGS extends any[]>(rule: IndirDef<Context, U, RET, ARGS>): IndirBuilder<Context, Names | U, {
+        [K in Names | U]: K extends U ? IndirDef<Context, K, RET, ARGS> : (K extends Names ? (RuleDefs[K] extends IndirDef<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 extends any[]>(rule: CheckOverlap<U, Names, IndirDef<Context, U, RET, ARGS>>): IndirBuilder<Context, Names | U, {
+        [K in Names | U]: K extends U ? IndirDef<Context, K, RET, ARGS> : (K extends Names ? (RuleDefs[K] extends IndirDef<Context, K> ? RuleDefs[K] : never) : never);
+    }>;
+    addMany<U extends readonly IndirDef<Context>[]>(...rules: CheckOverlap<ParseNamesFromList<U>, Names, U>): IndirBuilder<Context, Names | ParseNamesFromList<U>, {
+        [K in Names | ParseNamesFromList<U>]: K extends keyof ParseIndirsToObject<typeof rules> ? (ParseIndirsToObject<typeof rules>[K] extends IndirDef<Context, K> ? ParseIndirsToObject<typeof rules>[K] : never) : (K extends Names ? (RuleDefs[K] extends IndirDef<Context, K> ? RuleDefs[K] : never) : never);
+    }>;
+    /**
+     * Delete a grammar rule by its name.
+     */
+    deleteRule<U extends Names>(ruleName: U): IndirBuilder<Context, Exclude<Names, U>, {
+        [K in Exclude<Names, U>]: RuleDefs[K] extends IndirDef<Context, K> ? RuleDefs[K] : never;
+    }>;
+    build(): IndirectObjFromIndirDefs<Context, Names, RuleDefs>;
+}

package/lib/indirection-builder/IndirBuilder.js

@@ -0,0 +1,60 @@
+import { DynamicIndirect } from './dynamicIndirected';
+import { listToIndirectionMap } from './helpers';
+export class IndirBuilder {
+    static create(start) {
+        if (start instanceof IndirBuilder) {
+            return new IndirBuilder({ ...start.rules });
+        }
+        return new IndirBuilder(listToIndirectionMap(start));
+    }
+    constructor(startRules) {
+        this.rules = startRules;
+    }
+    widenContext() {
+        return this;
+    }
+    typePatch() {
+        return this;
+    }
+    /**
+     * Change the implementation of an existing indirection.
+     */
+    patchRule(patch) {
+        const self = this;
+        self.rules[patch.name] = patch;
+        return self;
+    }
+    /**
+     * Add an indirection function. 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(`Function ${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, ...listToIndirectionMap(rules) };
+        return this;
+    }
+    /**
+     * Delete a grammar rule by its name.
+     */
+    deleteRule(ruleName) {
+        delete this.rules[ruleName];
+        return this;
+    }
+    build() {
+        return new DynamicIndirect(this.rules);
+    }
+}
+//# sourceMappingURL=IndirBuilder.js.map

package/lib/indirection-builder/IndirBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IndirBuilder.js","sourceRoot":"","sources":["IndirBuilder.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAEtD,OAAO,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AAEjD,MAAM,OAAO,YAAY;IAUhB,MAAM,CAAC,MAAM,CAMlB,KAAqD;QAErD,IAAI,KAAK,YAAY,YAAY,EAAE,CAAC;YAClC,OAAO,IAAI,YAAY,CAAC,EAAE,GAAG,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC;QAC9C,CAAC;QACD,OAA0D,IAAI,YAAY,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAC,CAAC;IAC1G,CAAC;IAID,YAAoB,UAAoB;QACtC,IAAI,CAAC,KAAK,GAAG,UAAU,CAAC;IAC1B,CAAC;IAEM,YAAY;QACjB,OAA6D,IAAI,CAAC;IACpE,CAAC;IAEM,SAAS;QAId,OAEyF,IAAI,CAAC;IAChG,CAAC;IAED;;OAEG;IACI,SAAS,CAA2C,KAAsC;QAK/F,MAAM,IAAI,GAEE,IAAI,CAAC;QACjB,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,GAAS,KAAK,CAAC;QACrC,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACI,gBAAgB,CAA4C,IAAqC;QAKtG,MAAM,IAAI,GAGE,IAAI,CAAC;QACjB,MAAM,KAAK,GAAuC,IAAI,CAAC,KAAK,CAAC;QAC7D,IAAI,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,SAAS,IAAI,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,IAAI,EAAE,CAAC;YAChE,MAAM,IAAI,KAAK,CAAC,YAAY,IAAI,CAAC,IAAI,gCAAgC,CAAC,CAAC;QACzE,CAAC;QACD,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;QACxB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACI,OAAO,CACZ,IAA6D;QAI7D,OAAO,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;IACrC,CAAC;IAEM,OAAO,CACZ,GAAG,KAAoD;QAYvD,IAAI,CAAC,KAAK,GAAG,EAAE,GAAG,IAAI,CAAC,KAAK,EAAE,GAAG,oBAAoB,CAAC,KAAK,CAAC,EAAE,CAAC;QAC/D,OAAuB,IAAI,CAAC;IAC9B,CAAC;IAED;;OAEG;IACI,UAAU,CAAkB,QAAW;QAG5C,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;QAC5B,OAEY,IAAI,CAAC;IACnB,CAAC;IAEM,KAAK;QACV,OAA4D,IAAI,eAAe,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC9F,CAAC;CACF","sourcesContent":["import type { ParseNamesFromList } from '../parser-builder/builderTypes';\nimport type { CheckOverlap } from '../utils';\nimport { DynamicIndirect } from './dynamicIndirected';\nimport type { IndirDef, IndirectionMap, IndirectObjFromIndirDefs, ParseIndirsToObject } from './helpers';\nimport { listToIndirectionMap } from './helpers';\n\nexport class IndirBuilder<Context, Names extends string, RuleDefs extends IndirectionMap<Names>> {\n  public static create<Context, Names extends string, RuleDefs extends IndirectionMap<Names>>(\n    args: IndirBuilder<Context, Names, RuleDefs>\n  ): IndirBuilder<Context, Names, RuleDefs>;\n  public static create<\n    Rules extends readonly IndirDef[] = readonly IndirDef[],\n    Context = Rules[0] extends IndirDef<infer context> ? context : never,\n    Names extends string = ParseNamesFromList<Rules>,\n    RuleDefs extends IndirectionMap<Names> = ParseIndirsToObject<Rules>,\n  >(rules: Rules): IndirBuilder<Context, Names, RuleDefs>;\n  public static create<\n    Rules extends readonly IndirDef[] = readonly IndirDef[],\n    Context = Rules[0] extends IndirDef<infer context> ? context : never,\n    Names extends string = ParseNamesFromList<Rules>,\n    RuleDefs extends IndirectionMap<Names> = ParseIndirsToObject<Rules>,\n  >(\n    start: Rules | IndirBuilder<Context, Names, RuleDefs>,\n  ): IndirBuilder<Context, Names, RuleDefs> {\n    if (start instanceof IndirBuilder) {\n      return new IndirBuilder({ ...start.rules });\n    }\n    return <IndirBuilder<Context, Names, RuleDefs>> <unknown> new IndirBuilder(listToIndirectionMap(start));\n  }\n\n  private rules: RuleDefs;\n\n  private constructor(startRules: RuleDefs) {\n    this.rules = startRules;\n  }\n\n  public widenContext<NewContext extends Context>(): IndirBuilder<NewContext, Names, RuleDefs> {\n    return <IndirBuilder<NewContext, Names, RuleDefs>> <unknown> this;\n  }\n\n  public typePatch<Patch extends {[Key in Names]?: any }>():\n  IndirBuilder<Context, Names, {[Key in Names]: Key extends keyof Patch ? (\n    IndirDef<Context, Key, Patch[Key][0], Patch[Key][1]>\n  ) : (RuleDefs[Key] extends IndirDef<Context, Key> ? RuleDefs[Key] : never) }> {\n    return <IndirBuilder<Context, Names, {[Key in Names]: Key extends keyof Patch ? (\n      RuleDefs[Key] extends IndirDef<Context, Key, any, infer Par> ? IndirDef<Context, Key, Patch[Key], Par> : never\n    ) : (RuleDefs[Key] extends IndirDef<Context, Key> ? RuleDefs[Key] : never) }>> <unknown> this;\n  }\n\n  /**\n   * Change the implementation of an existing indirection.\n   */\n  public patchRule<U extends Names, RET, ARGS extends any[]>(patch: IndirDef<Context, U, RET, ARGS>):\n  IndirBuilder<Context, Names, {[Key in Names]: Key extends U ?\n    IndirDef<Context, Key, RET, ARGS> :\n      (RuleDefs[Key] extends IndirDef<Context, Key> ? RuleDefs[Key] : never)\n  } > {\n    const self = <IndirBuilder<Context, Names, {[Key in Names]: Key extends U ?\n      IndirDef<Context, Key, RET, ARGS> : (RuleDefs[Key] extends IndirDef<Context, Key> ? RuleDefs[Key] : never) }>>\n      <unknown> this;\n    self.rules[patch.name] = <any> patch;\n    return self;\n  }\n\n  /**\n   * Add an indirection function. 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: IndirDef<Context, U, RET, ARGS>):\n  IndirBuilder<Context, Names | U, {[K in Names | U]: K extends U ?\n    IndirDef<Context, K, RET, ARGS> :\n      (K extends Names ? (RuleDefs[K] extends IndirDef<Context, K> ? RuleDefs[K] : never) : never)\n  }> {\n    const self = <IndirBuilder<Context, Names | U, {[K in Names | U]: K extends U ?\n      IndirDef<Context, K, RET, ARGS> :\n        (K extends Names ? (RuleDefs[K] extends IndirDef<Context, K> ? RuleDefs[K] : never) : never) }>>\n      <unknown> this;\n    const rules = <Record<string, IndirDef<Context>>> self.rules;\n    if (rules[rule.name] !== undefined && rules[rule.name] !== rule) {\n      throw new Error(`Function ${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, IndirDef<Context, U, RET, ARGS>>,\n  ): IndirBuilder<Context, Names | U, {[K in Names | U]: K extends U ?\n    IndirDef<Context, K, RET, ARGS> :\n      (K extends Names ? (RuleDefs[K] extends IndirDef<Context, K> ? RuleDefs[K] : never) : never) }> {\n    return this.addRuleRedundant(rule);\n  }\n\n  public addMany<U extends readonly IndirDef<Context>[]>(\n    ...rules: CheckOverlap<ParseNamesFromList<U>, Names, U>\n  ): IndirBuilder<\n    Context,\n    Names | ParseNamesFromList<U>,\n    {[K in Names | ParseNamesFromList<U>]:\n      K extends keyof ParseIndirsToObject<typeof rules> ? (\n        ParseIndirsToObject<typeof rules>[K] extends IndirDef<Context, K> ? ParseIndirsToObject<typeof rules>[K] : never\n      ) : (\n        K extends Names ? (RuleDefs[K] extends IndirDef<Context, K> ? RuleDefs[K] : never) : never\n      )\n    }\n  > {\n    this.rules = { ...this.rules, ...listToIndirectionMap(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  IndirBuilder<Context, Exclude<Names, U>, {[K in Exclude<Names, U>]:\n    RuleDefs[K] extends IndirDef<Context, K> ? RuleDefs[K] : never }> {\n    delete this.rules[ruleName];\n    return <IndirBuilder<Context, Exclude<Names, U>, {[K in Exclude<Names, U>]:\n      RuleDefs[K] extends IndirDef<Context, K> ? RuleDefs[K] : never }>>\n      <unknown> this;\n  }\n\n  public build(): IndirectObjFromIndirDefs<Context, Names, RuleDefs> {\n    return <IndirectObjFromIndirDefs<Context, Names, RuleDefs>> new DynamicIndirect(this.rules);\n  }\n}\n"]}

package/lib/indirection-builder/dynamicIndirected.d.ts

@@ -0,0 +1,9 @@
+import type { IndirDefArg, IndirectionMap } from './helpers';
+export declare class DynamicIndirect<Context, Names extends string, RuleDefs extends IndirectionMap<Names>> {
+    protected rules: RuleDefs;
+    protected __context: Context | undefined;
+    constructor(rules: RuleDefs);
+    setContext(context: Context): void;
+    protected getSafeContext(): Context;
+    protected readonly subrule: IndirDefArg['SUBRULE'];
+}

package/lib/indirection-builder/dynamicIndirected.js

@@ -0,0 +1,28 @@
+export class DynamicIndirect {
+    constructor(rules) {
+        this.rules = rules;
+        this.__context = undefined;
+        this.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);
+        };
+        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;
+    }
+}
+//# sourceMappingURL=dynamicIndirected.js.map

package/lib/indirection-builder/dynamicIndirected.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dynamicIndirected.js","sourceRoot":"","sources":["dynamicIndirected.ts"],"names":[],"mappings":"AAEA,MAAM,OAAO,eAAe;IAG1B,YAA6B,KAAe;QAAf,UAAK,GAAL,KAAK,CAAU;QAFlC,cAAS,GAAwB,SAAS,CAAC;QAmBlC,YAAO,GAA2B,CAAC,MAAM,EAAE,GAAG,IAAI,EAAE,EAAE;YACvE,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAmB,MAAM,CAAC,IAAI,CAAC,CAAC;YACtD,IAAI,CAAC,GAAG,EAAE,CAAC;gBACT,MAAM,IAAI,KAAK,CAAC,QAAQ,MAAM,CAAC,IAAI,YAAY,CAAC,CAAC;YACnD,CAAC;YAED,OAAa,GAAG,CAAC,GAAG,CAAC;gBACnB,OAAO,EAAE,IAAI,CAAC,OAAO;aACtB,CAAC,CAAC,IAAI,CAAC,cAAc,EAAE,EAAE,GAAG,IAAI,CAAC,CAAC;QACrC,CAAC,CAAC;QAzBA,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,MAAM,CAAoC,KAAK,CAAC,EAAE,CAAC;YAC3E,IAAI,CAAsB,IAAI,CAAC,IAAI,CAAC,GAAS,CAAC,CAAC,OAAgB,EAAE,GAAG,IAAS,EAAO,EAAE;gBACpF,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;gBACzB,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,IAAI,CAAC,CAAC;YACrC,CAAC,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IAEM,UAAU,CAAC,OAAgB;QAChC,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC;IAC3B,CAAC;IAES,cAAc;QACtB,OAAiB,IAAI,CAAC,SAAS,CAAC;IAClC,CAAC;CAYF","sourcesContent":["import type { IndirDef, IndirDefArg, IndirectionMap } from './helpers';\n\nexport class DynamicIndirect<Context, Names extends string, RuleDefs extends IndirectionMap<Names>> {\n  protected __context: Context | undefined = undefined;\n\n  public constructor(protected rules: RuleDefs) {\n    for (const rule of Object.values(<Record<string, IndirDef<Context>>>rules)) {\n      this[<keyof (typeof this)>rule.name] = <any> ((context: Context, ...args: any): any => {\n        this.setContext(context);\n        return this.subrule(rule, ...args);\n      });\n    }\n  }\n\n  public setContext(context: Context): void {\n    this.__context = context;\n  }\n\n  protected getSafeContext(): Context {\n    return <Context> this.__context;\n  }\n\n  protected readonly subrule: IndirDefArg['SUBRULE'] = (cstDef, ...args) => {\n    const def = this.rules[<Names> <unknown> cstDef.name];\n    if (!def) {\n      throw new Error(`Rule ${cstDef.name} not found`);\n    }\n\n    return <any> def.fun({\n      SUBRULE: this.subrule,\n    })(this.getSafeContext(), ...args);\n  };\n}\n"]}

package/lib/indirection-builder/helpers.d.ts

@@ -0,0 +1,24 @@
+import type { ParseNamesFromList } from '../parser-builder/builderTypes';
+export type IndirDef<Context = any, NameType extends string = string, ReturnType = unknown, ParamType extends any[] = any[]> = {
+    name: NameType;
+    fun: (def: IndirDefArg) => (c: Context, ...params: ParamType) => ReturnType;
+};
+export type IndirDefArg = {
+    SUBRULE: <T, U extends any[]>(cstDef: IndirDef<any, any, T, U>, ...arg: U) => T;
+};
+export type IndirectionMap<RuleNames extends string> = {
+    [Key in RuleNames]: IndirDef<any, Key>;
+};
+/**
+ * Converts a list of ruledefs to a record mapping a name to the corresponding ruledef.
+ */
+export declare function listToIndirectionMap<T extends readonly IndirDef[]>(rules: T): ParseIndirsToObject<T>;
+/**
+ * Convert a list of IndirDefs to a Record with the name of the IndirDef as the key, matching the IndirectionMap type.
+ */
+export type ParseIndirsToObject<T extends readonly IndirDef[], Names extends string = ParseNamesFromList<T>, Agg extends Record<string, IndirDef> = Record<never, never>> = T extends readonly [infer First, ...infer Rest] ? (First extends IndirDef ? (Rest extends readonly IndirDef[] ? (ParseIndirsToObject<Rest, Names, {
+    [K in keyof Agg | First['name']]: K extends First['name'] ? First : Agg[K];
+}>) : never) : never) : IndirectionMap<Names> & Agg;
+export type IndirectObjFromIndirDefs<Context, Names extends string, RuleDefs extends IndirectionMap<Names>> = {
+    [K in Names]: RuleDefs[K] extends IndirDef<Context, K, infer RET, infer ARGS> ? (context: Context, ...args: ARGS) => RET : never;
+};

package/lib/indirection-builder/helpers.js

@@ -0,0 +1,11 @@
+/**
+ * Converts a list of ruledefs to a record mapping a name to the corresponding ruledef.
+ */
+export function listToIndirectionMap(rules) {
+    const newRules = {};
+    for (const rule of rules) {
+        newRules[rule.name] = rule;
+    }
+    return newRules;
+}
+//# sourceMappingURL=helpers.js.map

package/lib/indirection-builder/helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.js","sourceRoot":"","sources":["helpers.ts"],"names":[],"mappings":"AAkBA;;GAEG;AACH,MAAM,UAAU,oBAAoB,CAAgC,KAAQ;IAC1E,MAAM,QAAQ,GAA6B,EAAE,CAAC;IAC9C,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAC7B,CAAC;IACD,OAA+B,QAAQ,CAAC;AAC1C,CAAC","sourcesContent":["import type { ParseNamesFromList } from '../parser-builder/builderTypes';\n\nexport type IndirDef<\n  Context = any,\n  NameType extends string = string,\n  ReturnType = unknown,\n  ParamType extends any[] = any[],\n> = {\n  name: NameType;\n  fun: (def: IndirDefArg) => (c: Context, ...params: ParamType) => ReturnType;\n};\n\nexport type IndirDefArg = {\n  SUBRULE: <T, U extends any[]>(cstDef: IndirDef<any, any, T, U>, ...arg: U) => T;\n};\n\nexport type IndirectionMap<RuleNames extends string> = {[Key in RuleNames]: IndirDef<any, Key> };\n\n/**\n * Converts a list of ruledefs to a record mapping a name to the corresponding ruledef.\n */\nexport function listToIndirectionMap<T extends readonly IndirDef[]>(rules: T): ParseIndirsToObject<T> {\n  const newRules: Record<string, IndirDef> = {};\n  for (const rule of rules) {\n    newRules[rule.name] = rule;\n  }\n  return <ParseIndirsToObject<T>>newRules;\n}\n\n/**\n * Convert a list of IndirDefs to a Record with the name of the IndirDef as the key, matching the IndirectionMap type.\n */\nexport type ParseIndirsToObject<\n  T extends readonly IndirDef[],\n  Names extends string = ParseNamesFromList<T>,\n  Agg extends Record<string, IndirDef> = Record<never, never>,\n> = T extends readonly [infer First, ...infer Rest] ? (\n  First extends IndirDef ? (\n    Rest extends readonly IndirDef[] ? (\n      ParseIndirsToObject<Rest, Names, {[K in keyof Agg | First['name']]: K extends First['name'] ? First : Agg[K] }>\n    ) : never\n  ) : never\n) : IndirectionMap<Names> & Agg;\n\nexport type IndirectObjFromIndirDefs<Context, Names extends string, RuleDefs extends IndirectionMap<Names>> = {\n  [K in Names]: RuleDefs[K] extends IndirDef<Context, K, infer RET, infer ARGS> ?\n      (context: Context, ...args: ARGS) => RET : never\n};\n"]}

package/lib/lexer-builder/LexerBuilder.d.ts

@@ -10,6 +10,10 @@ export declare class LexerBuilder<NAMES extends string = string> {
     add<Name extends string>(...token: CheckOverlap<Name, NAMES, NamedToken<Name>[]>): LexerBuilder<Name | NAMES>;
     addBefore<Name extends string>(before: NamedToken<NAMES>, ...token: CheckOverlap<Name, NAMES, NamedToken<Name>[]>): LexerBuilder<NAMES | Name>;
     private moveBeforeOrAfter;
+    /**
+     * @param before token to move rest before
+     * @param tokens tokens to move before the first token
+     */
     moveBefore<Name extends string>(before: NamedToken<NAMES>, ...tokens: CheckOverlap<Name, NAMES, never, NamedToken<Name>[]>): LexerBuilder<NAMES>;
     moveAfter<Name extends string>(after: NamedToken<NAMES>, ...tokens: CheckOverlap<Name, NAMES, never, NamedToken<Name>[]>): LexerBuilder<NAMES>;
     addAfter<Name extends string>(after: NamedToken<NAMES>, ...token: CheckOverlap<Name, NAMES, never, NamedToken<Name>[]>): LexerBuilder<NAMES | Name>;

package/lib/lexer-builder/LexerBuilder.js

@@ -51,6 +51,10 @@ export class LexerBuilder {
         }
         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);
     }
@@ -79,9 +83,9 @@ export class LexerBuilder {
         return new Lexer(this.tokens, {
             positionTracking: 'onlyStart',
             recoveryEnabled: false,
+            ensureOptimizations: true,
             // SafeMode: true,
             // SkipValidations: true,
-            ensureOptimizations: true,
             ...lexerConfig,
         });
     }

package/lib/lexer-builder/LexerBuilder.js.map

@@ -1 +1 @@
-{"version":3,"file":"LexerBuilder.js","sourceRoot":"","sources":["LexerBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import type { ILexerConfig } from '@chevrotain/types';\nimport type { TokenType } from 'chevrotain';\nimport { Lexer } from 'chevrotain';\nimport type { CheckOverlap, NamedToken } from '../utils';\n\nexport class LexerBuilder<NAMES extends string = string> {\n  private readonly tokens: TokenType[];\n\n  public static create<U extends LexerBuilder<T>, T extends string = never>(starter?: U): U {\n    return <U> new LexerBuilder(starter);\n  }\n\n  private constructor(starter?: LexerBuilder<NAMES>) {\n    this.tokens = starter?.tokens ? [ ...starter.tokens ] : [];\n  }\n\n  public merge<OtherNames extends string, OW extends string>(\n    merge: LexerBuilder<OtherNames>,\n    overwrite: NamedToken<OW>[] = [],\n  ):\n    LexerBuilder<NAMES | OtherNames> {\n    const extraTokens = merge.tokens.filter((token) => {\n      const overwriteToken = overwrite.find(t => t.name === token.name);\n      if (overwriteToken) {\n        return false;\n      }\n      const match = this.tokens.find(t => t.name === token.name);\n      if (match) {\n        if (match !== token) {\n          throw new Error(`Token with name ${token.name} already exists. Implementation is different and no overwrite was provided.`);\n        }\n        return false;\n      }\n      return true;\n    });\n    this.tokens.push(...extraTokens);\n    return this;\n  }\n\n  public add<Name extends string>(...token: CheckOverlap<Name, NAMES, NamedToken<Name>[]>):\n  LexerBuilder<Name | NAMES> {\n    this.tokens.push(...token);\n    return this;\n  }\n\n  public addBefore<Name extends string>(\n    before: NamedToken<NAMES>,\n    ...token: CheckOverlap<Name, NAMES, NamedToken<Name>[]>\n  ): LexerBuilder<NAMES | Name> {\n    const index = this.tokens.indexOf(before);\n    if (index === -1) {\n      throw new Error('Token not found');\n    }\n    this.tokens.splice(index, 0, ...token);\n    return this;\n  }\n\n  private moveBeforeOrAfter<Name extends string>(\n    beforeOrAfter: 'before' | 'after',\n    before: NamedToken<NAMES>,\n    ...tokens: CheckOverlap<Name, NAMES, never, NamedToken<Name>[]>\n  ): LexerBuilder<NAMES> {\n    const beforeIndex = this.tokens.indexOf(before) + (beforeOrAfter === 'before' ? 0 : 1);\n    if (beforeIndex === -1) {\n      throw new Error('BeforeToken not found');\n    }\n    for (const token of tokens) {\n      const tokenIndex = this.tokens.indexOf(token);\n      if (tokenIndex === -1) {\n        throw new Error('Token not found');\n      }\n      this.tokens.splice(tokenIndex, 1);\n      this.tokens.splice(beforeIndex, 0, token);\n    }\n    return this;\n  }\n\n  public moveBefore<Name extends string>(\n    before: NamedToken<NAMES>,\n    ...tokens: CheckOverlap<Name, NAMES, never, NamedToken<Name>[]>\n  ): LexerBuilder<NAMES> {\n    return this.moveBeforeOrAfter('before', before, ...tokens);\n  }\n\n  public moveAfter<Name extends string>(\n    after: NamedToken<NAMES>,\n    ...tokens: CheckOverlap<Name, NAMES, never, NamedToken<Name>[]>\n  ): LexerBuilder<NAMES> {\n    return this.moveBeforeOrAfter('after', after, ...tokens);\n  }\n\n  public addAfter<Name extends string>(\n    after: NamedToken<NAMES>,\n    ...token: CheckOverlap<Name, NAMES, never, NamedToken<Name>[]>\n  ): LexerBuilder<NAMES | Name> {\n    const index = this.tokens.indexOf(after);\n    if (index === -1) {\n      throw new Error('Token not found');\n    }\n    this.tokens.splice(index + 1, 0, ...token);\n    return this;\n  }\n\n  public delete<Name extends NAMES>(...token: NamedToken<Name>[]): LexerBuilder<Exclude<NAMES, Name>> {\n    for (const t of token) {\n      const index = this.tokens.indexOf(t);\n      if (index === -1) {\n        throw new Error('Token not found');\n      }\n      this.tokens.splice(index, 1);\n    }\n    return this;\n  }\n\n  public build(lexerConfig?: ILexerConfig): Lexer {\n    return new Lexer(this.tokens, {\n      positionTracking: 'onlyStart',\n      recoveryEnabled: false,\n      // SafeMode: true,\n      // SkipValidations: true,\n      ensureOptimizations: true,\n      ...lexerConfig,\n    });\n  }\n\n  public get tokenVocabulary(): readonly TokenType[] {\n    return this.tokens;\n  }\n}\n"]}
+{"version":3,"file":"LexerBuilder.js","sourceRoot":"","sources":["LexerBuilder.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAGnC,MAAM,OAAO,YAAY;IAGhB,MAAM,CAAC,MAAM,CAAsD,OAAW;QACnF,OAAW,IAAI,YAAY,CAAC,OAAO,CAAC,CAAC;IACvC,CAAC;IAED,YAAoB,OAA6B;QAC/C,IAAI,CAAC,MAAM,GAAG,OAAO,EAAE,MAAM,CAAC,CAAC,CAAC,CAAE,GAAG,OAAO,CAAC,MAAM,CAAE,CAAC,CAAC,CAAC,EAAE,CAAC;IAC7D,CAAC;IAEM,KAAK,CACV,KAA+B,EAC/B,YAA8B,EAAE;QAGhC,MAAM,WAAW,GAAG,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE;YAChD,MAAM,cAAc,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,KAAK,CAAC,IAAI,CAAC,CAAC;YAClE,IAAI,cAAc,EAAE,CAAC;gBACnB,OAAO,KAAK,CAAC;YACf,CAAC;YACD,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,KAAK,CAAC,IAAI,CAAC,CAAC;YAC3D,IAAI,KAAK,EAAE,CAAC;gBACV,IAAI,KAAK,KAAK,KAAK,EAAE,CAAC;oBACpB,MAAM,IAAI,KAAK,CAAC,mBAAmB,KAAK,CAAC,IAAI,6EAA6E,CAAC,CAAC;gBAC9H,CAAC;gBACD,OAAO,KAAK,CAAC;YACf,CAAC;YACD,OAAO,IAAI,CAAC;QACd,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,WAAW,CAAC,CAAC;QACjC,OAAO,IAAI,CAAC;IACd,CAAC;IAEM,GAAG,CAAsB,GAAG,KAAoD;QAErF,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,CAAC;QAC3B,OAAO,IAAI,CAAC;IACd,CAAC;IAEM,SAAS,CACd,MAAyB,EACzB,GAAG,KAAoD;QAEvD,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QAC1C,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE,CAAC;YACjB,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAC;QACrC,CAAC;QACD,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,KAAK,CAAC,CAAC;QACvC,OAAO,IAAI,CAAC;IACd,CAAC;IAEO,iBAAiB,CACvB,aAAiC,EACjC,MAAyB,EACzB,GAAG,MAA4D;QAE/D,MAAM,WAAW,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,aAAa,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACvF,IAAI,WAAW,KAAK,CAAC,CAAC,EAAE,CAAC;YACvB,MAAM,IAAI,KAAK,CAAC,uBAAuB,CAAC,CAAC;QAC3C,CAAC;QACD,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;YAC3B,MAAM,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YAC9C,IAAI,UAAU,KAAK,CAAC,CAAC,EAAE,CAAC;gBACtB,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAC;YACrC,CAAC;YACD,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC;YAClC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;QAC5C,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;OAGG;IACI,UAAU,CACf,MAAyB,EACzB,GAAG,MAA4D;QAE/D,OAAO,IAAI,CAAC,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC,CAAC;IAC7D,CAAC;IAEM,SAAS,CACd,KAAwB,EACxB,GAAG,MAA4D;QAE/D,OAAO,IAAI,CAAC,iBAAiB,CAAC,OAAO,EAAE,KAAK,EAAE,GAAG,MAAM,CAAC,CAAC;IAC3D,CAAC;IAEM,QAAQ,CACb,KAAwB,EACxB,GAAG,KAA2D;QAE9D,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QACzC,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE,CAAC;YACjB,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAC;QACrC,CAAC;QACD,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,GAAG,CAAC,EAAE,CAAC,EAAE,GAAG,KAAK,CAAC,CAAC;QAC3C,OAAO,IAAI,CAAC;IACd,CAAC;IAEM,MAAM,CAAqB,GAAG,KAAyB;QAC5D,KAAK,MAAM,CAAC,IAAI,KAAK,EAAE,CAAC;YACtB,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;YACrC,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE,CAAC;gBACjB,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAC;YACrC,CAAC;YACD,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;QAC/B,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAEM,KAAK,CAAC,WAA0B;QACrC,OAAO,IAAI,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE;YAC5B,gBAAgB,EAAE,WAAW;YAC7B,eAAe,EAAE,KAAK;YACtB,mBAAmB,EAAE,IAAI;YACzB,kBAAkB;YAClB,yBAAyB;YACzB,GAAG,WAAW;SACf,CAAC,CAAC;IACL,CAAC;IAED,IAAW,eAAe;QACxB,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;CACF","sourcesContent":["import type { ILexerConfig } from '@chevrotain/types';\nimport type { TokenType } from 'chevrotain';\nimport { Lexer } from 'chevrotain';\nimport type { CheckOverlap, NamedToken } from '../utils';\n\nexport class LexerBuilder<NAMES extends string = string> {\n  private readonly tokens: TokenType[];\n\n  public static create<U extends LexerBuilder<T>, T extends string = never>(starter?: U): U {\n    return <U> new LexerBuilder(starter);\n  }\n\n  private constructor(starter?: LexerBuilder<NAMES>) {\n    this.tokens = starter?.tokens ? [ ...starter.tokens ] : [];\n  }\n\n  public merge<OtherNames extends string, OW extends string>(\n    merge: LexerBuilder<OtherNames>,\n    overwrite: NamedToken<OW>[] = [],\n  ):\n    LexerBuilder<NAMES | OtherNames> {\n    const extraTokens = merge.tokens.filter((token) => {\n      const overwriteToken = overwrite.find(t => t.name === token.name);\n      if (overwriteToken) {\n        return false;\n      }\n      const match = this.tokens.find(t => t.name === token.name);\n      if (match) {\n        if (match !== token) {\n          throw new Error(`Token with name ${token.name} already exists. Implementation is different and no overwrite was provided.`);\n        }\n        return false;\n      }\n      return true;\n    });\n    this.tokens.push(...extraTokens);\n    return this;\n  }\n\n  public add<Name extends string>(...token: CheckOverlap<Name, NAMES, NamedToken<Name>[]>):\n  LexerBuilder<Name | NAMES> {\n    this.tokens.push(...token);\n    return this;\n  }\n\n  public addBefore<Name extends string>(\n    before: NamedToken<NAMES>,\n    ...token: CheckOverlap<Name, NAMES, NamedToken<Name>[]>\n  ): LexerBuilder<NAMES | Name> {\n    const index = this.tokens.indexOf(before);\n    if (index === -1) {\n      throw new Error('Token not found');\n    }\n    this.tokens.splice(index, 0, ...token);\n    return this;\n  }\n\n  private moveBeforeOrAfter<Name extends string>(\n    beforeOrAfter: 'before' | 'after',\n    before: NamedToken<NAMES>,\n    ...tokens: CheckOverlap<Name, NAMES, never, NamedToken<Name>[]>\n  ): LexerBuilder<NAMES> {\n    const beforeIndex = this.tokens.indexOf(before) + (beforeOrAfter === 'before' ? 0 : 1);\n    if (beforeIndex === -1) {\n      throw new Error('BeforeToken not found');\n    }\n    for (const token of tokens) {\n      const tokenIndex = this.tokens.indexOf(token);\n      if (tokenIndex === -1) {\n        throw new Error('Token not found');\n      }\n      this.tokens.splice(tokenIndex, 1);\n      this.tokens.splice(beforeIndex, 0, token);\n    }\n    return this;\n  }\n\n  /**\n   * @param before token to move rest before\n   * @param tokens tokens to move before the first token\n   */\n  public moveBefore<Name extends string>(\n    before: NamedToken<NAMES>,\n    ...tokens: CheckOverlap<Name, NAMES, never, NamedToken<Name>[]>\n  ): LexerBuilder<NAMES> {\n    return this.moveBeforeOrAfter('before', before, ...tokens);\n  }\n\n  public moveAfter<Name extends string>(\n    after: NamedToken<NAMES>,\n    ...tokens: CheckOverlap<Name, NAMES, never, NamedToken<Name>[]>\n  ): LexerBuilder<NAMES> {\n    return this.moveBeforeOrAfter('after', after, ...tokens);\n  }\n\n  public addAfter<Name extends string>(\n    after: NamedToken<NAMES>,\n    ...token: CheckOverlap<Name, NAMES, never, NamedToken<Name>[]>\n  ): LexerBuilder<NAMES | Name> {\n    const index = this.tokens.indexOf(after);\n    if (index === -1) {\n      throw new Error('Token not found');\n    }\n    this.tokens.splice(index + 1, 0, ...token);\n    return this;\n  }\n\n  public delete<Name extends NAMES>(...token: NamedToken<Name>[]): LexerBuilder<Exclude<NAMES, Name>> {\n    for (const t of token) {\n      const index = this.tokens.indexOf(t);\n      if (index === -1) {\n        throw new Error('Token not found');\n      }\n      this.tokens.splice(index, 1);\n    }\n    return this;\n  }\n\n  public build(lexerConfig?: ILexerConfig): Lexer {\n    return new Lexer(this.tokens, {\n      positionTracking: 'onlyStart',\n      recoveryEnabled: false,\n      ensureOptimizations: true,\n      // SafeMode: true,\n      // SkipValidations: true,\n      ...lexerConfig,\n    });\n  }\n\n  public get tokenVocabulary(): readonly TokenType[] {\n    return this.tokens;\n  }\n}\n"]}

package/lib/nodeTypings.d.ts

@@ -0,0 +1,53 @@
+export interface Localized {
+    /**
+     * Location undefined means the node does have a string representation, but it was not clarified.
+     * This happens when an AST node is patched by a client of the lib.
+     */
+    loc: SourceLocation;
+}
+export interface Wrap<T> extends Localized {
+    val: T;
+}
+/**
+ * A AST node. Nodes are indexable by their types.
+ * When generating, the SUBRULES called should be located within the current location range.
+ */
+export interface Node extends Localized {
+    type: string;
+    subType?: string;
+}
+export interface SourceLocationBase {
+    sourceLocationType: string;
+}
+export interface SourceLocationSource extends SourceLocationBase {
+    sourceLocationType: 'source';
+    start: number;
+    end: number;
+}
+/**
+ * NoStringManifestation means the node does not have a string representation.
+ * For example the literal '5' has an integer type (which is an AST node),
+ * but the type does not have an associated string representation.
+ * When set to true, the node will not be printed, start and end are meaningless in this case.
+ */
+export interface SourceLocationNoMaterialize extends SourceLocationBase {
+    sourceLocationType: 'noMaterialize';
+}
+export interface SourceLocationStringReplace extends SourceLocationBase {
+    sourceLocationType: 'stringReplace';
+    newSource: string;
+    start: number;
+    end: number;
+}
+export interface SourceLocationNodeReplace extends SourceLocationBase {
+    sourceLocationType: 'nodeReplace';
+    start: number;
+    end: number;
+}
+/**
+ * Must have an ancestor of type {@link SourceLocationNodeReplace}
+ */
+export interface SourceLocationNodeAutoGenerate extends SourceLocationBase {
+    sourceLocationType: 'autoGenerate';
+}
+export type SourceLocation = SourceLocationSource | SourceLocationNoMaterialize | SourceLocationStringReplace | SourceLocationNodeReplace | SourceLocationNodeAutoGenerate;

package/lib/nodeTypings.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=nodeTypings.js.map

package/lib/nodeTypings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodeTypings.js","sourceRoot":"","sources":["nodeTypings.ts"],"names":[],"mappings":"","sourcesContent":["export interface Localized {\n  /**\n   * Location undefined means the node does have a string representation, but it was not clarified.\n   * This happens when an AST node is patched by a client of the lib.\n   */\n  loc: SourceLocation;\n}\n\nexport interface Wrap<T> extends Localized {\n  val: T;\n}\n\n/**\n * A AST node. Nodes are indexable by their types.\n * When generating, the SUBRULES called should be located within the current location range.\n */\nexport interface Node extends Localized {\n  type: string;\n  subType?: string;\n}\n\nexport interface SourceLocationBase {\n  sourceLocationType: string;\n}\n\nexport interface SourceLocationSource extends SourceLocationBase {\n  sourceLocationType: 'source';\n  start: number;\n  end: number;\n}\n\n/**\n * NoStringManifestation means the node does not have a string representation.\n * For example the literal '5' has an integer type (which is an AST node),\n * but the type does not have an associated string representation.\n * When set to true, the node will not be printed, start and end are meaningless in this case.\n */\nexport interface SourceLocationNoMaterialize extends SourceLocationBase {\n  sourceLocationType: 'noMaterialize';\n}\n\nexport interface SourceLocationStringReplace extends SourceLocationBase {\n  sourceLocationType: 'stringReplace';\n  newSource: string;\n  start: number;\n  end: number;\n}\n\nexport interface SourceLocationNodeReplace extends SourceLocationBase {\n  sourceLocationType: 'nodeReplace';\n  start: number;\n  end: number;\n}\n/**\n * Must have an ancestor of type {@link SourceLocationNodeReplace}\n */\nexport interface SourceLocationNodeAutoGenerate extends SourceLocationBase {\n  sourceLocationType: 'autoGenerate';\n}\n\nexport type SourceLocation =\n  | SourceLocationSource\n  | SourceLocationNoMaterialize\n  | SourceLocationStringReplace\n  | SourceLocationNodeReplace\n  | SourceLocationNodeAutoGenerate;\n"]}

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

@@ -3,7 +3,9 @@ import type { ParserRule } from './ruleDefTypes';
 /**
  * Get union-type of names used in list of ruledefs.
  */
-export type ParseNamesFromList<T extends readonly ParserRule[]> = T[number]['name'];
+export type ParseNamesFromList<T extends readonly {
+    name: string;
+}[]> = T[number]['name'];
 /**
  * Convert a list of ruledefs to a record that maps each rule name to its definition.
  */

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

@@ -1 +1 @@
-{"version":3,"file":"builderTypes.js","sourceRoot":"","sources":["builderTypes.ts"],"names":[],"mappings":"","sourcesContent":["import type { ParserMethod } from 'chevrotain';\nimport type { ParserRule } from './ruleDefTypes';\n\n/**\n * Get union-type of names used in list of ruledefs.\n */\nexport type ParseNamesFromList<T extends readonly ParserRule[]> = 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 ParseRuleMap<RuleNames extends string> = {[Key in RuleNames]: ParserRule<any, Key> };\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 ParseRulesToObject<\n  T extends readonly ParserRule[],\n  Names extends string = ParseNamesFromList<T>,\n  Agg extends Record<string, ParserRule> = Record<never, never>,\n> = T extends readonly [infer First, ...infer Rest] ? (\n  First extends ParserRule ? (\n    Rest extends readonly ParserRule[] ? (\n      ParseRulesToObject<Rest, Names, {[K in keyof Agg | First['name']]: K extends First['name'] ? First : Agg[K] }>\n    ) : never\n  ) : never\n) : ParseRuleMap<Names> & Agg;\n\nexport type ParserFromRules<Context, Names extends string, RuleDefs extends ParseRuleMap<Names>> = {\n  [K in Names]: RuleDefs[K] extends ParserRule<Context, K, infer RET, infer ARGS> ?\n      (input: string, context: Context, args: ARGS) => RET : never\n};\n\nexport type ParseMethodsFromRules<Context, Names extends string, RuleDefs extends ParseRuleMap<Names>> = {\n  [K in Names]: RuleDefs[K] extends ParserRule<Context, K, infer RET, infer ARGS> ?\n    ParserMethod<[Context, ARGS], RET> : never\n};\n"]}
+{"version":3,"file":"builderTypes.js","sourceRoot":"","sources":["builderTypes.ts"],"names":[],"mappings":"","sourcesContent":["import type { ParserMethod } from 'chevrotain';\nimport type { ParserRule } from './ruleDefTypes';\n\n/**\n * Get union-type of names used in list of ruledefs.\n */\nexport type ParseNamesFromList<T extends readonly { name: string }[]> = 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 ParseRuleMap<RuleNames extends string> = {[Key in RuleNames]: ParserRule<any, Key> };\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 ParseRulesToObject<\n  T extends readonly ParserRule[],\n  Names extends string = ParseNamesFromList<T>,\n  Agg extends Record<string, ParserRule> = Record<never, never>,\n> = T extends readonly [infer First, ...infer Rest] ? (\n  First extends ParserRule ? (\n    Rest extends readonly ParserRule[] ? (\n      ParseRulesToObject<Rest, Names, {[K in keyof Agg | First['name']]: K extends First['name'] ? First : Agg[K] }>\n    ) : never\n  ) : never\n) : ParseRuleMap<Names> & Agg;\n\nexport type ParserFromRules<Context, Names extends string, RuleDefs extends ParseRuleMap<Names>> = {\n  [K in Names]: RuleDefs[K] extends ParserRule<Context, K, infer RET, infer ARGS> ?\n      (input: string, context: Context, args: ARGS) => RET : never\n};\n\nexport type ParseMethodsFromRules<Context, Names extends string, RuleDefs extends ParseRuleMap<Names>> = {\n  [K in Names]: RuleDefs[K] extends ParserRule<Context, K, infer RET, infer ARGS> ?\n    ParserMethod<[Context, ARGS], RET> : never\n};\n"]}

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

@@ -1,7 +1,7 @@
 import type { ILexerConfig, IParserConfig, IRecognitionException } from '@chevrotain/types';
 import type { TokenType } from 'chevrotain';
 import type { CheckOverlap } from '../utils';
-import type { ParseNamesFromList, ParserFromRules, ParseRuleMap, ParseRulesToObject } from './builderTypes';
+import type { ParserFromRules, ParseRuleMap, ParseRulesToObject, ParseNamesFromList } from './builderTypes';
 import type { ParserRule } from './ruleDefTypes';
 /**
  * The grammar builder. This is the core of traqula (besides using the amazing chevrotain framework).
@@ -14,9 +14,10 @@ export declare class ParserBuilder<Context, Names extends string, RuleDefs exten
      * 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 ParserRule[] = readonly ParserRule[], Context = Rules[0] extends ParserRule<infer context> ? context : never, Names extends string = ParseNamesFromList<Rules>, RuleDefs extends ParseRuleMap<Names> = ParseRulesToObject<Rules>>(start: Rules | ParserBuilder<Context, Names, RuleDefs>): ParserBuilder<Context, Names, RuleDefs>;
+    static create<Rules extends readonly ParserRule[] = readonly ParserRule[], Context = Rules[0] extends ParserRule<infer context> ? context : never, Names extends string = ParseNamesFromList<Rules>, RuleDefs extends ParseRuleMap<Names> = ParseRulesToObject<Rules>>(start: Rules | ParserBuilder<Context, Names, RuleDefs>): ParserBuilder<Context, Names, RuleDefs>;
     private rules;
     private constructor();
+    widenContext<NewContext extends Context>(): ParserBuilder<NewContext, Names, RuleDefs>;
     typePatch<Patch extends {
         [Key in Names]?: any;
     }>(): ParserBuilder<Context, Names, {

package/lib/parser-builder/parserBuilder.js

@@ -22,7 +22,7 @@ export class ParserBuilder {
      * Create a builder from some initial grammar rules or an existing builder.
      * If a builder is provided, a new copy will be created.
      */
-    static createBuilder(start) {
+    static create(start) {
         if (start instanceof ParserBuilder) {
             return new ParserBuilder({ ...start.rules });
         }
@@ -31,6 +31,9 @@ export class ParserBuilder {
     constructor(startRules) {
         this.rules = startRules;
     }
+    widenContext() {
+        return this;
+    }
     typePatch() {
         return this;
     }
@@ -123,13 +126,20 @@ ${errorLine}`);
         throw new Error(messageBuilder.join(''));
     }
     build({ tokenVocabulary, parserConfig = {}, lexerConfig = {}, queryPreProcessor = s => s, errorHandler, }) {
-        const lexer = LexerBuilder.create().add(...tokenVocabulary).build(lexerConfig);
+        const lexer = LexerBuilder.create().add(...tokenVocabulary).build({
+            positionTracking: 'full',
+            recoveryEnabled: false,
+            // SafeMode: true,
+            // SkipValidations: true,
+            // ensureOptimizations: true,
+            ...lexerConfig,
+        });
         // Get the chevrotain parser
         const parser = this.consume({
             tokenVocabulary: tokenVocabulary,
             config: parserConfig,
         });
-        // Start building a parser accepts a string instead of tokenized input
+        // 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

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

@@ -1 +1 @@
-{"version":3,"file":"parserBuilder.js","sourceRoot":"","sources":["parserBuilder.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAS7D,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGhD;;GAEG;AACH,SAAS,gBAAgB,CAAkC,KAAQ;IACjE,MAAM,QAAQ,GAA+B,EAAE,CAAC;IAChD,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAC7B,CAAC;IACD,OAA8B,QAAQ,CAAC;AACzC,CAAC;AAED;;;;;GAKG;AACH,iDAAiD;AACjD,MAAM,OAAO,aAAa;IACxB;;;OAGG;IACI,MAAM,CAAC,aAAa,CAMzB,KAAsD;QAEtD,IAAI,KAAK,YAAY,aAAa,EAAE,CAAC;YACnC,OAAO,IAAI,aAAa,CAAC,EAAE,GAAG,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC;QAC/C,CAAC;QACD,OAA2D,IAAI,aAAa,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC,CAAC;IACxG,CAAC;IAID,YAAoB,UAAoB;QACtC,IAAI,CAAC,KAAK,GAAG,UAAU,CAAC;IAC1B,CAAC;IAEM,SAAS;QAId,OAE2F,IAAI,CAAC;IAClG,CAAC;IAED;;OAEG;IACI,SAAS,CAA6B,KAAwC;QAKnF,MAAM,IAAI,GAEE,IAAI,CAAC;QACjB,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,GAAS,KAAK,CAAC;QACrC,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACI,gBAAgB,CAA8B,IAAuC;QAK1F,MAAM,IAAI,GAGE,IAAI,CAAC;QACjB,MAAM,KAAK,GAAyC,IAAI,CAAC,KAAK,CAAC;QAC/D,IAAI,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,SAAS,IAAI,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,IAAI,EAAE,CAAC;YAChE,MAAM,IAAI,KAAK,CAAC,QAAQ,IAAI,CAAC,IAAI,gCAAgC,CAAC,CAAC;QACrE,CAAC;QACD,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;QACxB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACI,OAAO,CACZ,IAA+D;QAI/D,OAAO,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;IACrC,CAAC;IAEM,OAAO,CACZ,GAAG,KAAoD;QAYvD,IAAI,CAAC,KAAK,GAAG,EAAE,GAAG,IAAI,CAAC,KAAK,EAAE,GAAG,gBAAgB,CAAC,KAAK,CAAC,EAAE,CAAC;QAC3D,OAAuB,IAAI,CAAC;IAC9B,CAAC;IAED;;OAEG;IACI,UAAU,CAAkB,QAAW;QAG5C,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;QAC5B,OAEY,IAAI,CAAC;IACnB,CAAC;IAED;;;;;;;;OAQG;IACI,KAAK,CAKV,OAAuD,EACvD,eAAmB;QAcnB,yFAAyF;QACzF,MAAM,UAAU,GAAwC,EAAE,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC;QAC7E,MAAM,OAAO,GAAwC,IAAI,CAAC,KAAK,CAAC;QAEhE,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC;YAC1C,IAAI,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,SAAS,EAAE,CAAC;gBACxC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;YAC/B,CAAC;iBAAM,CAAC;gBACN,MAAM,YAAY,GAAG,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBAC3C,wCAAwC;gBACxC,IAAI,YAAY,KAAK,IAAI,EAAE,CAAC;oBAC1B,MAAM,QAAQ,GAAG,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,IAAI,CAAC,CAAC;oBACjE,mFAAmF;oBACnF,IAAI,QAAQ,EAAE,CAAC;wBACb,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,QAAQ,CAAC;oBACnC,CAAC;yBAAM,CAAC;wBACN,MAAM,IAAI,KAAK,CAAC,mBAAmB,IAAI,CAAC,IAAI,0EAA0E,CAAC,CAAC;oBAC1H,CAAC;gBACH,CAAC;YACH,CAAC;QACH,CAAC;QAED,IAAI,CAAC,KAAK,GAAmB,UAAU,CAAC;QACxC,OAAuB,IAAI,CAAC;IAC9B,CAAC;IAEO,mBAAmB,CAAC,KAAa,EAAE,MAA+B;QACxE,MAAM,UAAU,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;QAC7B,MAAM,cAAc,GAAa,CAAE,aAAa,CAAE,CAAC;QACnD,MAAM,OAAO,GAAG,UAAU,CAAC,KAAK,CAAC,SAAS,CAAC;QAC3C,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;YAC1B,MAAM,SAAS,GAAG,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC;YACjD,cAAc,CAAC,IAAI,CAAC,YAAY,OAAO;EAC3C,SAAS,EAAE,CAAC,CAAC;YACT,MAAM,SAAS,GAAG,UAAU,CAAC,KAAK,CAAC,WAAW,CAAC;YAC/C,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;gBAC5B,cAAc,CAAC,IAAI,CAAC,KAAK,GAAG,CAAC,MAAM,CAAC,SAAS,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;YACzD,CAAC;QACH,CAAC;QACD,cAAc,CAAC,IAAI,CAAC,KAAK,UAAU,CAAC,OAAO,EAAE,CAAC,CAAC;QAC/C,MAAM,IAAI,KAAK,CAAC,cAAc,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC;IAC3C,CAAC;IAEM,KAAK,CAAC,EACX,eAAe,EACf,YAAY,GAAG,EAAE,EACjB,WAAW,GAAG,EAAE,EAChB,iBAAiB,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,EAC1B,YAAY,GAOb;QACC,MAAM,KAAK,GAAU,YAAY,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,GAAG,eAAe,CAAC,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;QAEtF,4BAA4B;QAC5B,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC;YAC1B,eAAe,EAAgB,eAAe;YAC9C,MAAM,EAAE,YAAY;SACrB,CAAC,CAAC;QAEH,sEAAsE;QACtE,MAAM,oBAAoB,GAAuD,EAAE,CAAC;QAEpF,gEAAgE;QAChE,4DAA4D;QAC5D,KAAK,MAAM,IAAI,IAAmC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;YAC5E,oBAAoB,CAAC,IAAI,CAAC,IAAI,CAAC,GAAS,CAAC,CAAC,KAAa,EAAE,OAAgB,EAAE,GAAY,EAAE,EAAE;gBACzF,MAAM,cAAc,GAAG,iBAAiB,CAAC,KAAK,CAAC,CAAC;gBAChD,MAAM,SAAS,GAAG,KAAK,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC;gBAEjD,8BAA8B;gBAC9B,MAAM,CAAC,KAAK,GAAG,SAAS,CAAC,MAAM,CAAC;gBAChC,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;gBAC3B,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;gBAC/C,IAAI,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBAC7B,IAAI,YAAY,EAAE,CAAC;wBACjB,YAAY,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;oBAC9B,CAAC;yBAAM,CAAC;wBACN,IAAI,CAAC,mBAAmB,CAAC,cAAc,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;oBAC1D,CAAC;gBACH,CAAC;gBACD,OAAO,MAAM,CAAC;YAChB,CAAC,CAAC,CAAC;QACL,CAAC;QACD,OAAmD,oBAAoB,CAAC;IAC1E,CAAC;IAEO,OAAO,CAAC,EAAE,eAAe,EAAE,MAAM,GAAG,EAAE,EAG7C;QAEC,OACuD,IAAI,aAAa,CAAC,IAAI,CAAC,KAAK,EAAE,eAAe,EAAE,MAAM,CAAC,CAAC;IAChH,CAAC;CACF","sourcesContent":["import type { ILexerConfig, IParserConfig, IRecognitionException } from '@chevrotain/types';\nimport type { Lexer, TokenType, TokenVocabulary, EmbeddedActionsParser } from 'chevrotain';\nimport { LexerBuilder } from '../lexer-builder/LexerBuilder';\nimport type { CheckOverlap } from '../utils';\nimport type {\n  ParseMethodsFromRules,\n  ParseNamesFromList,\n  ParserFromRules,\n  ParseRuleMap,\n  ParseRulesToObject,\n} from './builderTypes';\nimport { DynamicParser } from './dynamicParser';\nimport type { ParserRule } from './ruleDefTypes';\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\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 createBuilder<\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 (start instanceof ParserBuilder) {\n      return new ParserBuilder({ ...start.rules });\n    }\n    return <ParserBuilder<Context, Names, RuleDefs>> <unknown> new ParserBuilder(listToRuleDefMap(start));\n  }\n\n  private rules: RuleDefs;\n\n  private constructor(startRules: RuleDefs) {\n    this.rules = startRules;\n  }\n\n  public typePatch<Patch extends {[Key in Names]?: any }>():\n  ParserBuilder<Context, Names, {[Key in Names]: Key extends keyof Patch ? (\n    RuleDefs[Key] extends ParserRule<Context, Key, any, infer Par> ? ParserRule<Context, Key, Patch[Key], Par> : never\n  ) : (RuleDefs[Key] extends ParserRule<Context, Key> ? RuleDefs[Key] : never) }> {\n    return <ParserBuilder<Context, Names, {[Key in Names]: Key extends keyof Patch ? (\n      RuleDefs[Key] extends ParserRule<Context, Key, any, infer Par> ? ParserRule<Context, Key, Patch[Key], Par> : never\n    ) : (RuleDefs[Key] extends ParserRule<Context, Key> ? RuleDefs[Key] : never) }>> <unknown> this;\n  }\n\n  /**\n   * Change the implementation of an existing grammar rule.\n   */\n  public patchRule<U extends Names, RET, ARGS>(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>(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>(\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  /**\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) {\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  }: {\n    tokenVocabulary: readonly TokenType[];\n    parserConfig?: IParserConfig;\n    lexerConfig?: ILexerConfig;\n    queryPreProcessor?: (input: string) => string;\n    errorHandler?: (errors: IRecognitionException[]) => void;\n  }): ParserFromRules<Context, Names, RuleDefs> {\n    const lexer: Lexer = LexerBuilder.create().add(...tokenVocabulary).build(lexerConfig);\n\n    // Get the chevrotain parser\n    const parser = this.consume({\n      tokenVocabulary: <TokenType[]> tokenVocabulary,\n      config: parserConfig,\n    });\n\n    // Start building a parser accepts a string instead of tokenized input\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, arg: 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, arg);\n        if (parser.errors.length > 0) {\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"]}
+{"version":3,"file":"parserBuilder.js","sourceRoot":"","sources":["parserBuilder.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAS7D,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGhD;;GAEG;AACH,SAAS,gBAAgB,CAAkC,KAAQ;IACjE,MAAM,QAAQ,GAA+B,EAAE,CAAC;IAChD,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAC7B,CAAC;IACD,OAA8B,QAAQ,CAAC;AACzC,CAAC;AAED;;;;;GAKG;AACH,iDAAiD;AACjD,MAAM,OAAO,aAAa;IACxB;;;OAGG;IACI,MAAM,CAAC,MAAM,CAMlB,KAAsD;QAEtD,IAAI,KAAK,YAAY,aAAa,EAAE,CAAC;YACnC,OAAO,IAAI,aAAa,CAAC,EAAE,GAAG,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC;QAC/C,CAAC;QACD,OAA2D,IAAI,aAAa,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC,CAAC;IACxG,CAAC;IAID,YAAoB,UAAoB;QACtC,IAAI,CAAC,KAAK,GAAG,UAAU,CAAC;IAC1B,CAAC;IAEM,YAAY;QACjB,OAA8D,IAAI,CAAC;IACrE,CAAC;IAEM,SAAS;QAId,OAE2F,IAAI,CAAC;IAClG,CAAC;IAED;;OAEG;IACI,SAAS,CAA6B,KAAwC;QAKnF,MAAM,IAAI,GAEE,IAAI,CAAC;QACjB,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,GAAS,KAAK,CAAC;QACrC,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACI,gBAAgB,CAA8B,IAAuC;QAK1F,MAAM,IAAI,GAGE,IAAI,CAAC;QACjB,MAAM,KAAK,GAAyC,IAAI,CAAC,KAAK,CAAC;QAC/D,IAAI,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,SAAS,IAAI,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,IAAI,EAAE,CAAC;YAChE,MAAM,IAAI,KAAK,CAAC,QAAQ,IAAI,CAAC,IAAI,gCAAgC,CAAC,CAAC;QACrE,CAAC;QACD,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;QACxB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACI,OAAO,CACZ,IAA+D;QAI/D,OAAO,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;IACrC,CAAC;IAEM,OAAO,CACZ,GAAG,KAAoD;QAYvD,IAAI,CAAC,KAAK,GAAG,EAAE,GAAG,IAAI,CAAC,KAAK,EAAE,GAAG,gBAAgB,CAAC,KAAK,CAAC,EAAE,CAAC;QAC3D,OAAuB,IAAI,CAAC;IAC9B,CAAC;IAED;;OAEG;IACI,UAAU,CAAkB,QAAW;QAG5C,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;QAC5B,OAEY,IAAI,CAAC;IACnB,CAAC;IAED;;;;;;;;OAQG;IACI,KAAK,CAKV,OAAuD,EACvD,eAAmB;QAcnB,yFAAyF;QACzF,MAAM,UAAU,GAAwC,EAAE,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC;QAC7E,MAAM,OAAO,GAAwC,IAAI,CAAC,KAAK,CAAC;QAEhE,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC;YAC1C,IAAI,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,SAAS,EAAE,CAAC;gBACxC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;YAC/B,CAAC;iBAAM,CAAC;gBACN,MAAM,YAAY,GAAG,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBAC3C,wCAAwC;gBACxC,IAAI,YAAY,KAAK,IAAI,EAAE,CAAC;oBAC1B,MAAM,QAAQ,GAAG,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,IAAI,CAAC,CAAC;oBACjE,mFAAmF;oBACnF,IAAI,QAAQ,EAAE,CAAC;wBACb,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,QAAQ,CAAC;oBACnC,CAAC;yBAAM,CAAC;wBACN,MAAM,IAAI,KAAK,CAAC,mBAAmB,IAAI,CAAC,IAAI,0EAA0E,CAAC,CAAC;oBAC1H,CAAC;gBACH,CAAC;YACH,CAAC;QACH,CAAC;QAED,IAAI,CAAC,KAAK,GAAmB,UAAU,CAAC;QACxC,OAAuB,IAAI,CAAC;IAC9B,CAAC;IAEO,mBAAmB,CAAC,KAAa,EAAE,MAA+B;QACxE,MAAM,UAAU,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;QAC7B,MAAM,cAAc,GAAa,CAAE,aAAa,CAAE,CAAC;QACnD,MAAM,OAAO,GAAG,UAAU,CAAC,KAAK,CAAC,SAAS,CAAC;QAC3C,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;YAC1B,MAAM,SAAS,GAAG,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC;YACjD,cAAc,CAAC,IAAI,CAAC,YAAY,OAAO;EAC3C,SAAS,EAAE,CAAC,CAAC;YACT,MAAM,SAAS,GAAG,UAAU,CAAC,KAAK,CAAC,WAAW,CAAC;YAC/C,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;gBAC5B,cAAc,CAAC,IAAI,CAAC,KAAK,GAAG,CAAC,MAAM,CAAC,SAAS,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;YACzD,CAAC;QACH,CAAC;QACD,cAAc,CAAC,IAAI,CAAC,KAAK,UAAU,CAAC,OAAO,EAAE,CAAC,CAAC;QAC/C,MAAM,IAAI,KAAK,CAAC,cAAc,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC;IAC3C,CAAC;IAEM,KAAK,CAAC,EACX,eAAe,EACf,YAAY,GAAG,EAAE,EACjB,WAAW,GAAG,EAAE,EAChB,iBAAiB,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,EAC1B,YAAY,GAOb;QACC,MAAM,KAAK,GAAG,YAAY,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,GAAG,eAAe,CAAC,CAAC,KAAK,CAAC;YAChE,gBAAgB,EAAE,MAAM;YACxB,eAAe,EAAE,KAAK;YACtB,kBAAkB;YAClB,yBAAyB;YACzB,6BAA6B;YAC7B,GAAG,WAAW;SACf,CAAC,CAAC;QACH,4BAA4B;QAC5B,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC;YAC1B,eAAe,EAAgB,eAAe;YAC9C,MAAM,EAAE,YAAY;SACrB,CAAC,CAAC;QACH,8GAA8G;QAC9G,MAAM,oBAAoB,GAAuD,EAAE,CAAC;QAEpF,gEAAgE;QAChE,4DAA4D;QAC5D,KAAK,MAAM,IAAI,IAAmC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;YAC5E,oBAAoB,CAAC,IAAI,CAAC,IAAI,CAAC,GAAS,CAAC,CAAC,KAAa,EAAE,OAAgB,EAAE,GAAY,EAAE,EAAE;gBACzF,MAAM,cAAc,GAAG,iBAAiB,CAAC,KAAK,CAAC,CAAC;gBAChD,MAAM,SAAS,GAAG,KAAK,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC;gBAEjD,8BAA8B;gBAC9B,MAAM,CAAC,KAAK,GAAG,SAAS,CAAC,MAAM,CAAC;gBAChC,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;gBAC3B,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;gBAC/C,IAAI,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBAC7B,IAAI,YAAY,EAAE,CAAC;wBACjB,YAAY,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;oBAC9B,CAAC;yBAAM,CAAC;wBACN,IAAI,CAAC,mBAAmB,CAAC,cAAc,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;oBAC1D,CAAC;gBACH,CAAC;gBACD,OAAO,MAAM,CAAC;YAChB,CAAC,CAAC,CAAC;QACL,CAAC;QACD,OAAmD,oBAAoB,CAAC;IAC1E,CAAC;IAEO,OAAO,CAAC,EAAE,eAAe,EAAE,MAAM,GAAG,EAAE,EAG7C;QAEC,OACuD,IAAI,aAAa,CAAC,IAAI,CAAC,KAAK,EAAE,eAAe,EAAE,MAAM,CAAC,CAAC;IAChH,CAAC;CACF","sourcesContent":["import type { ILexerConfig, IParserConfig, IRecognitionException } from '@chevrotain/types';\nimport type { TokenType, TokenVocabulary, EmbeddedActionsParser } from 'chevrotain';\nimport { LexerBuilder } from '../lexer-builder/LexerBuilder';\nimport type { CheckOverlap } from '../utils';\nimport type {\n  ParseMethodsFromRules,\n  ParserFromRules,\n  ParseRuleMap,\n  ParseRulesToObject,\n  ParseNamesFromList,\n} from './builderTypes';\nimport { DynamicParser } from './dynamicParser';\nimport type { ParserRule } from './ruleDefTypes';\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\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 (start instanceof ParserBuilder) {\n      return new ParserBuilder({ ...start.rules });\n    }\n    return <ParserBuilder<Context, Names, RuleDefs>> <unknown> new ParserBuilder(listToRuleDefMap(start));\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<NewContext, Names, RuleDefs> {\n    return <ParserBuilder<NewContext, Names, RuleDefs>> <unknown> this;\n  }\n\n  public typePatch<Patch extends {[Key in Names]?: any }>():\n  ParserBuilder<Context, Names, {[Key in Names]: Key extends keyof Patch ? (\n    RuleDefs[Key] extends ParserRule<Context, Key, any, infer Par> ? ParserRule<Context, Key, Patch[Key], Par> : never\n  ) : (RuleDefs[Key] extends ParserRule<Context, Key> ? RuleDefs[Key] : never) }> {\n    return <ParserBuilder<Context, Names, {[Key in Names]: Key extends keyof Patch ? (\n      RuleDefs[Key] extends ParserRule<Context, Key, any, infer Par> ? ParserRule<Context, Key, Patch[Key], Par> : never\n    ) : (RuleDefs[Key] extends ParserRule<Context, Key> ? RuleDefs[Key] : never) }>> <unknown> this;\n  }\n\n  /**\n   * Change the implementation of an existing grammar rule.\n   */\n  public patchRule<U extends Names, RET, ARGS>(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>(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>(\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  /**\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) {\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  }: {\n    tokenVocabulary: readonly TokenType[];\n    parserConfig?: IParserConfig;\n    lexerConfig?: ILexerConfig;\n    queryPreProcessor?: (input: string) => string;\n    errorHandler?: (errors: IRecognitionException[]) => void;\n  }): ParserFromRules<Context, Names, RuleDefs> {\n    const lexer = LexerBuilder.create().add(...tokenVocabulary).build({\n      positionTracking: 'full',\n      recoveryEnabled: false,\n      // SafeMode: true,\n      // SkipValidations: true,\n      // ensureOptimizations: 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, arg: 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, arg);\n        if (parser.errors.length > 0) {\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/lib/utils.d.ts

@@ -11,7 +11,7 @@ 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]?: unknown;
 }> = {
     [Key in keyof T]: Key extends keyof Patch ? Patch[Key] : T[Key];
 };

package/lib/utils.js.map

@@ -1 +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"]}
+{"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 ]?: unknown }> =\n  {[Key in keyof T]: Key extends keyof Patch ? Patch[Key] : T[Key] };\n"]}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@traqula/core",
   "type": "module",
-  "version": "0.0.1-alpha.176+9400dc5",
+  "version": "0.0.1",
   "description": "Core components of Traqula",
   "lsd:module": true,
   "license": "MIT",
@@ -43,5 +43,5 @@
   "devDependencies": {
     "@chevrotain/types": "^11.0.3"
   },
-  "gitHead": "9400dc5f8bda1d8c2b3d1f4cf56b308995744ba0"
+  "gitHead": "2bfa8222d972fda2ca6f0adc80a5362e0d583871"
 }