langchain 0.0.202 → 0.0.204-rc.0

package/dist/embeddings/voyage.d.ts

@@ -1,66 +1 @@
-import { Embeddings, EmbeddingsParams } from "./base.js";
-/**
- * Interface that extends EmbeddingsParams and defines additional
- * parameters specific to the VoyageEmbeddings class.
- */
-export interface VoyageEmbeddingsParams extends EmbeddingsParams {
-    modelName: string;
-    /**
-     * The maximum number of documents to embed in a single request. This is
-     * limited by the Voyage AI API to a maximum of 8.
-     */
-    batchSize?: number;
-}
-/**
- * Interface for the request body to generate embeddings.
- */
-export interface CreateVoyageEmbeddingRequest {
-    /**
-     * @type {string}
-     * @memberof CreateVoyageEmbeddingRequest
-     */
-    model: string;
-    /**
-     *  Text to generate vector expectation
-     * @type {CreateEmbeddingRequestInput}
-     * @memberof CreateVoyageEmbeddingRequest
-     */
-    input: string | string[];
-}
-/**
- * A class for generating embeddings using the Voyage AI API.
- */
-export declare class VoyageEmbeddings extends Embeddings implements VoyageEmbeddingsParams {
-    modelName: string;
-    batchSize: number;
-    private apiKey;
-    basePath?: string;
-    apiUrl: string;
-    headers?: Record<string, string>;
-    /**
-     * Constructor for the VoyageEmbeddings class.
-     * @param fields - An optional object with properties to configure the instance.
-     */
-    constructor(fields?: Partial<VoyageEmbeddingsParams> & {
-        verbose?: boolean;
-        apiKey?: string;
-    });
-    /**
-     * Generates embeddings for an array of texts.
-     * @param texts - An array of strings to generate embeddings for.
-     * @returns A Promise that resolves to an array of embeddings.
-     */
-    embedDocuments(texts: string[]): Promise<number[][]>;
-    /**
-     * Generates an embedding for a single text.
-     * @param text - A string to generate an embedding for.
-     * @returns A Promise that resolves to an array of numbers representing the embedding.
-     */
-    embedQuery(text: string): Promise<number[]>;
-    /**
-     * Makes a request to the Voyage AI API to generate embeddings for an array of texts.
-     * @param request - An object with properties to configure the request.
-     * @returns A Promise that resolves to the response from the Voyage AI API.
-     */
-    private embeddingWithRetry;
-}
+export * from "@langchain/community/embeddings/voyage";

package/dist/embeddings/voyage.js

@@ -1,116 +1 @@
-import { chunkArray } from "../util/chunk.js";
-import { getEnvironmentVariable } from "../util/env.js";
-import { Embeddings } from "./base.js";
-/**
- * A class for generating embeddings using the Voyage AI API.
- */
-export class VoyageEmbeddings extends Embeddings {
-    /**
-     * Constructor for the VoyageEmbeddings class.
-     * @param fields - An optional object with properties to configure the instance.
-     */
-    constructor(fields) {
-        const fieldsWithDefaults = { ...fields };
-        super(fieldsWithDefaults);
-        Object.defineProperty(this, "modelName", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "voyage-01"
-        });
-        Object.defineProperty(this, "batchSize", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 8
-        });
-        Object.defineProperty(this, "apiKey", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "basePath", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "https://api.voyageai.com/v1"
-        });
-        Object.defineProperty(this, "apiUrl", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "headers", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        const apiKey = fieldsWithDefaults?.apiKey || getEnvironmentVariable("VOYAGEAI_API_KEY");
-        if (!apiKey) {
-            throw new Error("Voyage AI API key not found");
-        }
-        this.modelName = fieldsWithDefaults?.modelName ?? this.modelName;
-        this.batchSize = fieldsWithDefaults?.batchSize ?? this.batchSize;
-        this.apiKey = apiKey;
-        this.apiUrl = `${this.basePath}/embeddings`;
-    }
-    /**
-     * Generates embeddings for an array of texts.
-     * @param texts - An array of strings to generate embeddings for.
-     * @returns A Promise that resolves to an array of embeddings.
-     */
-    async embedDocuments(texts) {
-        const batches = chunkArray(texts, this.batchSize);
-        const batchRequests = batches.map((batch) => this.embeddingWithRetry({
-            model: this.modelName,
-            input: batch,
-        }));
-        const batchResponses = await Promise.all(batchRequests);
-        const embeddings = [];
-        for (let i = 0; i < batchResponses.length; i += 1) {
-            const batch = batches[i];
-            const { data: batchResponse } = batchResponses[i];
-            for (let j = 0; j < batch.length; j += 1) {
-                embeddings.push(batchResponse[j].embedding);
-            }
-        }
-        return embeddings;
-    }
-    /**
-     * Generates an embedding for a single text.
-     * @param text - A string to generate an embedding for.
-     * @returns A Promise that resolves to an array of numbers representing the embedding.
-     */
-    async embedQuery(text) {
-        const { data } = await this.embeddingWithRetry({
-            model: this.modelName,
-            input: text,
-        });
-        return data[0].embedding;
-    }
-    /**
-     * Makes a request to the Voyage AI API to generate embeddings for an array of texts.
-     * @param request - An object with properties to configure the request.
-     * @returns A Promise that resolves to the response from the Voyage AI API.
-     */
-    async embeddingWithRetry(request) {
-        const makeCompletionRequest = async () => {
-            const url = `${this.apiUrl}`;
-            const response = await fetch(url, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    Authorization: `Bearer ${this.apiKey}`,
-                    ...this.headers,
-                },
-                body: JSON.stringify(request),
-            });
-            const json = await response.json();
-            return json;
-        };
-        return this.caller.call(makeCompletionRequest);
-    }
-}
+export * from "@langchain/community/embeddings/voyage";

