@hackylabs/deep-redact 3.0.1 → 3.0.3

package/dist/cjs/index.js

@@ -14,7 +14,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = exports.DeepRedact = void 0;
+exports.organisedStandardTransformers = exports.standardTransformers = exports.default = exports.DeepRedact = void 0;
+const standardTransformers_1 = require("./utils/standardTransformers");
+Object.defineProperty(exports, "organisedStandardTransformers", { enumerable: true, get: function () { return standardTransformers_1.organisedStandardTransformers; } });
+Object.defineProperty(exports, "standardTransformers", { enumerable: true, get: function () { return standardTransformers_1.standardTransformers; } });
 const utils_1 = __importDefault(require("./utils"));
 class DeepRedact {
     /**

package/dist/cjs/utils/TransformerRegistry.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransformerRegistry = void 0;
+/**
+ * Registry for organizing transformers by type and constructor for efficient lookup
+ */
+class TransformerRegistry {
+    constructor() {
+        this.typeTransformers = new Map();
+        this.constructorTransformers = new Map();
+        this.fallbackTransformers = [];
+    }
+    /**
+     * Add a transformer for a specific typeof result
+     * @param type - The typeof result (e.g., 'bigint', 'string', etc.)
+     * @param transformer - The transformer function
+     */
+    addTypeTransformer(type, transformer) {
+        if (!this.typeTransformers.has(type)) {
+            this.typeTransformers.set(type, []);
+        }
+        this.typeTransformers.get(type).push(transformer);
+    }
+    /**
+     * Add a transformer for a specific constructor
+     * @param constructor - The constructor function (e.g., Date, Error, etc.)
+     * @param transformer - The transformer function
+     */
+    addConstructorTransformer(constructor, transformer) {
+        if (!this.constructorTransformers.has(constructor)) {
+            this.constructorTransformers.set(constructor, []);
+        }
+        this.constructorTransformers.get(constructor).push(transformer);
+    }
+    /**
+     * Add a fallback transformer that runs on all values
+     * @param transformer - The transformer function
+     */
+    addFallbackTransformer(transformer) {
+        this.fallbackTransformers.push(transformer);
+    }
+    /**
+     * Get relevant transformers for a value
+     * @param value - The value to get transformers for
+     * @returns Array of relevant transformers
+     */
+    getTransformersForValue(value) {
+        const transformers = [];
+        const type = typeof value;
+        if (this.typeTransformers.has(type)) {
+            transformers.push(...this.typeTransformers.get(type));
+        }
+        if (typeof value === 'object' && value !== null) {
+            const constructor = value.constructor;
+            if (this.constructorTransformers.has(constructor)) {
+                transformers.push(...this.constructorTransformers.get(constructor));
+            }
+        }
+        transformers.push(...this.fallbackTransformers);
+        return transformers;
+    }
+    /**
+     * Apply transformers to a value
+     * @param value - The value to transform
+     * @param key - The key (optional)
+     * @param referenceMap - Reference map for circular references (optional)
+     * @returns The transformed value
+     */
+    applyTransformers(value, key, referenceMap) {
+        if (typeof value === 'string')
+            return value;
+        const transformers = this.getTransformersForValue(value);
+        for (const transformer of transformers) {
+            const transformed = transformer(value, key, referenceMap);
+            if (transformed !== value) {
+                return transformed;
+            }
+        }
+        return value;
+    }
+    /**
+     * Clear all transformers
+     */
+    clear() {
+        this.typeTransformers.clear();
+        this.constructorTransformers.clear();
+        this.fallbackTransformers = [];
+    }
+    /**
+     * Get all registered transformers for debugging
+     */
+    getRegisteredTransformers() {
+        return {
+            types: new Map(this.typeTransformers),
+            constructors: new Map(this.constructorTransformers),
+            fallback: [...this.fallbackTransformers]
+        };
+    }
+}
+exports.TransformerRegistry = TransformerRegistry;

package/dist/cjs/utils/index.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const standardTransformers_1 = require("./standardTransformers");
+const TransformerRegistry_1 = require("./TransformerRegistry");
 const defaultConfig = {
     stringTests: [],
     blacklistedKeys: [],
@@ -36,6 +37,11 @@ class RedactorUtils {
          * @private
          */
         this.blacklistedKeysTransformed = [];
+        /**
+         * The transformer registry for efficient transformer lookup
+         * @private
+         */
+        this.transformerRegistry = new TransformerRegistry_1.TransformerRegistry();
         this.createTransformedBlacklistedKey = (key, customConfig) => {
             var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t;
             if (key instanceof RegExp) {
@@ -67,15 +73,7 @@ class RedactorUtils {
          * @private
          */
         this.applyTransformers = (value, key, referenceMap) => {
-            if (typeof value === 'string')
-                return value;
-            let transformed = value;
-            for (const transformer of this.config.transformers) {
-                transformed = transformer(transformed, key, referenceMap);
-                if (transformed !== value)
-                    return transformed;
-            }
-            return value;
+            return this.transformerRegistry.applyTransformers(value, key, referenceMap);
         };
         /**
          * Sanitises a string for the computed regex
@@ -159,8 +157,8 @@ class RedactorUtils {
                 const { transformed } = this.applyStringTransformations(raw, false);
                 return transformed;
             }
-            if (typeof raw !== 'object' || raw === null)
-                return raw;
+            if (typeof raw !== 'object' || raw === null || this.requiresTransformers(raw))
+                return this.applyTransformers(raw);
             const referenceMap = new WeakMap();
             const cleanedInput = this.replaceCircularReferences(raw);
             const { output, stack } = this.initialiseTraversal(cleanedInput);
@@ -192,6 +190,49 @@ class RedactorUtils {
         const stringKeys = ((_b = customConfig.blacklistedKeys) !== null && _b !== void 0 ? _b : []).filter(key => typeof key === 'string');
         if (stringKeys.length > 0)
             this.computedRegex = new RegExp(stringKeys.map(this.sanitiseStringForRegex).filter(Boolean).join('|'));
+        this.setupTransformerRegistry(this.config.transformers);
+    }
+    /**
+     * Sets up the transformer registry based on the configuration
+     * @param transformers - The transformer configuration
+     * @private
+     */
+    setupTransformerRegistry(transformers) {
+        if (Array.isArray(transformers)) {
+            transformers.forEach(transformer => { this.transformerRegistry.addFallbackTransformer(transformer); });
+        }
+        else {
+            const organised = transformers;
+            if (organised.byType) {
+                Object.entries(organised.byType).forEach(([type, typeTransformers]) => {
+                    if (typeTransformers) {
+                        typeTransformers.forEach(transformer => {
+                            this.transformerRegistry.addTypeTransformer(type, transformer);
+                        });
+                    }
+                });
+            }
+            if (organised.byConstructor) {
+                Object.entries(organised.byConstructor).forEach(([constructorName, constructorTransformers]) => {
+                    if (constructorTransformers) {
+                        const constructorMap = {
+                            Date,
+                            Error,
+                            Map,
+                            Set,
+                            RegExp,
+                            URL,
+                        };
+                        const constructor = constructorMap[constructorName];
+                        if (constructor) {
+                            constructorTransformers.forEach(transformer => {
+                                this.transformerRegistry.addConstructorTransformer(constructor, transformer);
+                            });
+                        }
+                    }
+                });
+            }
+        }
     }
     /**
      * Applies string transformations
@@ -425,5 +466,28 @@ class RedactorUtils {
         };
         return processValue(raw, '');
     }
+    /**
+     * Checks if a non-traversable value requires transformers
+     * @param value - The value to check
+     * @returns Whether the value requires transformers
+     * @private
+     */
+    requiresTransformers(value) {
+        if (typeof value === 'bigint')
+            return true;
+        if (value instanceof Date)
+            return true;
+        if (value instanceof Error)
+            return true;
+        if (value instanceof Map)
+            return true;
+        if (value instanceof RegExp)
+            return true;
+        if (value instanceof Set)
+            return true;
+        if (value instanceof URL)
+            return true;
+        return false;
+    }
 }
 exports.default = RedactorUtils;

package/dist/cjs/utils/standardTransformers/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.standardTransformers = void 0;
+exports.organisedStandardTransformers = exports.standardTransformers = void 0;
 const bigint_1 = require("./bigint");
 const date_1 = require("./date");
 const error_1 = require("./error");
@@ -8,12 +8,31 @@ const map_1 = require("./map");
 const regex_1 = require("./regex");
 const set_1 = require("./set");
 const url_1 = require("./url");
+/**
+ * Standard transformers in array for legacy support
+ */
 exports.standardTransformers = [
     bigint_1._bigint,
-    url_1._url,
     date_1._date,
     error_1._error,
     map_1._map,
-    set_1._set,
     regex_1._regex,
+    set_1._set,
+    url_1._url,
 ];
+/**
+ * Standard transformers organised by type and constructor for performance reasons
+ */
+exports.organisedStandardTransformers = {
+    byType: {
+        bigint: [bigint_1._bigint],
+    },
+    byConstructor: {
+        URL: [url_1._url],
+        Date: [date_1._date],
+        Error: [error_1._error],
+        Map: [map_1._map],
+        Set: [set_1._set],
+        RegExp: [regex_1._regex],
+    },
+};

package/dist/esm/index.mjs

@@ -1,3 +1,4 @@
+import { organisedStandardTransformers, standardTransformers } from './utils/standardTransformers';
 import RedactorUtils from './utils';
 class DeepRedact {
     /**
@@ -36,4 +37,4 @@ class DeepRedact {
         return this.config.serialise ? JSON.stringify(redacted) : redacted;
     };
 }
-export { DeepRedact, DeepRedact as default, };
+export { DeepRedact, DeepRedact as default, standardTransformers, organisedStandardTransformers, };

package/dist/esm/utils/TransformerRegistry.mjs

@@ -0,0 +1,94 @@
+/**
+ * Registry for organizing transformers by type and constructor for efficient lookup
+ */
+export class TransformerRegistry {
+    typeTransformers = new Map();
+    constructorTransformers = new Map();
+    fallbackTransformers = [];
+    /**
+     * Add a transformer for a specific typeof result
+     * @param type - The typeof result (e.g., 'bigint', 'string', etc.)
+     * @param transformer - The transformer function
+     */
+    addTypeTransformer(type, transformer) {
+        if (!this.typeTransformers.has(type)) {
+            this.typeTransformers.set(type, []);
+        }
+        this.typeTransformers.get(type).push(transformer);
+    }
+    /**
+     * Add a transformer for a specific constructor
+     * @param constructor - The constructor function (e.g., Date, Error, etc.)
+     * @param transformer - The transformer function
+     */
+    addConstructorTransformer(constructor, transformer) {
+        if (!this.constructorTransformers.has(constructor)) {
+            this.constructorTransformers.set(constructor, []);
+        }
+        this.constructorTransformers.get(constructor).push(transformer);
+    }
+    /**
+     * Add a fallback transformer that runs on all values
+     * @param transformer - The transformer function
+     */
+    addFallbackTransformer(transformer) {
+        this.fallbackTransformers.push(transformer);
+    }
+    /**
+     * Get relevant transformers for a value
+     * @param value - The value to get transformers for
+     * @returns Array of relevant transformers
+     */
+    getTransformersForValue(value) {
+        const transformers = [];
+        const type = typeof value;
+        if (this.typeTransformers.has(type)) {
+            transformers.push(...this.typeTransformers.get(type));
+        }
+        if (typeof value === 'object' && value !== null) {
+            const constructor = value.constructor;
+            if (this.constructorTransformers.has(constructor)) {
+                transformers.push(...this.constructorTransformers.get(constructor));
+            }
+        }
+        transformers.push(...this.fallbackTransformers);
+        return transformers;
+    }
+    /**
+     * Apply transformers to a value
+     * @param value - The value to transform
+     * @param key - The key (optional)
+     * @param referenceMap - Reference map for circular references (optional)
+     * @returns The transformed value
+     */
+    applyTransformers(value, key, referenceMap) {
+        if (typeof value === 'string')
+            return value;
+        const transformers = this.getTransformersForValue(value);
+        for (const transformer of transformers) {
+            const transformed = transformer(value, key, referenceMap);
+            if (transformed !== value) {
+                return transformed;
+            }
+        }
+        return value;
+    }
+    /**
+     * Clear all transformers
+     */
+    clear() {
+        this.typeTransformers.clear();
+        this.constructorTransformers.clear();
+        this.fallbackTransformers = [];
+    }
+    /**
+     * Get all registered transformers for debugging
+     */
+    getRegisteredTransformers() {
+        return {
+            types: new Map(this.typeTransformers),
+            constructors: new Map(this.constructorTransformers),
+            fallback: [...this.fallbackTransformers]
+        };
+    }
+}

package/dist/esm/utils/index.mjs

@@ -1,4 +1,5 @@
 import { standardTransformers } from './standardTransformers';
+import { TransformerRegistry } from './TransformerRegistry';
 const defaultConfig = {
     stringTests: [],
     blacklistedKeys: [],
@@ -32,6 +33,11 @@ class RedactorUtils {
      * @private
      */
     blacklistedKeysTransformed = [];
+    /**
+     * The transformer registry for efficient transformer lookup
+     * @private
+     */
+    transformerRegistry = new TransformerRegistry();
     constructor(customConfig) {
         this.config = {
             ...defaultConfig,
@@ -41,6 +47,49 @@ class RedactorUtils {
         const stringKeys = (customConfig.blacklistedKeys ?? []).filter(key => typeof key === 'string');
         if (stringKeys.length > 0)
             this.computedRegex = new RegExp(stringKeys.map(this.sanitiseStringForRegex).filter(Boolean).join('|'));
+        this.setupTransformerRegistry(this.config.transformers);
+    }
+    /**
+     * Sets up the transformer registry based on the configuration
+     * @param transformers - The transformer configuration
+     * @private
+     */
+    setupTransformerRegistry(transformers) {
+        if (Array.isArray(transformers)) {
+            transformers.forEach(transformer => { this.transformerRegistry.addFallbackTransformer(transformer); });
+        }
+        else {
+            const organised = transformers;
+            if (organised.byType) {
+                Object.entries(organised.byType).forEach(([type, typeTransformers]) => {
+                    if (typeTransformers) {
+                        typeTransformers.forEach(transformer => {
+                            this.transformerRegistry.addTypeTransformer(type, transformer);
+                        });
+                    }
+                });
+            }
+            if (organised.byConstructor) {
+                Object.entries(organised.byConstructor).forEach(([constructorName, constructorTransformers]) => {
+                    if (constructorTransformers) {
+                        const constructorMap = {
+                            Date,
+                            Error,
+                            Map,
+                            Set,
+                            RegExp,
+                            URL,
+                        };
+                        const constructor = constructorMap[constructorName];
+                        if (constructor) {
+                            constructorTransformers.forEach(transformer => {
+                                this.transformerRegistry.addConstructorTransformer(constructor, transformer);
+                            });
+                        }
+                    }
+                });
+            }
+        }
     }
     createTransformedBlacklistedKey = (key, customConfig) => {
         if (key instanceof RegExp) {
@@ -72,15 +121,7 @@ class RedactorUtils {
      * @private
      */
     applyTransformers = (value, key, referenceMap) => {
-        if (typeof value === 'string')
-            return value;
-        let transformed = value;
-        for (const transformer of this.config.transformers) {
-            transformed = transformer(transformed, key, referenceMap);
-            if (transformed !== value)
-                return transformed;
-        }
-        return value;
+        return this.transformerRegistry.applyTransformers(value, key, referenceMap);
     };
     /**
      * Sanitises a string for the computed regex
@@ -381,6 +422,29 @@ class RedactorUtils {
         };
         return processValue(raw, '');
     }
+    /**
+     * Checks if a non-traversable value requires transformers
+     * @param value - The value to check
+     * @returns Whether the value requires transformers
+     * @private
+     */
+    requiresTransformers(value) {
+        if (typeof value === 'bigint')
+            return true;
+        if (value instanceof Date)
+            return true;
+        if (value instanceof Error)
+            return true;
+        if (value instanceof Map)
+            return true;
+        if (value instanceof RegExp)
+            return true;
+        if (value instanceof Set)
+            return true;
+        if (value instanceof URL)
+            return true;
+        return false;
+    }
     /**
      * Traverses the raw value
      * @param raw - The raw value to traverse
@@ -391,8 +455,8 @@ class RedactorUtils {
             const { transformed } = this.applyStringTransformations(raw, false);
             return transformed;
         }
-        if (typeof raw !== 'object' || raw === null)
-            return raw;
+        if (typeof raw !== 'object' || raw === null || this.requiresTransformers(raw))
+            return this.applyTransformers(raw);
         const referenceMap = new WeakMap();
         const cleanedInput = this.replaceCircularReferences(raw);
         const { output, stack } = this.initialiseTraversal(cleanedInput);

package/dist/esm/utils/standardTransformers/index.js

@@ -1,16 +1,35 @@
-import { _bigint } from "./bigint";
-import { _date } from "./date";
-import { _error } from "./error";
-import { _map } from "./map";
-import { _regex } from "./regex";
-import { _set } from "./set";
-import { _url } from "./url";
+import { _bigint } from './bigint';
+import { _date } from './date';
+import { _error } from './error';
+import { _map } from './map';
+import { _regex } from './regex';
+import { _set } from './set';
+import { _url } from './url';
+/**
+ * Standard transformers in array for legacy support
+ */
 export const standardTransformers = [
     _bigint,
-    _url,
     _date,
     _error,
     _map,
-    _set,
     _regex,
+    _set,
+    _url,
 ];
+/**
+ * Standard transformers organised by type and constructor for performance reasons
+ */
+export const organisedStandardTransformers = {
+    byType: {
+        bigint: [_bigint],
+    },
+    byConstructor: {
+        URL: [_url],
+        Date: [_date],
+        Error: [_error],
+        Map: [_map],
+        Set: [_set],
+        RegExp: [_regex],
+    },
+};

package/dist/types/index.d.ts

@@ -1,4 +1,5 @@
-import type { DeepRedactConfig, RedactorUtilsConfig, BlacklistKeyConfig, Types, Transformer, ComplexStringTest, BaseDeepRedactConfig } from './types';
+import type { DeepRedactConfig, RedactorUtilsConfig, BlacklistKeyConfig, Types, Transformer, ComplexStringTest, BaseDeepRedactConfig, OrganisedTransformers, TransformerConfig } from './types';
+import { organisedStandardTransformers, standardTransformers } from './utils/standardTransformers';
 declare class DeepRedact {
     /**
      * The redactorUtils instance to handle the redaction.
@@ -25,4 +26,4 @@ declare class DeepRedact {
      */
     redact: (value: unknown) => unknown;
 }
-export { DeepRedact, DeepRedact as default, type BaseDeepRedactConfig, type RedactorUtilsConfig, type BlacklistKeyConfig, type ComplexStringTest, type Transformer, type Types, };
+export { DeepRedact, DeepRedact as default, type BaseDeepRedactConfig, type RedactorUtilsConfig, type BlacklistKeyConfig, type ComplexStringTest, type Transformer, type Types, type OrganisedTransformers, type TransformerConfig, standardTransformers, organisedStandardTransformers, };

package/dist/types/types.d.ts

@@ -1,5 +1,43 @@
 export type Types = 'string' | 'number' | 'bigint' | 'boolean' | 'object' | 'function' | 'symbol' | 'undefined';
 export type Transformer = (value: unknown, key?: string, reference?: WeakMap<object, unknown>) => unknown;
+/**
+ * Configuration for organised transformers by type and constructor
+ */
+export interface OrganisedTransformers {
+    /**
+     * Transformers for primitive types (based on typeof result)
+     */
+    byType?: {
+        bigint?: Transformer[];
+        string?: Transformer[];
+        number?: Transformer[];
+        boolean?: Transformer[];
+        symbol?: Transformer[];
+        function?: Transformer[];
+        object?: Transformer[];
+        undefined?: Transformer[];
+    };
+    /**
+     * Transformers for specific constructors (based on instanceof checks)
+     */
+    byConstructor?: {
+        Date?: Transformer[];
+        Error?: Transformer[];
+        Map?: Transformer[];
+        Set?: Transformer[];
+        RegExp?: Transformer[];
+        URL?: Transformer[];
+        [key: string]: Transformer[] | undefined;
+    };
+    /**
+     * Transformers that run on all values (like the current system)
+     */
+    fallback?: Transformer[];
+}
+/**
+ * Transformer configuration - supports both old array format and new organised format
+ */
+export type TransformerConfig = Transformer[] | OrganisedTransformers;
 export interface BlacklistKeyConfig {
     /**
      * Perform a fuzzy match on the key. This will match any key that contains the string, rather than a case-sensitive match.
@@ -131,25 +169,40 @@ export interface BaseDeepRedactConfig {
      */
     serialize?: boolean;
     /**
-     * A list of transformers to apply when transforming unsupported values.
-     * Each transformer should conditionally transform the value, or return the value unchanged to be passed to the next transformer.
-     * Transformers will be run in the order they are provided recursively over the entire object.
+     * Configuration for transformers to apply when transforming unsupported values.
+     * Supports both legacy array format and new organised format for better performance.
+     *
+     * Legacy format: Array of transformers that run on all values in order
+     * New format: Object with transformers organised by type and constructor
+     *
      * @default []
-     * @example [
-     *   // redact a key by name.
-     *   standardTransformers.redactByKey,
-     *   // convert a Date to an ISO string.
-     *   (value: unknown) => {
-     *     if (!(value instanceof Date)) return value
-     *     return value.toISOString()
-     *   },
-     *   // convert a BigInt to a string.
+     * @example
+     * // Legacy format (still supported)
+     * [
      *   (value: unknown) => {
      *     if (typeof value !== 'bigint') return value
      *     return value.toString(10)
+     *   },
+     *   (value: unknown) => {
+     *     if (!(value instanceof Date)) return value
+     *     return value.toISOString()
      *   }
+     * ]
+     *
+     * @example
+     * {
+     *   byType: {
+     *     bigint: [(value: unknown) => (value as bigint).toString(10)]
+     *   },
+     *   byConstructor: {
+     *     Date: [(value: unknown) => (value as Date).toISOString()]
+     *   },
+     *   fallback: [
+     *     // transformers that run on all values
+     *   ]
+     * }
      */
-    transformers?: Array<Transformer>;
+    transformers?: TransformerConfig;
 }
 export type DeepRedactConfig = Partial<Omit<BaseDeepRedactConfig, '_blacklistedKeysTransformed' | 'blacklistedKeys' | 'stringTests'>> & ({
     blacklistedKeys: BaseDeepRedactConfig['blacklistedKeys'];
@@ -169,9 +222,3 @@ export type Stack = Array<{
     redactingParent: boolean;
     keyConfig: BlacklistKeyConfig | undefined;
 }>;
-export type Logs = Array<{
-    path: string;
-    message: string;
-    raw: unknown;
-    transformed: unknown;
-}> | null;

package/dist/types/utils/TransformerRegistry.d.ts

@@ -0,0 +1,52 @@
+import type { Transformer } from '../types';
+/**
+ * Registry for organizing transformers by type and constructor for efficient lookup
+ */
+export declare class TransformerRegistry {
+    private typeTransformers;
+    private constructorTransformers;
+    private fallbackTransformers;
+    /**
+     * Add a transformer for a specific typeof result
+     * @param type - The typeof result (e.g., 'bigint', 'string', etc.)
+     * @param transformer - The transformer function
+     */
+    addTypeTransformer(type: string, transformer: Transformer): void;
+    /**
+     * Add a transformer for a specific constructor
+     * @param constructor - The constructor function (e.g., Date, Error, etc.)
+     * @param transformer - The transformer function
+     */
+    addConstructorTransformer(constructor: Function, transformer: Transformer): void;
+    /**
+     * Add a fallback transformer that runs on all values
+     * @param transformer - The transformer function
+     */
+    addFallbackTransformer(transformer: Transformer): void;
+    /**
+     * Get relevant transformers for a value
+     * @param value - The value to get transformers for
+     * @returns Array of relevant transformers
+     */
+    getTransformersForValue(value: unknown): Transformer[];
+    /**
+     * Apply transformers to a value
+     * @param value - The value to transform
+     * @param key - The key (optional)
+     * @param referenceMap - Reference map for circular references (optional)
+     * @returns The transformed value
+     */
+    applyTransformers(value: unknown, key?: string, referenceMap?: WeakMap<object, string>): unknown;
+    /**
+     * Clear all transformers
+     */
+    clear(): void;
+    /**
+     * Get all registered transformers for debugging
+     */
+    getRegisteredTransformers(): {
+        types: Map<string, Transformer[]>;
+        constructors: Map<Function, Transformer[]>;
+        fallback: Transformer[];
+    };
+}

package/dist/types/utils/index.d.ts

@@ -20,7 +20,18 @@ declare class RedactorUtils {
      * @private
      */
     private readonly blacklistedKeysTransformed;
+    /**
+     * The transformer registry for efficient transformer lookup
+     * @private
+     */
+    private readonly transformerRegistry;
     constructor(customConfig: RedactorUtilsConfig);
+    /**
+     * Sets up the transformer registry based on the configuration
+     * @param transformers - The transformer configuration
+     * @private
+     */
+    private setupTransformerRegistry;
     private createTransformedBlacklistedKey;
     /**
      * Applies transformers to a value
@@ -120,6 +131,13 @@ declare class RedactorUtils {
      * @private
      */
     private replaceCircularReferences;
+    /**
+     * Checks if a non-traversable value requires transformers
+     * @param value - The value to check
+     * @returns Whether the value requires transformers
+     * @private
+     */
+    private requiresTransformers;
     /**
      * Traverses the raw value
      * @param raw - The raw value to traverse

package/dist/types/utils/standardTransformers/index.d.ts

@@ -1,2 +1,9 @@
-import type { Transformer } from "src/types";
+import type { Transformer, OrganisedTransformers } from 'src/types';
+/**
+ * Standard transformers in array for legacy support
+ */
 export declare const standardTransformers: Transformer[];
+/**
+ * Standard transformers organised by type and constructor for performance reasons
+ */
+export declare const organisedStandardTransformers: OrganisedTransformers;

package/dist/types/utils/standardTransformers/url.d.ts

@@ -1,2 +1,2 @@
-import type { Transformer } from "../../types";
+import type { Transformer } from '../../types';
 export declare const _url: Transformer;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hackylabs/deep-redact",
-  "version": "3.0.1",
+  "version": "3.0.3",
   "description": "A fast, safe and configurable zero-dependency library for redacting strings or deeply redacting arrays and objects.",
   "private": false,
   "license": "MIT",
@@ -11,58 +11,63 @@
   "module": "./dist/esm/index.mjs",
   "exports": {
     ".": {
-      "import": "./dist/index",
-      "require": "./dist/index",
+      "import": "./dist/esm/index.mjs",
+      "require": "./dist/cjs/index.js",
       "types": "./dist/types/index.d.ts"
     },
     "./types": {
-      "import": "./dist/types",
-      "require": "./dist/types",
+      "import": "./dist/esm/types.mjs",
+      "require": "./dist/cjs/types.js",
       "types": "./dist/types/types.d.ts"
     },
+    "./utils/TransformerRegistry": {
+      "import": "./dist/esm/utils/TransformerRegistry.mjs",
+      "require": "./dist/cjs/utils/TransformerRegistry.js",
+      "types": "./dist/types/utils/TransformerRegistry.d.ts"
+    },
     "./utils": {
-      "import": "./dist/utils",
-      "require": "./dist/utils",
+      "import": "./dist/esm/utils.mjs",
+      "require": "./dist/cjs/utils.js",
       "types": "./dist/types/utils.d.ts"
     },
     "./utils/standardTransformers/bigint": {
-      "import": "./dist/utils/standardTransformers/bigint",
-      "require": "./dist/utils/standardTransformers/bigint",
+      "import": "./dist/esm/utils/standardTransformers/bigint.mjs",
+      "require": "./dist/cjs/utils/standardTransformers/bigint.js",
       "types": "./dist/types/utils/standardTransformers/bigint.d.ts"
     },
     "./utils/standardTransformers/date": {
-      "import": "./dist/utils/standardTransformers/date",
-      "require": "./dist/utils/standardTransformers/date",
+      "import": "./dist/esm/utils/standardTransformers/date.mjs",
+      "require": "./dist/cjs/utils/standardTransformers/date.js",
       "types": "./dist/types/utils/standardTransformers/date.d.ts"
     },
     "./utils/standardTransformers/error": {
-      "import": "./dist/utils/standardTransformers/error",
-      "require": "./dist/utils/standardTransformers/error",
+      "import": "./dist/esm/utils/standardTransformers/error.mjs",
+      "require": "./dist/cjs/utils/standardTransformers/error.js",
       "types": "./dist/types/utils/standardTransformers/error.d.ts"
     },
     "./utils/standardTransformers": {
-      "import": "./dist/utils/standardTransformers",
-      "require": "./dist/utils/standardTransformers",
+      "import": "./dist/esm/utils/standardTransformers.mjs",
+      "require": "./dist/cjs/utils/standardTransformers.js",
       "types": "./dist/types/utils/standardTransformers.d.ts"
     },
     "./utils/standardTransformers/map": {
-      "import": "./dist/utils/standardTransformers/map",
-      "require": "./dist/utils/standardTransformers/map",
+      "import": "./dist/esm/utils/standardTransformers/map.mjs",
+      "require": "./dist/cjs/utils/standardTransformers/map.js",
       "types": "./dist/types/utils/standardTransformers/map.d.ts"
     },
     "./utils/standardTransformers/regex": {
-      "import": "./dist/utils/standardTransformers/regex",
-      "require": "./dist/utils/standardTransformers/regex",
+      "import": "./dist/esm/utils/standardTransformers/regex.mjs",
+      "require": "./dist/cjs/utils/standardTransformers/regex.js",
       "types": "./dist/types/utils/standardTransformers/regex.d.ts"
     },
     "./utils/standardTransformers/set": {
-      "import": "./dist/utils/standardTransformers/set",
-      "require": "./dist/utils/standardTransformers/set",
+      "import": "./dist/esm/utils/standardTransformers/set.mjs",
+      "require": "./dist/cjs/utils/standardTransformers/set.js",
       "types": "./dist/types/utils/standardTransformers/set.d.ts"
     },
     "./utils/standardTransformers/url": {
-      "import": "./dist/utils/standardTransformers/url",
-      "require": "./dist/utils/standardTransformers/url",
+      "import": "./dist/esm/utils/standardTransformers/url.mjs",
+      "require": "./dist/cjs/utils/standardTransformers/url.js",
       "types": "./dist/types/utils/standardTransformers/url.d.ts"
     }
   },
@@ -96,17 +101,19 @@
   },
   "scripts": {
     "lint": "eslint",
-    "build": "npm run lint && npm run test && npm run bench && npm run build:esm && npm run build:cjs && npm run update-exports && npm run update-readme && npm run update-license",
+    "build": "npm run lint && npm run test && npm run bench && npm run build:esm && npm run build:cjs && npm run update-exports && npm run test:build && npm run update-readme && npm run update-license",
     "build:esm": "tsc --project tsconfig.esm.json && ./scripts/js-to-mjs.sh",
     "build:cjs": "tsc --project tsconfig.cjs.json",
     "bench": "npx vitest bench --watch=false",
     "bench:dev": "npx vitest bench",
     "test:dev": "npx vitest",
     "test": "npx vitest run",
-    "load": "npx vitest run test/load/redact.test.ts --reporter=basic --coverage=false",
-    "load:dev": "npx vitest test/load/redact.test.ts --coverage=false --reporter=basic",
-    "unit": "npx vitest run test/unit --reporter=verbose",
-    "unit:dev": "npx vitest test/unit --coverage=false --reporter=verbose",
+    "test:build": "npx vitest run test/build.test.ts --reporter=basic --coverage=false",
+    "test:build:dev": "npm run build:cjs && npm run build:esm && npm run update-exports && npx vitest test/build.test.ts --coverage=false --reporter=basic",
+    "test:load": "npx vitest run test/load/redact.test.ts --reporter=basic --coverage=false",
+    "test:load:dev": "npx vitest test/load/redact.test.ts --coverage=false --reporter=basic",
+    "test:unit": "npx vitest run test/unit --reporter=verbose",
+    "test:unit:dev": "npx vitest test/unit --coverage=false --reporter=verbose",
     "update-readme": "npx ts-node ./scripts/update-readme.ts",
     "update-license": "npx ts-node ./scripts/update-license.ts",
     "update-exports": "npx ts-node ./scripts/update-exports.ts"