@wgtechlabs/log-engine 1.2.0 → 1.3.0

package/dist/logger/core.js

@@ -0,0 +1,185 @@
+"use strict";
+/**
+ * Core Logger class that handles log message output with configurable levels
+ * Supports DEBUG, INFO, WARN, ERROR, and LOG levels with intelligent filtering
+ * LOG level always outputs regardless of configuration
+ * Uses colorized console output with timestamps for better readability
+ * Includes automatic data redaction for sensitive information
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+const types_1 = require("../types");
+const formatter_1 = require("../formatter");
+const redaction_1 = require("../redaction");
+const config_1 = require("./config");
+const filtering_1 = require("./filtering");
+/**
+ * Logger class responsible for managing log output and configuration
+ * Provides mode-based filtering and formatted console output
+ */
+class Logger {
+    /**
+     * Logger constructor - sets up environment-based auto-configuration
+     */
+    constructor() {
+        this.configManager = new config_1.LoggerConfigManager();
+    }
+    /**
+     * Updates logger configuration with new settings
+     * Also updates redaction configuration based on environment
+     * @param config - Partial configuration object to apply
+     */
+    configure(config) {
+        this.configManager.updateConfig(config);
+        // Update redaction configuration based on current environment
+        redaction_1.DataRedactor.updateConfig({
+            ...redaction_1.defaultRedactionConfig,
+            ...redaction_1.RedactionController.getEnvironmentConfig()
+        });
+    }
+    /**
+     * Get current logger configuration
+     * @returns Current logger configuration
+     */
+    getConfig() {
+        return this.configManager.getConfig();
+    }
+    /**
+     * Determines if a message should be logged based on current log mode
+     * @param level - The log level of the message to check
+     * @returns true if message should be logged, false otherwise
+     */
+    shouldLog(level) {
+        const currentConfig = this.configManager.getConfig();
+        const currentMode = currentConfig.mode !== undefined ? currentConfig.mode : types_1.LogMode.INFO;
+        return filtering_1.LogFilter.shouldLog(level, currentMode);
+    }
+    /**
+     * Log a debug message with DEBUG level formatting
+     * Uses console.log for output with purple/magenta coloring
+     * Automatically redacts sensitive data when provided
+     * @param message - The debug message to log
+     * @param data - Optional data object to log (will be redacted)
+     */
+    debug(message, data) {
+        if (this.shouldLog(types_1.LogLevel.DEBUG)) {
+            const processedData = redaction_1.DataRedactor.redactData(data);
+            const formatted = formatter_1.LogFormatter.format(types_1.LogLevel.DEBUG, message, processedData);
+            console.log(formatted);
+        }
+    }
+    /**
+     * Log an informational message with INFO level formatting
+     * Uses console.log for output with blue coloring
+     * Automatically redacts sensitive data when provided
+     * @param message - The info message to log
+     * @param data - Optional data object to log (will be redacted)
+     */
+    info(message, data) {
+        if (this.shouldLog(types_1.LogLevel.INFO)) {
+            const processedData = redaction_1.DataRedactor.redactData(data);
+            const formatted = formatter_1.LogFormatter.format(types_1.LogLevel.INFO, message, processedData);
+            console.log(formatted);
+        }
+    }
+    /**
+     * Log a warning message with WARN level formatting
+     * Uses console.warn for output with yellow coloring
+     * Automatically redacts sensitive data when provided
+     * @param message - The warning message to log
+     * @param data - Optional data object to log (will be redacted)
+     */
+    warn(message, data) {
+        if (this.shouldLog(types_1.LogLevel.WARN)) {
+            const processedData = redaction_1.DataRedactor.redactData(data);
+            const formatted = formatter_1.LogFormatter.format(types_1.LogLevel.WARN, message, processedData);
+            console.warn(formatted);
+        }
+    }
+    /**
+     * Log an error message with ERROR level formatting
+     * Uses console.error for output with red coloring
+     * Automatically redacts sensitive data when provided
+     * @param message - The error message to log
+     * @param data - Optional data object to log (will be redacted)
+     */
+    error(message, data) {
+        if (this.shouldLog(types_1.LogLevel.ERROR)) {
+            const processedData = redaction_1.DataRedactor.redactData(data);
+            const formatted = formatter_1.LogFormatter.format(types_1.LogLevel.ERROR, message, processedData);
+            console.error(formatted);
+        }
+    }
+    /**
+     * Log a message with LOG level formatting (always outputs unless mode is OFF)
+     * Uses console.log for output with green coloring
+     * LOG level bypasses normal filtering and always outputs (except when OFF is set)
+     * Automatically redacts sensitive data when provided
+     * @param message - The log message to output
+     * @param data - Optional data object to log (will be redacted)
+     */
+    log(message, data) {
+        if (this.shouldLog(types_1.LogLevel.LOG)) {
+            const processedData = redaction_1.DataRedactor.redactData(data);
+            const formatted = formatter_1.LogFormatter.format(types_1.LogLevel.LOG, message, processedData);
+            console.log(formatted);
+        }
+    }
+    // Raw logging methods (bypass redaction for debugging)
+    /**
+     * Log a debug message without data redaction
+     * @param message - The debug message to log
+     * @param data - Optional data object to log (no redaction applied)
+     */
+    debugRaw(message, data) {
+        if (this.shouldLog(types_1.LogLevel.DEBUG)) {
+            const formatted = formatter_1.LogFormatter.format(types_1.LogLevel.DEBUG, message, data);
+            console.log(formatted);
+        }
+    }
+    /**
+     * Log an info message without data redaction
+     * @param message - The info message to log
+     * @param data - Optional data object to log (no redaction applied)
+     */
+    infoRaw(message, data) {
+        if (this.shouldLog(types_1.LogLevel.INFO)) {
+            const formatted = formatter_1.LogFormatter.format(types_1.LogLevel.INFO, message, data);
+            console.log(formatted);
+        }
+    }
+    /**
+     * Log a warning message without data redaction
+     * @param message - The warning message to log
+     * @param data - Optional data object to log (no redaction applied)
+     */
+    warnRaw(message, data) {
+        if (this.shouldLog(types_1.LogLevel.WARN)) {
+            const formatted = formatter_1.LogFormatter.format(types_1.LogLevel.WARN, message, data);
+            console.warn(formatted);
+        }
+    }
+    /**
+     * Log an error message without data redaction
+     * @param message - The error message to log
+     * @param data - Optional data object to log (no redaction applied)
+     */
+    errorRaw(message, data) {
+        if (this.shouldLog(types_1.LogLevel.ERROR)) {
+            const formatted = formatter_1.LogFormatter.format(types_1.LogLevel.ERROR, message, data);
+            console.error(formatted);
+        }
+    }
+    /**
+     * Log a message without data redaction (always outputs unless mode is OFF)
+     * @param message - The log message to output
+     * @param data - Optional data object to log (no redaction applied)
+     */
+    logRaw(message, data) {
+        if (this.shouldLog(types_1.LogLevel.LOG)) {
+            const formatted = formatter_1.LogFormatter.format(types_1.LogLevel.LOG, message, data);
+            console.log(formatted);
+        }
+    }
+}
+exports.Logger = Logger;