package/dist/experimental/chat_models/ollama_functions.d.ts

@@ -32,7 +32,7 @@ export declare class OllamaFunctions extends BaseChatModel<ChatOllamaFunctionsCa
     constructor(fields?: OllamaFunctionsInput);
     invocationParams(): {
         model: string;
-        format: import("../../util/types.js").StringWithAutocomplete<"json"> | undefined;
+        format: import("@langchain/core/utils/types").StringWithAutocomplete<"json"> | undefined;
         options: {
             embedding_only: boolean | undefined;
             f16_kv: boolean | undefined;

package/dist/experimental/masking/index.cjs

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MaskingTransformer = exports.RegexMaskingTransformer = exports.MaskingParser = void 0;
+var parser_js_1 = require("./parser.cjs");
+Object.defineProperty(exports, "MaskingParser", { enumerable: true, get: function () { return parser_js_1.MaskingParser; } });
+var regex_masking_transformer_js_1 = require("./regex_masking_transformer.cjs");
+Object.defineProperty(exports, "RegexMaskingTransformer", { enumerable: true, get: function () { return regex_masking_transformer_js_1.RegexMaskingTransformer; } });
+var transformer_js_1 = require("./transformer.cjs");
+Object.defineProperty(exports, "MaskingTransformer", { enumerable: true, get: function () { return transformer_js_1.MaskingTransformer; } });

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

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

package/dist/experimental/masking/index.js

@@ -0,0 +1,3 @@
+export { MaskingParser } from "./parser.js";
+export { RegexMaskingTransformer } from "./regex_masking_transformer.js";
+export { MaskingTransformer } from "./transformer.js";

package/dist/experimental/masking/parser.cjs

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MaskingParser = void 0;
+/**
+ * MaskingParser class for handling the masking and rehydrating of messages.
+ */
+class MaskingParser {
+    constructor(config = {}) {
+        Object.defineProperty(this, "transformers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "state", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.transformers = config.transformers ?? [];
+        this.state = 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 onMaskingStart is a function, handle it accordingly
+        if (this.config.onMaskingStart) {
+            await this.config.onMaskingStart(message);
+        }
+        // Check if there are any transformers added to the parser. If not, throw an error
+        // as masking requires at least one transformer to apply its logic.
+        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.");
+        }
+        // Initialize the variable to hold the progressively masked message.
+        // It starts as the original message and gets transformed by each transformer.
+        let processedMessage = message;
+        // Iterate through each transformer and apply their transform method.
+        for (const transformer of this.transformers) {
+            // Transform the message and get the transformer's state changes, ensuring no direct mutation of the shared state.
+            const [transformedMessage, transformerState] = await transformer.transform(processedMessage, new Map(this.state));
+            // Update the processed message for subsequent transformers.
+            processedMessage = transformedMessage;
+            // Merge state changes from the transformer into the parser's state.
+            // This accumulates all transformations' effects on the state.
+            transformerState.forEach((value, key) => this.state.set(key, value));
+        }
+        // Handle onMaskingEnd callback
+        if (this.config.onMaskingEnd) {
+            await this.config.onMaskingEnd(processedMessage);
+        }
+        // Return the fully masked message after all transformers have been applied.
+        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) {
+        // Handle onRehydratingStart callback
+        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.");
+        }
+        // Check if any transformers have been added to the parser.
+        // If no transformers are present, throw an error as rehydration requires at least one transformer.
+        if (this.transformers.length === 0) {
+            throw new Error("MaskingParser.rehydrate Error: No transformers have been added. Please add at least one transformer before rehydrating.");
+        }
+        // eslint-disable-next-line no-instanceof/no-instanceof
+        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; // Use provided state or fallback to internal state
+        // Initialize the rehydratedMessage with the input masked message.
+        // This variable will undergo rehydration by each transformer in reverse order.
+        let rehydratedMessage = message;
+        // Use a reverse for...of loop to accommodate asynchronous rehydrate methods
+        const reversedTransformers = this.transformers.slice().reverse();
+        for (const transformer of reversedTransformers) {
+            // Check if the result is a Promise and use await, otherwise use it directly
+            rehydratedMessage = await transformer.rehydrate(rehydratedMessage, rehydrationState);
+        }
+        // Handle onRehydratingEnd callback
+        if (this.config.onRehydratingEnd) {
+            await this.config.onRehydratingEnd(rehydratedMessage);
+        }
+        // Return the fully rehydrated message after all transformers have been applied.
+        return rehydratedMessage;
+    }
+}
+exports.MaskingParser = MaskingParser;

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

@@ -0,0 +1,44 @@
+import { MaskingTransformer } from "./transformer.js";
+import type { MaskingParserConfig } from "./types.js";
+/**
+ * MaskingParser class for handling the masking and rehydrating of messages.
+ */
+export 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>;
+}

