@wgtechlabs/log-engine 1.2.1 → 2.0.0

package/dist/index.js

@@ -1,117 +1,201 @@
 "use strict";
 /**
- * Main entry point for the Log Engine library
- * Provides a simple, configurable logging interface with environment-based auto-configuration
+ * Main LogEngine module - provides a comprehensive logging solution
+ * with mode-based filtering, colorized output, and automatic data redaction
+ *
+ * Features a modular architecture with separate modules for:
+ * - Logger: Core logging functionality with environment-based configuration
+ * - Formatter: Message formatting with ANSI colors and timestamps
+ * - Redaction: Automatic sensitive data protection with customizable patterns
+ *
+ * @example
+ * ```typescript
+ * import { LogEngine, LogMode } from '@wgtechlabs/log-engine';
+ *
+ * // Configure logging mode
+ * LogEngine.configure({ mode: LogMode.DEBUG });
+ *
+ * // Log with automatic redaction
+ * LogEngine.info('User login', { username: 'john', password: 'secret123' });
+ * // Output: [2025-06-18T...][3:45PM][INFO]: User login { username: 'john', password: '[REDACTED]' }
+ * ```
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LogMode = exports.LogLevel = exports.LogEngine = void 0;
+exports.RedactionController = exports.defaultRedactionConfig = exports.DataRedactor = exports.LogLevel = exports.LogMode = exports.LogEngine = void 0;
 const logger_1 = require("./logger");
-const types_1 = require("./types");
-// Create singleton logger instance
+const redaction_1 = require("./redaction");
+// Create a singleton logger instance
 const logger = new logger_1.Logger();
 /**
- * Determines the appropriate default log mode based on NODE_ENV
- * - development: DEBUG (most verbose - shows all messages)
- * - production: INFO (balanced - shows info, warn, error, log)
- * - staging: WARN (focused - shows warn, error, log only)
- * - test: ERROR (minimal - shows error and log only)
- * - default: INFO (balanced logging for other environments)
- * @returns The appropriate LogMode for the current environment
- */
-const getDefaultLogMode = () => {
-    const nodeEnv = process.env.NODE_ENV;
-    switch (nodeEnv) {
-        case 'development':
-            return types_1.LogMode.DEBUG;
-        case 'production':
-            return types_1.LogMode.INFO;
-        case 'staging':
-            return types_1.LogMode.WARN;
-        case 'test':
-            return types_1.LogMode.ERROR;
-        default:
-            return types_1.LogMode.INFO;
-    }
-};
-// Initialize logger with environment-appropriate default mode
-logger.configure({ mode: getDefaultLogMode() });
-/**
- * Main LogEngine API - provides all logging functionality with a clean interface
- * Auto-configured based on NODE_ENV, but can be reconfigured at runtime
+ * LogEngine - The main interface for logging operations
+ * Provides a simple, intuitive API for all logging needs with security-first design
  */
 exports.LogEngine = {
     /**
-     * Configure the logger with custom settings
-     * @param config - Partial configuration object containing level and/or environment
+     * Configure the logger with new settings
+     * @param config - Configuration object containing logger settings
      * @example
      * ```typescript
-     * LogEngine.configure({ level: LogLevel.DEBUG });
-     * LogEngine.configure({ level: LogLevel.WARN, environment: 'staging' });
+     * LogEngine.configure({ mode: LogMode.PRODUCTION });
      * ```
      */
     configure: (config) => logger.configure(config),
+    // Standard logging methods with automatic redaction
     /**
-     * Log a debug message (lowest priority)
-     * Only shown when log level is DEBUG or lower
-     * Useful for detailed diagnostic information during development
+     * Log a debug message with automatic data redaction
+     * Only shown in DEVELOPMENT mode
      * @param message - The debug message to log
+     * @param data - Optional data object to log (sensitive data will be redacted)
      * @example
      * ```typescript
-     * LogEngine.debug('User authentication flow started');
-     * LogEngine.debug(`Processing ${items.length} items`);
+     * LogEngine.debug('Processing user data', { userId: 123, email: 'user@example.com' });
      * ```
      */
-    debug: (message) => logger.debug(message),
+    debug: (message, data) => logger.debug(message, data),
     /**
-     * Log an informational message
-     * General information about application flow and state
-     * Shown when log level is INFO or lower
+     * Log an info message with automatic data redaction
+     * Shown in DEVELOPMENT and PRODUCTION modes
      * @param message - The info message to log
+     * @param data - Optional data object to log (sensitive data will be redacted)
      * @example
      * ```typescript
-     * LogEngine.info('Application started successfully');
-     * LogEngine.info('User logged in: john@example.com');
+     * LogEngine.info('User login successful', { username: 'john' });
      * ```
      */
-    info: (message) => logger.info(message),
+    info: (message, data) => logger.info(message, data),
     /**
-     * Log a warning message
-     * Indicates potential issues that don't prevent operation
-     * Shown when log level is WARN or lower
+     * Log a warning message with automatic data redaction
+     * Shown in DEVELOPMENT and PRODUCTION modes
      * @param message - The warning message to log
+     * @param data - Optional data object to log (sensitive data will be redacted)
      * @example
      * ```typescript
-     * LogEngine.warn('API rate limit approaching');
-     * LogEngine.warn('Deprecated function called');
+     * LogEngine.warn('API rate limit approaching', { requestsRemaining: 10 });
      * ```
      */
-    warn: (message) => logger.warn(message),
+    warn: (message, data) => logger.warn(message, data),
     /**
-     * Log an error message (highest priority)
-     * Indicates serious problems that need attention
-     * Always shown unless log level is SILENT
+     * Log an error message with automatic data redaction
+     * Shown in DEVELOPMENT and PRODUCTION modes
      * @param message - The error message to log
+     * @param data - Optional data object to log (sensitive data will be redacted)
      * @example
      * ```typescript
-     * LogEngine.error('Database connection failed');
-     * LogEngine.error('Authentication token expired');
+     * LogEngine.error('Database connection failed', { host: 'localhost', port: 5432 });
      * ```
      */
-    error: (message) => logger.error(message),
+    error: (message, data) => logger.error(message, data),
     /**
-     * Log a critical message that always outputs
-     * Essential messages that should always be visible regardless of log mode
-     * Always shown no matter what log mode is configured (except OFF mode)
+     * Log a critical message with automatic data redaction
+     * Always shown regardless of mode (except OFF)
      * @param message - The critical log message to log
+     * @param data - Optional data object to log (sensitive data will be redacted)
+     * @example
+     * ```typescript
+     * LogEngine.log('Application starting', { version: '1.0.0' });
+     * ```
+     */
+    log: (message, data) => logger.log(message, data),
+    // Raw methods that bypass redaction (use with caution)
+    /**
+     * 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, data) => logger.debugRaw(message, data),
+    /**
+     * 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, data) => logger.infoRaw(message, data),
+    /**
+     * 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, data) => logger.warnRaw(message, data),
+    /**
+     * 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, data) => logger.errorRaw(message, data),
+    /**
+     * 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)
+     */
+    logRaw: (message, data) => logger.logRaw(message, data),
+    // Redaction configuration methods
+    /**
+     * Configure data redaction settings
+     * @param config - Partial redaction configuration to apply
+     */
+    configureRedaction: (config) => redaction_1.DataRedactor.updateConfig(config),
+    /**
+     * Refresh redaction configuration from environment variables
+     * Useful for picking up runtime environment changes
+     */
+    refreshRedactionConfig: () => redaction_1.DataRedactor.refreshConfig(),
+    /**
+     * Reset redaction configuration to defaults
+     */
+    resetRedactionConfig: () => redaction_1.DataRedactor.updateConfig(redaction_1.defaultRedactionConfig),
+    /**
+     * Get current redaction configuration
+     * @returns Current redaction configuration
+     */
+    getRedactionConfig: () => redaction_1.DataRedactor.getConfig(),
+    // Advanced redaction methods (Phase 3)
+    /**
+     * Add custom regex patterns for advanced field detection
+     * @param patterns - Array of regex patterns to add
+     */
+    addCustomRedactionPatterns: (patterns) => redaction_1.DataRedactor.addCustomPatterns(patterns),
+    /**
+     * Clear all custom redaction patterns
+     */
+    clearCustomRedactionPatterns: () => redaction_1.DataRedactor.clearCustomPatterns(),
+    /**
+     * Add custom sensitive field names to the existing list
+     * @param fields - Array of field names to add
+     */
+    addSensitiveFields: (fields) => redaction_1.DataRedactor.addSensitiveFields(fields),
+    /**
+     * Test if a field name would be redacted with current configuration
+     * @param fieldName - Field name to test
+     * @returns true if field would be redacted, false otherwise
+     */
+    testFieldRedaction: (fieldName) => redaction_1.DataRedactor.testFieldRedaction(fieldName),
+    /**
+     * Temporarily disable redaction for a specific logging call
+     * @returns LogEngine instance with redaction bypassed
      * @example
      * ```typescript
-     * LogEngine.log('Application starting up');
-     * LogEngine.log('Server listening on port 3000');
-     * LogEngine.log('Graceful shutdown initiated');
+     * LogEngine.withoutRedaction().info('Debug data', sensitiveObject);
      * ```
      */
-    log: (message) => logger.log(message)
+    withoutRedaction: () => ({
+        debug: (message, data) => logger.debugRaw(message, data),
+        info: (message, data) => logger.infoRaw(message, data),
+        warn: (message, data) => logger.warnRaw(message, data),
+        error: (message, data) => logger.errorRaw(message, data),
+        log: (message, data) => logger.logRaw(message, data)
+    })
 };