package/dist/logger/environment.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Environment detection utilities for logging configuration
+ * Handles automatic environment-based configuration
+ */
+import { LogMode } from '../types';
+/**
+ * Environment detection and configuration utilities
+ */
+export declare class EnvironmentDetector {
+    /**
+     * Get the normalized NODE_ENV value
+     * @returns Normalized NODE_ENV (trimmed and lowercase)
+     */
+    private static getNormalizedNodeEnv;
+    /**
+     * Determines the appropriate log mode based on NODE_ENV
+     * @returns LogMode appropriate for current environment
+     */
+    static getEnvironmentMode(): LogMode;
+    /**
+     * Check if we're in a test environment
+     * @returns true if NODE_ENV is 'test'
+     */
+    static isTestEnvironment(): boolean;
+    /**
+     * Check if we're in a development environment
+     * @returns true if NODE_ENV is 'development'
+     */
+    static isDevelopmentEnvironment(): boolean;
+    /**
+     * Check if we're in a production environment
+     * @returns true if NODE_ENV is 'production'
+     */
+    static isProductionEnvironment(): boolean;
+}
+//# sourceMappingURL=environment.d.ts.map

package/dist/logger/environment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"environment.d.ts","sourceRoot":"","sources":["../../src/logger/environment.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAEnC;;GAEG;AACH,qBAAa,mBAAmB;IAC5B;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,oBAAoB;IAInC;;;OAGG;IACH,MAAM,CAAC,kBAAkB,IAAI,OAAO;IAiBpC;;;OAGG;IACH,MAAM,CAAC,iBAAiB,IAAI,OAAO;IAInC;;;OAGG;IACH,MAAM,CAAC,wBAAwB,IAAI,OAAO;IAI1C;;;OAGG;IACH,MAAM,CAAC,uBAAuB,IAAI,OAAO;CAG5C"}

