@veryfront/ext-content-mdx 0.1.1190 → 0.1.1192

package/esm/src/utils/logger/logger.js

@@ -3,7 +3,35 @@ import { isStdoutTTY } from "../../platform/compat/process/lifecycle.js";
 import { isTruthyEnvValue } from "../constants/env.js";
 import { RUNTIME_VERSION } from "../version.js";
 import { ANSI, colorize, formatContextText, formatTimestamp, LEVEL_COLORS, LEVEL_GLYPHS, padTag, serializeError, } from "./core.js";
-import { redactSensitive, sanitizeSerializedError, sanitizeUrlCredentials } from "./redact.js";
+import { REDACTED, redactForSerialization, redactSensitive, sanitizeSerializedError, sanitizeUrlCredentials, } from "./redact.js";
+import { stringifyRedactedJson } from "./serialization.js";
+const apply = Reflect.apply;
+const arrayPush = Array.prototype.push;
+const arrayIsArray = Array.isArray;
+const NativeConsole = console;
+const NativeDate = Date;
+const dateToISOString = Date.prototype.toISOString;
+const NativePerformance = performance;
+const performanceNow = Performance.prototype.now;
+const numberRound = Math.round;
+const objectCreate = Object.create;
+const objectGetPrototypeOf = Object.getPrototypeOf;
+const NativeSet = Set;
+const setAdd = Set.prototype.add;
+const setClear = Set.prototype.clear;
+const setDelete = Set.prototype.delete;
+const setValues = Set.prototype.values;
+const setIteratorNext = objectGetPrototypeOf(new NativeSet().values()).next;
+const stringToLowerCase = String.prototype.toLowerCase;
+const stringToUpperCase = String.prototype.toUpperCase;
+function readPerformanceNow() {
+    try {
+        return apply(performanceNow, NativePerformance, []);
+    }
+    catch {
+        return 0;
+    }
+}
 export var LogLevel;
 (function (LogLevel) {
     LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
@@ -21,7 +49,7 @@ const LOG_LEVEL_MAP = {
 function parseLogLevel(levelString) {
     if (!levelString)
         return undefined;
-    return LOG_LEVEL_MAP[levelString.toUpperCase()];
+    return LOG_LEVEL_MAP[apply(stringToUpperCase, levelString, [])];
 }
 /**
  * Determine the log level based on environment variables.
@@ -55,7 +83,7 @@ function getDefaultFormat(envFormat = getHostEnv("LOG_FORMAT"), envMode = getHos
  */
 let loggerConfig = null;
 let legacyLogRecordEmitter = null;
-const logRecordSubscribers = new Set();
+const logRecordSubscribers = new NativeSet();
 /**
  * Re-read logger configuration from environment variables.
  * Call after loading .env files so the logger picks up any overrides.
@@ -95,15 +123,15 @@ export function __registerLogRecordEmitter(emitter) {
 }
 /** Subscribe to process-level structured log records. Returns an unregister function. */
 export function __subscribeLogRecordEmitter(emitter) {
-    logRecordSubscribers.add(emitter);
+    apply(setAdd, logRecordSubscribers, [emitter]);
     return () => {
-        logRecordSubscribers.delete(emitter);
+        apply(setDelete, logRecordSubscribers, [emitter]);
     };
 }
 /** Reset the process-level structured log emitter. Only intended for tests. */
 export function __resetLogRecordEmitterForTests() {
     legacyLogRecordEmitter = null;
-    logRecordSubscribers.clear();
+    apply(setClear, logRecordSubscribers, []);
 }
 function resolveLoggerConfig() {
     if (loggerConfig === null) {
@@ -115,6 +143,28 @@ function resolveLoggerConfig() {
     }
     return loggerConfig;
 }
+function sanitizeLogString(value, fallback) {
+    try {
+        return sanitizeUrlCredentials(typeof value === "string" ? value : String(value));
+    }
+    catch {
+        return fallback;
+    }
+}
+function currentIsoTimestamp() {
+    return apply(dateToISOString, new NativeDate(), []);
+}
+function snapshotLogContext(context) {
+    try {
+        const snapshot = redactForSerialization(context);
+        return typeof snapshot === "object" && snapshot !== null && !arrayIsArray(snapshot)
+            ? snapshot
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
 /**
  * Extract context from variadic args.
  * First object argument becomes context, errors are handled specially.
@@ -123,21 +173,27 @@ function extractContext(args) {
     let context;
     let error;
     for (const arg of args) {
-        if (arg instanceof Error) {
-            error = serializeError(arg);
-            continue;
-        }
-        if (typeof arg === "object" && arg !== null && !Array.isArray(arg)) {
-            const contextArg = arg;
-            if (contextArg.error instanceof Error) {
-                const { error: contextError, ...rest } = contextArg;
-                error = serializeError(contextError);
-                if (Object.keys(rest).length > 0) {
-                    context = { ...context, ...rest };
-                }
+        try {
+            if (arg instanceof Error) {
+                error = serializeError(arg);
                 continue;
             }
-            context = { ...context, ...contextArg };
+            if (typeof arg === "object" && arg !== null && !arrayIsArray(arg)) {
+                const contextArg = arg;
+                if (contextArg.error instanceof Error) {
+                    const { error: contextError, ...rest } = contextArg;
+                    error = serializeError(contextError);
+                    if (Object.keys(rest).length > 0) {
+                        context = { ...context, ...rest };
+                    }
+                    continue;
+                }
+                context = { ...context, ...contextArg };
+            }
+        }
+        catch {
+            // Logging accepts application-owned objects. Ignore an unreadable value
+            // rather than allowing proxy traps or getters to break the caller.
         }
     }
     return { context, error };
@@ -196,6 +252,29 @@ function extractAliasToEntryField(entry, context, sourceKey, targetKey, coerce)
 function sanitizeStringFieldValue(value) {
     return sanitizeUrlCredentials(String(value));
 }
+function createFallbackLogEntry(entry) {
+    const fallback = objectCreate(null);
+    fallback.timestamp = entry.timestamp;
+    fallback.level = entry.level;
+    fallback.service = entry.service;
+    fallback.veryfrontVersion = entry.veryfrontVersion;
+    fallback.message = entry.message;
+    if (entry.component !== undefined)
+        fallback.component = entry.component;
+    const context = objectCreate(null);
+    context.unserializable_context = REDACTED;
+    fallback.context = context;
+    return fallback;
+}
+/**
+ * Serialize a log entry without letting caller-controlled values or inherited
+ * `toJSON` hooks escape the logging boundary. The redacted snapshot normalizes
+ * BigInt and deliberate serializers first, then shadows inherited hooks on
+ * every owned object and array before native JSON serialization.
+ */
+function stringifyLogEntry(entry) {
+    return stringifyRedactedJson(entry, createFallbackLogEntry(entry));
+}
 class ConsoleLogger {
     prefix;
     options;
@@ -204,24 +283,43 @@ class ConsoleLogger {
     constructor(prefix, boundContext, componentName, options = {}) {
         this.prefix = prefix;
         this.options = options;
-        this.boundContext = boundContext ?? {};
-        this.componentName = componentName;
+        this.boundContext = snapshotLogContext(boundContext ?? {});
+        this.componentName = componentName === undefined
+            ? undefined
+            : sanitizeLogString(componentName, REDACTED);
     }
     child(context) {
-        return new ConsoleLogger(this.prefix, { ...this.boundContext, ...context }, this.componentName, this.options);
+        const childContext = snapshotLogContext(context);
+        return new ConsoleLogger(this.prefix, { ...this.boundContext, ...childContext }, this.componentName, this.options);
     }
     component(name) {
         return new ConsoleLogger(this.prefix, { ...this.boundContext }, name, this.options);
     }
+    createEmergencyEntry(level) {
+        const entry = {
+            timestamp: currentIsoTimestamp(),
+            level,
+            service: apply(stringToLowerCase, sanitizeLogString(this.prefix, "veryfront"), []),
+            veryfrontVersion: RUNTIME_VERSION,
+            message: REDACTED,
+            context: { unserializable_context: REDACTED },
+        };
+        if (this.componentName)
+            entry.component = this.componentName;
+        return entry;
+    }
     createEntry(level, message, args) {
         const { context, error } = extractContext(args);
         const mergedContext = { ...this.boundContext, ...context };
         const entry = {
-            timestamp: new Date().toISOString(),
+            timestamp: currentIsoTimestamp(),
             level,
-            service: this.prefix.toLowerCase(),
+            service: apply(stringToLowerCase, this.prefix, []),
             veryfrontVersion: RUNTIME_VERSION,
-            message,
+            // The message string bypasses the key-based context redactor, so scrub
+            // credential-shaped text (URL userinfo, ?access_token=, header dumps)
+            // embedded directly in the message before emission (#1989).
+            message: sanitizeLogString(message, REDACTED),
         };
         if (this.componentName)
             entry.component = this.componentName;
@@ -308,18 +406,21 @@ class ConsoleLogger {
     }
     formatJson(level, message, args) {
         const entry = this.createEntry(level, message, args);
-        return JSON.stringify(entry);
+        return stringifyLogEntry(entry);
     }
     formatTextLine(level, message, args) {
         const { context, error } = extractContext(args);
         const mergedContext = { ...this.boundContext, ...context };
         const enableColor = shouldUseColor();
+        // Mirror the JSON path: the message string bypasses the key-based context
+        // redactor, so scrub credential-shaped text before rendering (#1989).
+        const safeMessage = sanitizeLogString(message, REDACTED);
         const contextText = formatContextText(redactSensitive(mergedContext), sanitizeSerializedError(error), enableColor);
         const { preset } = resolveLoggerConfig();
         if (preset === "cli") {
             // CLI preset: no timestamp or tag — 2-space indent + glyph only.
             const glyph = colorize(CLI_LEVEL_GLYPHS[level], LEVEL_COLORS[level], enableColor);
-            return `  ${glyph} ${message}${contextText}`;
+            return `  ${glyph} ${safeMessage}${contextText}`;
         }
         const timestamp = colorize(formatTimestamp(), ANSI.dim, enableColor);
         const tag = colorize(padTag(this.prefix), TAG_COLORS[this.prefix] ?? ANSI.cyan, enableColor);
@@ -327,63 +428,104 @@ class ConsoleLogger {
         const componentTag = this.componentName
             ? ` ${colorize(`[${this.componentName}]`, ANSI.dim, enableColor)}`
             : "";
-        return `${timestamp}  ${tag} ${glyph}${componentTag} ${message}${contextText}`;
-    }
-    log(level, logLevel, consoleFn, message, args) {
-        const { level: resolvedLevel, format: resolvedFormat } = resolveLoggerConfig();
-        if (resolvedLevel > logLevel)
-            return;
-        let entry;
-        const line = resolvedFormat === "json"
-            ? (() => {
-                entry = this.createEntry(level, message, args);
-                return JSON.stringify(entry);
-            })()
-            : this.formatTextLine(level, message, args);
-        const emittedEntry = entry ?? this.createEntry(level, message, args);
-        if (legacyLogRecordEmitter) {
+        return `${timestamp}  ${tag} ${glyph}${componentTag} ${safeMessage}${contextText}`;
+    }
+    log(level, logLevel, consoleMethod, message, args) {
+        try {
+            const { level: resolvedLevel, format: resolvedFormat } = resolveLoggerConfig();
+            if (resolvedLevel > logLevel)
+                return;
+            let emittedEntry;
+            let line;
             try {
-                legacyLogRecordEmitter(emittedEntry);
+                if (resolvedFormat === "json") {
+                    emittedEntry = this.createEntry(level, message, args);
+                    line = stringifyLogEntry(emittedEntry);
+                }
+                else {
+                    line = this.formatTextLine(level, message, args);
+                    emittedEntry = this.createEntry(level, message, args);
+                }
             }
-            catch (_) {
-                /* do not let telemetry export failures affect application logging */
+            catch {
+                try {
+                    emittedEntry = this.createEmergencyEntry(level);
+                    line = resolvedFormat === "json"
+                        ? stringifyLogEntry(emittedEntry)
+                        : `${apply(stringToUpperCase, level, [])}: ${REDACTED}`;
+                }
+                catch {
+                    return;
+                }
             }
-        }
-        for (const subscriber of logRecordSubscribers) {
-            if (subscriber === legacyLogRecordEmitter)
-                continue;
-            try {
-                subscriber(emittedEntry);
+            if (legacyLogRecordEmitter) {
+                try {
+                    legacyLogRecordEmitter(emittedEntry);
+                }
+                catch (_) {
+                    /* do not let telemetry export failures affect application logging */
+                }
             }
-            catch (_) {
-                /* do not let telemetry export failures affect application logging */
+            // Snapshot before invoking callbacks. Native Set iterators observe values
+            // deleted and reinserted during iteration, which can otherwise invoke one
+            // subscriber repeatedly (or keep a single log call alive indefinitely).
+            const subscribers = [];
+            const iterator = apply(setValues, logRecordSubscribers, []);
+            while (true) {
+                const next = apply(setIteratorNext, iterator, []);
+                if (next.done)
+                    break;
+                apply(arrayPush, subscribers, [next.value]);
             }
+            for (let index = 0; index < subscribers.length; index++) {
+                const subscriber = subscribers[index];
+                if (subscriber === legacyLogRecordEmitter)
+                    continue;
+                try {
+                    subscriber(emittedEntry);
+                }
+                catch (_) {
+                    /* do not let telemetry export failures affect application logging */
+                }
+            }
+            const consoleFn = NativeConsole[consoleMethod];
+            if (typeof consoleFn === "function") {
+                try {
+                    apply(consoleFn, NativeConsole, [line]);
+                }
+                catch (_) {
+                    /* logging sink failures must not affect application control flow */
+                }
+            }
+        }
+        catch (_) {
+            /* every logging concern is contained by this final nonthrowing boundary */
         }
-        consoleFn(line);
     }
     debug(message, ...args) {
-        this.log("debug", LogLevel.DEBUG, console.debug, message, args);
+        this.log("debug", LogLevel.DEBUG, "debug", message, args);
     }
     info(message, ...args) {
-        this.log("info", LogLevel.INFO, console.log, message, args);
+        this.log("info", LogLevel.INFO, "log", message, args);
     }
     warn(message, ...args) {
-        this.log("warn", LogLevel.WARN, console.warn, message, args);
+        this.log("warn", LogLevel.WARN, "warn", message, args);
     }
     error(message, ...args) {
-        this.log("error", LogLevel.ERROR, console.error, message, args);
+        this.log("error", LogLevel.ERROR, "error", message, args);
     }
     async time(label, fn) {
-        const start = performance.now();
+        const safeLabel = sanitizeLogString(label, REDACTED);
+        const start = readPerformanceNow();
         try {
             const result = await fn();
-            const durationMs = performance.now() - start;
-            this.debug(`${label} completed`, { durationMs: Math.round(durationMs) });
+            const durationMs = readPerformanceNow() - start;
+            this.debug(`${safeLabel} completed`, { durationMs: numberRound(durationMs) });
             return result;
         }
         catch (error) {
-            const durationMs = performance.now() - start;
-            this.error(`${label} failed`, { durationMs: Math.round(durationMs) }, error);
+            const durationMs = readPerformanceNow() - start;
+            this.error(`${safeLabel} failed`, { durationMs: numberRound(durationMs) }, error);
             throw error;
         }
     }
@@ -444,8 +586,147 @@ export function __resetTraceContextGetterForTests() {
     traceContextGetter = null;
 }
 function withRequestLogger(base) {
-    const ctx = requestContextGetter?.();
-    return ctx?.logger ?? base;
+    try {
+        const ctx = requestContextGetter?.();
+        return ctx?.logger ?? base;
+    }
+    catch {
+        return base;
+    }
+}
+function selectContextLogger(base) {
+    return { selected: withRequestLogger(base), fallback: base };
+}
+function selectComponentLoggers(base, componentName) {
+    let fallback = base;
+    try {
+        fallback = base.component(componentName);
+    }
+    catch {
+        // The base logger itself is still a safe final fallback.
+    }
+    const requestLogger = withRequestLogger(base);
+    if (requestLogger === base)
+        return { selected: fallback, fallback };
+    try {
+        return { selected: requestLogger.component(componentName), fallback };
+    }
+    catch {
+        return { selected: fallback, fallback };
+    }
+}
+function invokeLoggerMethod(logger, method, message, args) {
+    try {
+        const callback = logger[method];
+        if (typeof callback !== "function")
+            return false;
+        const callArgs = [message];
+        for (let index = 0; index < args.length; index++)
+            callArgs[index + 1] = args[index];
+        apply(callback, logger, callArgs);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function invokeContextAwareLog(base, method, message, args) {
+    invokeSelectedLoggerMethod(selectContextLogger(base), method, message, args);
+}
+function invokeSelectedLoggerMethod(selection, method, message, args) {
+    if (invokeLoggerMethod(selection.selected, method, message, args))
+        return;
+    if (selection.selected !== selection.fallback) {
+        invokeLoggerMethod(selection.fallback, method, message, args);
+    }
+}
+function invokeContextAwareComponentLog(base, componentName, method, message, args) {
+    invokeSelectedLoggerMethod(selectComponentLoggers(base, componentName), method, message, args);
+}
+function invokeLoggerChild(logger, context) {
+    try {
+        const callback = logger.child;
+        if (typeof callback !== "function")
+            return undefined;
+        const child = apply(callback, logger, [context]);
+        if ((typeof child === "object" && child !== null) || typeof child === "function") {
+            return child;
+        }
+    }
+    catch {
+        // Request-scoped logger composition must not escape the logging boundary.
+    }
+    return undefined;
+}
+function invokeSelectedLoggerChild(selection, context) {
+    const fallback = invokeLoggerChild(selection.fallback, context) ?? selection.fallback;
+    const selected = selection.selected === selection.fallback
+        ? fallback
+        : invokeLoggerChild(selection.selected, context) ?? fallback;
+    return createGuardedLogger({ selected, fallback });
+}
+function invokeLoggerComponent(logger, name) {
+    try {
+        const callback = logger.component;
+        if (typeof callback !== "function")
+            return undefined;
+        const component = apply(callback, logger, [name]);
+        if ((typeof component === "object" && component !== null) ||
+            typeof component === "function") {
+            return component;
+        }
+    }
+    catch {
+        // Component composition must remain inside the guarded facade.
+    }
+    return undefined;
+}
+function selectLoggerComponents(selection, name) {
+    const fallback = invokeLoggerComponent(selection.fallback, name) ?? selection.fallback;
+    const selected = selection.selected === selection.fallback
+        ? fallback
+        : invokeLoggerComponent(selection.selected, name) ?? fallback;
+    return { selected, fallback };
+}
+async function invokeSelectedLoggerTime(selection, label, fn) {
+    const safeLabel = sanitizeLogString(label, REDACTED);
+    const start = readPerformanceNow();
+    try {
+        const result = await fn();
+        const durationMs = numberRound(readPerformanceNow() - start);
+        invokeSelectedLoggerMethod(selection, "debug", `${safeLabel} completed`, [{ durationMs }]);
+        return result;
+    }
+    catch (error) {
+        const durationMs = numberRound(readPerformanceNow() - start);
+        invokeSelectedLoggerMethod(selection, "error", `${safeLabel} failed`, [{ durationMs }, error]);
+        throw error;
+    }
+}
+function createGuardedLogger(selection) {
+    return {
+        debug(message, ...args) {
+            invokeSelectedLoggerMethod(selection, "debug", message, args);
+        },
+        info(message, ...args) {
+            invokeSelectedLoggerMethod(selection, "info", message, args);
+        },
+        warn(message, ...args) {
+            invokeSelectedLoggerMethod(selection, "warn", message, args);
+        },
+        error(message, ...args) {
+            invokeSelectedLoggerMethod(selection, "error", message, args);
+        },
+        time(label, fn) {
+            return invokeSelectedLoggerTime(selection, label, fn);
+        },
+        child(context) {
+            return invokeSelectedLoggerChild(selection, context);
+        },
+        component(name) {
+            return createGuardedLogger(selectLoggerComponents(selection, name));
+        },
+    };
 }
 /**
  * Create a context-aware logger proxy that automatically uses
@@ -454,22 +735,22 @@ function withRequestLogger(base) {
 function createContextAwareLogger(base) {
     return {
         debug(message, ...args) {
-            withRequestLogger(base).debug(message, ...args);
+            invokeContextAwareLog(base, "debug", message, args);
         },
         info(message, ...args) {
-            withRequestLogger(base).info(message, ...args);
+            invokeContextAwareLog(base, "info", message, args);
         },
         warn(message, ...args) {
-            withRequestLogger(base).warn(message, ...args);
+            invokeContextAwareLog(base, "warn", message, args);
         },
         error(message, ...args) {
-            withRequestLogger(base).error(message, ...args);
+            invokeContextAwareLog(base, "error", message, args);
         },
         time(label, fn) {
-            return withRequestLogger(base).time(label, fn);
+            return invokeSelectedLoggerTime(selectContextLogger(base), label, fn);
         },
         child(context) {
-            return withRequestLogger(base).child(context);
+            return invokeSelectedLoggerChild(selectContextLogger(base), context);
         },
         component(name) {
             return createComponentAwareLogger(base, name);
@@ -485,22 +766,22 @@ function createContextAwareLogger(base) {
 function createComponentAwareLogger(base, componentName) {
     return {
         debug(message, ...args) {
-            withRequestLogger(base).component(componentName).debug(message, ...args);
+            invokeContextAwareComponentLog(base, componentName, "debug", message, args);
         },
         info(message, ...args) {
-            withRequestLogger(base).component(componentName).info(message, ...args);
+            invokeContextAwareComponentLog(base, componentName, "info", message, args);
         },
         warn(message, ...args) {
-            withRequestLogger(base).component(componentName).warn(message, ...args);
+            invokeContextAwareComponentLog(base, componentName, "warn", message, args);
         },
         error(message, ...args) {
-            withRequestLogger(base).component(componentName).error(message, ...args);
+            invokeContextAwareComponentLog(base, componentName, "error", message, args);
         },
         time(label, fn) {
-            return withRequestLogger(base).component(componentName).time(label, fn);
+            return invokeSelectedLoggerTime(selectComponentLoggers(base, componentName), label, fn);
         },
         child(context) {
-            return withRequestLogger(base).component(componentName).child(context);
+            return invokeSelectedLoggerChild(selectComponentLoggers(base, componentName), context);
         },
         component(name) {
             return createComponentAwareLogger(base, name);
@@ -525,7 +806,7 @@ export const logger = createContextAwareLogger(baseLogger);
  * Use this when you need to create a request-scoped logger in middleware.
  */
 export function getBaseLogger(prefix, options) {
-    const resolvedPrefix = prefix.toUpperCase();
+    const resolvedPrefix = apply(stringToUpperCase, prefix, []);
     const validPrefix = resolvedPrefix in BASE_LOGGER_MAP ? resolvedPrefix : "VERYFRONT";
     if (options?.injectTraceContext === false) {
         return createLogger(validPrefix, options);

package/esm/src/utils/logger/redact.d.ts

@@ -63,8 +63,10 @@ export declare function redactForSerialization(context: unknown): RedactedValue;
  * {@link redactSensitive}, which is key-based, this scrubs secrets embedded in
  * the *value* itself:
  *
- * - URL userinfo: `http://user:pass@host` → `http://user:[REDACTED]@host`
- * - sensitive query params: `?access_token=abc` → `?access_token=[REDACTED]`
+ * - URL userinfo: `https://user:password@example.test/path` -> `https://user:[REDACTED]@example.test/path`
+ * - sensitive query params: `?access_token=abc` -> `?access_token=[REDACTED]`
+ * - credential assignments: `refreshToken=abc` -> `refreshToken=[REDACTED]`
+ * - common provider tokens: `Using token sk-...` -> `Using token [REDACTED]`
  *
  * It is intentionally tolerant: it operates on any string (a DSN, a Mongo URI,
  * an axios error message containing a URL) via regex rather than requiring a

package/esm/src/utils/logger/redact.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"redact.d.ts","sourceRoot":"","sources":["../../../../src/src/utils/logger/redact.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,6DAA6D;AAC7D,eAAO,MAAM,QAAQ,eAAe,CAAC;AAmErC;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,GAClB,MAAM,CAiDR;AAoDD;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAmBnD;AAED,MAAM,MAAM,aAAa,GACrB,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,GACJ,aAAa,EAAE,GACf;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,aAAa,CAAA;CAAE,CAAC;AAsKrC;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,CAAC,CAKhD;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,GAAG,aAAa,CAKtE;AAiSD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CA8F5D;AAqBD;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CA2BxD;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,CAAC,SAAS;IAAE,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,SAAS,EAC5E,KAAK,EAAE,CAAC,GAAG,CAAC,CAOb"}
+{"version":3,"file":"redact.d.ts","sourceRoot":"","sources":["../../../../src/src/utils/logger/redact.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,6DAA6D;AAC7D,eAAO,MAAM,QAAQ,eAAe,CAAC;AA2KrC;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,GAClB,MAAM,CAiDR;AAwDD;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAwBnD;AAED,MAAM,MAAM,aAAa,GACrB,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,GACJ,aAAa,EAAE,GACf;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,aAAa,CAAA;CAAE,CAAC;AA8MrC;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,CAAC,CAKhD;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,GAAG,aAAa,CAKtE;AAwVD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAyG5D;AAqBD;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CA+BxD;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,CAAC,SAAS;IAAE,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,SAAS,EAC5E,KAAK,EAAE,CAAC,GAAG,CAAC,CAOb"}