package/dist/experimental/masking/parser.js

@@ -0,0 +1,130 @@
+/**
+ * MaskingParser class for handling the masking and rehydrating of messages.
+ */
+export class MaskingParser {
+    constructor(config = {}) {
+        Object.defineProperty(this, "transformers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "state", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.transformers = config.transformers ?? [];
+        this.state = 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 onMaskingStart is a function, handle it accordingly
+        if (this.config.onMaskingStart) {
+            await this.config.onMaskingStart(message);
+        }
+        // Check if there are any transformers added to the parser. If not, throw an error
+        // as masking requires at least one transformer to apply its logic.
+        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.");
+        }
+        // Initialize the variable to hold the progressively masked message.
+        // It starts as the original message and gets transformed by each transformer.
+        let processedMessage = message;
+        // Iterate through each transformer and apply their transform method.
+        for (const transformer of this.transformers) {
+            // Transform the message and get the transformer's state changes, ensuring no direct mutation of the shared state.
+            const [transformedMessage, transformerState] = await transformer.transform(processedMessage, new Map(this.state));
+            // Update the processed message for subsequent transformers.
+            processedMessage = transformedMessage;
+            // Merge state changes from the transformer into the parser's state.
+            // This accumulates all transformations' effects on the state.
+            transformerState.forEach((value, key) => this.state.set(key, value));
+        }
+        // Handle onMaskingEnd callback
+        if (this.config.onMaskingEnd) {
+            await this.config.onMaskingEnd(processedMessage);
+        }
+        // Return the fully masked message after all transformers have been applied.
+        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) {
+        // Handle onRehydratingStart callback
+        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.");
+        }
+        // Check if any transformers have been added to the parser.
+        // If no transformers are present, throw an error as rehydration requires at least one transformer.
+        if (this.transformers.length === 0) {
+            throw new Error("MaskingParser.rehydrate Error: No transformers have been added. Please add at least one transformer before rehydrating.");
+        }
+        // eslint-disable-next-line no-instanceof/no-instanceof
+        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; // Use provided state or fallback to internal state
+        // Initialize the rehydratedMessage with the input masked message.
+        // This variable will undergo rehydration by each transformer in reverse order.
+        let rehydratedMessage = message;
+        // Use a reverse for...of loop to accommodate asynchronous rehydrate methods
+        const reversedTransformers = this.transformers.slice().reverse();
+        for (const transformer of reversedTransformers) {
+            // Check if the result is a Promise and use await, otherwise use it directly
+            rehydratedMessage = await transformer.rehydrate(rehydratedMessage, rehydrationState);
+        }
+        // Handle onRehydratingEnd callback
+        if (this.config.onRehydratingEnd) {
+            await this.config.onRehydratingEnd(rehydratedMessage);
+        }
+        // Return the fully rehydrated message after all transformers have been applied.
+        return rehydratedMessage;
+    }
+}