package/dist/logger/environment.js

@@ -0,0 +1,61 @@
+"use strict";
+/**
+ * Environment detection utilities for logging configuration
+ * Handles automatic environment-based configuration
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvironmentDetector = void 0;
+const types_1 = require("../types");
+/**
+ * Environment detection and configuration utilities
+ */
+class EnvironmentDetector {
+    /**
+     * Get the normalized NODE_ENV value
+     * @returns Normalized NODE_ENV (trimmed and lowercase)
+     */
+    static getNormalizedNodeEnv() {
+        return (process.env.NODE_ENV || '').trim().toLowerCase();
+    }
+    /**
+     * Determines the appropriate log mode based on NODE_ENV
+     * @returns LogMode appropriate for current environment
+     */
+    static getEnvironmentMode() {
+        const nodeEnv = EnvironmentDetector.getNormalizedNodeEnv();
+        switch (nodeEnv) {
+            case 'development':
+                return types_1.LogMode.DEBUG; // Verbose logging for development
+            case 'production':
+                return types_1.LogMode.INFO; // Important info and above for production
+            case 'staging':
+                return types_1.LogMode.WARN; // Focused logging for staging
+            case 'test':
+                return types_1.LogMode.ERROR; // Minimal logging during tests
+            default:
+                return types_1.LogMode.INFO; // Default fallback for unknown environments
+        }
+    }
+    /**
+     * Check if we're in a test environment
+     * @returns true if NODE_ENV is 'test'
+     */
+    static isTestEnvironment() {
+        return EnvironmentDetector.getNormalizedNodeEnv() === 'test';
+    }
+    /**
+     * Check if we're in a development environment
+     * @returns true if NODE_ENV is 'development'
+     */
+    static isDevelopmentEnvironment() {
+        return EnvironmentDetector.getNormalizedNodeEnv() === 'development';
+    }
+    /**
+     * Check if we're in a production environment
+     * @returns true if NODE_ENV is 'production'
+     */
+    static isProductionEnvironment() {
+        return EnvironmentDetector.getNormalizedNodeEnv() === 'production';
+    }
+}
+exports.EnvironmentDetector = EnvironmentDetector;

