@traqula/core 0.0.23 → 0.0.25

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

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

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

@@ -1,16 +1,3 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var ruleDefTypes_exports = {};
-module.exports = __toCommonJS(ruleDefTypes_exports);
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ruleDefTypes.js.map

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

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

package/dist/cjs/lib/transformers/TransformerObject.js

@@ -1,213 +1,211 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var TransformerObject_exports = {};
-__export(TransformerObject_exports, {
-  TransformerObject: () => TransformerObject
-});
-module.exports = __toCommonJS(TransformerObject_exports);
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransformerObject = void 0;
 class TransformerObject {
-  defaultContext;
-  maxStackSize = 1e6;
-  /**
-   * Creates stateless transformer.
-   * @param defaultContext
-   */
-  constructor(defaultContext = {}) {
-    this.defaultContext = defaultContext;
-  }
-  clone(newDefaultContext = {}) {
-    return new TransformerObject({ ...this.defaultContext, ...newDefaultContext });
-  }
-  /**
-   * Function to shallow clone any type.
-   * @param obj
-   * @protected
-   */
-  cloneObj(obj) {
-    if (obj === null || typeof obj !== "object") {
-      return obj;
+    defaultContext;
+    maxStackSize = 1_000_000;
+    /**
+     * Creates stateless transformer.
+     * @param defaultContext
+     */
+    constructor(defaultContext = {}) {
+        this.defaultContext = defaultContext;
     }
-    const proto = Object.getPrototypeOf(obj);
-    if (proto === Object.prototype || proto === null) {
-      return { ...obj };
+    clone(newDefaultContext = {}) {
+        return new TransformerObject({ ...this.defaultContext, ...newDefaultContext });
     }
-    return Object.assign(Object.create(proto), obj);
-  }
-  /**
-   * Recursively transforms all objects that are not arrays. Mapper is called on deeper objects first.
-   * @param startObject object to start iterating from
-   * @param mapper mapper to transform the various objects - argument is a copy of the original
-   * @param preVisitor callback that is evaluated before iterating deeper.
-   *   If continues is false, we do not iterate deeper, current object is still mapped. - default: true
-   *   If shortcut is true, we do not iterate deeper, nor do we branch out, this mapper will be the last one called.
-   *    - Default false
-   */
-  transformObject(startObject, mapper, preVisitor = () => ({})) {
-    const defaults = this.defaultContext;
-    const defaultCopyFlag = defaults.copy ?? true;
-    const defaultContinues = defaults.continue ?? true;
-    const defaultIgnoreKeys = defaults.ignoreKeys;
-    const defaultShallowKeys = defaults.shallowKeys;
-    const defaultDidShortCut = defaults.shortcut ?? false;
-    let didShortCut = false;
-    const resultWrap = { res: startObject };
-    const stack = [startObject];
-    const stackParent = [resultWrap];
-    const stackParentKey = ["res"];
-    const handleMapperOnLen = [];
-    const mapperCopyStack = [];
-    const mapperOrigStack = [];
-    const mapperParent = [];
-    const mapperParentKey = [];
-    function handleMapper() {
-      while (stack.length === handleMapperOnLen.at(-1)) {
-        handleMapperOnLen.pop();
-        const copyToMap = mapperCopyStack.pop();
-        const origToMap = mapperOrigStack.pop();
-        const parent = mapperParent.pop();
-        const parentKey = mapperParentKey.pop();
-        parent[parentKey] = mapper(copyToMap, origToMap);
-      }
+    /**
+     * Function to shallow clone any type.
+     * @param obj
+     * @protected
+     */
+    cloneObj(obj) {
+        if (obj === null || typeof obj !== 'object') {
+            return obj;
+        }
+        const proto = Object.getPrototypeOf(obj);
+        // Fast path: plain object
+        if (proto === Object.prototype || proto === null) {
+            // Spread or assign preserves fast properties
+            return { ...obj };
+        }
+        // Otherwise, preserve prototype for custom objects
+        return Object.assign(Object.create(proto), obj);
     }
-    while (stack.length > 0 && stack.length < this.maxStackSize) {
-      const curObject = stack.pop();
-      const curParent = stackParent.pop();
-      const curKey = stackParentKey.pop();
-      if (!didShortCut) {
-        if (Array.isArray(curObject)) {
-          const newArr = [...curObject];
-          handleMapperOnLen.push(stack.length);
-          mapperCopyStack.push(newArr);
-          mapperOrigStack.push(curObject);
-          mapperParent.push(curParent);
-          mapperParentKey.push(curKey);
-          for (let index = curObject.length - 1; index >= 0; index--) {
-            const val = curObject[index];
-            if (val !== null && typeof val === "object") {
-              stack.push(val);
-              stackParent.push(newArr);
-              stackParentKey.push(index.toString());
+    /**
+     * Recursively transforms all objects that are not arrays. Mapper is called on deeper objects first.
+     * @param startObject object to start iterating from
+     * @param mapper mapper to transform the various objects - argument is a copy of the original
+     * @param preVisitor callback that is evaluated before iterating deeper.
+     *   If continues is false, we do not iterate deeper, current object is still mapped. - default: true
+     *   If shortcut is true, we do not iterate deeper, nor do we branch out, this mapper will be the last one called.
+     *    - Default false
+     */
+    transformObject(startObject, mapper, preVisitor = () => ({})) {
+        const defaults = this.defaultContext;
+        const defaultCopyFlag = defaults.copy ?? true;
+        const defaultContinues = defaults.continue ?? true;
+        const defaultIgnoreKeys = defaults.ignoreKeys;
+        const defaultShallowKeys = defaults.shallowKeys;
+        const defaultDidShortCut = defaults.shortcut ?? false;
+        // Code handles own stack instead of using recursion - this optimizes it for deep operations.
+        let didShortCut = false;
+        const resultWrap = { res: startObject };
+        // Grows with stack
+        const stack = [startObject];
+        const stackParent = [resultWrap];
+        const stackParentKey = ['res'];
+        // Grows with reverse stack - when popping down the stack, you realise you still want to map something.
+        // Counter of stack size when we started adding the children of this object, going beyond this means a new parent
+        const handleMapperOnLen = [];
+        const mapperCopyStack = [];
+        const mapperOrigStack = [];
+        const mapperParent = [];
+        const mapperParentKey = [];
+        function handleMapper() {
+            while (stack.length === handleMapperOnLen.at(-1)) {
+                handleMapperOnLen.pop();
+                const copyToMap = mapperCopyStack.pop();
+                const origToMap = mapperOrigStack.pop();
+                const parent = mapperParent.pop();
+                const parentKey = mapperParentKey.pop();
+                parent[parentKey] = mapper(copyToMap, origToMap);
             }
-          }
-          handleMapper();
-          continue;
         }
-        const context = preVisitor(curObject);
-        const copyFlag = context.copy ?? defaultCopyFlag;
-        const continues = context.continue ?? defaultContinues;
-        const ignoreKeys = context.ignoreKeys ?? defaultIgnoreKeys;
-        const shallowKeys = context.shallowKeys ?? defaultShallowKeys;
-        didShortCut = context.shortcut ?? defaultDidShortCut;
-        const copy = copyFlag ? this.cloneObj(curObject) : curObject;
-        handleMapperOnLen.push(stack.length);
-        mapperCopyStack.push(copy);
-        mapperOrigStack.push(curObject);
-        mapperParent.push(curParent);
-        mapperParentKey.push(curKey);
-        if (continues && !didShortCut) {
-          for (const key in copy) {
-            if (!Object.hasOwn(copy, key)) {
-              continue;
-            }
-            const val = copy[key];
-            const onlyShallow = shallowKeys && shallowKeys?.has(key);
-            if (onlyShallow) {
-              copy[key] = this.cloneObj(val);
-            }
-            if (ignoreKeys && ignoreKeys.has(key)) {
-              continue;
+        while (stack.length > 0 && stack.length < this.maxStackSize) {
+            const curObject = stack.pop();
+            const curParent = stackParent.pop();
+            const curKey = stackParentKey.pop();
+            // Only add to the stack when you did not shortcut
+            if (!didShortCut) {
+                if (Array.isArray(curObject)) {
+                    const newArr = [...curObject];
+                    handleMapperOnLen.push(stack.length);
+                    mapperCopyStack.push(newArr);
+                    mapperOrigStack.push(curObject);
+                    mapperParent.push(curParent);
+                    mapperParentKey.push(curKey);
+                    for (let index = curObject.length - 1; index >= 0; index--) {
+                        const val = curObject[index];
+                        if (val !== null && typeof val === 'object') {
+                            stack.push(val);
+                            stackParent.push(newArr);
+                            stackParentKey.push(index.toString());
+                        }
+                    }
+                    handleMapper();
+                    continue;
+                }
+                // Perform pre visit before expanding the stack
+                const context = preVisitor(curObject);
+                const copyFlag = context.copy ?? defaultCopyFlag;
+                const continues = context.continue ?? defaultContinues;
+                const ignoreKeys = context.ignoreKeys ?? defaultIgnoreKeys;
+                const shallowKeys = context.shallowKeys ?? defaultShallowKeys;
+                didShortCut = context.shortcut ?? defaultDidShortCut;
+                const copy = copyFlag ? this.cloneObj(curObject) : curObject;
+                // Register that you want to be visited
+                handleMapperOnLen.push(stack.length);
+                mapperCopyStack.push(copy);
+                mapperOrigStack.push(curObject);
+                mapperParent.push(curParent);
+                mapperParentKey.push(curKey);
+                // Extend stack if needed. When shortcutted, should still unwind the stack, but no longer add to it.
+                if (continues && !didShortCut) {
+                    for (const key in copy) {
+                        if (!Object.hasOwn(copy, key)) {
+                            continue;
+                        }
+                        const val = copy[key];
+                        // If shallow copy required, do
+                        const onlyShallow = shallowKeys && shallowKeys?.has(key);
+                        if (onlyShallow) {
+                            // Do not add stack entry - assign straight away
+                            copy[key] = this.cloneObj(val);
+                        }
+                        if (ignoreKeys && ignoreKeys.has(key)) {
+                            // Do not add stack entry
+                            continue;
+                        }
+                        if (!onlyShallow && val !== null && typeof val === 'object') {
+                            // Do add stack entry.
+                            stack.push(val);
+                            stackParentKey.push(key);
+                            stackParent.push(copy);
+                        }
+                    }
+                }
             }
-            if (!onlyShallow && val !== null && typeof val === "object") {
-              stack.push(val);
-              stackParentKey.push(key);
-              stackParent.push(copy);
-            }
-          }
+            handleMapper();
         }
-      }
-      handleMapper();
-    }
-    if (stack.length >= this.maxStackSize) {
-      throw new Error("Transform object stack overflowed");
-    }
-    handleMapper();
-    return resultWrap.res;
-  }
-  /**
-   * Visitor that visits all objects. Visits deeper objects first.
-   */
-  visitObject(startObject, visitor, preVisitor = () => ({})) {
-    const defaults = this.defaultContext;
-    const defaultContinues = defaults.continue ?? true;
-    const defaultIgnoreKeys = defaults.ignoreKeys;
-    const defaultShortcut = defaults.shortcut ?? false;
-    let didShortCut = false;
-    const stack = [startObject];
-    const handleVisitorOnLen = [];
-    const visitorStack = [];
-    function handleVisitor() {
-      while (stack.length === handleVisitorOnLen.at(-1)) {
-        handleVisitorOnLen.pop();
-        const toVisit = visitorStack.pop();
-        visitor(toVisit);
-      }
-    }
-    while (stack.length > 0 && stack.length < this.maxStackSize) {
-      const curObject = stack.pop();
-      if (!didShortCut) {
-        if (Array.isArray(curObject)) {
-          for (let i = curObject.length - 1; i >= 0; i--) {
-            stack.push(curObject[i]);
-          }
-          handleVisitor();
-          continue;
+        if (stack.length >= this.maxStackSize) {
+            throw new Error('Transform object stack overflowed');
         }
-        const context = preVisitor(curObject);
-        didShortCut = context.shortcut ?? defaultShortcut;
-        const continues = context.continue ?? defaultContinues;
-        const ignoreKeys = context.ignoreKeys ?? defaultIgnoreKeys;
-        handleVisitorOnLen.push(stack.length);
-        visitorStack.push(curObject);
-        if (continues && !didShortCut) {
-          for (const key in curObject) {
-            if (!Object.hasOwn(curObject, key)) {
-              continue;
-            }
-            if (ignoreKeys && ignoreKeys.has(key)) {
-              continue;
+        handleMapper();
+        return resultWrap.res;
+    }
+    /**
+     * Visitor that visits all objects. Visits deeper objects first.
+     */
+    visitObject(startObject, visitor, preVisitor = () => ({})) {
+        const defaults = this.defaultContext;
+        const defaultContinues = defaults.continue ?? true;
+        const defaultIgnoreKeys = defaults.ignoreKeys;
+        const defaultShortcut = defaults.shortcut ?? false;
+        let didShortCut = false;
+        // Stack of things to preVisit
+        const stack = [startObject];
+        // When the stack is done preVisiting things above this lengths, visit the bellow
+        const handleVisitorOnLen = [];
+        const visitorStack = [];
+        function handleVisitor() {
+            while (stack.length === handleVisitorOnLen.at(-1)) {
+                handleVisitorOnLen.pop();
+                const toVisit = visitorStack.pop();
+                visitor(toVisit);
             }
-            const val = curObject[key];
-            if (val && typeof val === "object") {
-              stack.push(val);
+        }
+        while (stack.length > 0 && stack.length < this.maxStackSize) {
+            const curObject = stack.pop();
+            if (!didShortCut) {
+                if (Array.isArray(curObject)) {
+                    for (let i = curObject.length - 1; i >= 0; i--) {
+                        stack.push(curObject[i]);
+                    }
+                    handleVisitor();
+                    continue;
+                }
+                // Perform pre visit before expanding the stack
+                const context = preVisitor(curObject);
+                didShortCut = context.shortcut ?? defaultShortcut;
+                const continues = context.continue ?? defaultContinues;
+                const ignoreKeys = context.ignoreKeys ?? defaultIgnoreKeys;
+                // Register that you want to be visited
+                handleVisitorOnLen.push(stack.length);
+                visitorStack.push(curObject);
+                // Extend stack if needed. When shortcutted, should still unwind the stack, but no longer add to it.
+                if (continues && !didShortCut) {
+                    for (const key in curObject) {
+                        if (!Object.hasOwn(curObject, key)) {
+                            continue;
+                        }
+                        if (ignoreKeys && ignoreKeys.has(key)) {
+                            continue;
+                        }
+                        const val = curObject[key];
+                        if (val && typeof val === 'object') {
+                            stack.push(val);
+                        }
+                    }
+                }
             }
-          }
+            handleVisitor();
         }
-      }
-      handleVisitor();
-    }
-    if (stack.length >= this.maxStackSize) {
-      throw new Error("Transform object stack overflowed");
+        if (stack.length >= this.maxStackSize) {
+            throw new Error('Transform object stack overflowed');
+        }
+        handleVisitor();
     }
-    handleVisitor();
-  }
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  TransformerObject
-});
+exports.TransformerObject = TransformerObject;
+//# sourceMappingURL=TransformerObject.js.map

package/dist/cjs/lib/transformers/TransformerObject.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransformerObject.js","sourceRoot":"","sources":["../../../../lib/transformers/TransformerObject.ts"],"names":[],"mappings":"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","sourcesContent":["export interface VisitContext {\n  /**\n   * Whether you should stop iterating after this object. Default false.\n   */\n  shortcut?: boolean;\n  /**\n   * Whether you should continue iterating deeper with this object. Default true.\n   */\n  continue?: boolean;\n  /**\n   * Object keys that can be ignored, meaning they do not get visited.\n   */\n  ignoreKeys?: Set<string>;\n}\n\nexport interface TransformContext extends VisitContext {\n  /**\n   * Object keys that will be shallowly copied but not traversed.\n   * When the same key is included here and in ignoreKeys, the copy will still be made.\n   */\n  shallowKeys?: Set<string>;\n  /**\n   * Whether the visited object should be shallowly copied or not. Defaults to true.\n   */\n  copy?: boolean;\n}\n\nexport interface SelectiveTraversalContext<Nodes> {\n  /**\n   * Nodes you should visit next. Defaults to empty list\n   */\n  next?: Nodes[];\n  /**\n   * Whether you should stop visiting after visiting this object. Default false.\n   */\n  shortcut?: boolean;\n}\n\nexport class TransformerObject {\n  protected maxStackSize = 1_000_000;\n  /**\n   * Creates stateless transformer.\n   * @param defaultContext\n   */\n  public constructor(protected readonly defaultContext: TransformContext = {}) {}\n\n  public clone(newDefaultContext: TransformContext = {}): TransformerObject {\n    return new TransformerObject({ ...this.defaultContext, ...newDefaultContext });\n  }\n\n  /**\n   * Function to shallow clone any type.\n   * @param obj\n   * @protected\n   */\n  public cloneObj<T>(obj: T): T {\n    if (obj === null || typeof obj !== 'object') {\n      return obj;\n    }\n\n    const proto = Object.getPrototypeOf(obj);\n\n    // Fast path: plain object\n    if (proto === Object.prototype || proto === null) {\n      // Spread or assign preserves fast properties\n      return { ...obj };\n    }\n\n    // Otherwise, preserve prototype for custom objects\n    return Object.assign(Object.create(proto), obj);\n  }\n\n  /**\n   * Recursively transforms all objects that are not arrays. Mapper is called on deeper objects first.\n   * @param startObject object to start iterating from\n   * @param mapper mapper to transform the various objects - argument is a copy of the original\n   * @param preVisitor callback that is evaluated before iterating deeper.\n   *   If continues is false, we do not iterate deeper, current object is still mapped. - default: true\n   *   If shortcut is true, we do not iterate deeper, nor do we branch out, this mapper will be the last one called.\n   *    - Default false\n   */\n  public transformObject(\n    startObject: object,\n    mapper: (copy: object, orig: object) => unknown,\n    preVisitor: (orig: object) => TransformContext = () => ({}),\n  ): unknown {\n    const defaults = this.defaultContext;\n    const defaultCopyFlag = defaults.copy ?? true;\n    const defaultContinues = defaults.continue ?? true;\n    const defaultIgnoreKeys = defaults.ignoreKeys;\n    const defaultShallowKeys = defaults.shallowKeys;\n    const defaultDidShortCut = defaults.shortcut ?? false;\n\n    // Code handles own stack instead of using recursion - this optimizes it for deep operations.\n    let didShortCut = false;\n    const resultWrap = { res: startObject };\n\n    // Grows with stack\n    const stack = [ startObject ];\n    const stackParent: object[] = [ resultWrap ];\n    const stackParentKey: string[] = [ 'res' ];\n\n    // Grows with reverse stack - when popping down the stack, you realise you still want to map something.\n    // Counter of stack size when we started adding the children of this object, going beyond this means a new parent\n    const handleMapperOnLen: number[] = [];\n    const mapperCopyStack: object[] = [];\n    const mapperOrigStack: object[] = [];\n    const mapperParent: object[] = [];\n    const mapperParentKey: string[] = [];\n\n    function handleMapper(): void {\n      while (stack.length === handleMapperOnLen.at(-1)) {\n        handleMapperOnLen.pop();\n        const copyToMap = mapperCopyStack.pop()!;\n        const origToMap = mapperOrigStack.pop()!;\n        const parent = <Record<string, unknown>> mapperParent.pop()!;\n        const parentKey = mapperParentKey.pop()!;\n        parent[parentKey] = mapper(copyToMap, origToMap);\n      }\n    }\n\n    while (stack.length > 0 && stack.length < this.maxStackSize) {\n      const curObject = stack.pop()!;\n      const curParent = stackParent.pop()!;\n      const curKey = stackParentKey.pop()!;\n\n      // Only add to the stack when you did not shortcut\n      if (!didShortCut) {\n        if (Array.isArray(curObject)) {\n          const newArr = [ ...curObject ];\n          handleMapperOnLen.push(stack.length);\n          mapperCopyStack.push(newArr);\n          mapperOrigStack.push(curObject);\n          mapperParent.push(curParent);\n          mapperParentKey.push(curKey);\n\n          for (let index = curObject.length - 1; index >= 0; index--) {\n            const val = curObject[index];\n            if (val !== null && typeof val === 'object') {\n              stack.push(val);\n              stackParent.push(newArr);\n              stackParentKey.push(index.toString());\n            }\n          }\n          handleMapper();\n          continue;\n        }\n\n        // Perform pre visit before expanding the stack\n        const context = preVisitor(<any>curObject);\n        const copyFlag = context.copy ?? defaultCopyFlag;\n        const continues = context.continue ?? defaultContinues;\n        const ignoreKeys = context.ignoreKeys ?? defaultIgnoreKeys;\n        const shallowKeys = context.shallowKeys ?? defaultShallowKeys;\n        didShortCut = context.shortcut ?? defaultDidShortCut;\n\n        const copy = copyFlag ? this.cloneObj(curObject) : curObject;\n\n        // Register that you want to be visited\n        handleMapperOnLen.push(stack.length);\n        mapperCopyStack.push(copy);\n        mapperOrigStack.push(curObject);\n        mapperParent.push(curParent);\n        mapperParentKey.push(curKey);\n\n        // Extend stack if needed. When shortcutted, should still unwind the stack, but no longer add to it.\n        if (continues && !didShortCut) {\n          for (const key in copy) {\n            if (!Object.hasOwn(copy, key)) {\n              continue;\n            }\n            const val = (<Record<string, unknown>> copy)[key];\n\n            // If shallow copy required, do\n            const onlyShallow = shallowKeys && shallowKeys?.has(key);\n            if (onlyShallow) {\n              // Do not add stack entry - assign straight away\n              (<Record<string, unknown>> copy)[key] = this.cloneObj(val);\n            }\n            if (ignoreKeys && ignoreKeys.has(key)) {\n              // Do not add stack entry\n              continue;\n            }\n            if (!onlyShallow && val !== null && typeof val === 'object') {\n              // Do add stack entry.\n              stack.push(val);\n              stackParentKey.push(key);\n              stackParent.push(copy);\n            }\n          }\n        }\n      }\n      handleMapper();\n    }\n    if (stack.length >= this.maxStackSize) {\n      throw new Error('Transform object stack overflowed');\n    }\n    handleMapper();\n\n    return <any> resultWrap.res;\n  }\n\n  /**\n   * Visitor that visits all objects. Visits deeper objects first.\n   */\n  public visitObject(\n    startObject: object,\n    visitor: (orig: object) => void,\n    preVisitor: (orig: object) => VisitContext = () => ({}),\n  ): void {\n    const defaults = this.defaultContext;\n    const defaultContinues = defaults.continue ?? true;\n    const defaultIgnoreKeys = defaults.ignoreKeys;\n    const defaultShortcut = defaults.shortcut ?? false;\n\n    let didShortCut = false;\n\n    // Stack of things to preVisit\n    const stack = [ startObject ];\n    // When the stack is done preVisiting things above this lengths, visit the bellow\n    const handleVisitorOnLen: number[] = [];\n    const visitorStack: object[] = [];\n\n    function handleVisitor(): void {\n      while (stack.length === handleVisitorOnLen.at(-1)) {\n        handleVisitorOnLen.pop();\n        const toVisit = visitorStack.pop()!;\n        visitor(toVisit);\n      }\n    }\n\n    while (stack.length > 0 && stack.length < this.maxStackSize) {\n      const curObject = stack.pop()!;\n\n      if (!didShortCut) {\n        if (Array.isArray(curObject)) {\n          for (let i = curObject.length - 1; i >= 0; i--) {\n            stack.push(curObject[i]);\n          }\n          handleVisitor();\n          continue;\n        }\n\n        // Perform pre visit before expanding the stack\n        const context = preVisitor(curObject);\n        didShortCut = context.shortcut ?? defaultShortcut;\n        const continues = context.continue ?? defaultContinues;\n        const ignoreKeys = context.ignoreKeys ?? defaultIgnoreKeys;\n\n        // Register that you want to be visited\n        handleVisitorOnLen.push(stack.length);\n        visitorStack.push(curObject);\n\n        // Extend stack if needed. When shortcutted, should still unwind the stack, but no longer add to it.\n        if (continues && !didShortCut) {\n          for (const key in curObject) {\n            if (!Object.hasOwn(curObject, key)) {\n              continue;\n            }\n            if (ignoreKeys && ignoreKeys.has(key)) {\n              continue;\n            }\n            const val = (<Record<string, unknown>> curObject)[key];\n            if (val && typeof val === 'object') {\n              stack.push(val);\n            }\n          }\n        }\n      }\n      handleVisitor();\n    }\n    if (stack.length >= this.maxStackSize) {\n      throw new Error('Transform object stack overflowed');\n    }\n    handleVisitor();\n  }\n}\n"]}