@langchain/classic 1.0.0-alpha.1

package/dist/experimental/generative_agents/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":[],"sources":["../../../src/experimental/generative_agents/index.ts"],"sourcesContent":["export { GenerativeAgentMemory } from \"./generative_agent_memory.js\";\nexport { GenerativeAgent } from \"./generative_agent.js\";\n"],"mappings":""}

package/dist/experimental/generative_agents/index.d.cts

@@ -0,0 +1,3 @@
+import { GenerativeAgentMemory } from "./generative_agent_memory.cjs";
+import { GenerativeAgent } from "./generative_agent.cjs";
+export { GenerativeAgent, GenerativeAgentMemory };

package/dist/experimental/generative_agents/index.d.ts

@@ -0,0 +1,3 @@
+import { GenerativeAgentMemory } from "./generative_agent_memory.js";
+import { GenerativeAgent } from "./generative_agent.js";
+export { GenerativeAgent, GenerativeAgentMemory };

package/dist/experimental/generative_agents/index.js

@@ -0,0 +1,14 @@
+import { __export } 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, {
+	GenerativeAgent: () => GenerativeAgent,
+	GenerativeAgentMemory: () => GenerativeAgentMemory
+});
+
+//#endregion
+export { GenerativeAgent, GenerativeAgentMemory, generative_agents_exports };
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/experimental/generative_agents/index.ts"],"sourcesContent":["export { GenerativeAgentMemory } from \"./generative_agent_memory.js\";\nexport { GenerativeAgent } from \"./generative_agent.js\";\n"],"mappings":""}

package/dist/experimental/masking/index.cjs

@@ -0,0 +1,24 @@
+const require_rolldown_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, {
+	MaskingParser: () => require_parser.MaskingParser,
+	MaskingTransformer: () => require_transformer.MaskingTransformer,
+	RegexMaskingTransformer: () => require_regex_masking_transformer.RegexMaskingTransformer
+});
+
+//#endregion
+exports.MaskingParser = require_parser.MaskingParser;
+exports.MaskingTransformer = require_transformer.MaskingTransformer;
+exports.RegexMaskingTransformer = require_regex_masking_transformer.RegexMaskingTransformer;
+Object.defineProperty(exports, 'masking_exports', {
+  enumerable: true,
+  get: function () {
+    return masking_exports;
+  }
+});
+//# sourceMappingURL=index.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":[],"sources":["../../../src/experimental/masking/index.ts"],"sourcesContent":["export { MaskingParser } from \"./parser.js\";\nexport { RegexMaskingTransformer } from \"./regex_masking_transformer.js\";\nexport { MaskingTransformer } from \"./transformer.js\";\nexport {\n  type MaskingParserConfig,\n  type HashFunction,\n  type HookFunction,\n} from \"./types.js\";\n"],"mappings":""}

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

@@ -0,0 +1,5 @@
+import { MaskingTransformer } from "./transformer.cjs";
+import { HashFunction, HookFunction, MaskingParserConfig } from "./types.cjs";
+import { MaskingParser } from "./parser.cjs";
+import { RegexMaskingTransformer } from "./regex_masking_transformer.cjs";
+export { type HashFunction, type HookFunction, MaskingParser, type MaskingParserConfig, MaskingTransformer, RegexMaskingTransformer };

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

@@ -0,0 +1,5 @@
+import { MaskingTransformer } from "./transformer.js";
+import { HashFunction, HookFunction, MaskingParserConfig } from "./types.js";
+import { MaskingParser } from "./parser.js";
+import { RegexMaskingTransformer } from "./regex_masking_transformer.js";
+export { type HashFunction, type HookFunction, MaskingParser, type MaskingParserConfig, MaskingTransformer, RegexMaskingTransformer };

package/dist/experimental/masking/index.js

@@ -0,0 +1,16 @@
+import { __export } 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, {
+	MaskingParser: () => MaskingParser,
+	MaskingTransformer: () => MaskingTransformer,
+	RegexMaskingTransformer: () => RegexMaskingTransformer
+});
+
+//#endregion
+export { MaskingParser, MaskingTransformer, RegexMaskingTransformer, masking_exports };
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/experimental/masking/index.ts"],"sourcesContent":["export { MaskingParser } from \"./parser.js\";\nexport { RegexMaskingTransformer } from \"./regex_masking_transformer.js\";\nexport { MaskingTransformer } from \"./transformer.js\";\nexport {\n  type MaskingParserConfig,\n  type HashFunction,\n  type HookFunction,\n} from \"./types.js\";\n"],"mappings":""}