package/dist/logger/filtering.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Log level and mode filtering logic
+ * Handles the decision logic for whether messages should be logged
+ */
+import { LogLevel, LogMode } from '../types';
+/**
+ * Filtering logic for log messages based on levels and modes
+ * Determines whether a message should be output based on current configuration
+ */
+export declare class LogFilter {
+    private static readonly SEVERITY_RANKS;
+    private static readonly MODE_THRESHOLDS;
+    /**
+     * Determines if a message should be logged based on current log mode
+     * Messages are shown only if their level is appropriate for the configured mode
+     * LOG level is special - it always outputs regardless of configured mode (except when OFF is set)
+     * OFF mode disables all logging including LOG level messages
+     * @param level - The log level of the message to check
+     * @param currentMode - The current logging mode
+     * @returns true if message should be logged, false otherwise
+     */
+    static shouldLog(level: LogLevel, currentMode: LogMode): boolean;
+    /**
+     * Get the severity rank for a log level
+     * @param level - The log level to get rank for
+     * @returns Numeric severity rank
+     */
+    static getSeverityRank(level: LogLevel): number;
+    /**
+     * Get the threshold for a log mode
+     * @param mode - The log mode to get threshold for
+     * @returns Numeric threshold value
+     */
+    static getModeThreshold(mode: LogMode): number;
+}
+//# sourceMappingURL=filtering.d.ts.map

package/dist/logger/filtering.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filtering.d.ts","sourceRoot":"","sources":["../../src/logger/filtering.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAE7C;;;GAGG;AACH,qBAAa,SAAS;IAElB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,cAAc,CAMpC;IAGF,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,eAAe,CAOrC;IAEF;;;;;;;;OAQG;IACH,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,QAAQ,EAAE,WAAW,EAAE,OAAO,GAAG,OAAO;IAWhE;;;;OAIG;IACH,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM;IAI/C;;;;OAIG;IACH,MAAM,CAAC,gBAAgB,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM;CAGjD"}

package/dist/logger/filtering.js

@@ -0,0 +1,65 @@
+"use strict";
+/**
+ * Log level and mode filtering logic
+ * Handles the decision logic for whether messages should be logged
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogFilter = void 0;
+const types_1 = require("../types");
+/**
+ * Filtering logic for log messages based on levels and modes
+ * Determines whether a message should be output based on current configuration
+ */
+class LogFilter {
+    /**
+     * Determines if a message should be logged based on current log mode
+     * Messages are shown only if their level is appropriate for the configured mode
+     * LOG level is special - it always outputs regardless of configured mode (except when OFF is set)
+     * OFF mode disables all logging including LOG level messages
+     * @param level - The log level of the message to check
+     * @param currentMode - The current logging mode
+     * @returns true if message should be logged, false otherwise
+     */
+    static shouldLog(level, currentMode) {
+        // Get the severity rank for the message level
+        const messageSeverity = this.SEVERITY_RANKS[level];
+        // Get the minimum severity threshold for the current mode
+        const modeThreshold = this.MODE_THRESHOLDS[currentMode];
+        // Allow the message if its severity meets or exceeds the mode threshold
+        return messageSeverity >= modeThreshold;
+    }
+    /**
+     * Get the severity rank for a log level
+     * @param level - The log level to get rank for
+     * @returns Numeric severity rank
+     */
+    static getSeverityRank(level) {
+        return this.SEVERITY_RANKS[level];
+    }
+    /**
+     * Get the threshold for a log mode
+     * @param mode - The log mode to get threshold for
+     * @returns Numeric threshold value
+     */
+    static getModeThreshold(mode) {
+        return this.MODE_THRESHOLDS[mode];
+    }
+}
+exports.LogFilter = LogFilter;
+// Maps LogLevel values to severity ranks for consistent comparison
+LogFilter.SEVERITY_RANKS = {
+    [types_1.LogLevel.DEBUG]: 0,
+    [types_1.LogLevel.INFO]: 1,
+    [types_1.LogLevel.WARN]: 2,
+    [types_1.LogLevel.ERROR]: 3,
+    [types_1.LogLevel.LOG]: 99 // Special case - always outputs (except when OFF)
+};
+// Maps LogMode values to minimum severity rank required for output
+LogFilter.MODE_THRESHOLDS = {
+    [types_1.LogMode.DEBUG]: 0, // Shows DEBUG and above
+    [types_1.LogMode.INFO]: 1, // Shows INFO and above
+    [types_1.LogMode.WARN]: 2, // Shows WARN and above
+    [types_1.LogMode.ERROR]: 3, // Shows ERROR and above
+    [types_1.LogMode.SILENT]: 99, // Only shows LOG messages
+    [types_1.LogMode.OFF]: 100 // Shows nothing
+};

