@langchain/classic 1.0.17 → 1.0.18

package/dist/experimental/generative_agents/generative_agent_memory.js.map

@@ -1 +1 @@
-{"version":3,"file":"generative_agent_memory.js","names":["llm: BaseLanguageModelInterface","memoryRetriever: TimeWeightedVectorStoreRetriever","config: Omit<GenerativeAgentMemoryConfig, \"maxTokensLimit\">","prompt: PromptTemplate","values: ChainValues","runManager?: CallbackManagerForChainRun","now?: Date","newInsights: string[]","memoryContent: string","lastK: number","o: { pageContent: string }","topic: string","relatedStatements: string","text: string","observation: string","_now?: Date","config?: GenerativeAgentMemoryConfig","metadata?: Record<string, unknown>","callbacks?: Callbacks","relevantMemories: Document[]","consumedTokens: number","inputs: InputValues","query: string","_inputs: InputValues","outputs: OutputValues"],"sources":["../../../src/experimental/generative_agents/generative_agent_memory.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { PromptTemplate } from \"@langchain/core/prompts\";\nimport { Document } from \"@langchain/core/documents\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { BaseMemory, InputValues, OutputValues } from \"@langchain/core/memory\";\nimport {\n  CallbackManagerForChainRun,\n  Callbacks,\n} from \"@langchain/core/callbacks/manager\";\nimport { TimeWeightedVectorStoreRetriever } from \"../../retrievers/time_weighted.js\";\nimport { BaseChain } from \"../../chains/base.js\";\nimport { LLMChain } from \"../../chains/llm_chain.js\";\n\nexport type GenerativeAgentMemoryConfig = {\n  reflectionThreshold?: number;\n  importanceWeight?: number;\n  verbose?: boolean;\n  maxTokensLimit?: number;\n};\n\n/**\n * Class that manages the memory of a generative agent in LangChain. It\n * extends the `BaseChain` class and has methods for adding observations\n * or memories to the agent's memory, scoring the importance of a memory,\n * reflecting on recent events to add synthesized memories, and generating\n * insights on a topic of reflection based on pertinent memories.\n */\nclass GenerativeAgentMemoryChain extends BaseChain {\n  static lc_name() {\n    return \"GenerativeAgentMemoryChain\";\n  }\n\n  reflecting = false;\n\n  reflectionThreshold?: number;\n\n  importanceWeight = 0.15;\n\n  memoryRetriever: TimeWeightedVectorStoreRetriever;\n\n  llm: BaseLanguageModelInterface;\n\n  verbose = false;\n\n  private aggregateImportance = 0.0;\n\n  constructor(\n    llm: BaseLanguageModelInterface,\n    memoryRetriever: TimeWeightedVectorStoreRetriever,\n    config: Omit<GenerativeAgentMemoryConfig, \"maxTokensLimit\">\n  ) {\n    super();\n    this.llm = llm;\n    this.memoryRetriever = memoryRetriever;\n    this.reflectionThreshold = config.reflectionThreshold;\n    this.importanceWeight = config.importanceWeight ?? this.importanceWeight;\n    this.verbose = config.verbose ?? this.verbose;\n  }\n\n  _chainType(): string {\n    return \"generative_agent_memory\";\n  }\n\n  get inputKeys(): string[] {\n    return [\"memory_content\", \"now\", \"memory_metadata\"];\n  }\n\n  get outputKeys(): string[] {\n    return [\"output\"];\n  }\n\n  /**\n   * Method that creates a new LLMChain with the given prompt.\n   * @param prompt The PromptTemplate to use for the new LLMChain.\n   * @returns A new LLMChain instance.\n   */\n  chain(prompt: PromptTemplate): LLMChain {\n    const chain = new LLMChain({\n      llm: this.llm,\n      prompt,\n      verbose: this.verbose,\n      outputKey: \"output\",\n    });\n    return chain;\n  }\n\n  async _call(values: ChainValues, runManager?: CallbackManagerForChainRun) {\n    const { memory_content: memoryContent, now } = values;\n    // add an observation or memory to the agent's memory\n    const importanceScore = await this.scoreMemoryImportance(\n      memoryContent,\n      runManager\n    );\n    this.aggregateImportance += importanceScore;\n    const document = new Document({\n      pageContent: memoryContent,\n      metadata: {\n        importance: importanceScore,\n        ...values.memory_metadata,\n      },\n    });\n    await this.memoryRetriever.addDocuments([document]);\n    // after an agent has processed a certain amount of memories (as measured by aggregate importance),\n    // it is time to pause and reflect on recent events to add more synthesized memories to the agent's\n    // memory stream.\n    if (\n      this.reflectionThreshold !== undefined &&\n      this.aggregateImportance > this.reflectionThreshold &&\n      !this.reflecting\n    ) {\n      console.log(\"Reflecting on current memories...\");\n      this.reflecting = true;\n      await this.pauseToReflect(now, runManager);\n      this.aggregateImportance = 0.0;\n      this.reflecting = false;\n    }\n    return { output: importanceScore };\n  }\n\n  /**\n   * Method that pauses the agent to reflect on recent events and generate\n   * new insights.\n   * @param now The current date.\n   * @param runManager The CallbackManagerForChainRun to use for the reflection.\n   * @returns An array of new insights as strings.\n   */\n  async pauseToReflect(\n    now?: Date,\n    runManager?: CallbackManagerForChainRun\n  ): Promise<string[]> {\n    if (this.verbose) {\n      console.log(\"Pausing to reflect...\");\n    }\n    const newInsights: string[] = [];\n    const topics = await this.getTopicsOfReflection(50, runManager);\n    for (const topic of topics) {\n      const insights = await this.getInsightsOnTopic(topic, now, runManager);\n      for (const insight of insights) {\n        // add memory\n        await this.call(\n          {\n            memory_content: insight,\n            now,\n            memory_metadata: {\n              source: \"reflection_insight\",\n            },\n          },\n          runManager?.getChild(\"reflection_insight_memory\")\n        );\n      }\n      newInsights.push(...insights);\n    }\n    return newInsights;\n  }\n\n  /**\n   * Method that scores the importance of a given memory.\n   * @param memoryContent The content of the memory to score.\n   * @param runManager The CallbackManagerForChainRun to use for scoring.\n   * @returns The importance score of the memory as a number.\n   */\n  async scoreMemoryImportance(\n    memoryContent: string,\n    runManager?: CallbackManagerForChainRun\n  ): Promise<number> {\n    // score the absolute importance of a given memory\n    const prompt = PromptTemplate.fromTemplate(\n      \"On the scale of 1 to 10, where 1 is purely mundane\" +\n        \" (e.g., brushing teeth, making bed) and 10 is\" +\n        \" extremely poignant (e.g., a break up, college\" +\n        \" acceptance), rate the likely poignancy of the\" +\n        \" following piece of memory. Respond with a single integer.\" +\n        \"\\nMemory: {memory_content}\" +\n        \"\\nRating: \"\n    );\n    const score = await this.chain(prompt).run(\n      memoryContent,\n      runManager?.getChild(\"determine_importance\")\n    );\n\n    const strippedScore = score.trim();\n\n    if (this.verbose) {\n      console.log(\"Importance score:\", strippedScore);\n    }\n    const match = strippedScore.match(/^\\D*(\\d+)/);\n    if (match) {\n      const capturedNumber = parseFloat(match[1]);\n      const result = (capturedNumber / 10) * this.importanceWeight;\n      return result;\n    } else {\n      return 0.0;\n    }\n  }\n\n  /**\n   * Method that retrieves the topics of reflection based on the last K\n   * memories.\n   * @param lastK The number of most recent memories to consider for generating topics.\n   * @param runManager The CallbackManagerForChainRun to use for retrieving topics.\n   * @returns An array of topics of reflection as strings.\n   */\n  async getTopicsOfReflection(\n    lastK: number,\n    runManager?: CallbackManagerForChainRun\n  ): Promise<string[]> {\n    const prompt = PromptTemplate.fromTemplate(\n      \"{observations}\\n\\n\" +\n        \"Given only the information above, what are the 3 most salient\" +\n        \" high-level questions we can answer about the subjects in\" +\n        \" the statements? Provide each question on a new line.\\n\\n\"\n    );\n\n    const observations = this.memoryRetriever.getMemoryStream().slice(-lastK);\n    const observationStr = observations\n      .map((o: { pageContent: string }) => o.pageContent)\n      .join(\"\\n\");\n    const result = await this.chain(prompt).run(\n      observationStr,\n      runManager?.getChild(\"reflection_topics\")\n    );\n    return GenerativeAgentMemoryChain.parseList(result);\n  }\n\n  /**\n   * Method that generates insights on a given topic of reflection based on\n   * pertinent memories.\n   * @param topic The topic of reflection.\n   * @param now The current date.\n   * @param runManager The CallbackManagerForChainRun to use for generating insights.\n   * @returns An array of insights as strings.\n   */\n  async getInsightsOnTopic(\n    topic: string,\n    now?: Date,\n    runManager?: CallbackManagerForChainRun\n  ): Promise<string[]> {\n    // generate insights on a topic of reflection, based on pertinent memories\n    const prompt = PromptTemplate.fromTemplate(\n      \"Statements about {topic}\\n\" +\n        \"{related_statements}\\n\\n\" +\n        \"What 5 high-level insights can you infer from the above statements?\" +\n        \" (example format: insight (because of 1, 5, 3))\"\n    );\n\n    const relatedMemories = await this.fetchMemories(topic, now, runManager);\n    const relatedStatements: string = relatedMemories\n      .map((memory, index) => `${index + 1}. ${memory.pageContent}`)\n      .join(\"\\n\");\n    const result = await this.chain(prompt).call(\n      {\n        topic,\n        related_statements: relatedStatements,\n      },\n      runManager?.getChild(\"reflection_insights\")\n    );\n    return GenerativeAgentMemoryChain.parseList(result.output); // added output\n  }\n\n  /**\n   * Method that parses a newline-separated string into a list of strings.\n   * @param text The newline-separated string to parse.\n   * @returns An array of strings.\n   */\n  static parseList(text: string): string[] {\n    // parse a newine seperates string into a list of strings\n    return text.split(\"\\n\").map((s) => s.trim());\n  }\n\n  // TODO: Mock \"now\" to simulate different times\n  /**\n   * Method that fetches memories related to a given observation.\n   * @param observation The observation to fetch memories for.\n   * @param _now The current date.\n   * @param runManager The CallbackManagerForChainRun to use for fetching memories.\n   * @returns An array of Document instances representing the fetched memories.\n   */\n  async fetchMemories(\n    observation: string,\n    _now?: Date,\n    runManager?: CallbackManagerForChainRun\n  ): Promise<Document[]> {\n    return this.memoryRetriever.invoke(\n      observation,\n      runManager?.getChild(\"memory_retriever\")\n    );\n  }\n}\n\n/**\n * Class that manages the memory of a generative agent in LangChain. It\n * extends the `BaseMemory` class and has methods for adding a memory,\n * formatting memories, getting memories until a token limit is reached,\n * loading memory variables, saving the context of a model run to memory,\n * and clearing memory contents.\n * @example\n * ```typescript\n * const createNewMemoryRetriever = async () => {\n *   const vectorStore = new MemoryVectorStore(new OpenAIEmbeddings());\n *   const retriever = new TimeWeightedVectorStoreRetriever({\n *     vectorStore,\n *     otherScoreKeys: [\"importance\"],\n *     k: 15,\n *   });\n *   return retriever;\n * };\n * const tommiesMemory = new GenerativeAgentMemory(\n *   llm,\n *   await createNewMemoryRetriever(),\n *   { reflectionThreshold: 8 },\n * );\n * const summary = await tommiesMemory.getSummary();\n * ```\n */\nexport class GenerativeAgentMemory extends BaseMemory {\n  llm: BaseLanguageModelInterface;\n\n  memoryRetriever: TimeWeightedVectorStoreRetriever;\n\n  verbose: boolean;\n\n  reflectionThreshold?: number;\n\n  private maxTokensLimit = 1200;\n\n  queriesKey = \"queries\";\n\n  mostRecentMemoriesTokenKey = \"recent_memories_token\";\n\n  addMemoryKey = \"addMemory\";\n\n  relevantMemoriesKey = \"relevant_memories\";\n\n  relevantMemoriesSimpleKey = \"relevant_memories_simple\";\n\n  mostRecentMemoriesKey = \"most_recent_memories\";\n\n  nowKey = \"now\";\n\n  memoryChain: GenerativeAgentMemoryChain;\n\n  constructor(\n    llm: BaseLanguageModelInterface,\n    memoryRetriever: TimeWeightedVectorStoreRetriever,\n    config?: GenerativeAgentMemoryConfig\n  ) {\n    super();\n    this.llm = llm;\n    this.memoryRetriever = memoryRetriever;\n    this.verbose = config?.verbose ?? this.verbose;\n    this.reflectionThreshold =\n      config?.reflectionThreshold ?? this.reflectionThreshold;\n    this.maxTokensLimit = config?.maxTokensLimit ?? this.maxTokensLimit;\n    this.memoryChain = new GenerativeAgentMemoryChain(llm, memoryRetriever, {\n      reflectionThreshold: config?.reflectionThreshold,\n      importanceWeight: config?.importanceWeight,\n    });\n  }\n\n  /**\n   * Method that returns the key for relevant memories.\n   * @returns The key for relevant memories as a string.\n   */\n  getRelevantMemoriesKey(): string {\n    return this.relevantMemoriesKey;\n  }\n\n  /**\n   * Method that returns the key for the most recent memories token.\n   * @returns The key for the most recent memories token as a string.\n   */\n  getMostRecentMemoriesTokenKey(): string {\n    return this.mostRecentMemoriesTokenKey;\n  }\n\n  /**\n   * Method that returns the key for adding a memory.\n   * @returns The key for adding a memory as a string.\n   */\n  getAddMemoryKey(): string {\n    return this.addMemoryKey;\n  }\n\n  /**\n   * Method that returns the key for the current time.\n   * @returns The key for the current time as a string.\n   */\n  getCurrentTimeKey(): string {\n    return this.nowKey;\n  }\n\n  get memoryKeys(): string[] {\n    // Return an array of memory keys\n    return [this.relevantMemoriesKey, this.mostRecentMemoriesKey];\n  }\n\n  /**\n   * Method that adds a memory to the agent's memory.\n   * @param memoryContent The content of the memory to add.\n   * @param now The current date.\n   * @param metadata The metadata for the memory.\n   * @param callbacks The Callbacks to use for adding the memory.\n   * @returns The result of the memory addition.\n   */\n  async addMemory(\n    memoryContent: string,\n    now?: Date,\n    metadata?: Record<string, unknown>,\n    callbacks?: Callbacks\n  ) {\n    return this.memoryChain.call(\n      { memory_content: memoryContent, now, memory_metadata: metadata },\n      callbacks\n    );\n  }\n\n  /**\n   * Method that formats the given relevant memories in detail.\n   * @param relevantMemories The relevant memories to format.\n   * @returns The formatted memories as a string.\n   */\n  formatMemoriesDetail(relevantMemories: Document[]): string {\n    if (!relevantMemories.length) {\n      return \"No relevant information.\";\n    }\n    const contentStrings = new Set();\n    const content = [];\n    for (const memory of relevantMemories) {\n      if (memory.pageContent in contentStrings) {\n        continue;\n      }\n      contentStrings.add(memory.pageContent);\n      const createdTime = memory.metadata.created_at.toLocaleString(\"en-US\", {\n        month: \"long\",\n        day: \"numeric\",\n        year: \"numeric\",\n        hour: \"numeric\",\n        minute: \"numeric\",\n        hour12: true,\n      });\n      content.push(`${createdTime}: ${memory.pageContent.trim()}`);\n    }\n    const joinedContent = content.map((mem) => `${mem}`).join(\"\\n\");\n    return joinedContent;\n  }\n\n  /**\n   * Method that formats the given relevant memories in a simple manner.\n   * @param relevantMemories The relevant memories to format.\n   * @returns The formatted memories as a string.\n   */\n  formatMemoriesSimple(relevantMemories: Document[]): string {\n    const joinedContent = relevantMemories\n      .map((mem) => `${mem.pageContent}`)\n      .join(\"; \");\n    return joinedContent;\n  }\n\n  /**\n   * Method that retrieves memories until a token limit is reached.\n   * @param consumedTokens The number of tokens consumed so far.\n   * @returns The memories as a string.\n   */\n  async getMemoriesUntilLimit(consumedTokens: number): Promise<string> {\n    // reduce the number of tokens in the documents\n    const result = [];\n    for (const doc of this.memoryRetriever\n      .getMemoryStream()\n      .slice()\n      .reverse()) {\n      if (consumedTokens >= this.maxTokensLimit) {\n        if (this.verbose) {\n          console.log(\"Exceeding max tokens for LLM, filtering memories\");\n        }\n        break;\n      }\n      // eslint-disable-next-line no-param-reassign\n      consumedTokens += await this.llm.getNumTokens(doc.pageContent);\n      if (consumedTokens < this.maxTokensLimit) {\n        result.push(doc);\n      }\n    }\n    return this.formatMemoriesSimple(result);\n  }\n\n  get memoryVariables(): string[] {\n    // input keys this memory class will load dynamically\n    return [];\n  }\n\n  /**\n   * Method that loads memory variables based on the given inputs.\n   * @param inputs The inputs to use for loading memory variables.\n   * @returns An object containing the loaded memory variables.\n   */\n  async loadMemoryVariables(\n    inputs: InputValues\n  ): Promise<Record<string, string>> {\n    const queries = inputs[this.queriesKey];\n    const now = inputs[this.nowKey];\n    if (queries !== undefined) {\n      const relevantMemories = (\n        await Promise.all(\n          queries.map((query: string) =>\n            this.memoryChain.fetchMemories(query, now)\n          )\n        )\n      ).flat();\n      return {\n        [this.relevantMemoriesKey]: this.formatMemoriesDetail(relevantMemories),\n        [this.relevantMemoriesSimpleKey]:\n          this.formatMemoriesSimple(relevantMemories),\n      };\n    }\n    const mostRecentMemoriesToken = inputs[this.mostRecentMemoriesTokenKey];\n    if (mostRecentMemoriesToken !== undefined) {\n      return {\n        [this.mostRecentMemoriesKey]: await this.getMemoriesUntilLimit(\n          mostRecentMemoriesToken\n        ),\n      };\n    }\n    return {};\n  }\n\n  /**\n   * Method that saves the context of a model run to memory.\n   * @param _inputs The inputs of the model run.\n   * @param outputs The outputs of the model run.\n   * @returns Nothing.\n   */\n  async saveContext(\n    _inputs: InputValues,\n    outputs: OutputValues\n  ): Promise<void> {\n    // save the context of this model run to memory\n    const mem = outputs[this.addMemoryKey];\n    const now = outputs[this.nowKey];\n    if (mem) {\n      await this.addMemory(mem, now, {});\n    }\n  }\n\n  /**\n   * Method that clears the memory contents.\n   * @returns Nothing.\n   */\n  clear(): void {\n    // TODO: clear memory contents\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"generative_agent_memory.js","names":[],"sources":["../../../src/experimental/generative_agents/generative_agent_memory.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { PromptTemplate } from \"@langchain/core/prompts\";\nimport { Document } from \"@langchain/core/documents\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { BaseMemory, InputValues, OutputValues } from \"@langchain/core/memory\";\nimport {\n  CallbackManagerForChainRun,\n  Callbacks,\n} from \"@langchain/core/callbacks/manager\";\nimport { TimeWeightedVectorStoreRetriever } from \"../../retrievers/time_weighted.js\";\nimport { BaseChain } from \"../../chains/base.js\";\nimport { LLMChain } from \"../../chains/llm_chain.js\";\n\nexport type GenerativeAgentMemoryConfig = {\n  reflectionThreshold?: number;\n  importanceWeight?: number;\n  verbose?: boolean;\n  maxTokensLimit?: number;\n};\n\n/**\n * Class that manages the memory of a generative agent in LangChain. It\n * extends the `BaseChain` class and has methods for adding observations\n * or memories to the agent's memory, scoring the importance of a memory,\n * reflecting on recent events to add synthesized memories, and generating\n * insights on a topic of reflection based on pertinent memories.\n */\nclass GenerativeAgentMemoryChain extends BaseChain {\n  static lc_name() {\n    return \"GenerativeAgentMemoryChain\";\n  }\n\n  reflecting = false;\n\n  reflectionThreshold?: number;\n\n  importanceWeight = 0.15;\n\n  memoryRetriever: TimeWeightedVectorStoreRetriever;\n\n  llm: BaseLanguageModelInterface;\n\n  verbose = false;\n\n  private aggregateImportance = 0.0;\n\n  constructor(\n    llm: BaseLanguageModelInterface,\n    memoryRetriever: TimeWeightedVectorStoreRetriever,\n    config: Omit<GenerativeAgentMemoryConfig, \"maxTokensLimit\">\n  ) {\n    super();\n    this.llm = llm;\n    this.memoryRetriever = memoryRetriever;\n    this.reflectionThreshold = config.reflectionThreshold;\n    this.importanceWeight = config.importanceWeight ?? this.importanceWeight;\n    this.verbose = config.verbose ?? this.verbose;\n  }\n\n  _chainType(): string {\n    return \"generative_agent_memory\";\n  }\n\n  get inputKeys(): string[] {\n    return [\"memory_content\", \"now\", \"memory_metadata\"];\n  }\n\n  get outputKeys(): string[] {\n    return [\"output\"];\n  }\n\n  /**\n   * Method that creates a new LLMChain with the given prompt.\n   * @param prompt The PromptTemplate to use for the new LLMChain.\n   * @returns A new LLMChain instance.\n   */\n  chain(prompt: PromptTemplate): LLMChain {\n    const chain = new LLMChain({\n      llm: this.llm,\n      prompt,\n      verbose: this.verbose,\n      outputKey: \"output\",\n    });\n    return chain;\n  }\n\n  async _call(values: ChainValues, runManager?: CallbackManagerForChainRun) {\n    const { memory_content: memoryContent, now } = values;\n    // add an observation or memory to the agent's memory\n    const importanceScore = await this.scoreMemoryImportance(\n      memoryContent,\n      runManager\n    );\n    this.aggregateImportance += importanceScore;\n    const document = new Document({\n      pageContent: memoryContent,\n      metadata: {\n        importance: importanceScore,\n        ...values.memory_metadata,\n      },\n    });\n    await this.memoryRetriever.addDocuments([document]);\n    // after an agent has processed a certain amount of memories (as measured by aggregate importance),\n    // it is time to pause and reflect on recent events to add more synthesized memories to the agent's\n    // memory stream.\n    if (\n      this.reflectionThreshold !== undefined &&\n      this.aggregateImportance > this.reflectionThreshold &&\n      !this.reflecting\n    ) {\n      console.log(\"Reflecting on current memories...\");\n      this.reflecting = true;\n      await this.pauseToReflect(now, runManager);\n      this.aggregateImportance = 0.0;\n      this.reflecting = false;\n    }\n    return { output: importanceScore };\n  }\n\n  /**\n   * Method that pauses the agent to reflect on recent events and generate\n   * new insights.\n   * @param now The current date.\n   * @param runManager The CallbackManagerForChainRun to use for the reflection.\n   * @returns An array of new insights as strings.\n   */\n  async pauseToReflect(\n    now?: Date,\n    runManager?: CallbackManagerForChainRun\n  ): Promise<string[]> {\n    if (this.verbose) {\n      console.log(\"Pausing to reflect...\");\n    }\n    const newInsights: string[] = [];\n    const topics = await this.getTopicsOfReflection(50, runManager);\n    for (const topic of topics) {\n      const insights = await this.getInsightsOnTopic(topic, now, runManager);\n      for (const insight of insights) {\n        // add memory\n        await this.call(\n          {\n            memory_content: insight,\n            now,\n            memory_metadata: {\n              source: \"reflection_insight\",\n            },\n          },\n          runManager?.getChild(\"reflection_insight_memory\")\n        );\n      }\n      newInsights.push(...insights);\n    }\n    return newInsights;\n  }\n\n  /**\n   * Method that scores the importance of a given memory.\n   * @param memoryContent The content of the memory to score.\n   * @param runManager The CallbackManagerForChainRun to use for scoring.\n   * @returns The importance score of the memory as a number.\n   */\n  async scoreMemoryImportance(\n    memoryContent: string,\n    runManager?: CallbackManagerForChainRun\n  ): Promise<number> {\n    // score the absolute importance of a given memory\n    const prompt = PromptTemplate.fromTemplate(\n      \"On the scale of 1 to 10, where 1 is purely mundane\" +\n        \" (e.g., brushing teeth, making bed) and 10 is\" +\n        \" extremely poignant (e.g., a break up, college\" +\n        \" acceptance), rate the likely poignancy of the\" +\n        \" following piece of memory. Respond with a single integer.\" +\n        \"\\nMemory: {memory_content}\" +\n        \"\\nRating: \"\n    );\n    const score = await this.chain(prompt).run(\n      memoryContent,\n      runManager?.getChild(\"determine_importance\")\n    );\n\n    const strippedScore = score.trim();\n\n    if (this.verbose) {\n      console.log(\"Importance score:\", strippedScore);\n    }\n    const match = strippedScore.match(/^\\D*(\\d+)/);\n    if (match) {\n      const capturedNumber = parseFloat(match[1]);\n      const result = (capturedNumber / 10) * this.importanceWeight;\n      return result;\n    } else {\n      return 0.0;\n    }\n  }\n\n  /**\n   * Method that retrieves the topics of reflection based on the last K\n   * memories.\n   * @param lastK The number of most recent memories to consider for generating topics.\n   * @param runManager The CallbackManagerForChainRun to use for retrieving topics.\n   * @returns An array of topics of reflection as strings.\n   */\n  async getTopicsOfReflection(\n    lastK: number,\n    runManager?: CallbackManagerForChainRun\n  ): Promise<string[]> {\n    const prompt = PromptTemplate.fromTemplate(\n      \"{observations}\\n\\n\" +\n        \"Given only the information above, what are the 3 most salient\" +\n        \" high-level questions we can answer about the subjects in\" +\n        \" the statements? Provide each question on a new line.\\n\\n\"\n    );\n\n    const observations = this.memoryRetriever.getMemoryStream().slice(-lastK);\n    const observationStr = observations\n      .map((o: { pageContent: string }) => o.pageContent)\n      .join(\"\\n\");\n    const result = await this.chain(prompt).run(\n      observationStr,\n      runManager?.getChild(\"reflection_topics\")\n    );\n    return GenerativeAgentMemoryChain.parseList(result);\n  }\n\n  /**\n   * Method that generates insights on a given topic of reflection based on\n   * pertinent memories.\n   * @param topic The topic of reflection.\n   * @param now The current date.\n   * @param runManager The CallbackManagerForChainRun to use for generating insights.\n   * @returns An array of insights as strings.\n   */\n  async getInsightsOnTopic(\n    topic: string,\n    now?: Date,\n    runManager?: CallbackManagerForChainRun\n  ): Promise<string[]> {\n    // generate insights on a topic of reflection, based on pertinent memories\n    const prompt = PromptTemplate.fromTemplate(\n      \"Statements about {topic}\\n\" +\n        \"{related_statements}\\n\\n\" +\n        \"What 5 high-level insights can you infer from the above statements?\" +\n        \" (example format: insight (because of 1, 5, 3))\"\n    );\n\n    const relatedMemories = await this.fetchMemories(topic, now, runManager);\n    const relatedStatements: string = relatedMemories\n      .map((memory, index) => `${index + 1}. ${memory.pageContent}`)\n      .join(\"\\n\");\n    const result = await this.chain(prompt).call(\n      {\n        topic,\n        related_statements: relatedStatements,\n      },\n      runManager?.getChild(\"reflection_insights\")\n    );\n    return GenerativeAgentMemoryChain.parseList(result.output); // added output\n  }\n\n  /**\n   * Method that parses a newline-separated string into a list of strings.\n   * @param text The newline-separated string to parse.\n   * @returns An array of strings.\n   */\n  static parseList(text: string): string[] {\n    // parse a newine seperates string into a list of strings\n    return text.split(\"\\n\").map((s) => s.trim());\n  }\n\n  // TODO: Mock \"now\" to simulate different times\n  /**\n   * Method that fetches memories related to a given observation.\n   * @param observation The observation to fetch memories for.\n   * @param _now The current date.\n   * @param runManager The CallbackManagerForChainRun to use for fetching memories.\n   * @returns An array of Document instances representing the fetched memories.\n   */\n  async fetchMemories(\n    observation: string,\n    _now?: Date,\n    runManager?: CallbackManagerForChainRun\n  ): Promise<Document[]> {\n    return this.memoryRetriever.invoke(\n      observation,\n      runManager?.getChild(\"memory_retriever\")\n    );\n  }\n}\n\n/**\n * Class that manages the memory of a generative agent in LangChain. It\n * extends the `BaseMemory` class and has methods for adding a memory,\n * formatting memories, getting memories until a token limit is reached,\n * loading memory variables, saving the context of a model run to memory,\n * and clearing memory contents.\n * @example\n * ```typescript\n * const createNewMemoryRetriever = async () => {\n *   const vectorStore = new MemoryVectorStore(new OpenAIEmbeddings());\n *   const retriever = new TimeWeightedVectorStoreRetriever({\n *     vectorStore,\n *     otherScoreKeys: [\"importance\"],\n *     k: 15,\n *   });\n *   return retriever;\n * };\n * const tommiesMemory = new GenerativeAgentMemory(\n *   llm,\n *   await createNewMemoryRetriever(),\n *   { reflectionThreshold: 8 },\n * );\n * const summary = await tommiesMemory.getSummary();\n * ```\n */\nexport class GenerativeAgentMemory extends BaseMemory {\n  llm: BaseLanguageModelInterface;\n\n  memoryRetriever: TimeWeightedVectorStoreRetriever;\n\n  verbose: boolean;\n\n  reflectionThreshold?: number;\n\n  private maxTokensLimit = 1200;\n\n  queriesKey = \"queries\";\n\n  mostRecentMemoriesTokenKey = \"recent_memories_token\";\n\n  addMemoryKey = \"addMemory\";\n\n  relevantMemoriesKey = \"relevant_memories\";\n\n  relevantMemoriesSimpleKey = \"relevant_memories_simple\";\n\n  mostRecentMemoriesKey = \"most_recent_memories\";\n\n  nowKey = \"now\";\n\n  memoryChain: GenerativeAgentMemoryChain;\n\n  constructor(\n    llm: BaseLanguageModelInterface,\n    memoryRetriever: TimeWeightedVectorStoreRetriever,\n    config?: GenerativeAgentMemoryConfig\n  ) {\n    super();\n    this.llm = llm;\n    this.memoryRetriever = memoryRetriever;\n    this.verbose = config?.verbose ?? this.verbose;\n    this.reflectionThreshold =\n      config?.reflectionThreshold ?? this.reflectionThreshold;\n    this.maxTokensLimit = config?.maxTokensLimit ?? this.maxTokensLimit;\n    this.memoryChain = new GenerativeAgentMemoryChain(llm, memoryRetriever, {\n      reflectionThreshold: config?.reflectionThreshold,\n      importanceWeight: config?.importanceWeight,\n    });\n  }\n\n  /**\n   * Method that returns the key for relevant memories.\n   * @returns The key for relevant memories as a string.\n   */\n  getRelevantMemoriesKey(): string {\n    return this.relevantMemoriesKey;\n  }\n\n  /**\n   * Method that returns the key for the most recent memories token.\n   * @returns The key for the most recent memories token as a string.\n   */\n  getMostRecentMemoriesTokenKey(): string {\n    return this.mostRecentMemoriesTokenKey;\n  }\n\n  /**\n   * Method that returns the key for adding a memory.\n   * @returns The key for adding a memory as a string.\n   */\n  getAddMemoryKey(): string {\n    return this.addMemoryKey;\n  }\n\n  /**\n   * Method that returns the key for the current time.\n   * @returns The key for the current time as a string.\n   */\n  getCurrentTimeKey(): string {\n    return this.nowKey;\n  }\n\n  get memoryKeys(): string[] {\n    // Return an array of memory keys\n    return [this.relevantMemoriesKey, this.mostRecentMemoriesKey];\n  }\n\n  /**\n   * Method that adds a memory to the agent's memory.\n   * @param memoryContent The content of the memory to add.\n   * @param now The current date.\n   * @param metadata The metadata for the memory.\n   * @param callbacks The Callbacks to use for adding the memory.\n   * @returns The result of the memory addition.\n   */\n  async addMemory(\n    memoryContent: string,\n    now?: Date,\n    metadata?: Record<string, unknown>,\n    callbacks?: Callbacks\n  ) {\n    return this.memoryChain.call(\n      { memory_content: memoryContent, now, memory_metadata: metadata },\n      callbacks\n    );\n  }\n\n  /**\n   * Method that formats the given relevant memories in detail.\n   * @param relevantMemories The relevant memories to format.\n   * @returns The formatted memories as a string.\n   */\n  formatMemoriesDetail(relevantMemories: Document[]): string {\n    if (!relevantMemories.length) {\n      return \"No relevant information.\";\n    }\n    const contentStrings = new Set();\n    const content = [];\n    for (const memory of relevantMemories) {\n      if (memory.pageContent in contentStrings) {\n        continue;\n      }\n      contentStrings.add(memory.pageContent);\n      const createdTime = memory.metadata.created_at.toLocaleString(\"en-US\", {\n        month: \"long\",\n        day: \"numeric\",\n        year: \"numeric\",\n        hour: \"numeric\",\n        minute: \"numeric\",\n        hour12: true,\n      });\n      content.push(`${createdTime}: ${memory.pageContent.trim()}`);\n    }\n    const joinedContent = content.map((mem) => `${mem}`).join(\"\\n\");\n    return joinedContent;\n  }\n\n  /**\n   * Method that formats the given relevant memories in a simple manner.\n   * @param relevantMemories The relevant memories to format.\n   * @returns The formatted memories as a string.\n   */\n  formatMemoriesSimple(relevantMemories: Document[]): string {\n    const joinedContent = relevantMemories\n      .map((mem) => `${mem.pageContent}`)\n      .join(\"; \");\n    return joinedContent;\n  }\n\n  /**\n   * Method that retrieves memories until a token limit is reached.\n   * @param consumedTokens The number of tokens consumed so far.\n   * @returns The memories as a string.\n   */\n  async getMemoriesUntilLimit(consumedTokens: number): Promise<string> {\n    // reduce the number of tokens in the documents\n    const result = [];\n    for (const doc of this.memoryRetriever\n      .getMemoryStream()\n      .slice()\n      .reverse()) {\n      if (consumedTokens >= this.maxTokensLimit) {\n        if (this.verbose) {\n          console.log(\"Exceeding max tokens for LLM, filtering memories\");\n        }\n        break;\n      }\n      // eslint-disable-next-line no-param-reassign\n      consumedTokens += await this.llm.getNumTokens(doc.pageContent);\n      if (consumedTokens < this.maxTokensLimit) {\n        result.push(doc);\n      }\n    }\n    return this.formatMemoriesSimple(result);\n  }\n\n  get memoryVariables(): string[] {\n    // input keys this memory class will load dynamically\n    return [];\n  }\n\n  /**\n   * Method that loads memory variables based on the given inputs.\n   * @param inputs The inputs to use for loading memory variables.\n   * @returns An object containing the loaded memory variables.\n   */\n  async loadMemoryVariables(\n    inputs: InputValues\n  ): Promise<Record<string, string>> {\n    const queries = inputs[this.queriesKey];\n    const now = inputs[this.nowKey];\n    if (queries !== undefined) {\n      const relevantMemories = (\n        await Promise.all(\n          queries.map((query: string) =>\n            this.memoryChain.fetchMemories(query, now)\n          )\n        )\n      ).flat();\n      return {\n        [this.relevantMemoriesKey]: this.formatMemoriesDetail(relevantMemories),\n        [this.relevantMemoriesSimpleKey]:\n          this.formatMemoriesSimple(relevantMemories),\n      };\n    }\n    const mostRecentMemoriesToken = inputs[this.mostRecentMemoriesTokenKey];\n    if (mostRecentMemoriesToken !== undefined) {\n      return {\n        [this.mostRecentMemoriesKey]: await this.getMemoriesUntilLimit(\n          mostRecentMemoriesToken\n        ),\n      };\n    }\n    return {};\n  }\n\n  /**\n   * Method that saves the context of a model run to memory.\n   * @param _inputs The inputs of the model run.\n   * @param outputs The outputs of the model run.\n   * @returns Nothing.\n   */\n  async saveContext(\n    _inputs: InputValues,\n    outputs: OutputValues\n  ): Promise<void> {\n    // save the context of this model run to memory\n    const mem = outputs[this.addMemoryKey];\n    const now = outputs[this.nowKey];\n    if (mem) {\n      await this.addMemory(mem, now, {});\n    }\n  }\n\n  /**\n   * Method that clears the memory contents.\n   * @returns Nothing.\n   */\n  clear(): void {\n    // TODO: clear memory contents\n  }\n}\n"],"mappings":"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"}