package/dist/experimental/masking/regex_masking_transformer.cjs

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegexMaskingTransformer = void 0;
+const transformer_js_1 = require("./transformer.cjs");
+/**
+ * RegexMaskingTransformer class for masking and rehydrating messages with Regex.
+ */
+class RegexMaskingTransformer extends transformer_js_1.MaskingTransformer {
+    /**
+     * 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();
+        Object.defineProperty(this, "patterns", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "hashFunction", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // Validates the provided masking patterns before initializing the transformer.
+        // This ensures that each pattern has a valid regular expression.
+        this.validatePatterns(patterns);
+        // Assigns the validated patterns and the hash function to the transformer.
+        // If no custom hash function is provided, the default hash function is used.
+        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];
+            // Checks that each pattern is an object and has a regex property that is an instance of RegExp.
+            // Throws an error if these conditions are not met, indicating an invalid pattern configuration.
+            if (!pattern ||
+                typeof pattern !== "object" ||
+                // eslint-disable-next-line no-instanceof/no-instanceof
+                !(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.");
+        }
+        // eslint-disable-next-line no-instanceof/no-instanceof
+        if (!(state instanceof Map)) {
+            throw new TypeError("RegexMaskingTransformer.transform Error: The 'state' argument must be an instance of Map.");
+        }
+        // Holds the progressively masked message
+        let processedMessage = message;
+        // Initialize original values map with the current state or a new map
+        const originalValues = state || new Map();
+        // Iterate over each pattern defined in the transformer
+        for (const key of Object.keys(this.patterns)) {
+            const pattern = this.patterns[key];
+            // Apply the current pattern's regex to the message
+            processedMessage = processedMessage.replace(pattern.regex, (match) => {
+                // Determine the masked value: use the mask function if provided, else use the replacement string,
+                // else use the hash function.
+                const maskedValue = pattern.mask
+                    ? pattern.mask(match)
+                    : pattern.replacement ?? this.hashFunction(match);
+                // Store the mapping of the masked value to the original value (match)
+                originalValues.set(maskedValue, match);
+                // Return the masked value to replace the original value in the message
+                return maskedValue;
+            });
+        }
+        // Return the fully masked message and the state map with all original values
+        // Wrap the synchronous return values in Promise.resolve() to maintain compatibility
+        // with the MaskingParser's expectation of a Promise return type.
+        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.");
+        }
+        // eslint-disable-next-line no-instanceof/no-instanceof
+        if (!(state instanceof Map)) {
+            throw new TypeError("RegexMaskingTransformer.rehydrate Error: The 'state' argument must be an instance of Map.");
+        }
+        // Convert the state map to an array and use reduce to sequentially replace masked values with original values.
+        const rehydratedMessage = Array.from(state).reduce((msg, [masked, original]) => {
+            // Escape special characters in the masked string to ensure it can be used in a regular expression safely.
+            // This is necessary because masked values might contain characters that have special meanings in regex.
+            const escapedMasked = masked.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+            // Replace all instances of the escaped masked value in the message with the original value.
+            // The 'g' flag in the RegExp ensures that all occurrences of the masked value are replaced.
+            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;
+        // Iterate over each character in the input string
+        for (let i = 0; i < input.length; i += 1) {
+            // Get ASCII value of the character
+            const char = input.charCodeAt(i);
+            // Combine the current hash with the new character and ensure it remains a 32-bit integer
+            hash = (hash << 5) - hash + char;
+            // Bitwise OR operation to convert to a 32-bit integer.
+            // This is a common technique to ensure the final hash value stays within the 32-bit limit,
+            // effectively wrapping the value when it becomes too large.
+            hash |= 0;
+        }
+        // Convert the numerical hash value to a string and return
+        return hash.toString();
+    }
+}
+exports.RegexMaskingTransformer = RegexMaskingTransformer;