-var types_2 = require("./types");
-Object.defineProperty(exports, "LogLevel", { enumerable: true, get: function () { return types_2.LogLevel; } });
-Object.defineProperty(exports, "LogMode", { enumerable: true, get: function () { return types_2.LogMode; } });
+// Re-export types and utilities for external use
+var types_1 = require("./types");
+Object.defineProperty(exports, "LogMode", { enumerable: true, get: function () { return types_1.LogMode; } });
+Object.defineProperty(exports, "LogLevel", { enumerable: true, get: function () { return types_1.LogLevel; } });
+var redaction_2 = require("./redaction");
+Object.defineProperty(exports, "DataRedactor", { enumerable: true, get: function () { return redaction_2.DataRedactor; } });
+Object.defineProperty(exports, "defaultRedactionConfig", { enumerable: true, get: function () { return redaction_2.defaultRedactionConfig; } });
+Object.defineProperty(exports, "RedactionController", { enumerable: true, get: function () { return redaction_2.RedactionController; } });
+// Default export for convenience
+exports.default = exports.LogEngine;

package/dist/logger/config.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Logger configuration management
+ * Handles logger settings and configuration updates
+ */
+import { LoggerConfig } from '../types';
+/**
+ * Configuration manager for logger settings
+ * Handles configuration validation, updates, and backward compatibility
+ */
+export declare class LoggerConfigManager {
+    private config;
+    constructor();
+    /**
+     * Get current configuration
+     * @returns Current logger configuration
+     */
+    getConfig(): LoggerConfig;
+    /**
+     * 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
+     * @param config - Partial configuration object to apply
+     */
+    updateConfig(config: Partial<LoggerConfig>): void;
+    /**
+     * Handle legacy level-based configuration with deprecation warnings
+     * @param config - Configuration containing legacy level property
+     */
+    private handleLegacyLevelConfig;
+    /**
+     * Map legacy LogLevel values to LogMode values
+     * @param levelValue - Legacy level value
+     * @returns Corresponding LogMode or undefined if invalid
+     */
+    private mapLevelToMode;
+    /**
+     * Create deprecation warning message using LogFormatter
+     * Outputs formatted deprecation warning messages to console
+     */
+    private createDeprecationWarning;
+}
+//# sourceMappingURL=config.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/logger/config.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,YAAY,EAAqB,MAAM,UAAU,CAAC;AAG3D;;;GAGG;AACH,qBAAa,mBAAmB;IAC5B,OAAO,CAAC,MAAM,CAAe;;IAS7B;;;OAGG;IACH,SAAS,IAAI,YAAY;IAIzB;;;;;OAKG;IACH,YAAY,CAAC,MAAM,EAAE,OAAO,CAAC,YAAY,CAAC,GAAG,IAAI;IAgBjD;;;OAGG;IACH,OAAO,CAAC,uBAAuB;IAqB/B;;;;OAIG;IACH,OAAO,CAAC,cAAc;IActB;;;OAGG;IACH,OAAO,CAAC,wBAAwB;CAQnC"}