package/dist/experimental/generative_agents/index.cjs

@@ -1,10 +1,10 @@
-const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../../_virtual/_rolldown/runtime.cjs');
 const require_generative_agent_memory = require('./generative_agent_memory.cjs');
 const require_generative_agent = require('./generative_agent.cjs');
 
 //#region src/experimental/generative_agents/index.ts
-var generative_agents_exports = {};
-require_rolldown_runtime.__export(generative_agents_exports, {
+var generative_agents_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	GenerativeAgent: () => require_generative_agent.GenerativeAgent,
 	GenerativeAgentMemory: () => require_generative_agent_memory.GenerativeAgentMemory
 });

package/dist/experimental/generative_agents/index.js

@@ -1,10 +1,9 @@
-import { __export } from "../../_virtual/rolldown_runtime.js";
+import { __exportAll } from "../../_virtual/_rolldown/runtime.js";
 import { GenerativeAgentMemory } from "./generative_agent_memory.js";
 import { GenerativeAgent } from "./generative_agent.js";
 
 //#region src/experimental/generative_agents/index.ts
-var generative_agents_exports = {};
-__export(generative_agents_exports, {
+var generative_agents_exports = /* @__PURE__ */ __exportAll({
 	GenerativeAgent: () => GenerativeAgent,
 	GenerativeAgentMemory: () => GenerativeAgentMemory
 });

package/dist/experimental/masking/index.cjs

@@ -1,11 +1,11 @@
-const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../../_virtual/_rolldown/runtime.cjs');
 const require_parser = require('./parser.cjs');
 const require_transformer = require('./transformer.cjs');
 const require_regex_masking_transformer = require('./regex_masking_transformer.cjs');
 
 //#region src/experimental/masking/index.ts
-var masking_exports = {};
-require_rolldown_runtime.__export(masking_exports, {
+var masking_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	MaskingParser: () => require_parser.MaskingParser,
 	MaskingTransformer: () => require_transformer.MaskingTransformer,
 	RegexMaskingTransformer: () => require_regex_masking_transformer.RegexMaskingTransformer

package/dist/experimental/masking/index.js

@@ -1,11 +1,10 @@
-import { __export } from "../../_virtual/rolldown_runtime.js";
+import { __exportAll } from "../../_virtual/_rolldown/runtime.js";
 import { MaskingParser } from "./parser.js";
 import { MaskingTransformer } from "./transformer.js";
 import { RegexMaskingTransformer } from "./regex_masking_transformer.js";
 
 //#region src/experimental/masking/index.ts
-var masking_exports = {};
-__export(masking_exports, {
+var masking_exports = /* @__PURE__ */ __exportAll({
 	MaskingParser: () => MaskingParser,
 	MaskingTransformer: () => MaskingTransformer,
 	RegexMaskingTransformer: () => RegexMaskingTransformer

package/dist/experimental/masking/parser.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"parser.cjs","names":["config: MaskingParserConfig","transformer: MaskingTransformer","message: string","state?: Map<string, string>"],"sources":["../../../src/experimental/masking/parser.ts"],"sourcesContent":["import { MaskingTransformer } from \"./transformer.js\";\nimport type { MaskingParserConfig } from \"./types.js\";\n\n/**\n * MaskingParser class for handling the masking and rehydrating of messages.\n */\nexport class MaskingParser {\n  private transformers: MaskingTransformer[];\n\n  private state: Map<string, string>;\n\n  private config: MaskingParserConfig;\n\n  constructor(config: MaskingParserConfig = {}) {\n    this.transformers = config.transformers ?? [];\n    this.state = new Map<string, string>();\n    this.config = config;\n  }\n\n  /**\n   * Adds a transformer to the parser.\n   * @param transformer - An instance of a class extending MaskingTransformer.\n   */\n  addTransformer(transformer: MaskingTransformer) {\n    this.transformers.push(transformer);\n  }\n\n  /**\n   * Getter method for retrieving the current state.\n   * @returns The current state map.\n   */\n  public getState(): Map<string, string> {\n    return this.state;\n  }\n\n  /**\n   * Masks the provided message using the added transformers.\n   * This method sequentially applies each transformer's masking logic to the message.\n   * It utilizes a state map to track original values corresponding to their masked versions.\n   *\n   * @param message - The message to be masked.\n   * @returns A masked version of the message.\n   * @throws {TypeError} If the message is not a string.\n   * @throws {Error} If no transformers are added.\n   */\n  async mask(message: string): Promise<string> {\n    // If onMaskingStart is a function, handle it accordingly\n    if (this.config.onMaskingStart) {\n      await this.config.onMaskingStart(message);\n    }\n\n    // Check if there are any transformers added to the parser. If not, throw an error\n    // as masking requires at least one transformer to apply its logic.\n    if (this.transformers.length === 0) {\n      throw new Error(\n        \"MaskingParser.mask Error: No transformers have been added. Please add at least one transformer before parsing.\"\n      );\n    }\n\n    if (typeof message !== \"string\") {\n      throw new TypeError(\n        \"MaskingParser.mask Error: The 'message' argument must be a string.\"\n      );\n    }\n\n    // Initialize the variable to hold the progressively masked message.\n    // It starts as the original message and gets transformed by each transformer.\n    let processedMessage = message;\n\n    // Iterate through each transformer and apply their transform method.\n    for (const transformer of this.transformers) {\n      // Transform the message and get the transformer's state changes, ensuring no direct mutation of the shared state.\n      const [transformedMessage, transformerState] =\n        await transformer.transform(processedMessage, new Map(this.state));\n\n      // Update the processed message for subsequent transformers.\n      processedMessage = transformedMessage;\n\n      // Merge state changes from the transformer into the parser's state.\n      // This accumulates all transformations' effects on the state.\n      transformerState.forEach((value, key) => this.state.set(key, value));\n    }\n\n    // Handle onMaskingEnd callback\n    if (this.config.onMaskingEnd) {\n      await this.config.onMaskingEnd(processedMessage);\n    }\n    // Return the fully masked message after all transformers have been applied.\n    return processedMessage;\n  }\n\n  /**\n   * Rehydrates a masked message back to its original form.\n   * This method sequentially applies the rehydration logic of each added transformer in reverse order.\n   * It relies on the state map to correctly map the masked values back to their original values.\n   *\n   * The rehydration process is essential for restoring the original content of a message\n   * that has been transformed (masked) by the transformers. This process is the inverse of the masking process.\n   *\n   * @param message - The masked message to be rehydrated.\n   * @returns The original (rehydrated) version of the message.\n   */\n  async rehydrate(\n    message: string,\n    state?: Map<string, string>\n  ): Promise<string> {\n    // Handle onRehydratingStart callback\n    if (this.config.onRehydratingStart) {\n      await this.config.onRehydratingStart(message);\n    }\n\n    if (typeof message !== \"string\") {\n      throw new TypeError(\n        \"MaskingParser.rehydrate Error: The 'message' argument must be a string.\"\n      );\n    }\n    // Check if any transformers have been added to the parser.\n    // If no transformers are present, throw an error as rehydration requires at least one transformer.\n    if (this.transformers.length === 0) {\n      throw new Error(\n        \"MaskingParser.rehydrate Error: No transformers have been added. Please add at least one transformer before rehydrating.\"\n      );\n    }\n\n    // eslint-disable-next-line no-instanceof/no-instanceof\n    if (state && !(state instanceof Map)) {\n      throw new TypeError(\n        \"MaskingParser.rehydrate Error: The 'state' argument, if provided, must be an instance of Map.\"\n      );\n    }\n\n    const rehydrationState = state || this.state; // Use provided state or fallback to internal state\n    // Initialize the rehydratedMessage with the input masked message.\n    // This variable will undergo rehydration by each transformer in reverse order.\n    let rehydratedMessage = message;\n    // Use a reverse for...of loop to accommodate asynchronous rehydrate methods\n    const reversedTransformers = this.transformers.slice().reverse();\n    for (const transformer of reversedTransformers) {\n      // Check if the result is a Promise and use await, otherwise use it directly\n      rehydratedMessage = await transformer.rehydrate(\n        rehydratedMessage,\n        rehydrationState\n      );\n    }\n\n    // Handle onRehydratingEnd callback\n    if (this.config.onRehydratingEnd) {\n      await this.config.onRehydratingEnd(rehydratedMessage);\n    }\n\n    // Return the fully rehydrated message after all transformers have been applied.\n    return rehydratedMessage;\n  }\n}\n"],"mappings":";;;;;AAMA,IAAa,gBAAb,MAA2B;CACzB,AAAQ;CAER,AAAQ;CAER,AAAQ;CAER,YAAYA,SAA8B,CAAE,GAAE;EAC5C,KAAK,eAAe,OAAO,gBAAgB,CAAE;EAC7C,KAAK,wBAAQ,IAAI;EACjB,KAAK,SAAS;CACf;;;;;CAMD,eAAeC,aAAiC;EAC9C,KAAK,aAAa,KAAK,YAAY;CACpC;;;;;CAMD,AAAO,WAAgC;AACrC,SAAO,KAAK;CACb;;;;;;;;;;;CAYD,MAAM,KAAKC,SAAkC;AAE3C,MAAI,KAAK,OAAO,gBACd,MAAM,KAAK,OAAO,eAAe,QAAQ;AAK3C,MAAI,KAAK,aAAa,WAAW,EAC/B,OAAM,IAAI,MACR;AAIJ,MAAI,OAAO,YAAY,SACrB,OAAM,IAAI,UACR;EAMJ,IAAI,mBAAmB;AAGvB,OAAK,MAAM,eAAe,KAAK,cAAc;GAE3C,MAAM,CAAC,oBAAoB,iBAAiB,GAC1C,MAAM,YAAY,UAAU,kBAAkB,IAAI,IAAI,KAAK,OAAO;GAGpE,mBAAmB;GAInB,iBAAiB,QAAQ,CAAC,OAAO,QAAQ,KAAK,MAAM,IAAI,KAAK,MAAM,CAAC;EACrE;AAGD,MAAI,KAAK,OAAO,cACd,MAAM,KAAK,OAAO,aAAa,iBAAiB;AAGlD,SAAO;CACR;;;;;;;;;;;;CAaD,MAAM,UACJA,SACAC,OACiB;AAEjB,MAAI,KAAK,OAAO,oBACd,MAAM,KAAK,OAAO,mBAAmB,QAAQ;AAG/C,MAAI,OAAO,YAAY,SACrB,OAAM,IAAI,UACR;AAKJ,MAAI,KAAK,aAAa,WAAW,EAC/B,OAAM,IAAI,MACR;AAKJ,MAAI,SAAS,EAAE,iBAAiB,KAC9B,OAAM,IAAI,UACR;EAIJ,MAAM,mBAAmB,SAAS,KAAK;EAGvC,IAAI,oBAAoB;EAExB,MAAM,uBAAuB,KAAK,aAAa,OAAO,CAAC,SAAS;AAChE,OAAK,MAAM,eAAe,sBAExB,oBAAoB,MAAM,YAAY,UACpC,mBACA,iBACD;AAIH,MAAI,KAAK,OAAO,kBACd,MAAM,KAAK,OAAO,iBAAiB,kBAAkB;AAIvD,SAAO;CACR;AACF"}
+{"version":3,"file":"parser.cjs","names":[],"sources":["../../../src/experimental/masking/parser.ts"],"sourcesContent":["import { MaskingTransformer } from \"./transformer.js\";\nimport type { MaskingParserConfig } from \"./types.js\";\n\n/**\n * MaskingParser class for handling the masking and rehydrating of messages.\n */\nexport class MaskingParser {\n  private transformers: MaskingTransformer[];\n\n  private state: Map<string, string>;\n\n  private config: MaskingParserConfig;\n\n  constructor(config: MaskingParserConfig = {}) {\n    this.transformers = config.transformers ?? [];\n    this.state = new Map<string, string>();\n    this.config = config;\n  }\n\n  /**\n   * Adds a transformer to the parser.\n   * @param transformer - An instance of a class extending MaskingTransformer.\n   */\n  addTransformer(transformer: MaskingTransformer) {\n    this.transformers.push(transformer);\n  }\n\n  /**\n   * Getter method for retrieving the current state.\n   * @returns The current state map.\n   */\n  public getState(): Map<string, string> {\n    return this.state;\n  }\n\n  /**\n   * Masks the provided message using the added transformers.\n   * This method sequentially applies each transformer's masking logic to the message.\n   * It utilizes a state map to track original values corresponding to their masked versions.\n   *\n   * @param message - The message to be masked.\n   * @returns A masked version of the message.\n   * @throws {TypeError} If the message is not a string.\n   * @throws {Error} If no transformers are added.\n   */\n  async mask(message: string): Promise<string> {\n    // If onMaskingStart is a function, handle it accordingly\n    if (this.config.onMaskingStart) {\n      await this.config.onMaskingStart(message);\n    }\n\n    // Check if there are any transformers added to the parser. If not, throw an error\n    // as masking requires at least one transformer to apply its logic.\n    if (this.transformers.length === 0) {\n      throw new Error(\n        \"MaskingParser.mask Error: No transformers have been added. Please add at least one transformer before parsing.\"\n      );\n    }\n\n    if (typeof message !== \"string\") {\n      throw new TypeError(\n        \"MaskingParser.mask Error: The 'message' argument must be a string.\"\n      );\n    }\n\n    // Initialize the variable to hold the progressively masked message.\n    // It starts as the original message and gets transformed by each transformer.\n    let processedMessage = message;\n\n    // Iterate through each transformer and apply their transform method.\n    for (const transformer of this.transformers) {\n      // Transform the message and get the transformer's state changes, ensuring no direct mutation of the shared state.\n      const [transformedMessage, transformerState] =\n        await transformer.transform(processedMessage, new Map(this.state));\n\n      // Update the processed message for subsequent transformers.\n      processedMessage = transformedMessage;\n\n      // Merge state changes from the transformer into the parser's state.\n      // This accumulates all transformations' effects on the state.\n      transformerState.forEach((value, key) => this.state.set(key, value));\n    }\n\n    // Handle onMaskingEnd callback\n    if (this.config.onMaskingEnd) {\n      await this.config.onMaskingEnd(processedMessage);\n    }\n    // Return the fully masked message after all transformers have been applied.\n    return processedMessage;\n  }\n\n  /**\n   * Rehydrates a masked message back to its original form.\n   * This method sequentially applies the rehydration logic of each added transformer in reverse order.\n   * It relies on the state map to correctly map the masked values back to their original values.\n   *\n   * The rehydration process is essential for restoring the original content of a message\n   * that has been transformed (masked) by the transformers. This process is the inverse of the masking process.\n   *\n   * @param message - The masked message to be rehydrated.\n   * @returns The original (rehydrated) version of the message.\n   */\n  async rehydrate(\n    message: string,\n    state?: Map<string, string>\n  ): Promise<string> {\n    // Handle onRehydratingStart callback\n    if (this.config.onRehydratingStart) {\n      await this.config.onRehydratingStart(message);\n    }\n\n    if (typeof message !== \"string\") {\n      throw new TypeError(\n        \"MaskingParser.rehydrate Error: The 'message' argument must be a string.\"\n      );\n    }\n    // Check if any transformers have been added to the parser.\n    // If no transformers are present, throw an error as rehydration requires at least one transformer.\n    if (this.transformers.length === 0) {\n      throw new Error(\n        \"MaskingParser.rehydrate Error: No transformers have been added. Please add at least one transformer before rehydrating.\"\n      );\n    }\n\n    // eslint-disable-next-line no-instanceof/no-instanceof\n    if (state && !(state instanceof Map)) {\n      throw new TypeError(\n        \"MaskingParser.rehydrate Error: The 'state' argument, if provided, must be an instance of Map.\"\n      );\n    }\n\n    const rehydrationState = state || this.state; // Use provided state or fallback to internal state\n    // Initialize the rehydratedMessage with the input masked message.\n    // This variable will undergo rehydration by each transformer in reverse order.\n    let rehydratedMessage = message;\n    // Use a reverse for...of loop to accommodate asynchronous rehydrate methods\n    const reversedTransformers = this.transformers.slice().reverse();\n    for (const transformer of reversedTransformers) {\n      // Check if the result is a Promise and use await, otherwise use it directly\n      rehydratedMessage = await transformer.rehydrate(\n        rehydratedMessage,\n        rehydrationState\n      );\n    }\n\n    // Handle onRehydratingEnd callback\n    if (this.config.onRehydratingEnd) {\n      await this.config.onRehydratingEnd(rehydratedMessage);\n    }\n\n    // Return the fully rehydrated message after all transformers have been applied.\n    return rehydratedMessage;\n  }\n}\n"],"mappings":";;;;;AAMA,IAAa,gBAAb,MAA2B;CACzB,AAAQ;CAER,AAAQ;CAER,AAAQ;CAER,YAAY,SAA8B,EAAE,EAAE;AAC5C,OAAK,eAAe,OAAO,gBAAgB,EAAE;AAC7C,OAAK,wBAAQ,IAAI,KAAqB;AACtC,OAAK,SAAS;;;;;;CAOhB,eAAe,aAAiC;AAC9C,OAAK,aAAa,KAAK,YAAY;;;;;;CAOrC,AAAO,WAAgC;AACrC,SAAO,KAAK;;;;;;;;;;;;CAad,MAAM,KAAK,SAAkC;AAE3C,MAAI,KAAK,OAAO,eACd,OAAM,KAAK,OAAO,eAAe,QAAQ;AAK3C,MAAI,KAAK,aAAa,WAAW,EAC/B,OAAM,IAAI,MACR,iHACD;AAGH,MAAI,OAAO,YAAY,SACrB,OAAM,IAAI,UACR,qEACD;EAKH,IAAI,mBAAmB;AAGvB,OAAK,MAAM,eAAe,KAAK,cAAc;GAE3C,MAAM,CAAC,oBAAoB,oBACzB,MAAM,YAAY,UAAU,kBAAkB,IAAI,IAAI,KAAK,MAAM,CAAC;AAGpE,sBAAmB;AAInB,oBAAiB,SAAS,OAAO,QAAQ,KAAK,MAAM,IAAI,KAAK,MAAM,CAAC;;AAItE,MAAI,KAAK,OAAO,aACd,OAAM,KAAK,OAAO,aAAa,iBAAiB;AAGlD,SAAO;;;;;;;;;;;;;CAcT,MAAM,UACJ,SACA,OACiB;AAEjB,MAAI,KAAK,OAAO,mBACd,OAAM,KAAK,OAAO,mBAAmB,QAAQ;AAG/C,MAAI,OAAO,YAAY,SACrB,OAAM,IAAI,UACR,0EACD;AAIH,MAAI,KAAK,aAAa,WAAW,EAC/B,OAAM,IAAI,MACR,0HACD;AAIH,MAAI,SAAS,EAAE,iBAAiB,KAC9B,OAAM,IAAI,UACR,gGACD;EAGH,MAAM,mBAAmB,SAAS,KAAK;EAGvC,IAAI,oBAAoB;EAExB,MAAM,uBAAuB,KAAK,aAAa,OAAO,CAAC,SAAS;AAChE,OAAK,MAAM,eAAe,qBAExB,qBAAoB,MAAM,YAAY,UACpC,mBACA,iBACD;AAIH,MAAI,KAAK,OAAO,iBACd,OAAM,KAAK,OAAO,iBAAiB,kBAAkB;AAIvD,SAAO"}

package/dist/experimental/masking/parser.d.cts

@@ -2,7 +2,6 @@ import { MaskingTransformer } from "./transformer.cjs";
 import { MaskingParserConfig } from "./types.cjs";
 
 //#region src/experimental/masking/parser.d.ts
-
 /**
  * MaskingParser class for handling the masking and rehydrating of messages.
  */

package/dist/experimental/masking/parser.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"parser.d.cts","names":["MaskingTransformer","MaskingParserConfig","MaskingParser","Map","Promise"],"sources":["../../../src/experimental/masking/parser.d.ts"],"sourcesContent":["import { MaskingTransformer } from \"./transformer.js\";\nimport type { MaskingParserConfig } from \"./types.js\";\n/**\n * MaskingParser class for handling the masking and rehydrating of messages.\n */\nexport declare class MaskingParser {\n    private transformers;\n    private state;\n    private config;\n    constructor(config?: MaskingParserConfig);\n    /**\n     * Adds a transformer to the parser.\n     * @param transformer - An instance of a class extending MaskingTransformer.\n     */\n    addTransformer(transformer: MaskingTransformer): void;\n    /**\n     * Getter method for retrieving the current state.\n     * @returns The current state map.\n     */\n    getState(): Map<string, string>;\n    /**\n     * Masks the provided message using the added transformers.\n     * This method sequentially applies each transformer's masking logic to the message.\n     * It utilizes a state map to track original values corresponding to their masked versions.\n     *\n     * @param message - The message to be masked.\n     * @returns A masked version of the message.\n     * @throws {TypeError} If the message is not a string.\n     * @throws {Error} If no transformers are added.\n     */\n    mask(message: string): Promise<string>;\n    /**\n     * Rehydrates a masked message back to its original form.\n     * This method sequentially applies the rehydration logic of each added transformer in reverse order.\n     * It relies on the state map to correctly map the masked values back to their original values.\n     *\n     * The rehydration process is essential for restoring the original content of a message\n     * that has been transformed (masked) by the transformers. This process is the inverse of the masking process.\n     *\n     * @param message - The masked message to be rehydrated.\n     * @returns The original (rehydrated) version of the message.\n     */\n    rehydrate(message: string, state?: Map<string, string>): Promise<string>;\n}\n//# sourceMappingURL=parser.d.ts.map"],"mappings":";;;;;;;AAKA;AAIyBC,cAJJC,aAAAA,CAIID;EAKOD,QAAAA,YAAAA;EAKhBG,QAAAA,KAAAA;EAWWC,QAAAA,MAAAA;EAYYD,WAAAA,CAAAA,MAAAA,CAAAA,EAjCdF,mBAiCcE;EAAsBC;AAAO;;;8BA5BpCJ;;;;;cAKhBG;;;;;;;;;;;yBAWWC;;;;;;;;;;;;qCAYYD,sBAAsBC"}
+{"version":3,"file":"parser.d.cts","names":[],"sources":["../../../src/experimental/masking/parser.ts"],"mappings":";;;;;;AAMA;cAAa,aAAA;EAAA,QACH,YAAA;EAAA,QAEA,KAAA;EAAA,QAEA,MAAA;EAER,WAAA,CAAY,MAAA,GAAQ,mBAAA;EAgCS;;;;EAtB7B,cAAA,CAAe,WAAA,EAAa,kBAAA;EAhBpB;;;;EAwBD,QAAA,CAAA,GAAY,GAAA;EAlBP;;;;;;;;;;EAgCN,IAAA,CAAK,OAAA,WAAkB,OAAA;EA2DnB;;;;;;;;;;;EAFJ,SAAA,CACJ,OAAA,UACA,KAAA,GAAQ,GAAA,mBACP,OAAA;AAAA"}

package/dist/experimental/masking/parser.d.ts

@@ -2,7 +2,6 @@ import { MaskingTransformer } from "./transformer.js";
 import { MaskingParserConfig } from "./types.js";
 
 //#region src/experimental/masking/parser.d.ts
-
 /**
  * MaskingParser class for handling the masking and rehydrating of messages.
  */

package/dist/experimental/masking/parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parser.d.ts","names":["MaskingTransformer","MaskingParserConfig","MaskingParser","Map","Promise"],"sources":["../../../src/experimental/masking/parser.d.ts"],"sourcesContent":["import { MaskingTransformer } from \"./transformer.js\";\nimport type { MaskingParserConfig } from \"./types.js\";\n/**\n * MaskingParser class for handling the masking and rehydrating of messages.\n */\nexport declare class MaskingParser {\n    private transformers;\n    private state;\n    private config;\n    constructor(config?: MaskingParserConfig);\n    /**\n     * Adds a transformer to the parser.\n     * @param transformer - An instance of a class extending MaskingTransformer.\n     */\n    addTransformer(transformer: MaskingTransformer): void;\n    /**\n     * Getter method for retrieving the current state.\n     * @returns The current state map.\n     */\n    getState(): Map<string, string>;\n    /**\n     * Masks the provided message using the added transformers.\n     * This method sequentially applies each transformer's masking logic to the message.\n     * It utilizes a state map to track original values corresponding to their masked versions.\n     *\n     * @param message - The message to be masked.\n     * @returns A masked version of the message.\n     * @throws {TypeError} If the message is not a string.\n     * @throws {Error} If no transformers are added.\n     */\n    mask(message: string): Promise<string>;\n    /**\n     * Rehydrates a masked message back to its original form.\n     * This method sequentially applies the rehydration logic of each added transformer in reverse order.\n     * It relies on the state map to correctly map the masked values back to their original values.\n     *\n     * The rehydration process is essential for restoring the original content of a message\n     * that has been transformed (masked) by the transformers. This process is the inverse of the masking process.\n     *\n     * @param message - The masked message to be rehydrated.\n     * @returns The original (rehydrated) version of the message.\n     */\n    rehydrate(message: string, state?: Map<string, string>): Promise<string>;\n}\n//# sourceMappingURL=parser.d.ts.map"],"mappings":";;;;;;;AAKA;AAIyBC,cAJJC,aAAAA,CAIID;EAKOD,QAAAA,YAAAA;EAKhBG,QAAAA,KAAAA;EAWWC,QAAAA,MAAAA;EAYYD,WAAAA,CAAAA,MAAAA,CAAAA,EAjCdF,mBAiCcE;EAAsBC;AAAO;;;8BA5BpCJ;;;;;cAKhBG;;;;;;;;;;;yBAWWC;;;;;;;;;;;;qCAYYD,sBAAsBC"}
+{"version":3,"file":"parser.d.ts","names":[],"sources":["../../../src/experimental/masking/parser.ts"],"mappings":";;;;;;AAMA;cAAa,aAAA;EAAA,QACH,YAAA;EAAA,QAEA,KAAA;EAAA,QAEA,MAAA;EAER,WAAA,CAAY,MAAA,GAAQ,mBAAA;EAgCS;;;;EAtB7B,cAAA,CAAe,WAAA,EAAa,kBAAA;EAhBpB;;;;EAwBD,QAAA,CAAA,GAAY,GAAA;EAlBP;;;;;;;;;;EAgCN,IAAA,CAAK,OAAA,WAAkB,OAAA;EA2DnB;;;;;;;;;;;EAFJ,SAAA,CACJ,OAAA,UACA,KAAA,GAAQ,GAAA,mBACP,OAAA;AAAA"}

package/dist/experimental/masking/parser.js.map

@@ -1 +1 @@
-{"version":3,"file":"parser.js","names":["config: MaskingParserConfig","transformer: MaskingTransformer","message: string","state?: Map<string, string>"],"sources":["../../../src/experimental/masking/parser.ts"],"sourcesContent":["import { MaskingTransformer } from \"./transformer.js\";\nimport type { MaskingParserConfig } from \"./types.js\";\n\n/**\n * MaskingParser class for handling the masking and rehydrating of messages.\n */\nexport class MaskingParser {\n  private transformers: MaskingTransformer[];\n\n  private state: Map<string, string>;\n\n  private config: MaskingParserConfig;\n\n  constructor(config: MaskingParserConfig = {}) {\n    this.transformers = config.transformers ?? [];\n    this.state = new Map<string, string>();\n    this.config = config;\n  }\n\n  /**\n   * Adds a transformer to the parser.\n   * @param transformer - An instance of a class extending MaskingTransformer.\n   */\n  addTransformer(transformer: MaskingTransformer) {\n    this.transformers.push(transformer);\n  }\n\n  /**\n   * Getter method for retrieving the current state.\n   * @returns The current state map.\n   */\n  public getState(): Map<string, string> {\n    return this.state;\n  }\n\n  /**\n   * Masks the provided message using the added transformers.\n   * This method sequentially applies each transformer's masking logic to the message.\n   * It utilizes a state map to track original values corresponding to their masked versions.\n   *\n   * @param message - The message to be masked.\n   * @returns A masked version of the message.\n   * @throws {TypeError} If the message is not a string.\n   * @throws {Error} If no transformers are added.\n   */\n  async mask(message: string): Promise<string> {\n    // If onMaskingStart is a function, handle it accordingly\n    if (this.config.onMaskingStart) {\n      await this.config.onMaskingStart(message);\n    }\n\n    // Check if there are any transformers added to the parser. If not, throw an error\n    // as masking requires at least one transformer to apply its logic.\n    if (this.transformers.length === 0) {\n      throw new Error(\n        \"MaskingParser.mask Error: No transformers have been added. Please add at least one transformer before parsing.\"\n      );\n    }\n\n    if (typeof message !== \"string\") {\n      throw new TypeError(\n        \"MaskingParser.mask Error: The 'message' argument must be a string.\"\n      );\n    }\n\n    // Initialize the variable to hold the progressively masked message.\n    // It starts as the original message and gets transformed by each transformer.\n    let processedMessage = message;\n\n    // Iterate through each transformer and apply their transform method.\n    for (const transformer of this.transformers) {\n      // Transform the message and get the transformer's state changes, ensuring no direct mutation of the shared state.\n      const [transformedMessage, transformerState] =\n        await transformer.transform(processedMessage, new Map(this.state));\n\n      // Update the processed message for subsequent transformers.\n      processedMessage = transformedMessage;\n\n      // Merge state changes from the transformer into the parser's state.\n      // This accumulates all transformations' effects on the state.\n      transformerState.forEach((value, key) => this.state.set(key, value));\n    }\n\n    // Handle onMaskingEnd callback\n    if (this.config.onMaskingEnd) {\n      await this.config.onMaskingEnd(processedMessage);\n    }\n    // Return the fully masked message after all transformers have been applied.\n    return processedMessage;\n  }\n\n  /**\n   * Rehydrates a masked message back to its original form.\n   * This method sequentially applies the rehydration logic of each added transformer in reverse order.\n   * It relies on the state map to correctly map the masked values back to their original values.\n   *\n   * The rehydration process is essential for restoring the original content of a message\n   * that has been transformed (masked) by the transformers. This process is the inverse of the masking process.\n   *\n   * @param message - The masked message to be rehydrated.\n   * @returns The original (rehydrated) version of the message.\n   */\n  async rehydrate(\n    message: string,\n    state?: Map<string, string>\n  ): Promise<string> {\n    // Handle onRehydratingStart callback\n    if (this.config.onRehydratingStart) {\n      await this.config.onRehydratingStart(message);\n    }\n\n    if (typeof message !== \"string\") {\n      throw new TypeError(\n        \"MaskingParser.rehydrate Error: The 'message' argument must be a string.\"\n      );\n    }\n    // Check if any transformers have been added to the parser.\n    // If no transformers are present, throw an error as rehydration requires at least one transformer.\n    if (this.transformers.length === 0) {\n      throw new Error(\n        \"MaskingParser.rehydrate Error: No transformers have been added. Please add at least one transformer before rehydrating.\"\n      );\n    }\n\n    // eslint-disable-next-line no-instanceof/no-instanceof\n    if (state && !(state instanceof Map)) {\n      throw new TypeError(\n        \"MaskingParser.rehydrate Error: The 'state' argument, if provided, must be an instance of Map.\"\n      );\n    }\n\n    const rehydrationState = state || this.state; // Use provided state or fallback to internal state\n    // Initialize the rehydratedMessage with the input masked message.\n    // This variable will undergo rehydration by each transformer in reverse order.\n    let rehydratedMessage = message;\n    // Use a reverse for...of loop to accommodate asynchronous rehydrate methods\n    const reversedTransformers = this.transformers.slice().reverse();\n    for (const transformer of reversedTransformers) {\n      // Check if the result is a Promise and use await, otherwise use it directly\n      rehydratedMessage = await transformer.rehydrate(\n        rehydratedMessage,\n        rehydrationState\n      );\n    }\n\n    // Handle onRehydratingEnd callback\n    if (this.config.onRehydratingEnd) {\n      await this.config.onRehydratingEnd(rehydratedMessage);\n    }\n\n    // Return the fully rehydrated message after all transformers have been applied.\n    return rehydratedMessage;\n  }\n}\n"],"mappings":";;;;AAMA,IAAa,gBAAb,MAA2B;CACzB,AAAQ;CAER,AAAQ;CAER,AAAQ;CAER,YAAYA,SAA8B,CAAE,GAAE;EAC5C,KAAK,eAAe,OAAO,gBAAgB,CAAE;EAC7C,KAAK,wBAAQ,IAAI;EACjB,KAAK,SAAS;CACf;;;;;CAMD,eAAeC,aAAiC;EAC9C,KAAK,aAAa,KAAK,YAAY;CACpC;;;;;CAMD,AAAO,WAAgC;AACrC,SAAO,KAAK;CACb;;;;;;;;;;;CAYD,MAAM,KAAKC,SAAkC;AAE3C,MAAI,KAAK,OAAO,gBACd,MAAM,KAAK,OAAO,eAAe,QAAQ;AAK3C,MAAI,KAAK,aAAa,WAAW,EAC/B,OAAM,IAAI,MACR;AAIJ,MAAI,OAAO,YAAY,SACrB,OAAM,IAAI,UACR;EAMJ,IAAI,mBAAmB;AAGvB,OAAK,MAAM,eAAe,KAAK,cAAc;GAE3C,MAAM,CAAC,oBAAoB,iBAAiB,GAC1C,MAAM,YAAY,UAAU,kBAAkB,IAAI,IAAI,KAAK,OAAO;GAGpE,mBAAmB;GAInB,iBAAiB,QAAQ,CAAC,OAAO,QAAQ,KAAK,MAAM,IAAI,KAAK,MAAM,CAAC;EACrE;AAGD,MAAI,KAAK,OAAO,cACd,MAAM,KAAK,OAAO,aAAa,iBAAiB;AAGlD,SAAO;CACR;;;;;;;;;;;;CAaD,MAAM,UACJA,SACAC,OACiB;AAEjB,MAAI,KAAK,OAAO,oBACd,MAAM,KAAK,OAAO,mBAAmB,QAAQ;AAG/C,MAAI,OAAO,YAAY,SACrB,OAAM,IAAI,UACR;AAKJ,MAAI,KAAK,aAAa,WAAW,EAC/B,OAAM,IAAI,MACR;AAKJ,MAAI,SAAS,EAAE,iBAAiB,KAC9B,OAAM,IAAI,UACR;EAIJ,MAAM,mBAAmB,SAAS,KAAK;EAGvC,IAAI,oBAAoB;EAExB,MAAM,uBAAuB,KAAK,aAAa,OAAO,CAAC,SAAS;AAChE,OAAK,MAAM,eAAe,sBAExB,oBAAoB,MAAM,YAAY,UACpC,mBACA,iBACD;AAIH,MAAI,KAAK,OAAO,kBACd,MAAM,KAAK,OAAO,iBAAiB,kBAAkB;AAIvD,SAAO;CACR;AACF"}
+{"version":3,"file":"parser.js","names":[],"sources":["../../../src/experimental/masking/parser.ts"],"sourcesContent":["import { MaskingTransformer } from \"./transformer.js\";\nimport type { MaskingParserConfig } from \"./types.js\";\n\n/**\n * MaskingParser class for handling the masking and rehydrating of messages.\n */\nexport class MaskingParser {\n  private transformers: MaskingTransformer[];\n\n  private state: Map<string, string>;\n\n  private config: MaskingParserConfig;\n\n  constructor(config: MaskingParserConfig = {}) {\n    this.transformers = config.transformers ?? [];\n    this.state = new Map<string, string>();\n    this.config = config;\n  }\n\n  /**\n   * Adds a transformer to the parser.\n   * @param transformer - An instance of a class extending MaskingTransformer.\n   */\n  addTransformer(transformer: MaskingTransformer) {\n    this.transformers.push(transformer);\n  }\n\n  /**\n   * Getter method for retrieving the current state.\n   * @returns The current state map.\n   */\n  public getState(): Map<string, string> {\n    return this.state;\n  }\n\n  /**\n   * Masks the provided message using the added transformers.\n   * This method sequentially applies each transformer's masking logic to the message.\n   * It utilizes a state map to track original values corresponding to their masked versions.\n   *\n   * @param message - The message to be masked.\n   * @returns A masked version of the message.\n   * @throws {TypeError} If the message is not a string.\n   * @throws {Error} If no transformers are added.\n   */\n  async mask(message: string): Promise<string> {\n    // If onMaskingStart is a function, handle it accordingly\n    if (this.config.onMaskingStart) {\n      await this.config.onMaskingStart(message);\n    }\n\n    // Check if there are any transformers added to the parser. If not, throw an error\n    // as masking requires at least one transformer to apply its logic.\n    if (this.transformers.length === 0) {\n      throw new Error(\n        \"MaskingParser.mask Error: No transformers have been added. Please add at least one transformer before parsing.\"\n      );\n    }\n\n    if (typeof message !== \"string\") {\n      throw new TypeError(\n        \"MaskingParser.mask Error: The 'message' argument must be a string.\"\n      );\n    }\n\n    // Initialize the variable to hold the progressively masked message.\n    // It starts as the original message and gets transformed by each transformer.\n    let processedMessage = message;\n\n    // Iterate through each transformer and apply their transform method.\n    for (const transformer of this.transformers) {\n      // Transform the message and get the transformer's state changes, ensuring no direct mutation of the shared state.\n      const [transformedMessage, transformerState] =\n        await transformer.transform(processedMessage, new Map(this.state));\n\n      // Update the processed message for subsequent transformers.\n      processedMessage = transformedMessage;\n\n      // Merge state changes from the transformer into the parser's state.\n      // This accumulates all transformations' effects on the state.\n      transformerState.forEach((value, key) => this.state.set(key, value));\n    }\n\n    // Handle onMaskingEnd callback\n    if (this.config.onMaskingEnd) {\n      await this.config.onMaskingEnd(processedMessage);\n    }\n    // Return the fully masked message after all transformers have been applied.\n    return processedMessage;\n  }\n\n  /**\n   * Rehydrates a masked message back to its original form.\n   * This method sequentially applies the rehydration logic of each added transformer in reverse order.\n   * It relies on the state map to correctly map the masked values back to their original values.\n   *\n   * The rehydration process is essential for restoring the original content of a message\n   * that has been transformed (masked) by the transformers. This process is the inverse of the masking process.\n   *\n   * @param message - The masked message to be rehydrated.\n   * @returns The original (rehydrated) version of the message.\n   */\n  async rehydrate(\n    message: string,\n    state?: Map<string, string>\n  ): Promise<string> {\n    // Handle onRehydratingStart callback\n    if (this.config.onRehydratingStart) {\n      await this.config.onRehydratingStart(message);\n    }\n\n    if (typeof message !== \"string\") {\n      throw new TypeError(\n        \"MaskingParser.rehydrate Error: The 'message' argument must be a string.\"\n      );\n    }\n    // Check if any transformers have been added to the parser.\n    // If no transformers are present, throw an error as rehydration requires at least one transformer.\n    if (this.transformers.length === 0) {\n      throw new Error(\n        \"MaskingParser.rehydrate Error: No transformers have been added. Please add at least one transformer before rehydrating.\"\n      );\n    }\n\n    // eslint-disable-next-line no-instanceof/no-instanceof\n    if (state && !(state instanceof Map)) {\n      throw new TypeError(\n        \"MaskingParser.rehydrate Error: The 'state' argument, if provided, must be an instance of Map.\"\n      );\n    }\n\n    const rehydrationState = state || this.state; // Use provided state or fallback to internal state\n    // Initialize the rehydratedMessage with the input masked message.\n    // This variable will undergo rehydration by each transformer in reverse order.\n    let rehydratedMessage = message;\n    // Use a reverse for...of loop to accommodate asynchronous rehydrate methods\n    const reversedTransformers = this.transformers.slice().reverse();\n    for (const transformer of reversedTransformers) {\n      // Check if the result is a Promise and use await, otherwise use it directly\n      rehydratedMessage = await transformer.rehydrate(\n        rehydratedMessage,\n        rehydrationState\n      );\n    }\n\n    // Handle onRehydratingEnd callback\n    if (this.config.onRehydratingEnd) {\n      await this.config.onRehydratingEnd(rehydratedMessage);\n    }\n\n    // Return the fully rehydrated message after all transformers have been applied.\n    return rehydratedMessage;\n  }\n}\n"],"mappings":";;;;AAMA,IAAa,gBAAb,MAA2B;CACzB,AAAQ;CAER,AAAQ;CAER,AAAQ;CAER,YAAY,SAA8B,EAAE,EAAE;AAC5C,OAAK,eAAe,OAAO,gBAAgB,EAAE;AAC7C,OAAK,wBAAQ,IAAI,KAAqB;AACtC,OAAK,SAAS;;;;;;CAOhB,eAAe,aAAiC;AAC9C,OAAK,aAAa,KAAK,YAAY;;;;;;CAOrC,AAAO,WAAgC;AACrC,SAAO,KAAK;;;;;;;;;;;;CAad,MAAM,KAAK,SAAkC;AAE3C,MAAI,KAAK,OAAO,eACd,OAAM,KAAK,OAAO,eAAe,QAAQ;AAK3C,MAAI,KAAK,aAAa,WAAW,EAC/B,OAAM,IAAI,MACR,iHACD;AAGH,MAAI,OAAO,YAAY,SACrB,OAAM,IAAI,UACR,qEACD;EAKH,IAAI,mBAAmB;AAGvB,OAAK,MAAM,eAAe,KAAK,cAAc;GAE3C,MAAM,CAAC,oBAAoB,oBACzB,MAAM,YAAY,UAAU,kBAAkB,IAAI,IAAI,KAAK,MAAM,CAAC;AAGpE,sBAAmB;AAInB,oBAAiB,SAAS,OAAO,QAAQ,KAAK,MAAM,IAAI,KAAK,MAAM,CAAC;;AAItE,MAAI,KAAK,OAAO,aACd,OAAM,KAAK,OAAO,aAAa,iBAAiB;AAGlD,SAAO;;;;;;;;;;;;;CAcT,MAAM,UACJ,SACA,OACiB;AAEjB,MAAI,KAAK,OAAO,mBACd,OAAM,KAAK,OAAO,mBAAmB,QAAQ;AAG/C,MAAI,OAAO,YAAY,SACrB,OAAM,IAAI,UACR,0EACD;AAIH,MAAI,KAAK,aAAa,WAAW,EAC/B,OAAM,IAAI,MACR,0HACD;AAIH,MAAI,SAAS,EAAE,iBAAiB,KAC9B,OAAM,IAAI,UACR,gGACD;EAGH,MAAM,mBAAmB,SAAS,KAAK;EAGvC,IAAI,oBAAoB;EAExB,MAAM,uBAAuB,KAAK,aAAa,OAAO,CAAC,SAAS;AAChE,OAAK,MAAM,eAAe,qBAExB,qBAAoB,MAAM,YAAY,UACpC,mBACA,iBACD;AAIH,MAAI,KAAK,OAAO,iBACd,OAAM,KAAK,OAAO,iBAAiB,kBAAkB;AAIvD,SAAO"}

package/dist/experimental/masking/regex_masking_transformer.cjs

@@ -64,11 +64,10 @@ var RegexMaskingTransformer = class extends require_transformer.MaskingTransform
 	async rehydrate(message, state) {
 		if (typeof message !== "string") throw new TypeError("RegexMaskingTransformer.rehydrate Error: The 'message' argument must be a string.");
 		if (!(state instanceof Map)) throw new TypeError("RegexMaskingTransformer.rehydrate Error: The 'state' argument must be an instance of Map.");
-		const rehydratedMessage = Array.from(state).reduce((msg, [masked, original]) => {
+		return Array.from(state).reduce((msg, [masked, original]) => {
 			const escapedMasked = masked.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 			return msg.replace(new RegExp(escapedMasked, "g"), original);
 		}, message);
-		return rehydratedMessage;
 	}
 	/**
 	* Default hash function for creating unique hash values.

package/dist/experimental/masking/regex_masking_transformer.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"regex_masking_transformer.cjs","names":["MaskingTransformer","patterns: { [key: string]: MaskingPattern }","hashFunction?: HashFunction","message: string","state: Map<string, string>","input: string"],"sources":["../../../src/experimental/masking/regex_masking_transformer.ts"],"sourcesContent":["import { MaskingTransformer } from \"./transformer.js\";\nimport type { HashFunction, MaskingPattern } from \"./types.js\";\n/**\n * RegexMaskingTransformer class for masking and rehydrating messages with Regex.\n */\nexport class RegexMaskingTransformer extends MaskingTransformer {\n  private patterns: { [key: string]: MaskingPattern };\n\n  private hashFunction: HashFunction;\n\n  /**\n   * Constructs a RegexMaskingTransformer with given patterns and an optional hash function.\n   * Validates the provided patterns to ensure they conform to the expected structure.\n   *\n   * @param patterns - An object containing masking patterns. Each pattern should include\n   *                   a regular expression (`regex`) and optionally a `replacement` string\n   *                   or a `mask` function.\n   * @param hashFunction - An optional custom hash function to be used for masking.\n   */\n  constructor(\n    patterns: { [key: string]: MaskingPattern },\n    hashFunction?: HashFunction\n  ) {\n    super();\n    // Validates the provided masking patterns before initializing the transformer.\n    // This ensures that each pattern has a valid regular expression.\n    this.validatePatterns(patterns);\n\n    // Assigns the validated patterns and the hash function to the transformer.\n    // If no custom hash function is provided, the default hash function is used.\n    this.patterns = patterns;\n    this.hashFunction = hashFunction || this.defaultHashFunction;\n  }\n\n  /**\n   * Validates the given masking patterns to ensure each pattern has a valid regular expression.\n   * Throws an error if any pattern is found to be invalid.\n   *\n   * @param patterns - The patterns object to validate.\n   */\n  private validatePatterns(patterns: { [key: string]: MaskingPattern }) {\n    for (const key of Object.keys(patterns)) {\n      const pattern = patterns[key];\n      // Checks that each pattern is an object and has a regex property that is an instance of RegExp.\n      // Throws an error if these conditions are not met, indicating an invalid pattern configuration.\n      if (\n        !pattern ||\n        typeof pattern !== \"object\" ||\n        // eslint-disable-next-line no-instanceof/no-instanceof\n        !(pattern.regex instanceof RegExp)\n      ) {\n        throw new Error(\"Invalid pattern configuration.\");\n      }\n    }\n  }\n\n  /**\n   * Masks content in a message based on the defined patterns.\n   * @param message - The message to be masked.\n   * @param state - The current state containing original values.\n   * @returns A tuple of the masked message and the updated state.\n   */\n  async transform(\n    message: string,\n    state: Map<string, string>\n  ): Promise<[string, Map<string, string>]> {\n    if (typeof message !== \"string\") {\n      throw new TypeError(\n        \"RegexMaskingTransformer.transform Error: The 'message' argument must be a string.\"\n      );\n    }\n\n    // eslint-disable-next-line no-instanceof/no-instanceof\n    if (!(state instanceof Map)) {\n      throw new TypeError(\n        \"RegexMaskingTransformer.transform Error: The 'state' argument must be an instance of Map.\"\n      );\n    }\n\n    // Holds the progressively masked message\n    let processedMessage = message;\n\n    // Initialize original values map with the current state or a new map\n    const originalValues = state || new Map<string, string>();\n\n    // Iterate over each pattern defined in the transformer\n    for (const key of Object.keys(this.patterns)) {\n      const pattern = this.patterns[key];\n\n      // Apply the current pattern's regex to the message\n      processedMessage = processedMessage.replace(pattern.regex, (match) => {\n        // Determine the masked value: use the mask function if provided, else use the replacement string,\n        // else use the hash function.\n        const maskedValue = pattern.mask\n          ? pattern.mask(match)\n          : (pattern.replacement ?? this.hashFunction(match));\n\n        // Store the mapping of the masked value to the original value (match)\n        originalValues.set(maskedValue, match);\n\n        // Return the masked value to replace the original value in the message\n        return maskedValue;\n      });\n    }\n\n    // Return the fully masked message and the state map with all original values\n    // Wrap the synchronous return values in Promise.resolve() to maintain compatibility\n    // with the MaskingParser's expectation of a Promise return type.\n    return [processedMessage, originalValues];\n  }\n\n  /**\n   * Rehydrates a masked message back to its original form using the provided state.\n   * @param message - The masked message to be rehydrated.\n   * @param state - The state map containing mappings of masked values to their original values.\n   * @returns The rehydrated (original) message.\n   */\n  async rehydrate(\n    message: string,\n    state: Map<string, string>\n  ): Promise<string> {\n    if (typeof message !== \"string\") {\n      throw new TypeError(\n        \"RegexMaskingTransformer.rehydrate Error: The 'message' argument must be a string.\"\n      );\n    }\n\n    // eslint-disable-next-line no-instanceof/no-instanceof\n    if (!(state instanceof Map)) {\n      throw new TypeError(\n        \"RegexMaskingTransformer.rehydrate Error: The 'state' argument must be an instance of Map.\"\n      );\n    }\n\n    // Convert the state map to an array and use reduce to sequentially replace masked values with original values.\n    const rehydratedMessage = Array.from(state).reduce(\n      (msg, [masked, original]) => {\n        // Escape special characters in the masked string to ensure it can be used in a regular expression safely.\n        // This is necessary because masked values might contain characters that have special meanings in regex.\n        const escapedMasked = masked.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n\n        // Replace all instances of the escaped masked value in the message with the original value.\n        // The 'g' flag in the RegExp ensures that all occurrences of the masked value are replaced.\n        return msg.replace(new RegExp(escapedMasked, \"g\"), original);\n      },\n      message\n    );\n\n    return rehydratedMessage;\n  }\n\n  /**\n   * Default hash function for creating unique hash values.\n   * @param input - The input string to hash.\n   * @returns The resulting hash as a string.\n   */\n  private defaultHashFunction(input: string): string {\n    let hash = 0;\n    // Iterate over each character in the input string\n    for (let i = 0; i < input.length; i += 1) {\n      // Get ASCII value of the character\n      const char = input.charCodeAt(i);\n      // Combine the current hash with the new character and ensure it remains a 32-bit integer\n      hash = (hash << 5) - hash + char;\n      // Bitwise OR operation to convert to a 32-bit integer.\n      // This is a common technique to ensure the final hash value stays within the 32-bit limit,\n      // effectively wrapping the value when it becomes too large.\n      hash |= 0;\n    }\n\n    // Convert the numerical hash value to a string and return\n    return hash.toString();\n  }\n}\n"],"mappings":";;;;;;AAKA,IAAa,0BAAb,cAA6CA,uCAAmB;CAC9D,AAAQ;CAER,AAAQ;;;;;;;;;;CAWR,YACEC,UACAC,cACA;EACA,OAAO;EAGP,KAAK,iBAAiB,SAAS;EAI/B,KAAK,WAAW;EAChB,KAAK,eAAe,gBAAgB,KAAK;CAC1C;;;;;;;CAQD,AAAQ,iBAAiBD,UAA6C;AACpE,OAAK,MAAM,OAAO,OAAO,KAAK,SAAS,EAAE;GACvC,MAAM,UAAU,SAAS;AAGzB,OACE,CAAC,WACD,OAAO,YAAY,YAEnB,EAAE,QAAQ,iBAAiB,QAE3B,OAAM,IAAI,MAAM;EAEnB;CACF;;;;;;;CAQD,MAAM,UACJE,SACAC,OACwC;AACxC,MAAI,OAAO,YAAY,SACrB,OAAM,IAAI,UACR;AAKJ,MAAI,EAAE,iBAAiB,KACrB,OAAM,IAAI,UACR;EAKJ,IAAI,mBAAmB;EAGvB,MAAM,iBAAiB,yBAAS,IAAI;AAGpC,OAAK,MAAM,OAAO,OAAO,KAAK,KAAK,SAAS,EAAE;GAC5C,MAAM,UAAU,KAAK,SAAS;GAG9B,mBAAmB,iBAAiB,QAAQ,QAAQ,OAAO,CAAC,UAAU;IAGpE,MAAM,cAAc,QAAQ,OACxB,QAAQ,KAAK,MAAM,GAClB,QAAQ,eAAe,KAAK,aAAa,MAAM;IAGpD,eAAe,IAAI,aAAa,MAAM;AAGtC,WAAO;GACR,EAAC;EACH;AAKD,SAAO,CAAC,kBAAkB,cAAe;CAC1C;;;;;;;CAQD,MAAM,UACJD,SACAC,OACiB;AACjB,MAAI,OAAO,YAAY,SACrB,OAAM,IAAI,UACR;AAKJ,MAAI,EAAE,iBAAiB,KACrB,OAAM,IAAI,UACR;EAKJ,MAAM,oBAAoB,MAAM,KAAK,MAAM,CAAC,OAC1C,CAAC,KAAK,CAAC,QAAQ,SAAS,KAAK;GAG3B,MAAM,gBAAgB,OAAO,QAAQ,uBAAuB,OAAO;AAInE,UAAO,IAAI,QAAQ,IAAI,OAAO,eAAe,MAAM,SAAS;EAC7D,GACD,QACD;AAED,SAAO;CACR;;;;;;CAOD,AAAQ,oBAAoBC,OAAuB;EACjD,IAAI,OAAO;AAEX,OAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,GAAG;GAExC,MAAM,OAAO,MAAM,WAAW,EAAE;GAEhC,QAAQ,QAAQ,KAAK,OAAO;GAI5B,QAAQ;EACT;AAGD,SAAO,KAAK,UAAU;CACvB;AACF"}
+{"version":3,"file":"regex_masking_transformer.cjs","names":["MaskingTransformer"],"sources":["../../../src/experimental/masking/regex_masking_transformer.ts"],"sourcesContent":["import { MaskingTransformer } from \"./transformer.js\";\nimport type { HashFunction, MaskingPattern } from \"./types.js\";\n/**\n * RegexMaskingTransformer class for masking and rehydrating messages with Regex.\n */\nexport class RegexMaskingTransformer extends MaskingTransformer {\n  private patterns: { [key: string]: MaskingPattern };\n\n  private hashFunction: HashFunction;\n\n  /**\n   * Constructs a RegexMaskingTransformer with given patterns and an optional hash function.\n   * Validates the provided patterns to ensure they conform to the expected structure.\n   *\n   * @param patterns - An object containing masking patterns. Each pattern should include\n   *                   a regular expression (`regex`) and optionally a `replacement` string\n   *                   or a `mask` function.\n   * @param hashFunction - An optional custom hash function to be used for masking.\n   */\n  constructor(\n    patterns: { [key: string]: MaskingPattern },\n    hashFunction?: HashFunction\n  ) {\n    super();\n    // Validates the provided masking patterns before initializing the transformer.\n    // This ensures that each pattern has a valid regular expression.\n    this.validatePatterns(patterns);\n\n    // Assigns the validated patterns and the hash function to the transformer.\n    // If no custom hash function is provided, the default hash function is used.\n    this.patterns = patterns;\n    this.hashFunction = hashFunction || this.defaultHashFunction;\n  }\n\n  /**\n   * Validates the given masking patterns to ensure each pattern has a valid regular expression.\n   * Throws an error if any pattern is found to be invalid.\n   *\n   * @param patterns - The patterns object to validate.\n   */\n  private validatePatterns(patterns: { [key: string]: MaskingPattern }) {\n    for (const key of Object.keys(patterns)) {\n      const pattern = patterns[key];\n      // Checks that each pattern is an object and has a regex property that is an instance of RegExp.\n      // Throws an error if these conditions are not met, indicating an invalid pattern configuration.\n      if (\n        !pattern ||\n        typeof pattern !== \"object\" ||\n        // eslint-disable-next-line no-instanceof/no-instanceof\n        !(pattern.regex instanceof RegExp)\n      ) {\n        throw new Error(\"Invalid pattern configuration.\");\n      }\n    }\n  }\n\n  /**\n   * Masks content in a message based on the defined patterns.\n   * @param message - The message to be masked.\n   * @param state - The current state containing original values.\n   * @returns A tuple of the masked message and the updated state.\n   */\n  async transform(\n    message: string,\n    state: Map<string, string>\n  ): Promise<[string, Map<string, string>]> {\n    if (typeof message !== \"string\") {\n      throw new TypeError(\n        \"RegexMaskingTransformer.transform Error: The 'message' argument must be a string.\"\n      );\n    }\n\n    // eslint-disable-next-line no-instanceof/no-instanceof\n    if (!(state instanceof Map)) {\n      throw new TypeError(\n        \"RegexMaskingTransformer.transform Error: The 'state' argument must be an instance of Map.\"\n      );\n    }\n\n    // Holds the progressively masked message\n    let processedMessage = message;\n\n    // Initialize original values map with the current state or a new map\n    const originalValues = state || new Map<string, string>();\n\n    // Iterate over each pattern defined in the transformer\n    for (const key of Object.keys(this.patterns)) {\n      const pattern = this.patterns[key];\n\n      // Apply the current pattern's regex to the message\n      processedMessage = processedMessage.replace(pattern.regex, (match) => {\n        // Determine the masked value: use the mask function if provided, else use the replacement string,\n        // else use the hash function.\n        const maskedValue = pattern.mask\n          ? pattern.mask(match)\n          : (pattern.replacement ?? this.hashFunction(match));\n\n        // Store the mapping of the masked value to the original value (match)\n        originalValues.set(maskedValue, match);\n\n        // Return the masked value to replace the original value in the message\n        return maskedValue;\n      });\n    }\n\n    // Return the fully masked message and the state map with all original values\n    // Wrap the synchronous return values in Promise.resolve() to maintain compatibility\n    // with the MaskingParser's expectation of a Promise return type.\n    return [processedMessage, originalValues];\n  }\n\n  /**\n   * Rehydrates a masked message back to its original form using the provided state.\n   * @param message - The masked message to be rehydrated.\n   * @param state - The state map containing mappings of masked values to their original values.\n   * @returns The rehydrated (original) message.\n   */\n  async rehydrate(\n    message: string,\n    state: Map<string, string>\n  ): Promise<string> {\n    if (typeof message !== \"string\") {\n      throw new TypeError(\n        \"RegexMaskingTransformer.rehydrate Error: The 'message' argument must be a string.\"\n      );\n    }\n\n    // eslint-disable-next-line no-instanceof/no-instanceof\n    if (!(state instanceof Map)) {\n      throw new TypeError(\n        \"RegexMaskingTransformer.rehydrate Error: The 'state' argument must be an instance of Map.\"\n      );\n    }\n\n    // Convert the state map to an array and use reduce to sequentially replace masked values with original values.\n    const rehydratedMessage = Array.from(state).reduce(\n      (msg, [masked, original]) => {\n        // Escape special characters in the masked string to ensure it can be used in a regular expression safely.\n        // This is necessary because masked values might contain characters that have special meanings in regex.\n        const escapedMasked = masked.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n\n        // Replace all instances of the escaped masked value in the message with the original value.\n        // The 'g' flag in the RegExp ensures that all occurrences of the masked value are replaced.\n        return msg.replace(new RegExp(escapedMasked, \"g\"), original);\n      },\n      message\n    );\n\n    return rehydratedMessage;\n  }\n\n  /**\n   * Default hash function for creating unique hash values.\n   * @param input - The input string to hash.\n   * @returns The resulting hash as a string.\n   */\n  private defaultHashFunction(input: string): string {\n    let hash = 0;\n    // Iterate over each character in the input string\n    for (let i = 0; i < input.length; i += 1) {\n      // Get ASCII value of the character\n      const char = input.charCodeAt(i);\n      // Combine the current hash with the new character and ensure it remains a 32-bit integer\n      hash = (hash << 5) - hash + char;\n      // Bitwise OR operation to convert to a 32-bit integer.\n      // This is a common technique to ensure the final hash value stays within the 32-bit limit,\n      // effectively wrapping the value when it becomes too large.\n      hash |= 0;\n    }\n\n    // Convert the numerical hash value to a string and return\n    return hash.toString();\n  }\n}\n"],"mappings":";;;;;;AAKA,IAAa,0BAAb,cAA6CA,uCAAmB;CAC9D,AAAQ;CAER,AAAQ;;;;;;;;;;CAWR,YACE,UACA,cACA;AACA,SAAO;AAGP,OAAK,iBAAiB,SAAS;AAI/B,OAAK,WAAW;AAChB,OAAK,eAAe,gBAAgB,KAAK;;;;;;;;CAS3C,AAAQ,iBAAiB,UAA6C;AACpE,OAAK,MAAM,OAAO,OAAO,KAAK,SAAS,EAAE;GACvC,MAAM,UAAU,SAAS;AAGzB,OACE,CAAC,WACD,OAAO,YAAY,YAEnB,EAAE,QAAQ,iBAAiB,QAE3B,OAAM,IAAI,MAAM,iCAAiC;;;;;;;;;CAWvD,MAAM,UACJ,SACA,OACwC;AACxC,MAAI,OAAO,YAAY,SACrB,OAAM,IAAI,UACR,oFACD;AAIH,MAAI,EAAE,iBAAiB,KACrB,OAAM,IAAI,UACR,4FACD;EAIH,IAAI,mBAAmB;EAGvB,MAAM,iBAAiB,yBAAS,IAAI,KAAqB;AAGzD,OAAK,MAAM,OAAO,OAAO,KAAK,KAAK,SAAS,EAAE;GAC5C,MAAM,UAAU,KAAK,SAAS;AAG9B,sBAAmB,iBAAiB,QAAQ,QAAQ,QAAQ,UAAU;IAGpE,MAAM,cAAc,QAAQ,OACxB,QAAQ,KAAK,MAAM,GAClB,QAAQ,eAAe,KAAK,aAAa,MAAM;AAGpD,mBAAe,IAAI,aAAa,MAAM;AAGtC,WAAO;KACP;;AAMJ,SAAO,CAAC,kBAAkB,eAAe;;;;;;;;CAS3C,MAAM,UACJ,SACA,OACiB;AACjB,MAAI,OAAO,YAAY,SACrB,OAAM,IAAI,UACR,oFACD;AAIH,MAAI,EAAE,iBAAiB,KACrB,OAAM,IAAI,UACR,4FACD;AAiBH,SAb0B,MAAM,KAAK,MAAM,CAAC,QACzC,KAAK,CAAC,QAAQ,cAAc;GAG3B,MAAM,gBAAgB,OAAO,QAAQ,uBAAuB,OAAO;AAInE,UAAO,IAAI,QAAQ,IAAI,OAAO,eAAe,IAAI,EAAE,SAAS;KAE9D,QACD;;;;;;;CAUH,AAAQ,oBAAoB,OAAuB;EACjD,IAAI,OAAO;AAEX,OAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,GAAG;GAExC,MAAM,OAAO,MAAM,WAAW,EAAE;AAEhC,WAAQ,QAAQ,KAAK,OAAO;AAI5B,WAAQ;;AAIV,SAAO,KAAK,UAAU"}

package/dist/experimental/masking/regex_masking_transformer.d.cts

@@ -2,7 +2,6 @@ import { MaskingTransformer } from "./transformer.cjs";
 import { HashFunction, MaskingPattern } from "./types.cjs";
 
 //#region src/experimental/masking/regex_masking_transformer.d.ts
-
 /**
  * RegexMaskingTransformer class for masking and rehydrating messages with Regex.
  */

package/dist/experimental/masking/regex_masking_transformer.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"regex_masking_transformer.d.cts","names":["MaskingTransformer","HashFunction","MaskingPattern","RegexMaskingTransformer","Map","Promise"],"sources":["../../../src/experimental/masking/regex_masking_transformer.d.ts"],"sourcesContent":["import { MaskingTransformer } from \"./transformer.js\";\nimport type { HashFunction, MaskingPattern } from \"./types.js\";\n/**\n * RegexMaskingTransformer class for masking and rehydrating messages with Regex.\n */\nexport declare class RegexMaskingTransformer extends MaskingTransformer {\n    private patterns;\n    private hashFunction;\n    /**\n     * Constructs a RegexMaskingTransformer with given patterns and an optional hash function.\n     * Validates the provided patterns to ensure they conform to the expected structure.\n     *\n     * @param patterns - An object containing masking patterns. Each pattern should include\n     *                   a regular expression (`regex`) and optionally a `replacement` string\n     *                   or a `mask` function.\n     * @param hashFunction - An optional custom hash function to be used for masking.\n     */\n    constructor(patterns: {\n        [key: string]: MaskingPattern;\n    }, hashFunction?: HashFunction);\n    /**\n     * Validates the given masking patterns to ensure each pattern has a valid regular expression.\n     * Throws an error if any pattern is found to be invalid.\n     *\n     * @param patterns - The patterns object to validate.\n     */\n    private validatePatterns;\n    /**\n     * Masks content in a message based on the defined patterns.\n     * @param message - The message to be masked.\n     * @param state - The current state containing original values.\n     * @returns A tuple of the masked message and the updated state.\n     */\n    transform(message: string, state: Map<string, string>): Promise<[string, Map<string, string>]>;\n    /**\n     * Rehydrates a masked message back to its original form using the provided state.\n     * @param message - The masked message to be rehydrated.\n     * @param state - The state map containing mappings of masked values to their original values.\n     * @returns The rehydrated (original) message.\n     */\n    rehydrate(message: string, state: Map<string, string>): Promise<string>;\n    /**\n     * Default hash function for creating unique hash values.\n     * @param input - The input string to hash.\n     * @returns The resulting hash as a string.\n     */\n    private defaultHashFunction;\n}\n//# sourceMappingURL=regex_masking_transformer.d.ts.map"],"mappings":";;;;;;;AAKA;AAauBE,cAbFC,uBAAAA,SAAgCH,kBAAAA,CAa9BE;EACDD,QAAAA,QAAAA;EAcgBG,QAAAA,YAAAA;EAAuCA;;;;;AA5BN;;;;;mBAahDF;oBACDD;;;;;;;;;;;;;;oCAcgBG,sBAAsBC,iBAAiBD;;;;;;;oCAOvCA,sBAAsBC"}
+{"version":3,"file":"regex_masking_transformer.d.cts","names":[],"sources":["../../../src/experimental/masking/regex_masking_transformer.ts"],"mappings":";;;;;;AAKA;cAAa,uBAAA,SAAgC,kBAAA;EAAA,QACnC,QAAA;EAAA,QAEA,YAAA;EAaS;;;;;;;;;EAFjB,WAAA,CACE,QAAA;IAAA,CAAa,GAAA,WAAc,cAAA;EAAA,GAC3B,YAAA,GAAe,YAAA;EAFjB;;;;;;EAAA,QAqBQ,gBAAA;EAsBF;;;;;;EAAA,SAAA,CACJ,OAAA,UACA,KAAA,EAAO,GAAA,mBACN,OAAA,UAAiB,GAAA;EAqDlB;;;;;;EADI,SAAA,CACJ,OAAA,UACA,KAAA,EAAO,GAAA,mBACN,OAAA;;;;;;UAoCK,mBAAA;AAAA"}

package/dist/experimental/masking/regex_masking_transformer.d.ts

@@ -2,7 +2,6 @@ import { MaskingTransformer } from "./transformer.js";
 import { HashFunction, MaskingPattern } from "./types.js";
 
 //#region src/experimental/masking/regex_masking_transformer.d.ts
-
 /**
  * RegexMaskingTransformer class for masking and rehydrating messages with Regex.
  */

package/dist/experimental/masking/regex_masking_transformer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"regex_masking_transformer.d.ts","names":["MaskingTransformer","HashFunction","MaskingPattern","RegexMaskingTransformer","Map","Promise"],"sources":["../../../src/experimental/masking/regex_masking_transformer.d.ts"],"sourcesContent":["import { MaskingTransformer } from \"./transformer.js\";\nimport type { HashFunction, MaskingPattern } from \"./types.js\";\n/**\n * RegexMaskingTransformer class for masking and rehydrating messages with Regex.\n */\nexport declare class RegexMaskingTransformer extends MaskingTransformer {\n    private patterns;\n    private hashFunction;\n    /**\n     * Constructs a RegexMaskingTransformer with given patterns and an optional hash function.\n     * Validates the provided patterns to ensure they conform to the expected structure.\n     *\n     * @param patterns - An object containing masking patterns. Each pattern should include\n     *                   a regular expression (`regex`) and optionally a `replacement` string\n     *                   or a `mask` function.\n     * @param hashFunction - An optional custom hash function to be used for masking.\n     */\n    constructor(patterns: {\n        [key: string]: MaskingPattern;\n    }, hashFunction?: HashFunction);\n    /**\n     * Validates the given masking patterns to ensure each pattern has a valid regular expression.\n     * Throws an error if any pattern is found to be invalid.\n     *\n     * @param patterns - The patterns object to validate.\n     */\n    private validatePatterns;\n    /**\n     * Masks content in a message based on the defined patterns.\n     * @param message - The message to be masked.\n     * @param state - The current state containing original values.\n     * @returns A tuple of the masked message and the updated state.\n     */\n    transform(message: string, state: Map<string, string>): Promise<[string, Map<string, string>]>;\n    /**\n     * Rehydrates a masked message back to its original form using the provided state.\n     * @param message - The masked message to be rehydrated.\n     * @param state - The state map containing mappings of masked values to their original values.\n     * @returns The rehydrated (original) message.\n     */\n    rehydrate(message: string, state: Map<string, string>): Promise<string>;\n    /**\n     * Default hash function for creating unique hash values.\n     * @param input - The input string to hash.\n     * @returns The resulting hash as a string.\n     */\n    private defaultHashFunction;\n}\n//# sourceMappingURL=regex_masking_transformer.d.ts.map"],"mappings":";;;;;;;AAKA;AAauBE,cAbFC,uBAAAA,SAAgCH,kBAAAA,CAa9BE;EACDD,QAAAA,QAAAA;EAcgBG,QAAAA,YAAAA;EAAuCA;;;;;AA5BN;;;;;mBAahDF;oBACDD;;;;;;;;;;;;;;oCAcgBG,sBAAsBC,iBAAiBD;;;;;;;oCAOvCA,sBAAsBC"}
+{"version":3,"file":"regex_masking_transformer.d.ts","names":[],"sources":["../../../src/experimental/masking/regex_masking_transformer.ts"],"mappings":";;;;;;AAKA;cAAa,uBAAA,SAAgC,kBAAA;EAAA,QACnC,QAAA;EAAA,QAEA,YAAA;EAaS;;;;;;;;;EAFjB,WAAA,CACE,QAAA;IAAA,CAAa,GAAA,WAAc,cAAA;EAAA,GAC3B,YAAA,GAAe,YAAA;EAFjB;;;;;;EAAA,QAqBQ,gBAAA;EAsBF;;;;;;EAAA,SAAA,CACJ,OAAA,UACA,KAAA,EAAO,GAAA,mBACN,OAAA,UAAiB,GAAA;EAqDlB;;;;;;EADI,SAAA,CACJ,OAAA,UACA,KAAA,EAAO,GAAA,mBACN,OAAA;;;;;;UAoCK,mBAAA;AAAA"}

package/dist/experimental/masking/regex_masking_transformer.js

@@ -64,11 +64,10 @@ var RegexMaskingTransformer = class extends MaskingTransformer {
 	async rehydrate(message, state) {
 		if (typeof message !== "string") throw new TypeError("RegexMaskingTransformer.rehydrate Error: The 'message' argument must be a string.");
 		if (!(state instanceof Map)) throw new TypeError("RegexMaskingTransformer.rehydrate Error: The 'state' argument must be an instance of Map.");
-		const rehydratedMessage = Array.from(state).reduce((msg, [masked, original]) => {
+		return Array.from(state).reduce((msg, [masked, original]) => {
 			const escapedMasked = masked.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 			return msg.replace(new RegExp(escapedMasked, "g"), original);
 		}, message);
-		return rehydratedMessage;
 	}
 	/**
 	* Default hash function for creating unique hash values.

package/dist/experimental/masking/regex_masking_transformer.js.map

@@ -1 +1 @@
-{"version":3,"file":"regex_masking_transformer.js","names":["patterns: { [key: string]: MaskingPattern }","hashFunction?: HashFunction","message: string","state: Map<string, string>","input: string"],"sources":["../../../src/experimental/masking/regex_masking_transformer.ts"],"sourcesContent":["import { MaskingTransformer } from \"./transformer.js\";\nimport type { HashFunction, MaskingPattern } from \"./types.js\";\n/**\n * RegexMaskingTransformer class for masking and rehydrating messages with Regex.\n */\nexport class RegexMaskingTransformer extends MaskingTransformer {\n  private patterns: { [key: string]: MaskingPattern };\n\n  private hashFunction: HashFunction;\n\n  /**\n   * Constructs a RegexMaskingTransformer with given patterns and an optional hash function.\n   * Validates the provided patterns to ensure they conform to the expected structure.\n   *\n   * @param patterns - An object containing masking patterns. Each pattern should include\n   *                   a regular expression (`regex`) and optionally a `replacement` string\n   *                   or a `mask` function.\n   * @param hashFunction - An optional custom hash function to be used for masking.\n   */\n  constructor(\n    patterns: { [key: string]: MaskingPattern },\n    hashFunction?: HashFunction\n  ) {\n    super();\n    // Validates the provided masking patterns before initializing the transformer.\n    // This ensures that each pattern has a valid regular expression.\n    this.validatePatterns(patterns);\n\n    // Assigns the validated patterns and the hash function to the transformer.\n    // If no custom hash function is provided, the default hash function is used.\n    this.patterns = patterns;\n    this.hashFunction = hashFunction || this.defaultHashFunction;\n  }\n\n  /**\n   * Validates the given masking patterns to ensure each pattern has a valid regular expression.\n   * Throws an error if any pattern is found to be invalid.\n   *\n   * @param patterns - The patterns object to validate.\n   */\n  private validatePatterns(patterns: { [key: string]: MaskingPattern }) {\n    for (const key of Object.keys(patterns)) {\n      const pattern = patterns[key];\n      // Checks that each pattern is an object and has a regex property that is an instance of RegExp.\n      // Throws an error if these conditions are not met, indicating an invalid pattern configuration.\n      if (\n        !pattern ||\n        typeof pattern !== \"object\" ||\n        // eslint-disable-next-line no-instanceof/no-instanceof\n        !(pattern.regex instanceof RegExp)\n      ) {\n        throw new Error(\"Invalid pattern configuration.\");\n      }\n    }\n  }\n\n  /**\n   * Masks content in a message based on the defined patterns.\n   * @param message - The message to be masked.\n   * @param state - The current state containing original values.\n   * @returns A tuple of the masked message and the updated state.\n   */\n  async transform(\n    message: string,\n    state: Map<string, string>\n  ): Promise<[string, Map<string, string>]> {\n    if (typeof message !== \"string\") {\n      throw new TypeError(\n        \"RegexMaskingTransformer.transform Error: The 'message' argument must be a string.\"\n      );\n    }\n\n    // eslint-disable-next-line no-instanceof/no-instanceof\n    if (!(state instanceof Map)) {\n      throw new TypeError(\n        \"RegexMaskingTransformer.transform Error: The 'state' argument must be an instance of Map.\"\n      );\n    }\n\n    // Holds the progressively masked message\n    let processedMessage = message;\n\n    // Initialize original values map with the current state or a new map\n    const originalValues = state || new Map<string, string>();\n\n    // Iterate over each pattern defined in the transformer\n    for (const key of Object.keys(this.patterns)) {\n      const pattern = this.patterns[key];\n\n      // Apply the current pattern's regex to the message\n      processedMessage = processedMessage.replace(pattern.regex, (match) => {\n        // Determine the masked value: use the mask function if provided, else use the replacement string,\n        // else use the hash function.\n        const maskedValue = pattern.mask\n          ? pattern.mask(match)\n          : (pattern.replacement ?? this.hashFunction(match));\n\n        // Store the mapping of the masked value to the original value (match)\n        originalValues.set(maskedValue, match);\n\n        // Return the masked value to replace the original value in the message\n        return maskedValue;\n      });\n    }\n\n    // Return the fully masked message and the state map with all original values\n    // Wrap the synchronous return values in Promise.resolve() to maintain compatibility\n    // with the MaskingParser's expectation of a Promise return type.\n    return [processedMessage, originalValues];\n  }\n\n  /**\n   * Rehydrates a masked message back to its original form using the provided state.\n   * @param message - The masked message to be rehydrated.\n   * @param state - The state map containing mappings of masked values to their original values.\n   * @returns The rehydrated (original) message.\n   */\n  async rehydrate(\n    message: string,\n    state: Map<string, string>\n  ): Promise<string> {\n    if (typeof message !== \"string\") {\n      throw new TypeError(\n        \"RegexMaskingTransformer.rehydrate Error: The 'message' argument must be a string.\"\n      );\n    }\n\n    // eslint-disable-next-line no-instanceof/no-instanceof\n    if (!(state instanceof Map)) {\n      throw new TypeError(\n        \"RegexMaskingTransformer.rehydrate Error: The 'state' argument must be an instance of Map.\"\n      );\n    }\n\n    // Convert the state map to an array and use reduce to sequentially replace masked values with original values.\n    const rehydratedMessage = Array.from(state).reduce(\n      (msg, [masked, original]) => {\n        // Escape special characters in the masked string to ensure it can be used in a regular expression safely.\n        // This is necessary because masked values might contain characters that have special meanings in regex.\n        const escapedMasked = masked.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n\n        // Replace all instances of the escaped masked value in the message with the original value.\n        // The 'g' flag in the RegExp ensures that all occurrences of the masked value are replaced.\n        return msg.replace(new RegExp(escapedMasked, \"g\"), original);\n      },\n      message\n    );\n\n    return rehydratedMessage;\n  }\n\n  /**\n   * Default hash function for creating unique hash values.\n   * @param input - The input string to hash.\n   * @returns The resulting hash as a string.\n   */\n  private defaultHashFunction(input: string): string {\n    let hash = 0;\n    // Iterate over each character in the input string\n    for (let i = 0; i < input.length; i += 1) {\n      // Get ASCII value of the character\n      const char = input.charCodeAt(i);\n      // Combine the current hash with the new character and ensure it remains a 32-bit integer\n      hash = (hash << 5) - hash + char;\n      // Bitwise OR operation to convert to a 32-bit integer.\n      // This is a common technique to ensure the final hash value stays within the 32-bit limit,\n      // effectively wrapping the value when it becomes too large.\n      hash |= 0;\n    }\n\n    // Convert the numerical hash value to a string and return\n    return hash.toString();\n  }\n}\n"],"mappings":";;;;;;AAKA,IAAa,0BAAb,cAA6C,mBAAmB;CAC9D,AAAQ;CAER,AAAQ;;;;;;;;;;CAWR,YACEA,UACAC,cACA;EACA,OAAO;EAGP,KAAK,iBAAiB,SAAS;EAI/B,KAAK,WAAW;EAChB,KAAK,eAAe,gBAAgB,KAAK;CAC1C;;;;;;;CAQD,AAAQ,iBAAiBD,UAA6C;AACpE,OAAK,MAAM,OAAO,OAAO,KAAK,SAAS,EAAE;GACvC,MAAM,UAAU,SAAS;AAGzB,OACE,CAAC,WACD,OAAO,YAAY,YAEnB,EAAE,QAAQ,iBAAiB,QAE3B,OAAM,IAAI,MAAM;EAEnB;CACF;;;;;;;CAQD,MAAM,UACJE,SACAC,OACwC;AACxC,MAAI,OAAO,YAAY,SACrB,OAAM,IAAI,UACR;AAKJ,MAAI,EAAE,iBAAiB,KACrB,OAAM,IAAI,UACR;EAKJ,IAAI,mBAAmB;EAGvB,MAAM,iBAAiB,yBAAS,IAAI;AAGpC,OAAK,MAAM,OAAO,OAAO,KAAK,KAAK,SAAS,EAAE;GAC5C,MAAM,UAAU,KAAK,SAAS;GAG9B,mBAAmB,iBAAiB,QAAQ,QAAQ,OAAO,CAAC,UAAU;IAGpE,MAAM,cAAc,QAAQ,OACxB,QAAQ,KAAK,MAAM,GAClB,QAAQ,eAAe,KAAK,aAAa,MAAM;IAGpD,eAAe,IAAI,aAAa,MAAM;AAGtC,WAAO;GACR,EAAC;EACH;AAKD,SAAO,CAAC,kBAAkB,cAAe;CAC1C;;;;;;;CAQD,MAAM,UACJD,SACAC,OACiB;AACjB,MAAI,OAAO,YAAY,SACrB,OAAM,IAAI,UACR;AAKJ,MAAI,EAAE,iBAAiB,KACrB,OAAM,IAAI,UACR;EAKJ,MAAM,oBAAoB,MAAM,KAAK,MAAM,CAAC,OAC1C,CAAC,KAAK,CAAC,QAAQ,SAAS,KAAK;GAG3B,MAAM,gBAAgB,OAAO,QAAQ,uBAAuB,OAAO;AAInE,UAAO,IAAI,QAAQ,IAAI,OAAO,eAAe,MAAM,SAAS;EAC7D,GACD,QACD;AAED,SAAO;CACR;;;;;;CAOD,AAAQ,oBAAoBC,OAAuB;EACjD,IAAI,OAAO;AAEX,OAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,GAAG;GAExC,MAAM,OAAO,MAAM,WAAW,EAAE;GAEhC,QAAQ,QAAQ,KAAK,OAAO;GAI5B,QAAQ;EACT;AAGD,SAAO,KAAK,UAAU;CACvB;AACF"}
+{"version":3,"file":"regex_masking_transformer.js","names":[],"sources":["../../../src/experimental/masking/regex_masking_transformer.ts"],"sourcesContent":["import { MaskingTransformer } from \"./transformer.js\";\nimport type { HashFunction, MaskingPattern } from \"./types.js\";\n/**\n * RegexMaskingTransformer class for masking and rehydrating messages with Regex.\n */\nexport class RegexMaskingTransformer extends MaskingTransformer {\n  private patterns: { [key: string]: MaskingPattern };\n\n  private hashFunction: HashFunction;\n\n  /**\n   * Constructs a RegexMaskingTransformer with given patterns and an optional hash function.\n   * Validates the provided patterns to ensure they conform to the expected structure.\n   *\n   * @param patterns - An object containing masking patterns. Each pattern should include\n   *                   a regular expression (`regex`) and optionally a `replacement` string\n   *                   or a `mask` function.\n   * @param hashFunction - An optional custom hash function to be used for masking.\n   */\n  constructor(\n    patterns: { [key: string]: MaskingPattern },\n    hashFunction?: HashFunction\n  ) {\n    super();\n    // Validates the provided masking patterns before initializing the transformer.\n    // This ensures that each pattern has a valid regular expression.\n    this.validatePatterns(patterns);\n\n    // Assigns the validated patterns and the hash function to the transformer.\n    // If no custom hash function is provided, the default hash function is used.\n    this.patterns = patterns;\n    this.hashFunction = hashFunction || this.defaultHashFunction;\n  }\n\n  /**\n   * Validates the given masking patterns to ensure each pattern has a valid regular expression.\n   * Throws an error if any pattern is found to be invalid.\n   *\n   * @param patterns - The patterns object to validate.\n   */\n  private validatePatterns(patterns: { [key: string]: MaskingPattern }) {\n    for (const key of Object.keys(patterns)) {\n      const pattern = patterns[key];\n      // Checks that each pattern is an object and has a regex property that is an instance of RegExp.\n      // Throws an error if these conditions are not met, indicating an invalid pattern configuration.\n      if (\n        !pattern ||\n        typeof pattern !== \"object\" ||\n        // eslint-disable-next-line no-instanceof/no-instanceof\n        !(pattern.regex instanceof RegExp)\n      ) {\n        throw new Error(\"Invalid pattern configuration.\");\n      }\n    }\n  }\n\n  /**\n   * Masks content in a message based on the defined patterns.\n   * @param message - The message to be masked.\n   * @param state - The current state containing original values.\n   * @returns A tuple of the masked message and the updated state.\n   */\n  async transform(\n    message: string,\n    state: Map<string, string>\n  ): Promise<[string, Map<string, string>]> {\n    if (typeof message !== \"string\") {\n      throw new TypeError(\n        \"RegexMaskingTransformer.transform Error: The 'message' argument must be a string.\"\n      );\n    }\n\n    // eslint-disable-next-line no-instanceof/no-instanceof\n    if (!(state instanceof Map)) {\n      throw new TypeError(\n        \"RegexMaskingTransformer.transform Error: The 'state' argument must be an instance of Map.\"\n      );\n    }\n\n    // Holds the progressively masked message\n    let processedMessage = message;\n\n    // Initialize original values map with the current state or a new map\n    const originalValues = state || new Map<string, string>();\n\n    // Iterate over each pattern defined in the transformer\n    for (const key of Object.keys(this.patterns)) {\n      const pattern = this.patterns[key];\n\n      // Apply the current pattern's regex to the message\n      processedMessage = processedMessage.replace(pattern.regex, (match) => {\n        // Determine the masked value: use the mask function if provided, else use the replacement string,\n        // else use the hash function.\n        const maskedValue = pattern.mask\n          ? pattern.mask(match)\n          : (pattern.replacement ?? this.hashFunction(match));\n\n        // Store the mapping of the masked value to the original value (match)\n        originalValues.set(maskedValue, match);\n\n        // Return the masked value to replace the original value in the message\n        return maskedValue;\n      });\n    }\n\n    // Return the fully masked message and the state map with all original values\n    // Wrap the synchronous return values in Promise.resolve() to maintain compatibility\n    // with the MaskingParser's expectation of a Promise return type.\n    return [processedMessage, originalValues];\n  }\n\n  /**\n   * Rehydrates a masked message back to its original form using the provided state.\n   * @param message - The masked message to be rehydrated.\n   * @param state - The state map containing mappings of masked values to their original values.\n   * @returns The rehydrated (original) message.\n   */\n  async rehydrate(\n    message: string,\n    state: Map<string, string>\n  ): Promise<string> {\n    if (typeof message !== \"string\") {\n      throw new TypeError(\n        \"RegexMaskingTransformer.rehydrate Error: The 'message' argument must be a string.\"\n      );\n    }\n\n    // eslint-disable-next-line no-instanceof/no-instanceof\n    if (!(state instanceof Map)) {\n      throw new TypeError(\n        \"RegexMaskingTransformer.rehydrate Error: The 'state' argument must be an instance of Map.\"\n      );\n    }\n\n    // Convert the state map to an array and use reduce to sequentially replace masked values with original values.\n    const rehydratedMessage = Array.from(state).reduce(\n      (msg, [masked, original]) => {\n        // Escape special characters in the masked string to ensure it can be used in a regular expression safely.\n        // This is necessary because masked values might contain characters that have special meanings in regex.\n        const escapedMasked = masked.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n\n        // Replace all instances of the escaped masked value in the message with the original value.\n        // The 'g' flag in the RegExp ensures that all occurrences of the masked value are replaced.\n        return msg.replace(new RegExp(escapedMasked, \"g\"), original);\n      },\n      message\n    );\n\n    return rehydratedMessage;\n  }\n\n  /**\n   * Default hash function for creating unique hash values.\n   * @param input - The input string to hash.\n   * @returns The resulting hash as a string.\n   */\n  private defaultHashFunction(input: string): string {\n    let hash = 0;\n    // Iterate over each character in the input string\n    for (let i = 0; i < input.length; i += 1) {\n      // Get ASCII value of the character\n      const char = input.charCodeAt(i);\n      // Combine the current hash with the new character and ensure it remains a 32-bit integer\n      hash = (hash << 5) - hash + char;\n      // Bitwise OR operation to convert to a 32-bit integer.\n      // This is a common technique to ensure the final hash value stays within the 32-bit limit,\n      // effectively wrapping the value when it becomes too large.\n      hash |= 0;\n    }\n\n    // Convert the numerical hash value to a string and return\n    return hash.toString();\n  }\n}\n"],"mappings":";;;;;;AAKA,IAAa,0BAAb,cAA6C,mBAAmB;CAC9D,AAAQ;CAER,AAAQ;;;;;;;;;;CAWR,YACE,UACA,cACA;AACA,SAAO;AAGP,OAAK,iBAAiB,SAAS;AAI/B,OAAK,WAAW;AAChB,OAAK,eAAe,gBAAgB,KAAK;;;;;;;;CAS3C,AAAQ,iBAAiB,UAA6C;AACpE,OAAK,MAAM,OAAO,OAAO,KAAK,SAAS,EAAE;GACvC,MAAM,UAAU,SAAS;AAGzB,OACE,CAAC,WACD,OAAO,YAAY,YAEnB,EAAE,QAAQ,iBAAiB,QAE3B,OAAM,IAAI,MAAM,iCAAiC;;;;;;;;;CAWvD,MAAM,UACJ,SACA,OACwC;AACxC,MAAI,OAAO,YAAY,SACrB,OAAM,IAAI,UACR,oFACD;AAIH,MAAI,EAAE,iBAAiB,KACrB,OAAM,IAAI,UACR,4FACD;EAIH,IAAI,mBAAmB;EAGvB,MAAM,iBAAiB,yBAAS,IAAI,KAAqB;AAGzD,OAAK,MAAM,OAAO,OAAO,KAAK,KAAK,SAAS,EAAE;GAC5C,MAAM,UAAU,KAAK,SAAS;AAG9B,sBAAmB,iBAAiB,QAAQ,QAAQ,QAAQ,UAAU;IAGpE,MAAM,cAAc,QAAQ,OACxB,QAAQ,KAAK,MAAM,GAClB,QAAQ,eAAe,KAAK,aAAa,MAAM;AAGpD,mBAAe,IAAI,aAAa,MAAM;AAGtC,WAAO;KACP;;AAMJ,SAAO,CAAC,kBAAkB,eAAe;;;;;;;;CAS3C,MAAM,UACJ,SACA,OACiB;AACjB,MAAI,OAAO,YAAY,SACrB,OAAM,IAAI,UACR,oFACD;AAIH,MAAI,EAAE,iBAAiB,KACrB,OAAM,IAAI,UACR,4FACD;AAiBH,SAb0B,MAAM,KAAK,MAAM,CAAC,QACzC,KAAK,CAAC,QAAQ,cAAc;GAG3B,MAAM,gBAAgB,OAAO,QAAQ,uBAAuB,OAAO;AAInE,UAAO,IAAI,QAAQ,IAAI,OAAO,eAAe,IAAI,EAAE,SAAS;KAE9D,QACD;;;;;;;CAUH,AAAQ,oBAAoB,OAAuB;EACjD,IAAI,OAAO;AAEX,OAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,GAAG;GAExC,MAAM,OAAO,MAAM,WAAW,EAAE;AAEhC,WAAQ,QAAQ,KAAK,OAAO;AAI5B,WAAQ;;AAIV,SAAO,KAAK,UAAU"}

package/dist/experimental/masking/transformer.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"transformer.cjs","names":[],"sources":["../../../src/experimental/masking/transformer.ts"],"sourcesContent":["/**\n * Abstract class representing a transformer used for masking and rehydrating messages.\n */\nexport abstract class MaskingTransformer {\n  abstract transform(\n    message: string,\n    state?: Map<string, string>\n  ): Promise<[string, Map<string, string>]>;\n\n  abstract rehydrate(\n    message: string,\n    state: Map<string, string>\n  ): Promise<string>;\n}\n"],"mappings":";;;;;AAGA,IAAsB,qBAAtB,MAAyC,CAUxC"}
+{"version":3,"file":"transformer.cjs","names":[],"sources":["../../../src/experimental/masking/transformer.ts"],"sourcesContent":["/**\n * Abstract class representing a transformer used for masking and rehydrating messages.\n */\nexport abstract class MaskingTransformer {\n  abstract transform(\n    message: string,\n    state?: Map<string, string>\n  ): Promise<[string, Map<string, string>]>;\n\n  abstract rehydrate(\n    message: string,\n    state: Map<string, string>\n  ): Promise<string>;\n}\n"],"mappings":";;;;;AAGA,IAAsB,qBAAtB,MAAyC"}

package/dist/experimental/masking/transformer.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"transformer.d.cts","names":["MaskingTransformer","Map","Promise"],"sources":["../../../src/experimental/masking/transformer.d.ts"],"sourcesContent":["/**\n * Abstract class representing a transformer used for masking and rehydrating messages.\n */\nexport declare abstract class MaskingTransformer {\n    abstract transform(message: string, state?: Map<string, string>): Promise<[string, Map<string, string>]>;\n    abstract rehydrate(message: string, state: Map<string, string>): Promise<string>;\n}\n//# sourceMappingURL=transformer.d.ts.map"],"mappings":";;AAGA;;AACuFC,uBADzDD,kBAAAA,CACyDC;EAAjBC,SAAAA,SAAAA,CAAAA,OAAAA,EAAAA,MAAAA,EAAAA,KAAAA,CAAAA,EAAtBD,GAAsBC,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA,CAAAA,EAAAA,OAAAA,CAAAA,CAAAA,MAAAA,EAAiBD,GAAjBC,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA,CAAAA,CAAAA;EACvBD,SAAAA,SAAAA,CAAAA,OAAAA,EAAAA,MAAAA,EAAAA,KAAAA,EAAAA,GAAAA,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA,CAAAA,EAAsBC,OAAtBD,CAAAA,MAAAA,CAAAA"}
+{"version":3,"file":"transformer.d.cts","names":[],"sources":["../../../src/experimental/masking/transformer.ts"],"mappings":";;AAGA;;uBAAsB,kBAAA;EAAA,SACX,SAAA,CACP,OAAA,UACA,KAAA,GAAQ,GAAA,mBACP,OAAA,UAAiB,GAAA;EAAA,SAEX,SAAA,CACP,OAAA,UACA,KAAA,EAAO,GAAA,mBACN,OAAA;AAAA"}

package/dist/experimental/masking/transformer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transformer.d.ts","names":["MaskingTransformer","Map","Promise"],"sources":["../../../src/experimental/masking/transformer.d.ts"],"sourcesContent":["/**\n * Abstract class representing a transformer used for masking and rehydrating messages.\n */\nexport declare abstract class MaskingTransformer {\n    abstract transform(message: string, state?: Map<string, string>): Promise<[string, Map<string, string>]>;\n    abstract rehydrate(message: string, state: Map<string, string>): Promise<string>;\n}\n//# sourceMappingURL=transformer.d.ts.map"],"mappings":";;AAGA;;AACuFC,uBADzDD,kBAAAA,CACyDC;EAAjBC,SAAAA,SAAAA,CAAAA,OAAAA,EAAAA,MAAAA,EAAAA,KAAAA,CAAAA,EAAtBD,GAAsBC,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA,CAAAA,EAAAA,OAAAA,CAAAA,CAAAA,MAAAA,EAAiBD,GAAjBC,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA,CAAAA,CAAAA;EACvBD,SAAAA,SAAAA,CAAAA,OAAAA,EAAAA,MAAAA,EAAAA,KAAAA,EAAAA,GAAAA,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA,CAAAA,EAAsBC,OAAtBD,CAAAA,MAAAA,CAAAA"}
+{"version":3,"file":"transformer.d.ts","names":[],"sources":["../../../src/experimental/masking/transformer.ts"],"mappings":";;AAGA;;uBAAsB,kBAAA;EAAA,SACX,SAAA,CACP,OAAA,UACA,KAAA,GAAQ,GAAA,mBACP,OAAA,UAAiB,GAAA;EAAA,SAEX,SAAA,CACP,OAAA,UACA,KAAA,EAAO,GAAA,mBACN,OAAA;AAAA"}

package/dist/experimental/masking/transformer.js.map

@@ -1 +1 @@
-{"version":3,"file":"transformer.js","names":[],"sources":["../../../src/experimental/masking/transformer.ts"],"sourcesContent":["/**\n * Abstract class representing a transformer used for masking and rehydrating messages.\n */\nexport abstract class MaskingTransformer {\n  abstract transform(\n    message: string,\n    state?: Map<string, string>\n  ): Promise<[string, Map<string, string>]>;\n\n  abstract rehydrate(\n    message: string,\n    state: Map<string, string>\n  ): Promise<string>;\n}\n"],"mappings":";;;;AAGA,IAAsB,qBAAtB,MAAyC,CAUxC"}
+{"version":3,"file":"transformer.js","names":[],"sources":["../../../src/experimental/masking/transformer.ts"],"sourcesContent":["/**\n * Abstract class representing a transformer used for masking and rehydrating messages.\n */\nexport abstract class MaskingTransformer {\n  abstract transform(\n    message: string,\n    state?: Map<string, string>\n  ): Promise<[string, Map<string, string>]>;\n\n  abstract rehydrate(\n    message: string,\n    state: Map<string, string>\n  ): Promise<string>;\n}\n"],"mappings":";;;;AAGA,IAAsB,qBAAtB,MAAyC"}

package/dist/experimental/masking/types.d.cts

@@ -1,7 +1,6 @@
 import { MaskingTransformer } from "./transformer.cjs";
 
 //#region src/experimental/masking/types.d.ts
-
 /**
  * Configuration type for MaskingParser.
  */

package/dist/experimental/masking/types.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.cts","names":["MaskingTransformer","MaskingParserConfig","HashFunction","HookFunction","MaskingPattern","RegExp","Promise"],"sources":["../../../src/experimental/masking/types.d.ts"],"sourcesContent":["import { MaskingTransformer } from \"./transformer.js\";\n/**\n * Configuration type for MaskingParser.\n */\nexport type MaskingParserConfig = {\n    transformers?: MaskingTransformer[];\n    defaultHashFunction?: HashFunction;\n    onMaskingStart?: HookFunction;\n    onMaskingEnd?: HookFunction;\n    onRehydratingStart?: HookFunction;\n    onRehydratingEnd?: HookFunction;\n};\n/**\n *  Regex Masking Pattern used for masking in PIIMaskingTransformer.\n */\nexport type MaskingPattern = {\n    regex: RegExp;\n    replacement?: string;\n    mask?: (match: string) => string;\n};\nexport type HookFunction = ((message: string) => Promise<void>) | ((message: string) => void);\n/**\n * Represents a function that can hash a string input.\n */\nexport type HashFunction = (input: string) => string;\n//# sourceMappingURL=types.d.ts.map"],"mappings":";;;;;;AAIA;AACmBA,KADPC,mBAAAA,GACOD;EACOE,YAAAA,CAAAA,EADPF,kBACOE,EAAAA;EACLC,mBAAAA,CAAAA,EADKD,YACLC;EACFA,cAAAA,CAAAA,EADEA,YACFA;EACMA,YAAAA,CAAAA,EADNA,YACMA;EACFA,kBAAAA,CAAAA,EADEA,YACFA;EAAY,gBAAA,CAAA,EAAZA,YAAY;AAKnC,CAAA;AAKA;AAIA;;KATYC,cAAAA;SACDC;;;;KAICF,YAAAA,yBAAqCG;;;;KAIrCJ,YAAAA"}
+{"version":3,"file":"types.d.cts","names":[],"sources":["../../../src/experimental/masking/types.ts"],"mappings":";;;;;AAKA;KAAY,mBAAA;EACV,YAAA,GAAe,kBAAA;EACf,mBAAA,GAAsB,YAAA;EACtB,cAAA,GAAiB,YAAA;EACjB,YAAA,GAAe,YAAA;EACf,kBAAA,GAAqB,YAAA;EACrB,gBAAA,GAAmB,YAAA;AAAA;;;;KAMT,cAAA;EACV,KAAA,EAAO,MAAA;EACP,WAAA;EACA,IAAA,IAAQ,KAAA;AAAA;AAAA,KAGE,YAAA,KACN,OAAA,aAAoB,OAAA,YACpB,OAAA;;;;KAKM,YAAA,IAAgB,KAAA"}

package/dist/experimental/masking/types.d.ts

@@ -1,7 +1,6 @@
 import { MaskingTransformer } from "./transformer.js";
 
 //#region src/experimental/masking/types.d.ts
-
 /**
  * Configuration type for MaskingParser.
  */

package/dist/experimental/masking/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":["MaskingTransformer","MaskingParserConfig","HashFunction","HookFunction","MaskingPattern","RegExp","Promise"],"sources":["../../../src/experimental/masking/types.d.ts"],"sourcesContent":["import { MaskingTransformer } from \"./transformer.js\";\n/**\n * Configuration type for MaskingParser.\n */\nexport type MaskingParserConfig = {\n    transformers?: MaskingTransformer[];\n    defaultHashFunction?: HashFunction;\n    onMaskingStart?: HookFunction;\n    onMaskingEnd?: HookFunction;\n    onRehydratingStart?: HookFunction;\n    onRehydratingEnd?: HookFunction;\n};\n/**\n *  Regex Masking Pattern used for masking in PIIMaskingTransformer.\n */\nexport type MaskingPattern = {\n    regex: RegExp;\n    replacement?: string;\n    mask?: (match: string) => string;\n};\nexport type HookFunction = ((message: string) => Promise<void>) | ((message: string) => void);\n/**\n * Represents a function that can hash a string input.\n */\nexport type HashFunction = (input: string) => string;\n//# sourceMappingURL=types.d.ts.map"],"mappings":";;;;;;AAIA;AACmBA,KADPC,mBAAAA,GACOD;EACOE,YAAAA,CAAAA,EADPF,kBACOE,EAAAA;EACLC,mBAAAA,CAAAA,EADKD,YACLC;EACFA,cAAAA,CAAAA,EADEA,YACFA;EACMA,YAAAA,CAAAA,EADNA,YACMA;EACFA,kBAAAA,CAAAA,EADEA,YACFA;EAAY,gBAAA,CAAA,EAAZA,YAAY;AAKnC,CAAA;AAKA;AAIA;;KATYC,cAAAA;SACDC;;;;KAICF,YAAAA,yBAAqCG;;;;KAIrCJ,YAAAA"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/experimental/masking/types.ts"],"mappings":";;;;;AAKA;KAAY,mBAAA;EACV,YAAA,GAAe,kBAAA;EACf,mBAAA,GAAsB,YAAA;EACtB,cAAA,GAAiB,YAAA;EACjB,YAAA,GAAe,YAAA;EACf,kBAAA,GAAqB,YAAA;EACrB,gBAAA,GAAmB,YAAA;AAAA;;;;KAMT,cAAA;EACV,KAAA,EAAO,MAAA;EACP,WAAA;EACA,IAAA,IAAQ,KAAA;AAAA;AAAA,KAGE,YAAA,KACN,OAAA,aAAoB,OAAA,YACpB,OAAA;;;;KAKM,YAAA,IAAgB,KAAA"}