package/dist/experimental/masking/parser.cjs

@@ -0,0 +1,79 @@
+
+//#region src/experimental/masking/parser.ts
+/**
+* MaskingParser class for handling the masking and rehydrating of messages.
+*/
+var MaskingParser = class {
+	transformers;
+	state;
+	config;
+	constructor(config = {}) {
+		this.transformers = config.transformers ?? [];
+		this.state = /* @__PURE__ */ new Map();
+		this.config = config;
+	}
+	/**
+	* Adds a transformer to the parser.
+	* @param transformer - An instance of a class extending MaskingTransformer.
+	*/
+	addTransformer(transformer) {
+		this.transformers.push(transformer);
+	}
+	/**
+	* Getter method for retrieving the current state.
+	* @returns The current state map.
+	*/
+	getState() {
+		return this.state;
+	}
+	/**
+	* Masks the provided message using the added transformers.
+	* This method sequentially applies each transformer's masking logic to the message.
+	* It utilizes a state map to track original values corresponding to their masked versions.
+	*
+	* @param message - The message to be masked.
+	* @returns A masked version of the message.
+	* @throws {TypeError} If the message is not a string.
+	* @throws {Error} If no transformers are added.
+	*/
+	async mask(message) {
+		if (this.config.onMaskingStart) await this.config.onMaskingStart(message);
+		if (this.transformers.length === 0) throw new Error("MaskingParser.mask Error: No transformers have been added. Please add at least one transformer before parsing.");
+		if (typeof message !== "string") throw new TypeError("MaskingParser.mask Error: The 'message' argument must be a string.");
+		let processedMessage = message;
+		for (const transformer of this.transformers) {
+			const [transformedMessage, transformerState] = await transformer.transform(processedMessage, new Map(this.state));
+			processedMessage = transformedMessage;
+			transformerState.forEach((value, key) => this.state.set(key, value));
+		}
+		if (this.config.onMaskingEnd) await this.config.onMaskingEnd(processedMessage);
+		return processedMessage;
+	}
+	/**
+	* Rehydrates a masked message back to its original form.
+	* This method sequentially applies the rehydration logic of each added transformer in reverse order.
+	* It relies on the state map to correctly map the masked values back to their original values.
+	*
+	* The rehydration process is essential for restoring the original content of a message
+	* that has been transformed (masked) by the transformers. This process is the inverse of the masking process.
+	*
+	* @param message - The masked message to be rehydrated.
+	* @returns The original (rehydrated) version of the message.
+	*/
+	async rehydrate(message, state) {
+		if (this.config.onRehydratingStart) await this.config.onRehydratingStart(message);
+		if (typeof message !== "string") throw new TypeError("MaskingParser.rehydrate Error: The 'message' argument must be a string.");
+		if (this.transformers.length === 0) throw new Error("MaskingParser.rehydrate Error: No transformers have been added. Please add at least one transformer before rehydrating.");
+		if (state && !(state instanceof Map)) throw new TypeError("MaskingParser.rehydrate Error: The 'state' argument, if provided, must be an instance of Map.");
+		const rehydrationState = state || this.state;
+		let rehydratedMessage = message;
+		const reversedTransformers = this.transformers.slice().reverse();
+		for (const transformer of reversedTransformers) rehydratedMessage = await transformer.rehydrate(rehydratedMessage, rehydrationState);
+		if (this.config.onRehydratingEnd) await this.config.onRehydratingEnd(rehydratedMessage);
+		return rehydratedMessage;
+	}
+};
+
+//#endregion
+exports.MaskingParser = MaskingParser;
+//# sourceMappingURL=parser.cjs.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,50 @@
+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.
+ */
+declare class MaskingParser {
+  private transformers;
+  private state;
+  private config;
+  constructor(config?: MaskingParserConfig);
+  /**
+   * Adds a transformer to the parser.
+   * @param transformer - An instance of a class extending MaskingTransformer.
+   */
+  addTransformer(transformer: MaskingTransformer): void;
+  /**
+   * Getter method for retrieving the current state.
+   * @returns The current state map.
+   */
+  getState(): Map<string, string>;
+  /**
+   * Masks the provided message using the added transformers.
+   * This method sequentially applies each transformer's masking logic to the message.
+   * It utilizes a state map to track original values corresponding to their masked versions.
+   *
+   * @param message - The message to be masked.
+   * @returns A masked version of the message.
+   * @throws {TypeError} If the message is not a string.
+   * @throws {Error} If no transformers are added.
+   */
+  mask(message: string): Promise<string>;
+  /**
+   * Rehydrates a masked message back to its original form.
+   * This method sequentially applies the rehydration logic of each added transformer in reverse order.
+   * It relies on the state map to correctly map the masked values back to their original values.
+   *
+   * The rehydration process is essential for restoring the original content of a message
+   * that has been transformed (masked) by the transformers. This process is the inverse of the masking process.
+   *
+   * @param message - The masked message to be rehydrated.
+   * @returns The original (rehydrated) version of the message.
+   */
+  rehydrate(message: string, state?: Map<string, string>): Promise<string>;
+}
+//#endregion
+export { MaskingParser };
+//# sourceMappingURL=parser.d.cts.map

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

