@hackylabs/deep-redact 3.0.2 → 3.0.4

package/dist/{cjs/index.js → index.js}

@@ -14,8 +14,11 @@ 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;
-const utils_1 = __importDefault(require("./utils"));
+exports.organisedStandardTransformers = exports.standardTransformers = exports.default = exports.DeepRedact = void 0;
+const index_js_1 = require("./utils/standardTransformers/index.js");
+Object.defineProperty(exports, "organisedStandardTransformers", { enumerable: true, get: function () { return index_js_1.organisedStandardTransformers; } });
+Object.defineProperty(exports, "standardTransformers", { enumerable: true, get: function () { return index_js_1.standardTransformers; } });
+const index_js_2 = __importDefault(require("./utils/index.js"));
 class DeepRedact {
     /**
      * Create a new DeepRedact instance with the provided configuration.
@@ -45,7 +48,7 @@ class DeepRedact {
         const englishSerialise = serialise !== null && serialise !== void 0 ? serialise : serialize;
         if (typeof englishSerialise === 'boolean')
             this.config.serialise = englishSerialise;
-        this.redactorUtils = new utils_1.default(Object.assign({}, rest));
+        this.redactorUtils = new index_js_2.default(Object.assign({}, rest));
     }
 }
 exports.DeepRedact = DeepRedact;

package/dist/{esm/index.mjs → index.mjs}

@@ -1,4 +1,5 @@
-import RedactorUtils from './utils';
+import { organisedStandardTransformers, standardTransformers } from './utils/standardTransformers/index.mjs';
+import RedactorUtils from './utils/index.mjs';
 class DeepRedact {
     /**
      * The redactorUtils instance to handle the redaction.
@@ -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/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.js';
+import { organisedStandardTransformers, standardTransformers } from './utils/standardTransformers/index.js';
 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

@@ -1,4 +1,4 @@
-import type { RedactorUtilsConfig } from '../types';
+import type { RedactorUtilsConfig } from '../types.js';
 declare class RedactorUtils {
     /**
      * The configuration for the redaction.
@@ -6,21 +6,22 @@ declare class RedactorUtils {
      */
     private readonly config;
     /**
-     * The computed regex pattern generated from sanitised blacklist keys of flat strings
+     * The transformed blacklist keys of flat regex patterns and complex config objects
      * @private
      */
-    private readonly computedRegex;
+    private readonly blacklistedKeysTransformed;
     /**
-     * Regex to sanitise strings for the computed regex
+     * The transformer registry for efficient transformer lookup
      * @private
      */
-    private readonly sanitiseRegex;
+    private readonly transformerRegistry;
+    constructor(customConfig: RedactorUtilsConfig);
     /**
-     * The transformed blacklist keys of flat regex patterns and complex config objects
+     * Sets up the transformer registry based on the configuration
+     * @param transformers - The transformer configuration
      * @private
      */
-    private readonly blacklistedKeysTransformed;
-    constructor(customConfig: RedactorUtilsConfig);
+    private setupTransformerRegistry;
     private createTransformedBlacklistedKey;
     /**
      * Applies transformers to a value
@@ -30,13 +31,6 @@ declare class RedactorUtils {
      * @private
      */
     private applyTransformers;
-    /**
-     * Sanitises a string for the computed regex
-     * @param key - The string to sanitise
-     * @returns The sanitised string
-     * @private
-     */
-    private sanitiseStringForRegex;
     /**
      * Checks if a key should be redacted
      * @param key - The key to check

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

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

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

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

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

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

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

@@ -1,2 +1,9 @@
-import type { Transformer } from "src/types";
+import type { Transformer, OrganisedTransformers } from "../../types.js";
+/**
+ * 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/map.d.ts

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

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

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

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

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

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

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

package/dist/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/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/{cjs/utils → utils}/index.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const standardTransformers_1 = require("./standardTransformers");
+const index_js_1 = require("./standardTransformers/index.js");
+const TransformerRegistry_js_1 = require("./TransformerRegistry.js");
 const defaultConfig = {
     stringTests: [],
     blacklistedKeys: [],
@@ -11,33 +12,28 @@ const defaultConfig = {
     replaceStringByLength: false,
     replacement: '[REDACTED]',
     types: ['string'],
-    transformers: standardTransformers_1.standardTransformers,
+    transformers: index_js_1.standardTransformers,
 };
 class RedactorUtils {
     constructor(customConfig) {
-        var _a, _b;
+        var _a;
         /**
          * The configuration for the redaction.
          * @private
          */
         this.config = defaultConfig;
         /**
-         * The computed regex pattern generated from sanitised blacklist keys of flat strings
-         * @private
-         */
-        this.computedRegex = null;
-        /**
-         * Regex to sanitise strings for the computed regex
+         * The transformed blacklist keys of flat regex patterns and complex config objects
          * @private
          */
-        this.sanitiseRegex = /[^a-zA-Z0-9_\-\$]/g;
+        this.blacklistedKeysTransformed = [];
         /**
-         * The transformed blacklist keys of flat regex patterns and complex config objects
+         * The transformer registry for efficient transformer lookup
          * @private
          */
-        this.blacklistedKeysTransformed = [];
+        this.transformerRegistry = new TransformerRegistry_js_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;
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z;
             if (key instanceof RegExp) {
                 return {
                     key,
@@ -49,13 +45,24 @@ class RedactorUtils {
                     remove: (_f = customConfig.remove) !== null && _f !== void 0 ? _f : defaultConfig.remove,
                 };
             }
+            if (typeof key === 'string') {
+                return {
+                    key,
+                    fuzzyKeyMatch: (_g = customConfig.fuzzyKeyMatch) !== null && _g !== void 0 ? _g : defaultConfig.fuzzyKeyMatch,
+                    caseSensitiveKeyMatch: (_h = customConfig.caseSensitiveKeyMatch) !== null && _h !== void 0 ? _h : defaultConfig.caseSensitiveKeyMatch,
+                    retainStructure: (_j = customConfig.retainStructure) !== null && _j !== void 0 ? _j : defaultConfig.retainStructure,
+                    replacement: (_k = customConfig.replacement) !== null && _k !== void 0 ? _k : defaultConfig.replacement,
+                    replaceStringByLength: (_l = customConfig.replaceStringByLength) !== null && _l !== void 0 ? _l : defaultConfig.replaceStringByLength,
+                    remove: (_m = customConfig.remove) !== null && _m !== void 0 ? _m : defaultConfig.remove,
+                };
+            }
             return {
-                fuzzyKeyMatch: (_h = (_g = key.fuzzyKeyMatch) !== null && _g !== void 0 ? _g : customConfig.fuzzyKeyMatch) !== null && _h !== void 0 ? _h : defaultConfig.fuzzyKeyMatch,
-                caseSensitiveKeyMatch: (_k = (_j = key.caseSensitiveKeyMatch) !== null && _j !== void 0 ? _j : customConfig.caseSensitiveKeyMatch) !== null && _k !== void 0 ? _k : defaultConfig.caseSensitiveKeyMatch,
-                retainStructure: (_m = (_l = key.retainStructure) !== null && _l !== void 0 ? _l : customConfig.retainStructure) !== null && _m !== void 0 ? _m : defaultConfig.retainStructure,
-                replacement: (_p = (_o = key.replacement) !== null && _o !== void 0 ? _o : customConfig.replacement) !== null && _p !== void 0 ? _p : defaultConfig.replacement,
-                replaceStringByLength: (_r = (_q = key.replaceStringByLength) !== null && _q !== void 0 ? _q : customConfig.replaceStringByLength) !== null && _r !== void 0 ? _r : defaultConfig.replaceStringByLength,
-                remove: (_t = (_s = key.remove) !== null && _s !== void 0 ? _s : customConfig.remove) !== null && _t !== void 0 ? _t : defaultConfig.remove,
+                fuzzyKeyMatch: (_p = (_o = key.fuzzyKeyMatch) !== null && _o !== void 0 ? _o : customConfig.fuzzyKeyMatch) !== null && _p !== void 0 ? _p : defaultConfig.fuzzyKeyMatch,
+                caseSensitiveKeyMatch: (_r = (_q = key.caseSensitiveKeyMatch) !== null && _q !== void 0 ? _q : customConfig.caseSensitiveKeyMatch) !== null && _r !== void 0 ? _r : defaultConfig.caseSensitiveKeyMatch,
+                retainStructure: (_t = (_s = key.retainStructure) !== null && _s !== void 0 ? _s : customConfig.retainStructure) !== null && _t !== void 0 ? _t : defaultConfig.retainStructure,
+                replacement: (_v = (_u = key.replacement) !== null && _u !== void 0 ? _u : customConfig.replacement) !== null && _v !== void 0 ? _v : defaultConfig.replacement,
+                replaceStringByLength: (_x = (_w = key.replaceStringByLength) !== null && _w !== void 0 ? _w : customConfig.replaceStringByLength) !== null && _x !== void 0 ? _x : defaultConfig.replaceStringByLength,
+                remove: (_z = (_y = key.remove) !== null && _y !== void 0 ? _y : customConfig.remove) !== null && _z !== void 0 ? _z : defaultConfig.remove,
                 key: key.key,
             };
         };
@@ -67,23 +74,8 @@ 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
-         * @param key - The string to sanitise
-         * @returns The sanitised string
-         * @private
-         */
-        this.sanitiseStringForRegex = (key) => key.replace(this.sanitiseRegex, '');
         /**
          * Checks if a key should be redacted
          * @param key - The key to check
@@ -91,17 +83,14 @@ class RedactorUtils {
          * @private
          */
         this.shouldRedactKey = (key) => {
-            var _a;
-            if ((_a = this.computedRegex) === null || _a === void 0 ? void 0 : _a.test(this.sanitiseStringForRegex(key)))
-                return true;
             return this.blacklistedKeysTransformed.some(config => {
                 const pattern = config.key;
                 if (pattern instanceof RegExp)
                     return pattern.test(key);
                 if (!config.fuzzyKeyMatch && !config.caseSensitiveKeyMatch)
-                    return key.toLowerCase() === pattern.toLowerCase();
+                    return key.toLowerCase().trim().replace(/[_-]/g, '') === pattern.toLowerCase().trim().replace(/[_-]/g, '');
                 if (config.fuzzyKeyMatch && !config.caseSensitiveKeyMatch)
-                    return key.toLowerCase().includes(pattern.toLowerCase());
+                    return key.toLowerCase().trim().replace(/[_-]/g, '').includes(pattern.toLowerCase().trim().replace(/[_-]/g, ''));
                 if (config.fuzzyKeyMatch && config.caseSensitiveKeyMatch)
                     return key.includes(pattern);
                 if (!config.fuzzyKeyMatch && config.caseSensitiveKeyMatch)
@@ -188,10 +177,50 @@ class RedactorUtils {
             return output;
         };
         this.config = Object.assign(Object.assign({}, defaultConfig), customConfig);
-        this.blacklistedKeysTransformed = ((_a = customConfig.blacklistedKeys) !== null && _a !== void 0 ? _a : []).filter(key => typeof key !== 'string').map((key) => this.createTransformedBlacklistedKey(key, customConfig));
-        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.blacklistedKeysTransformed = ((_a = customConfig.blacklistedKeys) !== null && _a !== void 0 ? _a : []).map((key) => this.createTransformedBlacklistedKey(key, customConfig));
+        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
@@ -311,28 +340,18 @@ class RedactorUtils {
      * @private
      */
     findMatchingKeyConfig(key) {
-        var _a;
-        if ((_a = this.computedRegex) === null || _a === void 0 ? void 0 : _a.test(key)) {
-            return {
-                key,
-                fuzzyKeyMatch: this.config.fuzzyKeyMatch,
-                caseSensitiveKeyMatch: this.config.caseSensitiveKeyMatch,
-                replaceStringByLength: this.config.replaceStringByLength,
-                replacement: this.config.replacement,
-                retainStructure: this.config.retainStructure,
-                remove: this.config.remove,
-            };
-        }
         return this.blacklistedKeysTransformed.find(config => {
             const pattern = config.key;
             if (pattern instanceof RegExp)
                 return pattern.test(key);
+            const normalisedKey = key.toLowerCase().trim().replace(/[_-]/g, '');
+            const normalisedPattern = pattern.toLowerCase().trim().replace(/[_-]/g, '');
             if (config.fuzzyKeyMatch) {
-                const compareKey = config.caseSensitiveKeyMatch ? key : key.toLowerCase();
-                const comparePattern = config.caseSensitiveKeyMatch ? pattern : pattern.toLowerCase();
+                const compareKey = config.caseSensitiveKeyMatch ? key : normalisedKey;
+                const comparePattern = config.caseSensitiveKeyMatch ? pattern : normalisedPattern;
                 return compareKey.includes(comparePattern);
             }
-            return config.caseSensitiveKeyMatch ? key === pattern : key.toLowerCase() === pattern.toLowerCase();
+            return config.caseSensitiveKeyMatch ? key === pattern : normalisedKey === normalisedPattern;
         });
     }
     /**

package/dist/{esm/utils → utils}/index.mjs

@@ -1,4 +1,5 @@
-import { standardTransformers } from './standardTransformers';
+import { standardTransformers } from './standardTransformers/index.mjs';
+import { TransformerRegistry } from './TransformerRegistry.mjs';
 const defaultConfig = {
     stringTests: [],
     blacklistedKeys: [],
@@ -18,29 +19,64 @@ class RedactorUtils {
      */
     config = defaultConfig;
     /**
-     * The computed regex pattern generated from sanitised blacklist keys of flat strings
-     * @private
-     */
-    computedRegex = null;
-    /**
-     * Regex to sanitise strings for the computed regex
+     * The transformed blacklist keys of flat regex patterns and complex config objects
      * @private
      */
-    sanitiseRegex = /[^a-zA-Z0-9_\-\$]/g;
+    blacklistedKeysTransformed = [];
     /**
-     * The transformed blacklist keys of flat regex patterns and complex config objects
+     * The transformer registry for efficient transformer lookup
      * @private
      */
-    blacklistedKeysTransformed = [];
+    transformerRegistry = new TransformerRegistry();
     constructor(customConfig) {
         this.config = {
             ...defaultConfig,
             ...customConfig,
         };
-        this.blacklistedKeysTransformed = (customConfig.blacklistedKeys ?? []).filter(key => typeof key !== 'string').map((key) => this.createTransformedBlacklistedKey(key, customConfig));
-        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.blacklistedKeysTransformed = (customConfig.blacklistedKeys ?? []).map((key) => this.createTransformedBlacklistedKey(key, customConfig));
+        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) {
@@ -54,6 +90,17 @@ class RedactorUtils {
                 remove: customConfig.remove ?? defaultConfig.remove,
             };
         }
+        if (typeof key === 'string') {
+            return {
+                key,
+                fuzzyKeyMatch: customConfig.fuzzyKeyMatch ?? defaultConfig.fuzzyKeyMatch,
+                caseSensitiveKeyMatch: customConfig.caseSensitiveKeyMatch ?? defaultConfig.caseSensitiveKeyMatch,
+                retainStructure: customConfig.retainStructure ?? defaultConfig.retainStructure,
+                replacement: customConfig.replacement ?? defaultConfig.replacement,
+                replaceStringByLength: customConfig.replaceStringByLength ?? defaultConfig.replaceStringByLength,
+                remove: customConfig.remove ?? defaultConfig.remove,
+            };
+        }
         return {
             fuzzyKeyMatch: key.fuzzyKeyMatch ?? customConfig.fuzzyKeyMatch ?? defaultConfig.fuzzyKeyMatch,
             caseSensitiveKeyMatch: key.caseSensitiveKeyMatch ?? customConfig.caseSensitiveKeyMatch ?? defaultConfig.caseSensitiveKeyMatch,
@@ -72,23 +119,8 @@ 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
-     * @param key - The string to sanitise
-     * @returns The sanitised string
-     * @private
-     */
-    sanitiseStringForRegex = (key) => key.replace(this.sanitiseRegex, '');
     /**
      * Checks if a key should be redacted
      * @param key - The key to check
@@ -96,16 +128,14 @@ class RedactorUtils {
      * @private
      */
     shouldRedactKey = (key) => {
-        if (this.computedRegex?.test(this.sanitiseStringForRegex(key)))
-            return true;
         return this.blacklistedKeysTransformed.some(config => {
             const pattern = config.key;
             if (pattern instanceof RegExp)
                 return pattern.test(key);
             if (!config.fuzzyKeyMatch && !config.caseSensitiveKeyMatch)
-                return key.toLowerCase() === pattern.toLowerCase();
+                return key.toLowerCase().trim().replace(/[_-]/g, '') === pattern.toLowerCase().trim().replace(/[_-]/g, '');
             if (config.fuzzyKeyMatch && !config.caseSensitiveKeyMatch)
-                return key.toLowerCase().includes(pattern.toLowerCase());
+                return key.toLowerCase().trim().replace(/[_-]/g, '').includes(pattern.toLowerCase().trim().replace(/[_-]/g, ''));
             if (config.fuzzyKeyMatch && config.caseSensitiveKeyMatch)
                 return key.includes(pattern);
             if (!config.fuzzyKeyMatch && config.caseSensitiveKeyMatch)
@@ -268,27 +298,18 @@ class RedactorUtils {
      * @private
      */
     findMatchingKeyConfig(key) {
-        if (this.computedRegex?.test(key)) {
-            return {
-                key,
-                fuzzyKeyMatch: this.config.fuzzyKeyMatch,
-                caseSensitiveKeyMatch: this.config.caseSensitiveKeyMatch,
-                replaceStringByLength: this.config.replaceStringByLength,
-                replacement: this.config.replacement,
-                retainStructure: this.config.retainStructure,
-                remove: this.config.remove,
-            };
-        }
         return this.blacklistedKeysTransformed.find(config => {
             const pattern = config.key;
             if (pattern instanceof RegExp)
                 return pattern.test(key);
+            const normalisedKey = key.toLowerCase().trim().replace(/[_-]/g, '');
+            const normalisedPattern = pattern.toLowerCase().trim().replace(/[_-]/g, '');
             if (config.fuzzyKeyMatch) {
-                const compareKey = config.caseSensitiveKeyMatch ? key : key.toLowerCase();
-                const comparePattern = config.caseSensitiveKeyMatch ? pattern : pattern.toLowerCase();
+                const compareKey = config.caseSensitiveKeyMatch ? key : normalisedKey;
+                const comparePattern = config.caseSensitiveKeyMatch ? pattern : normalisedPattern;
                 return compareKey.includes(comparePattern);
             }
-            return config.caseSensitiveKeyMatch ? key === pattern : key.toLowerCase() === pattern.toLowerCase();
+            return config.caseSensitiveKeyMatch ? key === pattern : normalisedKey === normalisedPattern;
         });
     }
     /**

package/dist/utils/standardTransformers/index.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.organisedStandardTransformers = exports.standardTransformers = void 0;
+const bigint_js_1 = require("./bigint.js");
+const date_js_1 = require("./date.js");
+const error_js_1 = require("./error.js");
+const map_js_1 = require("./map.js");
+const regex_js_1 = require("./regex.js");
+const set_js_1 = require("./set.js");
+const url_js_1 = require("./url.js");
+/**
+ * Standard transformers in array for legacy support
+ */
+exports.standardTransformers = [
+    bigint_js_1._bigint,
+    date_js_1._date,
+    error_js_1._error,
+    map_js_1._map,
+    regex_js_1._regex,
+    set_js_1._set,
+    url_js_1._url,
+];
+/**
+ * Standard transformers organised by type and constructor for performance reasons
+ */
+exports.organisedStandardTransformers = {
+    byType: {
+        bigint: [bigint_js_1._bigint],
+    },
+    byConstructor: {
+        URL: [url_js_1._url],
+        Date: [date_js_1._date],
+        Error: [error_js_1._error],
+        Map: [map_js_1._map],
+        Set: [set_js_1._set],
+        RegExp: [regex_js_1._regex],
+    },
+};

package/dist/utils/standardTransformers/index.mjs

@@ -0,0 +1,35 @@
+import { _bigint } from "./bigint.mjs";
+import { _date } from "./date.mjs";
+import { _error } from "./error.mjs";
+import { _map } from "./map.mjs";
+import { _regex } from "./regex.mjs";
+import { _set } from "./set.mjs";
+import { _url } from "./url.mjs";
+/**
+ * Standard transformers in array for legacy support
+ */
+export const standardTransformers = [
+    _bigint,
+    _date,
+    _error,
+    _map,
+    _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/package.json

@@ -1,68 +1,73 @@
 {
   "name": "@hackylabs/deep-redact",
-  "version": "3.0.2",
+  "version": "3.0.4",
   "description": "A fast, safe and configurable zero-dependency library for redacting strings or deeply redacting arrays and objects.",
   "private": false,
   "license": "MIT",
   "author": "Benjamin Green (https://bengreen.dev)",
   "funding": "https://ko-fi.com/hackylabs",
   "types": "./dist/types/index.d.ts",
-  "main": "./dist/cjs/index.js",
-  "module": "./dist/esm/index.mjs",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
   "exports": {
-    ".": {
-      "import": "./dist/index",
-      "require": "./dist/index",
+    "./index.ts": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
       "types": "./dist/types/index.d.ts"
     },
-    "./types": {
-      "import": "./dist/types",
-      "require": "./dist/types",
+    "./types.ts": {
+      "import": "./dist/types.mjs",
+      "require": "./dist/types.js",
       "types": "./dist/types/types.d.ts"
     },
-    "./utils": {
-      "import": "./dist/utils",
-      "require": "./dist/utils",
-      "types": "./dist/types/utils.d.ts"
+    "./utils/TransformerRegistry.ts": {
+      "import": "./dist/utils/TransformerRegistry.mjs",
+      "require": "./dist/utils/TransformerRegistry.js",
+      "types": "./dist/types/utils/TransformerRegistry.d.ts"
     },
-    "./utils/standardTransformers/bigint": {
-      "import": "./dist/utils/standardTransformers/bigint",
-      "require": "./dist/utils/standardTransformers/bigint",
+    "./utils/index.ts": {
+      "import": "./dist/utils/index.mjs",
+      "require": "./dist/utils/index.js",
+      "types": "./dist/types/utils/index.d.ts"
+    },
+    "./utils/standardTransformers/bigint.ts": {
+      "import": "./dist/utils/standardTransformers/bigint.mjs",
+      "require": "./dist/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",
+    "./utils/standardTransformers/date.ts": {
+      "import": "./dist/utils/standardTransformers/date.mjs",
+      "require": "./dist/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",
+    "./utils/standardTransformers/error.ts": {
+      "import": "./dist/utils/standardTransformers/error.mjs",
+      "require": "./dist/utils/standardTransformers/error.js",
       "types": "./dist/types/utils/standardTransformers/error.d.ts"
     },
-    "./utils/standardTransformers": {
-      "import": "./dist/utils/standardTransformers",
-      "require": "./dist/utils/standardTransformers",
-      "types": "./dist/types/utils/standardTransformers.d.ts"
+    "./utils/standardTransformers/index.ts": {
+      "import": "./dist/utils/standardTransformers/index.mjs",
+      "require": "./dist/utils/standardTransformers/index.js",
+      "types": "./dist/types/utils/standardTransformers/index.d.ts"
     },
-    "./utils/standardTransformers/map": {
-      "import": "./dist/utils/standardTransformers/map",
-      "require": "./dist/utils/standardTransformers/map",
+    "./utils/standardTransformers/map.ts": {
+      "import": "./dist/utils/standardTransformers/map.mjs",
+      "require": "./dist/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",
+    "./utils/standardTransformers/regex.ts": {
+      "import": "./dist/utils/standardTransformers/regex.mjs",
+      "require": "./dist/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",
+    "./utils/standardTransformers/set.ts": {
+      "import": "./dist/utils/standardTransformers/set.mjs",
+      "require": "./dist/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",
+    "./utils/standardTransformers/url.ts": {
+      "import": "./dist/utils/standardTransformers/url.mjs",
+      "require": "./dist/utils/standardTransformers/url.js",
       "types": "./dist/types/utils/standardTransformers/url.d.ts"
     }
   },
@@ -96,17 +101,20 @@
   },
   "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:dev": "rm -rf dist && npm run build:esm && npm run build:cjs && npm run update-exports",
     "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"

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

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.standardTransformers = void 0;
-const bigint_1 = require("./bigint");
-const date_1 = require("./date");
-const error_1 = require("./error");
-const map_1 = require("./map");
-const regex_1 = require("./regex");
-const set_1 = require("./set");
-const url_1 = require("./url");
-exports.standardTransformers = [
-    bigint_1._bigint,
-    url_1._url,
-    date_1._date,
-    error_1._error,
-    map_1._map,
-    set_1._set,
-    regex_1._regex,
-];

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

@@ -1,16 +0,0 @@
-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";
-export const standardTransformers = [
-    _bigint,
-    _url,
-    _date,
-    _error,
-    _map,
-    _set,
-    _regex,
-];