@traqula/core 0.0.1-alpha.9 → 0.0.2

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

@@ -1,8 +1,5 @@
+import type { ParseNamesFromList } from '../parser-builder/builderTypes';
 import type { GeneratorRule } from './generatorTypes';
-/**
- * Get union-type of names used in list of ruledefs.
- */
-export type GenNamesFromList<T extends readonly GeneratorRule[]> = T[number]['name'];
 /**
  * Convert a list of ruledefs to a record that maps each rule name to its definition.
  */
@@ -12,7 +9,7 @@ export type GenRuleMap<RuleNames extends string> = {
 /**
  * Convert a list of RuleDefs to a Record with the name of the RuleDef as the key, matching the RuleDefMap type.
  */
-export type GenRulesToObject<T extends readonly GeneratorRule[], Names extends string = GenNamesFromList<T>, Agg extends Record<string, GeneratorRule> = Record<never, never>> = T extends readonly [infer First, ...infer Rest] ? (First extends GeneratorRule ? (Rest extends readonly GeneratorRule[] ? (GenRulesToObject<Rest, Names, {
+export type GenRulesToObject<T extends readonly GeneratorRule[], Names extends string = ParseNamesFromList<T>, Agg extends Record<string, GeneratorRule> = Record<never, never>> = T extends readonly [infer First, ...infer Rest] ? (First extends GeneratorRule ? (Rest extends readonly GeneratorRule[] ? (GenRulesToObject<Rest, Names, {
     [K in keyof Agg | First['name']]: K extends First['name'] ? First : Agg[K];
 }>) : never) : never) : GenRuleMap<Names> & Agg;
 export type GeneratorFromRules<Context, Names extends string, RuleDefs extends GenRuleMap<Names>> = {

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

@@ -1 +1 @@
-{"version":3,"file":"builderTypes.js","sourceRoot":"","sources":["builderTypes.ts"],"names":[],"mappings":"","sourcesContent":["import type { GeneratorRule } from './generatorTypes';\n\n/**\n * Get union-type of names used in list of ruledefs.\n */\nexport type GenNamesFromList<T extends readonly GeneratorRule[]> = 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 GenRuleMap<RuleNames extends string> = {[Key in RuleNames]: GeneratorRule<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 GenRulesToObject<\n  T extends readonly GeneratorRule[],\n  Names extends string = GenNamesFromList<T>,\n  Agg extends Record<string, GeneratorRule> = Record<never, never>,\n> = T extends readonly [infer First, ...infer Rest] ? (\n  First extends GeneratorRule ? (\n    Rest extends readonly GeneratorRule[] ? (\n      GenRulesToObject<Rest, Names, {[K in keyof Agg | First['name']]: K extends First['name'] ? First : Agg[K] }>\n    ) : never\n  ) : never\n) : GenRuleMap<Names> & Agg;\n\nexport type GeneratorFromRules<Context, Names extends string, RuleDefs extends GenRuleMap<Names>> = {\n  [K in Names]: RuleDefs[K] extends GeneratorRule<Context, K, infer RET, infer ARGS> ?\n      (input: RET, context: Context & { origSource: string; offset?: number }, args: ARGS) => string : never\n};\n"]}
+{"version":3,"file":"builderTypes.js","sourceRoot":"","sources":["builderTypes.ts"],"names":[],"mappings":"","sourcesContent":["import type { ParseNamesFromList } from '../parser-builder/builderTypes';\nimport type { GeneratorRule } from './generatorTypes';\n\n/**\n * Convert a list of ruledefs to a record that maps each rule name to its definition.\n */\nexport type GenRuleMap<RuleNames extends string> = {[Key in RuleNames]: GeneratorRule<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 GenRulesToObject<\n  T extends readonly GeneratorRule[],\n  Names extends string = ParseNamesFromList<T>,\n  Agg extends Record<string, GeneratorRule> = Record<never, never>,\n> = T extends readonly [infer First, ...infer Rest] ? (\n  First extends GeneratorRule ? (\n    Rest extends readonly GeneratorRule[] ? (\n      GenRulesToObject<Rest, Names, {[K in keyof Agg | First['name']]: K extends First['name'] ? First : Agg[K] }>\n    ) : never\n  ) : never\n) : GenRuleMap<Names> & Agg;\n\nexport type GeneratorFromRules<Context, Names extends string, RuleDefs extends GenRuleMap<Names>> = {\n  [K in Names]: RuleDefs[K] extends GeneratorRule<Context, K, infer RET, infer ARGS> ?\n      (input: RET, context: Context & { origSource: string; offset?: number }, args: ARGS) => string : never\n};\n"]}

package/lib/generator-builder/generatorBuilder.d.ts

@@ -1,5 +1,6 @@
+import type { ParseNamesFromList } from '../parser-builder/builderTypes';
 import type { CheckOverlap } from '../utils';
-import type { GeneratorFromRules, GenRuleMap, GenRulesToObject, GenNamesFromList } from './builderTypes';
+import type { GeneratorFromRules, GenRuleMap, GenRulesToObject } from './builderTypes';
 import type { GeneratorRule } from './generatorTypes';
 export declare class GeneratorBuilder<Context, Names extends string, RuleDefs extends GenRuleMap<Names>> {
     /**
@@ -7,7 +8,7 @@ export declare class GeneratorBuilder<Context, Names extends string, RuleDefs ex
      * If a GeneratorBuilder is provided, a new copy will be created.
      */
     static create<Context, Names extends string, RuleDefs extends GenRuleMap<Names>>(args: GeneratorBuilder<Context, Names, RuleDefs>): GeneratorBuilder<Context, Names, RuleDefs>;
-    static create<Rules extends readonly GeneratorRule[] = readonly GeneratorRule[], Context = Rules[0] extends GeneratorRule<infer context> ? context : never, Names extends string = GenNamesFromList<Rules>, RuleDefs extends GenRuleMap<Names> = GenRulesToObject<Rules>>(rules: Rules): GeneratorBuilder<Context, Names, RuleDefs>;
+    static create<Rules extends readonly GeneratorRule[] = readonly GeneratorRule[], Context = Rules[0] extends GeneratorRule<infer context> ? context : never, Names extends string = ParseNamesFromList<Rules>, RuleDefs extends GenRuleMap<Names> = GenRulesToObject<Rules>>(rules: Rules): GeneratorBuilder<Context, Names, RuleDefs>;
     private rules;
     private constructor();
     widenContext<NewContext extends Context>(): GeneratorBuilder<NewContext, Names, RuleDefs>;
@@ -34,8 +35,8 @@ export declare class GeneratorBuilder<Context, Names extends string, RuleDefs ex
     addRule<U extends string, RET, ARGS>(rule: CheckOverlap<U, Names, GeneratorRule<Context, U, RET, ARGS>>): GeneratorBuilder<Context, Names | U, {
         [K in Names | U]: K extends Names ? (RuleDefs[K] extends GeneratorRule<Context, K> ? RuleDefs[K] : never) : (K extends U ? GeneratorRule<Context, K, RET, ARGS> : never);
     }>;
-    addMany<U extends readonly GeneratorRule<Context>[]>(...rules: CheckOverlap<GenNamesFromList<U>, Names, U>): GeneratorBuilder<Context, Names | GenNamesFromList<U>, {
-        [K in Names | GenNamesFromList<U>]: K extends keyof GenRulesToObject<typeof rules> ? (GenRulesToObject<typeof rules>[K] extends GeneratorRule<Context, K> ? GenRulesToObject<typeof rules>[K] : never) : (K extends Names ? (RuleDefs[K] extends GeneratorRule<Context, K> ? RuleDefs[K] : never) : never);
+    addMany<U extends readonly GeneratorRule<Context>[]>(...rules: CheckOverlap<ParseNamesFromList<U>, Names, U>): GeneratorBuilder<Context, Names | ParseNamesFromList<U>, {
+        [K in Names | ParseNamesFromList<U>]: K extends keyof GenRulesToObject<typeof rules> ? (GenRulesToObject<typeof rules>[K] extends GeneratorRule<Context, K> ? GenRulesToObject<typeof rules>[K] : never) : (K extends Names ? (RuleDefs[K] extends GeneratorRule<Context, K> ? RuleDefs[K] : never) : never);
     }>;
     /**
      * Delete a grammar rule by its name.
@@ -52,8 +53,8 @@ export declare class GeneratorBuilder<Context, Names extends string, RuleDefs ex
      * 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 GenRuleMap<OtherNames>, OW extends readonly GeneratorRule<Context>[]>(GeneratorBuilder: GeneratorBuilder<Context, OtherNames, OtherRules>, overridingRules: OW): GeneratorBuilder<Context, Names | OtherNames | GenNamesFromList<OW>, {
-        [K in Names | OtherNames | GenNamesFromList<OW>]: K extends keyof GenRulesToObject<OW> ? (GenRulesToObject<OW>[K] extends GeneratorRule<Context, K> ? GenRulesToObject<OW>[K] : never) : (K extends Names ? (RuleDefs[K] extends GeneratorRule<Context, K> ? RuleDefs[K] : never) : K extends OtherNames ? (OtherRules[K] extends GeneratorRule<Context, K> ? OtherRules[K] : never) : never);
+    merge<OtherNames extends string, OtherRules extends GenRuleMap<OtherNames>, OW extends readonly GeneratorRule<Context>[]>(GeneratorBuilder: GeneratorBuilder<Context, OtherNames, OtherRules>, overridingRules: OW): GeneratorBuilder<Context, Names | OtherNames | ParseNamesFromList<OW>, {
+        [K in Names | OtherNames | ParseNamesFromList<OW>]: K extends keyof GenRulesToObject<OW> ? (GenRulesToObject<OW>[K] extends GeneratorRule<Context, K> ? GenRulesToObject<OW>[K] : never) : (K extends Names ? (RuleDefs[K] extends GeneratorRule<Context, K> ? RuleDefs[K] : never) : K extends OtherNames ? (OtherRules[K] extends GeneratorRule<Context, K> ? OtherRules[K] : never) : never);
     }>;
     build(): GeneratorFromRules<Context, Names, RuleDefs>;
 }

package/lib/generator-builder/generatorBuilder.js.map

@@ -1 +1 @@
-{"version":3,"file":"generatorBuilder.js","sourceRoot":"","sources":["generatorBuilder.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAGtD;;GAEG;AACH,SAAS,gBAAgB,CAAqC,KAAQ;IACpE,MAAM,QAAQ,GAAkC,EAAE,CAAC;IACnD,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAC7B,CAAC;IACD,OAA4B,QAAQ,CAAC;AACvC,CAAC;AAED,MAAM,OAAO,gBAAgB;IAcpB,MAAM,CAAC,MAAM,CAMlB,KAAyD;QAEzD,IAAI,KAAK,YAAY,gBAAgB,EAAE,CAAC;YACtC,OAAO,IAAI,gBAAgB,CAAC,EAAE,GAAG,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC;QAClD,CAAC;QACD,OAA8D,IAAI,gBAAgB,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC,CAAC;IAC9G,CAAC;IAID,YAAoB,UAAoB;QACtC,IAAI,CAAC,KAAK,GAAG,UAAU,CAAC;IAC1B,CAAC;IAEM,YAAY;QACjB,OAAiE,IAAI,CAAC;IACxE,CAAC;IAEM,SAAS;QAKd,OAG8F,IAAI,CAAC;IACrG,CAAC;IAED;;OAEG;IACI,SAAS,CAA6B,KAA2C;QAKtF,MAAM,IAAI,GAGE,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,IAA0C;QAK7F,MAAM,IAAI,GAGE,IAAI,CAAC;QACjB,MAAM,KAAK,GAA4C,IAAI,CAAC,KAAK,CAAC;QAClE,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,yCAAyC,CAAC,CAAC;QAC9E,CAAC;QACD,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;QACxB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACI,OAAO,CACZ,IAAkE;QAKlE,OAAO,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;IACrC,CAAC;IAEM,OAAO,CACZ,GAAG,KAAkD;QAYrD,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,gBAAmE,EACnE,eAAmB;QAenB,yFAAyF;QACzF,MAAM,UAAU,GAA2C,EAAE,GAAG,gBAAgB,CAAC,KAAK,EAAE,CAAC;QACzF,MAAM,OAAO,GAA2C,IAAI,CAAC,KAAK,CAAC;QAEnE,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,mFAAmF,CAAC,CAAC;oBACnI,CAAC;gBACH,CAAC;YACH,CAAC;QACH,CAAC;QAED,IAAI,CAAC,KAAK,GAAmB,UAAU,CAAC;QACxC,OAAuB,IAAI,CAAC;IAC9B,CAAC;IAEM,KAAK;QACV,OAAsD,IAAI,gBAAgB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACzF,CAAC;CACF","sourcesContent":["import type { CheckOverlap } from '../utils';\nimport type { GeneratorFromRules, GenRuleMap, GenRulesToObject, GenNamesFromList } from './builderTypes';\nimport { DynamicGenerator } from './dynamicGenerator';\nimport type { GeneratorRule } from './generatorTypes';\n\n/**\n * Converts a list of ruledefs to a record mapping a name to the corresponding ruledef.\n */\nfunction listToRuleDefMap<T extends readonly GeneratorRule[]>(rules: T): GenRulesToObject<T> {\n  const newRules: Record<string, GeneratorRule> = {};\n  for (const rule of rules) {\n    newRules[rule.name] = rule;\n  }\n  return <GenRulesToObject<T>>newRules;\n}\n\nexport class GeneratorBuilder<Context, Names extends string, RuleDefs extends GenRuleMap<Names>> {\n  /**\n   * Create a GeneratorBuilder from some initial grammar rules or an existing GeneratorBuilder.\n   * If a GeneratorBuilder is provided, a new copy will be created.\n   */\n  public static create<Context, Names extends string, RuleDefs extends GenRuleMap<Names>>(\n    args: GeneratorBuilder<Context, Names, RuleDefs>\n  ): GeneratorBuilder<Context, Names, RuleDefs>;\n  public static create<\n    Rules extends readonly GeneratorRule[] = readonly GeneratorRule[],\n    Context = Rules[0] extends GeneratorRule<infer context> ? context : never,\n    Names extends string = GenNamesFromList<Rules>,\n    RuleDefs extends GenRuleMap<Names> = GenRulesToObject<Rules>,\n  >(rules: Rules): GeneratorBuilder<Context, Names, RuleDefs>;\n  public static create<\n    Rules extends readonly GeneratorRule[] = readonly GeneratorRule[],\n    Context = Rules[0] extends GeneratorRule<infer context> ? context : never,\n    Names extends string = GenNamesFromList<Rules>,\n    RuleDefs extends GenRuleMap<Names> = GenRulesToObject<Rules>,\n  >(\n    start: Rules | GeneratorBuilder<Context, Names, RuleDefs>,\n  ): GeneratorBuilder<Context, Names, RuleDefs> {\n    if (start instanceof GeneratorBuilder) {\n      return new GeneratorBuilder({ ...start.rules });\n    }\n    return <GeneratorBuilder<Context, Names, RuleDefs>> <unknown> new GeneratorBuilder(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>(): GeneratorBuilder<NewContext, Names, RuleDefs> {\n    return <GeneratorBuilder<NewContext, Names, RuleDefs>> <unknown> this;\n  }\n\n  public typePatch<Patch extends {[Key in Names]?: any }>():\n  GeneratorBuilder<Context, Names, {[Key in Names]: Key extends keyof Patch ? (\n    RuleDefs[Key] extends GeneratorRule<Context, Key, any, infer Args> ?\n      GeneratorRule<Context, Key, Patch[Key], Args> : never\n  ) : (RuleDefs[Key] extends GeneratorRule<Context, Key> ? RuleDefs[Key] : never) }> {\n    return <GeneratorBuilder<Context, Names, {[Key in Names]: Key extends keyof Patch ? (\n      RuleDefs[Key] extends GeneratorRule<Context, Key, any, infer Args> ?\n        GeneratorRule<Context, Key, Patch[Key], Args> : never\n    ) : (RuleDefs[Key] extends GeneratorRule<Context, Key> ? RuleDefs[Key] : never) }>> <unknown> this;\n  }\n\n  /**\n   * Change the implementation of an existing generator rule.\n   */\n  public patchRule<U extends Names, RET, ARGS>(patch: GeneratorRule<Context, U, RET, ARGS>):\n  GeneratorBuilder<Context, Names, {[Key in Names]: Key extends U ?\n    GeneratorRule<Context, Key, RET, ARGS> :\n      (RuleDefs[Key] extends GeneratorRule<Context, Key> ? RuleDefs[Key] : never)\n  } > {\n    const self = <GeneratorBuilder<Context, Names, {[Key in Names]: Key extends U ?\n      GeneratorRule<Context, Key, RET, ARGS> :\n        (RuleDefs[Key] extends GeneratorRule<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: GeneratorRule<Context, U, RET, ARGS>):\n  GeneratorBuilder<Context, Names | U, {[K in Names | U]: K extends Names ?\n      (RuleDefs[K] extends GeneratorRule<Context, K> ? RuleDefs[K] : never)\n    : (K extends U ? GeneratorRule<Context, K, RET, ARGS> : never)\n  }> {\n    const self = <GeneratorBuilder<Context, Names | U, {[K in Names | U]: K extends Names ?\n        (RuleDefs[K] extends GeneratorRule<Context, K> ? RuleDefs[K] : never)\n      : (K extends U ? GeneratorRule<Context, K, RET, ARGS> : never) }>>\n      <unknown> this;\n    const rules = <Record<string, GeneratorRule<Context>>> self.rules;\n    if (rules[rule.name] !== undefined && rules[rule.name] !== rule) {\n      throw new Error(`Rule ${rule.name} already exists in the GeneratorBuilder`);\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, GeneratorRule<Context, U, RET, ARGS>>,\n  ): GeneratorBuilder<Context, Names | U, {[K in Names | U]: K extends Names ?\n      (RuleDefs[K] extends GeneratorRule<Context, K> ? RuleDefs[K] : never)\n    : (K extends U ? GeneratorRule<Context, K, RET, ARGS> : never)\n  }> {\n    return this.addRuleRedundant(rule);\n  }\n\n  public addMany<U extends readonly GeneratorRule<Context>[]>(\n    ...rules: CheckOverlap<GenNamesFromList<U>, Names, U>\n  ): GeneratorBuilder<\n    Context,\n    Names | GenNamesFromList<U>,\n    {[K in Names | GenNamesFromList<U>]:\n      K extends keyof GenRulesToObject<typeof rules> ? (\n        GenRulesToObject<typeof rules>[K] extends GeneratorRule<Context, K> ? GenRulesToObject<typeof rules>[K] : never\n      ) : (\n        K extends Names ? (RuleDefs[K] extends GeneratorRule<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  GeneratorBuilder<Context, Exclude<Names, U>, {[K in Exclude<Names, U>]:\n    RuleDefs[K] extends GeneratorRule<Context, K> ? RuleDefs[K] : never }> {\n    delete this.rules[ruleName];\n    return <GeneratorBuilder<Context, Exclude<Names, U>, {[K in Exclude<Names, U>]:\n      RuleDefs[K] extends GeneratorRule<Context, K> ? RuleDefs[K] : never }>>\n      <unknown> this;\n  }\n\n  /**\n   * Merge this grammar GeneratorBuilder 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 GenRuleMap<OtherNames>,\n    OW extends readonly GeneratorRule<Context>[],\n  >(\n    GeneratorBuilder: GeneratorBuilder<Context, OtherNames, OtherRules>,\n    overridingRules: OW,\n  ):\n    GeneratorBuilder<\n      Context,\n      Names | OtherNames | GenNamesFromList<OW>,\n      {[K in Names | OtherNames | GenNamesFromList<OW>]:\n        K extends keyof GenRulesToObject<OW> ? (\n          GenRulesToObject<OW>[K] extends GeneratorRule<Context, K> ? GenRulesToObject<OW>[K] : never\n        )\n          : (\n              K extends Names ? (RuleDefs[K] extends GeneratorRule<Context, K> ? RuleDefs[K] : never)\n                : K extends OtherNames ? (OtherRules[K] extends GeneratorRule<Context, K> ? OtherRules[K] : never)\n                  : 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, GeneratorRule<Context>> = { ...GeneratorBuilder.rules };\n    const myRules: Record<string, GeneratorRule<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 GeneratorBuilder, 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  public build(): GeneratorFromRules<Context, Names, RuleDefs> {\n    return <GeneratorFromRules<Context, Names, RuleDefs>> new DynamicGenerator(this.rules);\n  }\n}\n"]}
+{"version":3,"file":"generatorBuilder.js","sourceRoot":"","sources":["generatorBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import type { ParseNamesFromList } from '../parser-builder/builderTypes';\nimport type { CheckOverlap } from '../utils';\nimport type { GeneratorFromRules, GenRuleMap, GenRulesToObject } from './builderTypes';\nimport { DynamicGenerator } from './dynamicGenerator';\nimport type { GeneratorRule } from './generatorTypes';\n\n/**\n * Converts a list of ruledefs to a record mapping a name to the corresponding ruledef.\n */\nfunction listToRuleDefMap<T extends readonly GeneratorRule[]>(rules: T): GenRulesToObject<T> {\n  const newRules: Record<string, GeneratorRule> = {};\n  for (const rule of rules) {\n    newRules[rule.name] = rule;\n  }\n  return <GenRulesToObject<T>>newRules;\n}\n\nexport class GeneratorBuilder<Context, Names extends string, RuleDefs extends GenRuleMap<Names>> {\n  /**\n   * Create a GeneratorBuilder from some initial grammar rules or an existing GeneratorBuilder.\n   * If a GeneratorBuilder is provided, a new copy will be created.\n   */\n  public static create<Context, Names extends string, RuleDefs extends GenRuleMap<Names>>(\n    args: GeneratorBuilder<Context, Names, RuleDefs>\n  ): GeneratorBuilder<Context, Names, RuleDefs>;\n  public static create<\n    Rules extends readonly GeneratorRule[] = readonly GeneratorRule[],\n    Context = Rules[0] extends GeneratorRule<infer context> ? context : never,\n    Names extends string = ParseNamesFromList<Rules>,\n    RuleDefs extends GenRuleMap<Names> = GenRulesToObject<Rules>,\n  >(rules: Rules): GeneratorBuilder<Context, Names, RuleDefs>;\n  public static create<\n    Rules extends readonly GeneratorRule[] = readonly GeneratorRule[],\n    Context = Rules[0] extends GeneratorRule<infer context> ? context : never,\n    Names extends string = ParseNamesFromList<Rules>,\n    RuleDefs extends GenRuleMap<Names> = GenRulesToObject<Rules>,\n  >(\n    start: Rules | GeneratorBuilder<Context, Names, RuleDefs>,\n  ): GeneratorBuilder<Context, Names, RuleDefs> {\n    if (start instanceof GeneratorBuilder) {\n      return new GeneratorBuilder({ ...start.rules });\n    }\n    return <GeneratorBuilder<Context, Names, RuleDefs>> <unknown> new GeneratorBuilder(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>(): GeneratorBuilder<NewContext, Names, RuleDefs> {\n    return <GeneratorBuilder<NewContext, Names, RuleDefs>> <unknown> this;\n  }\n\n  public typePatch<Patch extends {[Key in Names]?: any }>():\n  GeneratorBuilder<Context, Names, {[Key in Names]: Key extends keyof Patch ? (\n    RuleDefs[Key] extends GeneratorRule<Context, Key, any, infer Args> ?\n      GeneratorRule<Context, Key, Patch[Key], Args> : never\n  ) : (RuleDefs[Key] extends GeneratorRule<Context, Key> ? RuleDefs[Key] : never) }> {\n    return <GeneratorBuilder<Context, Names, {[Key in Names]: Key extends keyof Patch ? (\n      RuleDefs[Key] extends GeneratorRule<Context, Key, any, infer Args> ?\n        GeneratorRule<Context, Key, Patch[Key], Args> : never\n    ) : (RuleDefs[Key] extends GeneratorRule<Context, Key> ? RuleDefs[Key] : never) }>> <unknown> this;\n  }\n\n  /**\n   * Change the implementation of an existing generator rule.\n   */\n  public patchRule<U extends Names, RET, ARGS>(patch: GeneratorRule<Context, U, RET, ARGS>):\n  GeneratorBuilder<Context, Names, {[Key in Names]: Key extends U ?\n    GeneratorRule<Context, Key, RET, ARGS> :\n      (RuleDefs[Key] extends GeneratorRule<Context, Key> ? RuleDefs[Key] : never)\n  } > {\n    const self = <GeneratorBuilder<Context, Names, {[Key in Names]: Key extends U ?\n      GeneratorRule<Context, Key, RET, ARGS> :\n        (RuleDefs[Key] extends GeneratorRule<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: GeneratorRule<Context, U, RET, ARGS>):\n  GeneratorBuilder<Context, Names | U, {[K in Names | U]: K extends Names ?\n      (RuleDefs[K] extends GeneratorRule<Context, K> ? RuleDefs[K] : never)\n    : (K extends U ? GeneratorRule<Context, K, RET, ARGS> : never)\n  }> {\n    const self = <GeneratorBuilder<Context, Names | U, {[K in Names | U]: K extends Names ?\n        (RuleDefs[K] extends GeneratorRule<Context, K> ? RuleDefs[K] : never)\n      : (K extends U ? GeneratorRule<Context, K, RET, ARGS> : never) }>>\n      <unknown> this;\n    const rules = <Record<string, GeneratorRule<Context>>> self.rules;\n    if (rules[rule.name] !== undefined && rules[rule.name] !== rule) {\n      throw new Error(`Rule ${rule.name} already exists in the GeneratorBuilder`);\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, GeneratorRule<Context, U, RET, ARGS>>,\n  ): GeneratorBuilder<Context, Names | U, {[K in Names | U]: K extends Names ?\n      (RuleDefs[K] extends GeneratorRule<Context, K> ? RuleDefs[K] : never)\n    : (K extends U ? GeneratorRule<Context, K, RET, ARGS> : never)\n  }> {\n    return this.addRuleRedundant(rule);\n  }\n\n  public addMany<U extends readonly GeneratorRule<Context>[]>(\n    ...rules: CheckOverlap<ParseNamesFromList<U>, Names, U>\n  ): GeneratorBuilder<\n    Context,\n    Names | ParseNamesFromList<U>,\n    {[K in Names | ParseNamesFromList<U>]:\n      K extends keyof GenRulesToObject<typeof rules> ? (\n        GenRulesToObject<typeof rules>[K] extends GeneratorRule<Context, K> ? GenRulesToObject<typeof rules>[K] : never\n      ) : (\n        K extends Names ? (RuleDefs[K] extends GeneratorRule<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  GeneratorBuilder<Context, Exclude<Names, U>, {[K in Exclude<Names, U>]:\n    RuleDefs[K] extends GeneratorRule<Context, K> ? RuleDefs[K] : never }> {\n    delete this.rules[ruleName];\n    return <GeneratorBuilder<Context, Exclude<Names, U>, {[K in Exclude<Names, U>]:\n      RuleDefs[K] extends GeneratorRule<Context, K> ? RuleDefs[K] : never }>>\n      <unknown> this;\n  }\n\n  /**\n   * Merge this grammar GeneratorBuilder 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 GenRuleMap<OtherNames>,\n    OW extends readonly GeneratorRule<Context>[],\n  >(\n    GeneratorBuilder: GeneratorBuilder<Context, OtherNames, OtherRules>,\n    overridingRules: OW,\n  ):\n    GeneratorBuilder<\n      Context,\n      Names | OtherNames | ParseNamesFromList<OW>,\n      {[K in Names | OtherNames | ParseNamesFromList<OW>]:\n        K extends keyof GenRulesToObject<OW> ? (\n          GenRulesToObject<OW>[K] extends GeneratorRule<Context, K> ? GenRulesToObject<OW>[K] : never\n        )\n          : (\n              K extends Names ? (RuleDefs[K] extends GeneratorRule<Context, K> ? RuleDefs[K] : never)\n                : K extends OtherNames ? (OtherRules[K] extends GeneratorRule<Context, K> ? OtherRules[K] : never)\n                  : 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, GeneratorRule<Context>> = { ...GeneratorBuilder.rules };\n    const myRules: Record<string, GeneratorRule<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 GeneratorBuilder, 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  public build(): GeneratorFromRules<Context, Names, RuleDefs> {\n    return <GeneratorFromRules<Context, Names, RuleDefs>> new DynamicGenerator(this.rules);\n  }\n}\n"]}

package/lib/index.cjs

@@ -22,11 +22,12 @@ var index_exports = {};
 __export(index_exports, {
   CoreFactory: () => CoreFactory,
   GeneratorBuilder: () => GeneratorBuilder,
+  IndirBuilder: () => IndirBuilder,
   LexerBuilder: () => LexerBuilder,
   ParserBuilder: () => ParserBuilder,
-  RangeArithmetic: () => RangeArithmetic,
   Transformer: () => Transformer,
   createToken: () => createToken2,
+  listToIndirectionMap: () => listToIndirectionMap,
   unCapitalize: () => unCapitalize
 });
 module.exports = __toCommonJS(index_exports);
@@ -363,6 +364,103 @@ var GeneratorBuilder = class _GeneratorBuilder {
   }
 };
 
+// lib/indirection-builder/helpers.ts
+function listToIndirectionMap(rules) {
+  const newRules = {};
+  for (const rule of rules) {
+    newRules[rule.name] = rule;
+  }
+  return newRules;
+}
+
+// lib/indirection-builder/dynamicIndirected.ts
+var DynamicIndirect = class {
+  constructor(rules) {
+    this.rules = rules;
+    this.__context = void 0;
+    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;
+  }
+};
+
+// lib/indirection-builder/IndirBuilder.ts
+var IndirBuilder = 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 self2 = this;
+    self2.rules[patch.name] = patch;
+    return self2;
+  }
+  /**
+   * Add an indirection function. If the rule already exists, but the implementation differs, an error will be thrown.
+   */
+  addRuleRedundant(rule) {
+    const self2 = this;
+    const rules = self2.rules;
+    if (rules[rule.name] !== void 0 && rules[rule.name] !== rule) {
+      throw new Error(`Function ${rule.name} already exists in the builder`);
+    }
+    rules[rule.name] = rule;
+    return self2;
+  }
+  /**
+   * Add a rule to the grammar. Will raise a typescript error if the rule already exists in the grammar.
+   */
+  addRule(rule) {
+    return this.addRuleRedundant(rule);
+  }
+  addMany(...rules) {
+    this.rules = { ...this.rules, ...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);
+  }
+};
+
 // ../../node_modules/lodash-es/_freeGlobal.js
 var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
 var freeGlobal_default = freeGlobal;
@@ -9954,73 +10052,6 @@ function createToken2(config) {
   return createToken(config);
 }
 
-// lib/RangeArithmetic.ts
-var RangeArithmetic = class _RangeArithmetic {
-  constructor(start, end) {
-    this.ranges = [];
-    this.initRange = _RangeArithmetic.validate(start, end);
-    this.ranges.push(this.initRange);
-  }
-  static validate(...range) {
-    const [start, end] = range;
-    if (start >= end) {
-      throw new Error("Invalid range");
-    }
-    return range;
-  }
-  static substractRange(included, ...range) {
-    const [sMinus, eMinus] = _RangeArithmetic.validate(...range);
-    return included.flatMap(([sCur, eCur]) => {
-      if (sCur < sMinus && eMinus < eCur) {
-        return [[sCur, sMinus], [eMinus, eCur]];
-      }
-      if (sMinus <= sCur && sCur < eMinus && eMinus < eCur) {
-        return [[eMinus, eCur]];
-      }
-      if (sCur < sMinus && sMinus < eCur && eCur <= eMinus) {
-        return [[sCur, sMinus]];
-      }
-      if (sMinus <= sCur && eCur <= eMinus) {
-        return [];
-      }
-      return [[sCur, eCur]];
-    });
-  }
-  subtract(...range) {
-    this.ranges = _RangeArithmetic.substractRange(this.ranges, ...range);
-    return this;
-  }
-  negate() {
-    let iter = [this.initRange];
-    for (const range of this.ranges) {
-      iter = _RangeArithmetic.substractRange(iter, ...range);
-    }
-    this.ranges = iter;
-    return this;
-  }
-  projection(...range) {
-    const [sProj, eProj] = range;
-    if (sProj >= eProj) {
-      return [];
-    }
-    return this.ranges.flatMap(([sCur, eCur]) => {
-      if (sCur < sProj && eProj < eCur) {
-        return [[sProj, eProj]];
-      }
-      if (sProj <= sCur && eCur <= eProj) {
-        return [[sCur, eCur]];
-      }
-      if (sProj <= sCur && sCur < eProj && eProj < eCur) {
-        return [[sCur, eProj]];
-      }
-      if (sCur < sProj && sProj < eCur && eCur < eProj) {
-        return [[sProj, eCur]];
-      }
-      return [];
-    });
-  }
-};
-
 // lib/Transformer.ts
 var Transformer = class {
   transformNode(curObject, searchType, patch) {

package/lib/index.d.ts

@@ -1,12 +1,13 @@
 export * from './generator-builder/builderTypes';
 export * from './generator-builder/generatorBuilder';
 export * from './generator-builder/generatorTypes';
+export * from './indirection-builder/helpers';
+export * from './indirection-builder/IndirBuilder';
 export * from './lexer-builder/LexerBuilder';
 export * from './parser-builder/builderTypes';
 export * from './parser-builder/parserBuilder';
 export * from './parser-builder/ruleDefTypes';
 export * from './utils';
-export * from './RangeArithmetic';
 export * from './CoreFactory';
 export * from './nodeTypings';
 export * from './Transformer';

package/lib/index.js

@@ -2,6 +2,9 @@
 export * from './generator-builder/builderTypes';
 export * from './generator-builder/generatorBuilder';
 export * from './generator-builder/generatorTypes';
+// Export Indirection Builder
+export * from './indirection-builder/helpers';
+export * from './indirection-builder/IndirBuilder';
 // Export lexer builder
 export * from './lexer-builder/LexerBuilder';
 // Export parser builder
@@ -10,7 +13,6 @@ export * from './parser-builder/parserBuilder';
 export * from './parser-builder/ruleDefTypes';
 // Export general types
 export * from './utils';
-export * from './RangeArithmetic';
 export * from './CoreFactory';
 export * from './nodeTypings';
 export * from './Transformer';

package/lib/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA,2BAA2B;AAC3B,cAAc,kCAAkC,CAAC;AACjD,cAAc,sCAAsC,CAAC;AACrD,cAAc,oCAAoC,CAAC;AACnD,uBAAuB;AACvB,cAAc,8BAA8B,CAAC;AAC7C,wBAAwB;AACxB,cAAc,+BAA+B,CAAC;AAC9C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,+BAA+B,CAAC;AAC9C,uBAAuB;AACvB,cAAc,SAAS,CAAC;AACxB,cAAc,mBAAmB,CAAC;AAClC,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC","sourcesContent":["// Export generator builder\nexport * from './generator-builder/builderTypes';\nexport * from './generator-builder/generatorBuilder';\nexport * from './generator-builder/generatorTypes';\n// Export lexer builder\nexport * from './lexer-builder/LexerBuilder';\n// Export parser builder\nexport * from './parser-builder/builderTypes';\nexport * from './parser-builder/parserBuilder';\nexport * from './parser-builder/ruleDefTypes';\n// Export general types\nexport * from './utils';\nexport * from './RangeArithmetic';\nexport * from './CoreFactory';\nexport * from './nodeTypings';\nexport * from './Transformer';\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA,2BAA2B;AAC3B,cAAc,kCAAkC,CAAC;AACjD,cAAc,sCAAsC,CAAC;AACrD,cAAc,oCAAoC,CAAC;AACnD,6BAA6B;AAC7B,cAAc,+BAA+B,CAAC;AAC9C,cAAc,oCAAoC,CAAC;AACnD,uBAAuB;AACvB,cAAc,8BAA8B,CAAC;AAC7C,wBAAwB;AACxB,cAAc,+BAA+B,CAAC;AAC9C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,+BAA+B,CAAC;AAC9C,uBAAuB;AACvB,cAAc,SAAS,CAAC;AACxB,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC","sourcesContent":["// Export generator builder\nexport * from './generator-builder/builderTypes';\nexport * from './generator-builder/generatorBuilder';\nexport * from './generator-builder/generatorTypes';\n// Export Indirection Builder\nexport * from './indirection-builder/helpers';\nexport * from './indirection-builder/IndirBuilder';\n// Export lexer builder\nexport * from './lexer-builder/LexerBuilder';\n// Export parser builder\nexport * from './parser-builder/builderTypes';\nexport * from './parser-builder/parserBuilder';\nexport * from './parser-builder/ruleDefTypes';\n// Export general types\nexport * from './utils';\nexport * from './CoreFactory';\nexport * from './nodeTypings';\nexport * from './Transformer';\n"]}

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/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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@traqula/core",
   "type": "module",
-  "version": "0.0.1-alpha.9+427f381",
+  "version": "0.0.2",
   "description": "Core components of Traqula",
   "lsd:module": true,
   "license": "MIT",
@@ -15,8 +15,11 @@
   },
   "sideEffects": false,
   "exports": {
-    "import": "./lib/index.js",
-    "require": "./lib/index.cjs"
+    "./package.json": "./package.json",
+    ".": {
+      "import": "./lib/index.js",
+      "require": "./lib/index.cjs"
+    }
   },
   "main": "lib/index.js",
   "publishConfig": {
@@ -43,5 +46,5 @@
   "devDependencies": {
     "@chevrotain/types": "^11.0.3"
   },
-  "gitHead": "427f3819138dd557621cae40c761213573e60017"
+  "gitHead": "8d4d4a6b155e14db6e1f87a0b855ade7515c4e35"
 }

package/lib/RangeArithmetic.d.ts

@@ -1,14 +0,0 @@
-/**
- * Starting inclusive, ending exclusive
- */
-export type Range<A extends number = number, B extends number = number> = [A, B];
-export declare class RangeArithmetic {
-    ranges: Range[];
-    private readonly initRange;
-    constructor(start: number, end: number);
-    private static validate;
-    private static substractRange;
-    subtract(...range: Range): this;
-    negate(): this;
-    projection(...range: Range): Range[];
-}

package/lib/RangeArithmetic.js

@@ -1,71 +0,0 @@
-export class RangeArithmetic {
-    constructor(start, end) {
-        this.ranges = [];
-        this.initRange = RangeArithmetic.validate(start, end);
-        this.ranges.push(this.initRange);
-    }
-    static validate(...range) {
-        const [start, end] = range;
-        if (start >= end) {
-            throw new Error('Invalid range');
-        }
-        return range;
-    }
-    static substractRange(included, ...range) {
-        const [sMinus, eMinus] = RangeArithmetic.validate(...range);
-        return included.flatMap(([sCur, eCur]) => {
-            // Split in half
-            if (sCur < sMinus && eMinus < eCur) {
-                return [[sCur, sMinus], [eMinus, eCur]];
-            }
-            if (sMinus <= sCur && sCur < eMinus && eMinus < eCur) {
-                return [[eMinus, eCur]];
-            }
-            if (sCur < sMinus && sMinus < eCur && eCur <= eMinus) {
-                return [[sCur, sMinus]];
-            }
-            if (sMinus <= sCur && eCur <= eMinus) {
-                return [];
-            }
-            return [[sCur, eCur]];
-        });
-    }
-    subtract(...range) {
-        this.ranges = RangeArithmetic.substractRange(this.ranges, ...range);
-        return this;
-    }
-    negate() {
-        // Can be optimized
-        let iter = [this.initRange];
-        for (const range of this.ranges) {
-            iter = RangeArithmetic.substractRange(iter, ...range);
-        }
-        this.ranges = iter;
-        return this;
-    }
-    projection(...range) {
-        const [sProj, eProj] = range;
-        if (sProj >= eProj) {
-            return [];
-        }
-        return this.ranges.flatMap(([sCur, eCur]) => {
-            // If projection is inside the range
-            if (sCur < sProj && eProj < eCur) {
-                return [[sProj, eProj]];
-            }
-            // Projection wraps around
-            if (sProj <= sCur && eCur <= eProj) {
-                return [[sCur, eCur]];
-            }
-            // Matches left side
-            if (sProj <= sCur && sCur < eProj && eProj < eCur) {
-                return [[sCur, eProj]];
-            }
-            if (sCur < sProj && sProj < eCur && eCur < eProj) {
-                return [[sProj, eCur]];
-            }
-            return [];
-        });
-    }
-}
-//# sourceMappingURL=RangeArithmetic.js.map

package/lib/RangeArithmetic.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"RangeArithmetic.js","sourceRoot":"","sources":["RangeArithmetic.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Starting inclusive, ending exclusive\n */\nexport type Range<A extends number = number, B extends number = number> = [A, B];\n\nexport class RangeArithmetic {\n  public ranges: Range[] = [];\n  private readonly initRange: Range;\n  public constructor(start: number, end: number) {\n    this.initRange = RangeArithmetic.validate(start, end);\n    this.ranges.push(this.initRange);\n  }\n\n  private static validate(...range: Range): Range {\n    const [ start, end ] = range;\n    if (start >= end) {\n      throw new Error('Invalid range');\n    }\n    return range;\n  }\n\n  private static substractRange(included: Range[], ...range: Range): Range[] {\n    const [ sMinus, eMinus ] = RangeArithmetic.validate(...range);\n\n    return included.flatMap(([ sCur, eCur ]) => {\n      // Split in half\n      if (sCur < sMinus && eMinus < eCur) {\n        return [[ sCur, sMinus ], [ eMinus, eCur ]];\n      }\n      if (sMinus <= sCur && sCur < eMinus && eMinus < eCur) {\n        return [[ eMinus, eCur ]];\n      }\n      if (sCur < sMinus && sMinus < eCur && eCur <= eMinus) {\n        return [[ sCur, sMinus ]];\n      }\n      if (sMinus <= sCur && eCur <= eMinus) {\n        return [];\n      }\n      return [[ sCur, eCur ]];\n    });\n  }\n\n  public subtract(...range: Range): this {\n    this.ranges = RangeArithmetic.substractRange(this.ranges, ...range);\n    return this;\n  }\n\n  public negate(): this {\n    // Can be optimized\n    let iter = [ this.initRange ];\n    for (const range of this.ranges) {\n      iter = RangeArithmetic.substractRange(iter, ...range);\n    }\n    this.ranges = iter;\n    return this;\n  }\n\n  public projection(...range: Range): Range[] {\n    const [ sProj, eProj ] = range;\n    if (sProj >= eProj) {\n      return [];\n    }\n    return this.ranges.flatMap(([ sCur, eCur ]) => {\n      // If projection is inside the range\n      if (sCur < sProj && eProj < eCur) {\n        return [[ sProj, eProj ]];\n      }\n      // Projection wraps around\n      if (sProj <= sCur && eCur <= eProj) {\n        return [[ sCur, eCur ]];\n      }\n      // Matches left side\n      if (sProj <= sCur && sCur < eProj && eProj < eCur) {\n        return [[ sCur, eProj ]];\n      }\n      if (sCur < sProj && sProj < eCur && eCur < eProj) {\n        return [[ sProj, eCur ]];\n      }\n      return [];\n    });\n  }\n}\n"]}