@@ -0,0 +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"],"mappings":";;;;;;;AAKA;AAAkC,cAAbE,aAAAA,CAAa;EAAA,QAITD,YAAAA;EAAmB,QAKZD,KAAAA;EAAkB,QAKlCG,MAAAA;EAAG,WAWQC,CAAAA,MAAAA,CAAAA,EArBFH,mBAqBEG;EAAO;;AAYkC;;8BA5BpCJ;;;;;cAKhBG;;;;;;;;;;;yBAWWC;;;;;;;;;;;;qCAYYD,sBAAsBC"}

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

@@ -0,0 +1,50 @@
+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.
+ */
+declare class MaskingParser {
+  private transformers;
+  private state;
+  private config;
+  constructor(config?: MaskingParserConfig);
+  /**
+   * Adds a transformer to the parser.
+   * @param transformer - An instance of a class extending MaskingTransformer.
+   */
+  addTransformer(transformer: MaskingTransformer): void;
+  /**
+   * Getter method for retrieving the current state.
+   * @returns The current state map.
+   */
+  getState(): Map<string, string>;
+  /**
+   * Masks the provided message using the added transformers.
+   * This method sequentially applies each transformer's masking logic to the message.
+   * It utilizes a state map to track original values corresponding to their masked versions.
+   *
+   * @param message - The message to be masked.
+   * @returns A masked version of the message.
+   * @throws {TypeError} If the message is not a string.
+   * @throws {Error} If no transformers are added.
+   */
+  mask(message: string): Promise<string>;
+  /**
+   * Rehydrates a masked message back to its original form.
+   * This method sequentially applies the rehydration logic of each added transformer in reverse order.
+   * It relies on the state map to correctly map the masked values back to their original values.
+   *
+   * The rehydration process is essential for restoring the original content of a message
+   * that has been transformed (masked) by the transformers. This process is the inverse of the masking process.
+   *
+   * @param message - The masked message to be rehydrated.
+   * @returns The original (rehydrated) version of the message.
+   */
+  rehydrate(message: string, state?: Map<string, string>): Promise<string>;
+}
+//#endregion
+export { MaskingParser };
+//# sourceMappingURL=parser.d.ts.map

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

@@ -0,0 +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"],"mappings":";;;;;;;AAKA;AAAkC,cAAbE,aAAAA,CAAa;EAAA,QAITD,YAAAA;EAAmB,QAKZD,KAAAA;EAAkB,QAKlCG,MAAAA;EAAG,WAWQC,CAAAA,MAAAA,CAAAA,EArBFH,mBAqBEG;EAAO;;AAYkC;;8BA5BpCJ;;;;;cAKhBG;;;;;;;;;;;yBAWWC;;;;;;;;;;;;qCAYYD,sBAAsBC"}

package/dist/experimental/masking/parser.js