package/dist/logger/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Logger module exports
+ * Provides centralized access to all logging functionality
+ */
+export { Logger } from './core';
+export { LoggerConfigManager } from './config';
+export { LogFilter } from './filtering';
+export { EnvironmentDetector } from './environment';
+export { Logger as CoreLogger } from './core';
+//# sourceMappingURL=index.d.ts.map

package/dist/logger/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/logger/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAC/C,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAGpD,OAAO,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,QAAQ,CAAC"}

package/dist/logger/index.js

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * Logger module exports
+ * Provides centralized access to all logging functionality
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoreLogger = exports.EnvironmentDetector = exports.LogFilter = exports.LoggerConfigManager = exports.Logger = void 0;
+var core_1 = require("./core");
+Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return core_1.Logger; } });
+var config_1 = require("./config");
+Object.defineProperty(exports, "LoggerConfigManager", { enumerable: true, get: function () { return config_1.LoggerConfigManager; } });
+var filtering_1 = require("./filtering");
+Object.defineProperty(exports, "LogFilter", { enumerable: true, get: function () { return filtering_1.LogFilter; } });
+var environment_1 = require("./environment");
+Object.defineProperty(exports, "EnvironmentDetector", { enumerable: true, get: function () { return environment_1.EnvironmentDetector; } });
+// Backward compatibility - maintain the original Logger class interface
+var core_2 = require("./core");
+Object.defineProperty(exports, "CoreLogger", { enumerable: true, get: function () { return core_2.Logger; } });

package/dist/logger.d.ts

@@ -3,6 +3,7 @@
  * Supports DEBUG, INFO, WARN, ERROR, and LOG levels with intelligent filtering
  * LOG level always outputs regardless of configuration
  * Uses colorized console output with timestamps for better readability
