@traqula/core 0.0.1-alpha.176 → 0.0.1

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

@@ -1 +1 @@
-{"version":3,"file":"generatorBuilder.js","sourceRoot":"","sources":["generatorBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import type { CheckOverlap } from '../utils';\nimport type { GeneratorFromRules, GenNamesFromList, 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 createBuilder<Context, Names extends string, RuleDefs extends GenRuleMap<Names>>(\n    args: GeneratorBuilder<Context, Names, RuleDefs>\n  ): GeneratorBuilder<Context, Names, RuleDefs>;\n  public static createBuilder<\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 createBuilder<\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 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/generator-builder/generatorTypes.d.ts

@@ -1,3 +1,4 @@
+import type { Localized } from '../nodeTypings';
 /**
  * Type used to declare generator rules.
  */
@@ -11,8 +12,10 @@ Context = any,
  */
 NameType extends string = string, 
 /**
- * Type that will be returned after a correct parse of this rule.
- * This type will be the return type of calling SUBRULE with this grammar rule.
+ * Type that of the AST that we will generate the string for.
+ * This type will be the provided when calling SUBRULE with this generator rule.
+ * Generation happens on a per AST node basis.
+ * The core will implement the generation as such. If this ever changes, we will cross that bridge when we get there.
  */
 ReturnType = any, 
 /**
@@ -20,8 +23,14 @@ ReturnType = any,
  */
 ParamType = any> = {
     name: NameType;
-    gImpl: (def: RuleDefArg) => (ast: ReturnType, context: Context, params: ParamType) => string;
+    gImpl: (def: RuleDefArg) => (ast: ReturnType, context: Context, params: ParamType) => void;
 };
 export interface RuleDefArg {
-    SUBRULE: <T, U>(cstDef: GeneratorRule<any, any, T, U>, input: T, arg: U) => string;
+    SUBRULE: <T, U>(cstDef: GeneratorRule<any, any, T, U>, input: T, arg: U) => void;
+    PRINT: (...args: string[]) => void;
+    PRINT_SPACE_LEFT: (...args: string[]) => void;
+    PRINT_WORD: (...args: string[]) => void;
+    PRINT_WORDS: (...args: string[]) => void;
+    HANDLE_LOC: <T>(loc: Localized, nodeHandle: () => T) => T | undefined;
+    CATCHUP: (until: number) => void;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"generatorTypes.js","sourceRoot":"","sources":["generatorTypes.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Type used to declare generator rules.\n */\nexport type GeneratorRule<\n  /**\n   * Context object available in rule implementation.\n   */\n  Context = any,\n  /**\n   * Name of grammar rule, should be a strict subtype of string like 'myGrammarRule'.\n   */\n  NameType extends string = string,\n  /**\n   * Type that will be returned after a correct parse of this rule.\n   * This type will be the return type of calling SUBRULE with this grammar rule.\n   */\n  ReturnType = any,\n  /**\n   * Function arguments that can be given to convey the state of the current parse operation.\n   */\n  ParamType = any,\n> = {\n  name: NameType;\n  gImpl: (def: RuleDefArg) =>\n  (ast: ReturnType, context: Context, params: ParamType) => string;\n};\n\nexport interface RuleDefArg {\n  SUBRULE: <T, U>(cstDef: GeneratorRule<any, any, T, U>, input: T, arg: U) => string;\n}\n"]}
+{"version":3,"file":"generatorTypes.js","sourceRoot":"","sources":["generatorTypes.ts"],"names":[],"mappings":"","sourcesContent":["import type { Localized } from '../nodeTypings';\n\n/**\n * Type used to declare generator rules.\n */\nexport type GeneratorRule<\n  /**\n   * Context object available in rule implementation.\n   */\n  Context = any,\n  /**\n   * Name of grammar rule, should be a strict subtype of string like 'myGrammarRule'.\n   */\n  NameType extends string = string,\n  /**\n   * Type that of the AST that we will generate the string for.\n   * This type will be the provided when calling SUBRULE with this generator rule.\n   * Generation happens on a per AST node basis.\n   * The core will implement the generation as such. If this ever changes, we will cross that bridge when we get there.\n   */\n  ReturnType = any,\n  /**\n   * Function arguments that can be given to convey the state of the current parse operation.\n   */\n  ParamType = any,\n> = {\n  name: NameType;\n  gImpl: (def: RuleDefArg) =>\n  (ast: ReturnType, context: Context, params: ParamType) => void;\n};\n\nexport interface RuleDefArg {\n  SUBRULE: <T, U>(cstDef: GeneratorRule<any, any, T, U>, input: T, arg: U) => void;\n  PRINT: (...args: string[]) => void;\n  PRINT_SPACE_LEFT: (...args: string[]) => void;\n  PRINT_WORD: (...args: string[]) => void;\n  PRINT_WORDS: (...args: string[]) => void;\n  HANDLE_LOC: <T>(loc: Localized, nodeHandle: () => T) => T | undefined;\n  CATCHUP: (until: number) => void;\n}\n"]}

package/lib/index.cjs

@@ -20,31 +20,243 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // lib/index.ts
 var index_exports = {};
 __export(index_exports, {
+  CoreFactory: () => CoreFactory,
   GeneratorBuilder: () => GeneratorBuilder,
+  IndirBuilder: () => IndirBuilder,
   LexerBuilder: () => LexerBuilder,
   ParserBuilder: () => ParserBuilder,
+  Transformer: () => Transformer,
   createToken: () => createToken2,
+  listToIndirectionMap: () => listToIndirectionMap,
   unCapitalize: () => unCapitalize
 });
 module.exports = __toCommonJS(index_exports);
 
+// lib/CoreFactory.ts
+var CoreFactory = class {
+  wrap(val, loc) {
+    return { val, loc };
+  }
+  isLocalized(obj) {
+    return typeof obj === "object" && obj !== null && "loc" in obj && typeof obj.loc === "object" && obj.loc !== null && "sourceLocationType" in obj.loc;
+  }
+  sourceLocation(...elements) {
+    const pureElements = elements.filter((x) => x !== void 0);
+    if (pureElements.length === 0) {
+      return this.sourceLocationNoMaterialize();
+    }
+    const filtered = pureElements.filter((element) => !this.isLocalized(element) || this.isSourceLocationSource(element.loc) || this.isSourceLocationStringReplace(element.loc) || this.isSourceLocationNodeReplace(element.loc));
+    if (filtered.length === 0) {
+      return this.gen();
+    }
+    const first2 = filtered[0];
+    const last2 = filtered.at(-1);
+    return {
+      sourceLocationType: "source",
+      start: this.isLocalized(first2) ? first2.loc.start : first2.startOffset,
+      end: this.isLocalized(last2) ? last2.loc.end : last2.endOffset + 1
+    };
+  }
+  sourceLocationNoMaterialize() {
+    return { sourceLocationType: "noMaterialize" };
+  }
+  /**
+   * Returns a copy of the argument that is not materialized
+   */
+  dematerialized(arg) {
+    return { ...arg, loc: this.sourceLocationNoMaterialize() };
+  }
+  safeObjectTransform(value, mapper) {
+    if (value && typeof value === "object") {
+      if (Array.isArray(value)) {
+        return value.map((x) => this.safeObjectTransform(x, mapper));
+      }
+      return mapper(value);
+    }
+    return value;
+  }
+  forcedAutoGenTree(obj) {
+    const copy = { ...obj };
+    for (const [key, value] of Object.entries(copy)) {
+      copy[key] = this.safeObjectTransform(value, (obj2) => this.forcedAutoGenTree(obj2));
+    }
+    if (this.isLocalized(copy)) {
+      copy.loc = this.gen();
+    }
+    return copy;
+  }
+  forceMaterialized(arg) {
+    if (this.isSourceLocationNoMaterialize(arg.loc)) {
+      return this.forcedAutoGenTree(arg);
+    }
+    return { ...arg };
+  }
+  isSourceLocation(loc) {
+    return "sourceLocationType" in loc;
+  }
+  sourceLocationSource(start, end) {
+    return {
+      sourceLocationType: "source",
+      start,
+      end
+    };
+  }
+  gen() {
+    return { sourceLocationType: "autoGenerate" };
+  }
+  isSourceLocationSource(loc) {
+    return this.isSourceLocation(loc) && loc.sourceLocationType === "source";
+  }
+  isSourceLocationStringReplace(loc) {
+    return this.isSourceLocation(loc) && loc.sourceLocationType === "stringReplace";
+  }
+  sourceLocationNodeReplaceUnsafe(loc) {
+    if (this.isSourceLocationSource(loc)) {
+      return this.sourceLocationNodeReplace(loc);
+    }
+    throw new Error("not possible");
+  }
+  sourceLocationNodeReplace(startOrLoc, end) {
+    let starting;
+    let ending;
+    if (typeof startOrLoc === "number") {
+      starting = startOrLoc;
+      ending = end;
+    } else {
+      starting = startOrLoc.start;
+      ending = startOrLoc.end;
+    }
+    return {
+      sourceLocationType: "nodeReplace",
+      start: starting,
+      end: ending
+    };
+  }
+  isSourceLocationNodeReplace(loc) {
+    return this.isSourceLocation(loc) && loc.sourceLocationType === "nodeReplace";
+  }
+  isSourceLocationNodeAutoGenerate(loc) {
+    return this.isSourceLocation(loc) && loc.sourceLocationType === "autoGenerate";
+  }
+  nodeShouldPrint(node) {
+    return this.isSourceLocationNodeReplace(node.loc) || this.isSourceLocationNodeAutoGenerate(node.loc);
+  }
+  printFilter(node, callback) {
+    if (this.nodeShouldPrint(node)) {
+      callback();
+    }
+  }
+  isSourceLocationNoMaterialize(loc) {
+    return this.isSourceLocation(loc) && loc.sourceLocationType === "noMaterialize";
+  }
+  isOfType(obj, type) {
+    const casted = obj;
+    return casted.type === type;
+  }
+  isOfSubType(obj, type, subType) {
+    const temp = obj;
+    return temp.type === type && temp.subType === subType;
+  }
+};
+
 // lib/generator-builder/dynamicGenerator.ts
 var DynamicGenerator = class {
   constructor(rules) {
+    this.rules = rules;
+    this.factory = new CoreFactory();
     this.__context = void 0;
-    const selfRef = {
-      SUBRULE: (cstDef, input, arg) => {
-        const def = rules[cstDef.name];
-        if (!def) {
-          throw new Error(`Rule ${cstDef.name} not found`);
+    this.origSource = "";
+    this.generatedUntil = 0;
+    this.stringBuilder = [];
+    this.subrule = (cstDef, ast, arg) => {
+      const def = this.rules[cstDef.name];
+      if (!def) {
+        throw new Error(`Rule ${cstDef.name} not found`);
+      }
+      const generate = () => def.gImpl({
+        SUBRULE: this.subrule,
+        PRINT: this.print,
+        PRINT_SPACE_LEFT: this.printSpaceLeft,
+        PRINT_WORD: this.printWord,
+        PRINT_WORDS: this.printWords,
+        CATCHUP: this.catchup,
+        HANDLE_LOC: this.handleLoc
+      })(ast, this.getSafeContext(), arg);
+      if (this.factory.isLocalized(ast)) {
+        this.handleLoc(ast, generate);
+      } else {
+        generate();
+      }
+    };
+    this.handleLoc = (localized, handle) => {
+      if (this.factory.isSourceLocationNoMaterialize(localized.loc)) {
+        return;
+      }
+      if (this.factory.isSourceLocationStringReplace(localized.loc)) {
+        this.catchup(localized.loc.start);
+        this.print(localized.loc.newSource);
+        this.generatedUntil = localized.loc.end;
+        return;
+      }
+      if (this.factory.isSourceLocationNodeReplace(localized.loc)) {
+        this.catchup(localized.loc.start);
+        this.generatedUntil = localized.loc.end;
+      }
+      if (this.factory.isSourceLocationSource(localized.loc)) {
+        this.catchup(localized.loc.start);
+      }
+      const ret = handle();
+      if (this.factory.isSourceLocationSource(localized.loc)) {
+        this.catchup(localized.loc.end);
+      }
+      return ret;
+    };
+    this.catchup = (until) => {
+      const start = this.generatedUntil;
+      if (start < until) {
+        this.print(this.origSource.slice(start, until));
+      }
+      this.generatedUntil = Math.max(this.generatedUntil, until);
+    };
+    this.print = (...args) => {
+      const pureArgs = args.filter((x) => x.length > 0);
+      if (pureArgs.length > 0) {
+        const [head2, ...tail] = pureArgs;
+        if (this.expectsSpace) {
+          this.expectsSpace = false;
+          const blanks = /* @__PURE__ */ new Set(["\n", " ", "	"]);
+          if (this.stringBuilder.length > 0 && !(blanks.has(head2[0]) || blanks.has(this.stringBuilder.at(-1).at(-1)))) {
+            this.stringBuilder.push(" ");
+          }
         }
-        return def.gImpl(selfRef)(input, this.getSafeContext(), arg);
+        this.stringBuilder.push(head2);
+        this.stringBuilder.push(...tail);
+      }
+    };
+    this.printWord = (...args) => {
+      this.expectsSpace = true;
+      this.print(...args);
+      this.expectsSpace = true;
+    };
+    this.printSpaceLeft = (...args) => {
+      this.expectsSpace = true;
+      this.print(...args);
+    };
+    this.printWords = (...args) => {
+      for (const arg of args) {
+        this.printWord(arg);
       }
     };
     for (const rule of Object.values(rules)) {
       this[rule.name] = (input, context, args) => {
+        this.expectsSpace = false;
+        this.stringBuilder.length = 0;
+        this.origSource = context.origSource;
+        this.generatedUntil = context?.offset ?? 0;
         this.setContext(context);
-        return rule.gImpl(selfRef)(input, this.getSafeContext(), args);
+        this.subrule(rule, input, args);
+        this.catchup(this.origSource.length);
+        return this.stringBuilder.join("");
       };
     }
   }
@@ -65,7 +277,7 @@ function listToRuleDefMap(rules) {
   return newRules;
 }
 var GeneratorBuilder = class _GeneratorBuilder {
-  static createBuilder(start) {
+  static create(start) {
     if (start instanceof _GeneratorBuilder) {
       return new _GeneratorBuilder({ ...start.rules });
     }
@@ -74,6 +286,9 @@ var GeneratorBuilder = class _GeneratorBuilder {
   constructor(startRules) {
     this.rules = startRules;
   }
+  widenContext() {
+    return this;
+  }
   typePatch() {
     return this;
   }
@@ -149,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;
@@ -1514,8 +1826,8 @@ var Promise2 = getNative_default(root_default, "Promise");
 var Promise_default = Promise2;
 
 // ../../node_modules/lodash-es/_Set.js
-var Set = getNative_default(root_default, "Set");
-var Set_default = Set;
+var Set2 = getNative_default(root_default, "Set");
+var Set_default = Set2;
 
 // ../../node_modules/lodash-es/_getTag.js
 var mapTag2 = "[object Map]";
@@ -9420,6 +9732,10 @@ var LexerBuilder = 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);
   }
@@ -9448,9 +9764,9 @@ var LexerBuilder = class _LexerBuilder {
     return new Lexer(this.tokens, {
       positionTracking: "onlyStart",
       recoveryEnabled: false,
+      ensureOptimizations: true,
       // SafeMode: true,
       // SkipValidations: true,
-      ensureOptimizations: true,
       ...lexerConfig
     });
   }
@@ -9584,7 +9900,7 @@ var ParserBuilder = 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 });
     }
@@ -9593,6 +9909,9 @@ var ParserBuilder = class _ParserBuilder {
   constructor(startRules) {
     this.rules = startRules;
   }
+  widenContext() {
+    return this;
+  }
   typePatch() {
     return this;
   }
@@ -9688,7 +10007,14 @@ ${firstError.message}`);
     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
+    });
     const parser = this.consume({
       tokenVocabulary,
       config: parserConfig
@@ -9725,6 +10051,61 @@ function unCapitalize(str) {
 function createToken2(config) {
   return createToken(config);
 }
+
+// lib/Transformer.ts
+var Transformer = class {
+  transformNode(curObject, searchType, patch) {
+    const copy = { ...curObject };
+    for (const [key, value] of Object.entries(copy)) {
+      copy[key] = this.safeObjectVisit(value, (obj) => this.transformNode(obj, searchType, patch));
+    }
+    if (copy.type === searchType) {
+      return patch(copy);
+    }
+    return copy;
+  }
+  transformNodeSpecific(curObject, searchType, searchSubType, patch) {
+    const copy = { ...curObject };
+    for (const [key, value] of Object.entries(copy)) {
+      copy[key] = this.safeObjectVisit(value, (obj) => this.transformNodeSpecific(obj, searchType, searchSubType, patch));
+    }
+    if (copy.type === searchType && copy.subType === searchSubType) {
+      return patch(copy);
+    }
+    return copy;
+  }
+  visitObjects(curObject, visitor) {
+    for (const value of Object.values(curObject)) {
+      this.safeObjectVisit(value, (obj) => this.visitObjects(obj, visitor));
+    }
+  }
+  visitNode(curObject, searchType, visitor) {
+    for (const value of Object.values(curObject)) {
+      this.safeObjectVisit(value, (obj) => this.visitNode(obj, searchType, visitor));
+    }
+    if (curObject.type === searchType) {
+      visitor(curObject);
+    }
+  }
+  visitNodeSpecific(curObject, searchType, searchSubType, visitor) {
+    for (const value of Object.values(curObject)) {
+      this.safeObjectVisit(value, (obj) => this.visitNodeSpecific(obj, searchType, searchSubType, visitor));
+    }
+    const cast = curObject;
+    if (cast.type === searchType && cast.subType === searchSubType) {
+      visitor(curObject);
+    }
+  }
+  safeObjectVisit(value, mapper) {
+    if (value && typeof value === "object") {
+      if (Array.isArray(value)) {
+        return value.map((x) => this.safeObjectVisit(x, mapper));
+      }
+      return mapper(value);
+    }
+    return value;
+  }
+};
 /*! Bundled license information:
 
 lodash-es/lodash.js:

package/lib/index.d.ts

@@ -1,8 +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 './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,4 +13,7 @@ export * from './parser-builder/parserBuilder';
 export * from './parser-builder/ruleDefTypes';
 // Export general types
 export * from './utils';
+export * from './CoreFactory';
+export * from './nodeTypings';
+export * from './Transformer';
 //# sourceMappingURL=index.js.map

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","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';\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"]}