@@ -0,0 +1,78 @@
+//#region src/experimental/masking/parser.ts
+/**
+* MaskingParser class for handling the masking and rehydrating of messages.
+*/
+var MaskingParser = class {
+	transformers;
+	state;
+	config;
+	constructor(config = {}) {
+		this.transformers = config.transformers ?? [];
+		this.state = /* @__PURE__ */ new Map();
+		this.config = config;
+	}
+	/**
+	* Adds a transformer to the parser.
+	* @param transformer - An instance of a class extending MaskingTransformer.
+	*/
+	addTransformer(transformer) {
+		this.transformers.push(transformer);
+	}
+	/**
+	* Getter method for retrieving the current state.
+	* @returns The current state map.
+	*/
+	getState() {
+		return this.state;
+	}
+	/**
+	* Masks the provided message using the added transformers.
+	* This method sequentially applies each transformer's masking logic to the message.
+	* It utilizes a state map to track original values corresponding to their masked versions.
+	*
+	* @param message - The message to be masked.
+	* @returns A masked version of the message.
+	* @throws {TypeError} If the message is not a string.
+	* @throws {Error} If no transformers are added.
+	*/
+	async mask(message) {
+		if (this.config.onMaskingStart) await this.config.onMaskingStart(message);
+		if (this.transformers.length === 0) throw new Error("MaskingParser.mask Error: No transformers have been added. Please add at least one transformer before parsing.");
+		if (typeof message !== "string") throw new TypeError("MaskingParser.mask Error: The 'message' argument must be a string.");
+		let processedMessage = message;
+		for (const transformer of this.transformers) {
+			const [transformedMessage, transformerState] = await transformer.transform(processedMessage, new Map(this.state));
+			processedMessage = transformedMessage;
+			transformerState.forEach((value, key) => this.state.set(key, value));
+		}
+		if (this.config.onMaskingEnd) await this.config.onMaskingEnd(processedMessage);
+		return processedMessage;
+	}
+	/**
+	* Rehydrates a masked message back to its original form.
+	* This method sequentially applies the rehydration logic of each added transformer in reverse order.
+	* It relies on the state map to correctly map the masked values back to their original values.
+	*
+	* The rehydration process is essential for restoring the original content of a message
+	* that has been transformed (masked) by the transformers. This process is the inverse of the masking process.
+	*
+	* @param message - The masked message to be rehydrated.
+	* @returns The original (rehydrated) version of the message.
+	*/
+	async rehydrate(message, state) {
+		if (this.config.onRehydratingStart) await this.config.onRehydratingStart(message);
+		if (typeof message !== "string") throw new TypeError("MaskingParser.rehydrate Error: The 'message' argument must be a string.");
+		if (this.transformers.length === 0) throw new Error("MaskingParser.rehydrate Error: No transformers have been added. Please add at least one transformer before rehydrating.");
+		if (state && !(state instanceof Map)) throw new TypeError("MaskingParser.rehydrate Error: The 'state' argument, if provided, must be an instance of Map.");
+		const rehydrationState = state || this.state;
+		let rehydratedMessage = message;
+		const reversedTransformers = this.transformers.slice().reverse();
+		for (const transformer of reversedTransformers) rehydratedMessage = await transformer.rehydrate(rehydratedMessage, rehydrationState);
+		if (this.config.onRehydratingEnd) await this.config.onRehydratingEnd(rehydratedMessage);
+		return rehydratedMessage;
+	}
+};
+
+//#endregion
+export { MaskingParser };
+//# sourceMappingURL=parser.js.map

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

@@ -0,0 +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"}

package/dist/experimental/masking/regex_masking_transformer.cjs