package/dist/logger/config.js

@@ -0,0 +1,101 @@
+"use strict";
+/**
+ * Logger configuration management
+ * Handles logger settings and configuration updates
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerConfigManager = void 0;
+const types_1 = require("../types");
+const environment_1 = require("./environment");
+/**
+ * Configuration manager for logger settings
+ * Handles configuration validation, updates, and backward compatibility
+ */
+class LoggerConfigManager {
+    constructor() {
+        // Set initial configuration with environment-based auto-configuration
+        this.config = {
+            mode: environment_1.EnvironmentDetector.getEnvironmentMode()
+        };
+    }
+    /**
+     * Get current configuration
+     * @returns Current logger configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * 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
+     * @param config - Partial configuration object to apply
+     */
+    updateConfig(config) {
+        // Handle backwards compatibility - if level is provided but mode is not
+        if (config.level !== undefined && config.mode === undefined) {
+            this.handleLegacyLevelConfig(config);
+        }
+        else {
+            // Normal configuration update
+            // If mode is present, remove legacy level property to avoid conflicts
+            if (config.mode !== undefined && config.level !== undefined) {
+                const { level, ...configWithoutLevel } = config;
+                this.config = { ...this.config, ...configWithoutLevel };
+            }
+            else {
+                this.config = { ...this.config, ...config };
+            }
+        }
+    }
+    /**
+     * Handle legacy level-based configuration with deprecation warnings
+     * @param config - Configuration containing legacy level property
+     */
+    handleLegacyLevelConfig(config) {
+        // Map legacy level values to new LogMode values and validate first
+        const levelValue = config.level;
+        const mappedMode = this.mapLevelToMode(levelValue);
+        // Fail fast if the level value is invalid
+        if (mappedMode === undefined) {
+            throw new Error(`Invalid LogLevel value: ${config.level}. Valid values are: DEBUG(0), INFO(1), WARN(2), ERROR(3), LOG(99), or use LogMode instead.`);
+        }
+        // Only show deprecation warning after confirming the level is valid and in non-test environments
+        if (!environment_1.EnvironmentDetector.isTestEnvironment()) {
+            this.createDeprecationWarning();
+        }
+        // Merge existing config with all keys from the passed config, and override mode with mapped value
+        // Remove the legacy 'level' property to avoid conflicts with the new 'mode' property
+        const { level, ...configWithoutLevel } = config;
+        this.config = { ...this.config, ...configWithoutLevel, mode: mappedMode };
+    }
+    /**
+     * Map legacy LogLevel values to LogMode values
+     * @param levelValue - Legacy level value
+     * @returns Corresponding LogMode or undefined if invalid
+     */
+    mapLevelToMode(levelValue) {
+        const levelToModeMap = {
+            [types_1.LogLevel.DEBUG]: types_1.LogMode.DEBUG, // 0 -> 0
+            [types_1.LogLevel.INFO]: types_1.LogMode.INFO, // 1 -> 1
+            [types_1.LogLevel.WARN]: types_1.LogMode.WARN, // 2 -> 2
+            [types_1.LogLevel.ERROR]: types_1.LogMode.ERROR, // 3 -> 3
+            [types_1.LogLevel.LOG]: types_1.LogMode.SILENT, // 99 -> 4 (preserves critical-only behavior)
+            4: types_1.LogMode.SILENT, // Legacy SILENT -> 4
+            5: types_1.LogMode.OFF // Legacy OFF -> 5
+        };
+        return levelToModeMap[levelValue];
+    }
+    /**
+     * Create deprecation warning message using LogFormatter
+     * Outputs formatted deprecation warning messages to console
+     */
+    createDeprecationWarning() {
+        // Import LogFormatter to format system messages properly
+        const { LogFormatter } = require('../formatter');
+        console.warn(LogFormatter.formatSystemMessage('⚠️  DEPRECATION WARNING: The "level" configuration is deprecated and will be removed in v2.0.0. Please use "mode" instead.'));
+        console.warn(LogFormatter.formatSystemMessage('   Migration: LogEngine.configure({ level: LogLevel.DEBUG }) → LogEngine.configure({ mode: LogMode.DEBUG })'));
+        console.warn(LogFormatter.formatSystemMessage('   See: https://github.com/wgtechlabs/log-engine#migration-guide-loglevel--logmode'));
+    }
+}
+exports.LoggerConfigManager = LoggerConfigManager;