+ * Includes automatic data redaction for sensitive information
  */
 import { LoggerConfig } from './types';
 /**
@@ -11,10 +12,20 @@ import { LoggerConfig } from './types';
  */
 export declare class Logger {
     private config;
+    /**
+     * Logger constructor - sets up environment-based auto-configuration
+     */
+    constructor();
+    /**
+     * Determines the appropriate log mode based on NODE_ENV
+     * @returns LogMode appropriate for current environment
+     */
+    private getEnvironmentMode;
     /**
      * Updates logger configuration with new settings
      * Merges provided config with existing settings (partial update)
      * Supports backwards compatibility by mapping level to mode with deprecation warnings
+     * Also updates redaction configuration based on environment
      * @param config - Partial configuration object to apply
      */
     configure(config: Partial<LoggerConfig>): void;
@@ -40,33 +51,78 @@ export declare class Logger {
     /**
      * Log a debug message with DEBUG level formatting
      * Uses console.log for output with purple/magenta coloring
+     * Automatically redacts sensitive data when provided
      * @param message - The debug message to log
+     * @param data - Optional data object to log (will be redacted)
      */
-    debug(message: string): void;
+    debug(message: string, data?: any): void;
     /**
      * Log an informational message with INFO level formatting
      * Uses console.log for output with blue coloring
+     * Automatically redacts sensitive data when provided
      * @param message - The info message to log
+     * @param data - Optional data object to log (will be redacted)
      */
-    info(message: string): void;
+    info(message: string, data?: any): void;
     /**
      * Log a warning message with WARN level formatting
      * Uses console.warn for output with yellow coloring
+     * Automatically redacts sensitive data when provided
      * @param message - The warning message to log
+     * @param data - Optional data object to log (will be redacted)
      */
-    warn(message: string): void;
+    warn(message: string, data?: any): void;
     /**
      * Log an error message with ERROR level formatting
      * Uses console.error for output with red coloring
+     * Automatically redacts sensitive data when provided
      * @param message - The error message to log
+     * @param data - Optional data object to log (will be redacted)
      */
-    error(message: string): void;
+    error(message: string, data?: any): void;
     /**
      * Log a critical message that always outputs (LOG level)
      * Uses console.log for output with green coloring
      * Always shown regardless of configured log level
+     * Automatically redacts sensitive data when provided
+     * @param message - The critical log message to log
+     * @param data - Optional data object to log (will be redacted)
+     */
+    log(message: string, data?: any): void;
+    /**
+     * Log a debug message without redaction (use with caution)
+     * Bypasses automatic data redaction for debugging purposes
+     * @param message - The debug message to log
+     * @param data - Optional data object to log (no redaction applied)
+     */
+    debugRaw(message: string, data?: any): void;
+    /**
+     * Log an info message without redaction (use with caution)
+     * Bypasses automatic data redaction for debugging purposes
+     * @param message - The info message to log
+     * @param data - Optional data object to log (no redaction applied)
+     */
+    infoRaw(message: string, data?: any): void;
+    /**
+     * Log a warning message without redaction (use with caution)
+     * Bypasses automatic data redaction for debugging purposes
+     * @param message - The warning message to log
+     * @param data - Optional data object to log (no redaction applied)
+     */
+    warnRaw(message: string, data?: any): void;
+    /**
+     * Log an error message without redaction (use with caution)
+     * Bypasses automatic data redaction for debugging purposes
+     * @param message - The error message to log
+     * @param data - Optional data object to log (no redaction applied)
+     */
+    errorRaw(message: string, data?: any): void;
+    /**
+     * Log a critical message without redaction (use with caution)
+     * Bypasses automatic data redaction for debugging purposes
      * @param message - The critical log message to log
+     * @param data - Optional data object to log (no redaction applied)
      */
-    log(message: string): void;
+    logRaw(message: string, data?: any): void;
 }
 //# sourceMappingURL=logger.d.ts.map

package/dist/logger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAqB,YAAY,EAAE,MAAM,SAAS,CAAC;AAG1D;;;GAGG;AACH,qBAAa,MAAM;IAEf,OAAO,CAAC,MAAM,CAEZ;IAEF;;;;;OAKG;IACH,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC,YAAY,CAAC,GAAG,IAAI;IAmC9C;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,cAAc,CAMpC;IAEF;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,eAAe,CAOrC;IAEF;;;;;;;OAOG;IACH,OAAO,CAAC,SAAS;IAajB;;;;OAIG;IACH,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAO5B;;;;OAIG;IACH,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAO3B;;;;OAIG;IACH,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAO3B;;;;OAIG;IACH,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAO5B;;;;;OAKG;IACH,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;CAM7B"}
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAqB,YAAY,EAAE,MAAM,SAAS,CAAC;AAI1D;;;GAGG;AACH,qBAAa,MAAM;IAEf,OAAO,CAAC,MAAM,CAEZ;IAEF;;OAEG;;IAMH;;;OAGG;IACH,OAAO,CAAC,kBAAkB;IAiB1B;;;;;;OAMG;IACH,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC,YAAY,CAAC,GAAG,IAAI;IAyC9C;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,cAAc,CAMpC;IAEF;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,eAAe,CAOrC;IAEF;;;;;;;OAOG;IACH,OAAO,CAAC,SAAS;IAajB;;;;;;OAMG;IACH,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,GAAG,IAAI;IAQxC;;;;;;OAMG;IACH,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,GAAG,IAAI;IAQvC;;;;;;OAMG;IACH,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,GAAG,IAAI;IAQvC;;;;;;OAMG;IACH,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,GAAG,IAAI;IAQxC;;;;;;;OAOG;IACH,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,GAAG,IAAI;IAQtC;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,GAAG,IAAI;IAO3C;;;;;OAKG;IACH,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,GAAG,IAAI;IAO1C;;;;;OAKG;IACH,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,GAAG,IAAI;IAO1C;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,GAAG,IAAI;IAO3C;;;;;OAKG;IACH,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,GAAG,IAAI;CAM5C"}