@@ -0,0 +1,91 @@
+const require_transformer = require('./transformer.cjs');
+
+//#region src/experimental/masking/regex_masking_transformer.ts
+/**
+* RegexMaskingTransformer class for masking and rehydrating messages with Regex.
+*/
+var RegexMaskingTransformer = class extends require_transformer.MaskingTransformer {
+	patterns;
+	hashFunction;
+	/**
+	* Constructs a RegexMaskingTransformer with given patterns and an optional hash function.
+	* Validates the provided patterns to ensure they conform to the expected structure.
+	*
+	* @param patterns - An object containing masking patterns. Each pattern should include
+	*                   a regular expression (`regex`) and optionally a `replacement` string
+	*                   or a `mask` function.
+	* @param hashFunction - An optional custom hash function to be used for masking.
+	*/
+	constructor(patterns, hashFunction) {
+		super();
+		this.validatePatterns(patterns);
+		this.patterns = patterns;
+		this.hashFunction = hashFunction || this.defaultHashFunction;
+	}
+	/**
+	* Validates the given masking patterns to ensure each pattern has a valid regular expression.
+	* Throws an error if any pattern is found to be invalid.
+	*
+	* @param patterns - The patterns object to validate.
+	*/
+	validatePatterns(patterns) {
+		for (const key of Object.keys(patterns)) {
+			const pattern = patterns[key];
+			if (!pattern || typeof pattern !== "object" || !(pattern.regex instanceof RegExp)) throw new Error("Invalid pattern configuration.");
+		}
+	}
+	/**
+	* Masks content in a message based on the defined patterns.
+	* @param message - The message to be masked.
+	* @param state - The current state containing original values.
+	* @returns A tuple of the masked message and the updated state.
+	*/
+	async transform(message, state) {
+		if (typeof message !== "string") throw new TypeError("RegexMaskingTransformer.transform Error: The 'message' argument must be a string.");
+		if (!(state instanceof Map)) throw new TypeError("RegexMaskingTransformer.transform Error: The 'state' argument must be an instance of Map.");
+		let processedMessage = message;
+		const originalValues = state || /* @__PURE__ */ new Map();
+		for (const key of Object.keys(this.patterns)) {
+			const pattern = this.patterns[key];
+			processedMessage = processedMessage.replace(pattern.regex, (match) => {
+				const maskedValue = pattern.mask ? pattern.mask(match) : pattern.replacement ?? this.hashFunction(match);
+				originalValues.set(maskedValue, match);
+				return maskedValue;
+			});
+		}
+		return [processedMessage, originalValues];
+	}
+	/**
+	* Rehydrates a masked message back to its original form using the provided state.
+	* @param message - The masked message to be rehydrated.
+	* @param state - The state map containing mappings of masked values to their original values.
+	* @returns The rehydrated (original) message.
+	*/
+	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]) => {
+			const escapedMasked = masked.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+			return msg.replace(new RegExp(escapedMasked, "g"), original);
+		}, message);
+		return rehydratedMessage;
+	}
+	/**
+	* Default hash function for creating unique hash values.
+	* @param input - The input string to hash.
+	* @returns The resulting hash as a string.
+	*/
+	defaultHashFunction(input) {
+		let hash = 0;
+		for (let i = 0; i < input.length; i += 1) {
+			const char = input.charCodeAt(i);
+			hash = (hash << 5) - hash + char;
+			hash |= 0;
+		}
+		return hash.toString();
+	}
+};
+
+//#endregion
+exports.RegexMaskingTransformer = RegexMaskingTransformer;
+//# sourceMappingURL=regex_masking_transformer.cjs.map

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

@@ -0,0 +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,GACnB,QAAQ,eAAe,KAAK,aAAa,MAAM;IAGnD,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"}

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

@@ -0,0 +1,54 @@
+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.
+ */
+declare class RegexMaskingTransformer extends MaskingTransformer {
+  private patterns;
+  private hashFunction;
+  /**
+   * Constructs a RegexMaskingTransformer with given patterns and an optional hash function.
+   * Validates the provided patterns to ensure they conform to the expected structure.
+   *
+   * @param patterns - An object containing masking patterns. Each pattern should include
+   *                   a regular expression (`regex`) and optionally a `replacement` string
+   *                   or a `mask` function.
+   * @param hashFunction - An optional custom hash function to be used for masking.
+   */
+  constructor(patterns: {
+    [key: string]: MaskingPattern;
+  }, hashFunction?: HashFunction);
+  /**
+   * Validates the given masking patterns to ensure each pattern has a valid regular expression.
+   * Throws an error if any pattern is found to be invalid.
+   *
+   * @param patterns - The patterns object to validate.
+   */
+  private validatePatterns;
+  /**
+   * Masks content in a message based on the defined patterns.
+   * @param message - The message to be masked.
+   * @param state - The current state containing original values.
+   * @returns A tuple of the masked message and the updated state.
+   */
+  transform(message: string, state: Map<string, string>): Promise<[string, Map<string, string>]>;
+  /**
+   * Rehydrates a masked message back to its original form using the provided state.
+   * @param message - The masked message to be rehydrated.
+   * @param state - The state map containing mappings of masked values to their original values.
+   * @returns The rehydrated (original) message.
+   */
+  rehydrate(message: string, state: Map<string, string>): Promise<string>;
+  /**
+   * Default hash function for creating unique hash values.
+   * @param input - The input string to hash.
+   * @returns The resulting hash as a string.
+   */
+  private defaultHashFunction;
+}
+//#endregion
+export { RegexMaskingTransformer };
+//# sourceMappingURL=regex_masking_transformer.d.cts.map

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

@@ -0,0 +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"],"mappings":";;;;;;;AAKA;AAA4C,cAAvBG,uBAAAA,SAAgCH,kBAAAA,CAAT;EAAA,QAarBE,QAAAA;EAAc,QACfD,YAAAA;EAAY;;;;;;AAdqC;;;;mBAahDC;oBACDD;;;;;;;;;;;;;;oCAcgBG,sBAAsBC,iBAAiBD;;;;;;;oCAOvCA,sBAAsBC"}