package/dist/logger/core.d.ts

@@ -0,0 +1,108 @@
+/**
+ * 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
+ */
+import { LoggerConfig } from '../types';
+/**
+ * Logger class responsible for managing log output and configuration
+ * Provides mode-based filtering and formatted console output
+ */
+export declare class Logger {
+    private configManager;
+    /**
+     * Logger constructor - sets up environment-based auto-configuration
+     */
+    constructor();
+    /**
+     * Updates logger configuration with new settings
+     * Also updates redaction configuration based on environment
+     * @param config - Partial configuration object to apply
+     */
+    configure(config: Partial<LoggerConfig>): void;
+    /**
+     * Get current logger configuration
+     * @returns Current logger configuration
+     */
+    getConfig(): LoggerConfig;
+    /**
+     * 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
+     */
+    private shouldLog;
+    /**
+     * 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, 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, 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, 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, data?: any): void;
+    /**
+     * 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: string, data?: any): void;
+    /**
+     * 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: string, data?: any): void;
+    /**
+     * 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: string, data?: any): void;
+    /**
+     * 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: string, data?: any): void;
+    /**
+     * 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: string, data?: any): void;
+    /**
+     * 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: string, data?: any): void;
+}
+//# sourceMappingURL=core.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../src/logger/core.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAqB,YAAY,EAAE,MAAM,UAAU,CAAC;AAM3D;;;GAGG;AACH,qBAAa,MAAM;IACf,OAAO,CAAC,aAAa,CAAsB;IAE3C;;OAEG;;IAKH;;;;OAIG;IACH,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC,YAAY,CAAC,GAAG,IAAI;IAU9C;;;OAGG;IACH,SAAS,IAAI,YAAY;IAIzB;;;;OAIG;IACH,OAAO,CAAC,SAAS;IAMjB;;;;;;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;IAStC;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,GAAG,IAAI;IAO3C;;;;OAIG;IACH,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,GAAG,IAAI;IAO1C;;;;OAIG;IACH,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,GAAG,IAAI;IAO1C;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,GAAG,IAAI;IAO3C;;;;OAIG;IACH,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,GAAG,IAAI;CAM5C"}