@wgtechlabs/log-engine 2.0.0 → 2.1.0

package/dist/logger/core.js

@@ -13,22 +13,146 @@ const formatter_1 = require("../formatter");
 const redaction_1 = require("../redaction");
 const config_1 = require("./config");
 const filtering_1 = require("./filtering");
+const advanced_outputs_1 = require("./advanced-outputs");
 /**
  * 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
-     */
+       * 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
-     */
+       * Built-in output handlers for common use cases
+       */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    getBuiltInHandler(type, config) {
+        switch (type) {
+            case 'console':
+                return (level, message, data) => {
+                    // Use appropriate console method based on level
+                    if (level === 'error') {
+                        if (data !== undefined) {
+                            console.error(message, data);
+                        }
+                        else {
+                            console.error(message);
+                        }
+                    }
+                    else if (level === 'warn') {
+                        if (data !== undefined) {
+                            console.warn(message, data);
+                        }
+                        else {
+                            console.warn(message);
+                        }
+                    }
+                    else {
+                        if (data !== undefined) {
+                            console.log(message, data);
+                        }
+                        else {
+                            console.log(message);
+                        }
+                    }
+                };
+            case 'silent':
+                return () => {
+                    // Do nothing - silent output
+                };
+            case 'file':
+            case 'http':
+                // Use advanced output handlers for file and http
+                return (0, advanced_outputs_1.createBuiltInHandler)(type, config);
+            default:
+                return null;
+        }
+    }
+    /**
+       * Process a single output target with error handling
+       * @param output - Single output target to process
+       * @param level - Log level
+       * @param rawMessage - Original unformatted message
+       * @param formattedMessage - Formatted message for console-based outputs
+       * @param data - Optional data
+       * @param isEnhanced - Whether this is an enhanced output (supports configured handler objects)
+       */
+    processSingleOutput(output, level, rawMessage, formattedMessage, data, isEnhanced = false) {
+        const config = this.configManager.getConfig();
+        try {
+            if (typeof output === 'string') {
+                // Built-in handler - get config if available
+                const outputConfig = config.advancedOutputConfig?.[output];
+                const handler = this.getBuiltInHandler(output, outputConfig);
+                if (handler) {
+                    // Advanced handlers (file, http) get raw message, console gets formatted
+                    const messageToUse = (output === 'file' || output === 'http') ? rawMessage : formattedMessage;
+                    handler(level, messageToUse, data);
+                }
+                else {
+                    console.error('[LogEngine] Unknown built-in output handler:', JSON.stringify(output));
+                }
+            }
+            else if (typeof output === 'function') {
+                // Custom function handler gets formatted message for backward compatibility
+                output(level, formattedMessage, data);
+            }
+            else if (isEnhanced && typeof output === 'object' && output.type && output.config) {
+                // Configured handler object (only available for enhanced outputs)
+                const handler = this.getBuiltInHandler(output.type, output.config);
+                if (handler) {
+                    // Advanced configured handlers get raw message
+                    handler(level, rawMessage, data);
+                }
+                else {
+                    console.error('[LogEngine] Unknown enhanced output handler type:', JSON.stringify(output));
+                }
+            }
+            else {
+                const outputType = isEnhanced ? 'enhanced output target' : 'output target';
+                console.error(`[LogEngine] Invalid ${outputType}:`, output);
+            }
+        }
+        catch (error) {
+            // Continue processing other outputs even if one fails
+            const handlerType = isEnhanced ? 'Enhanced output' : 'Output';
+            console.error(`[LogEngine] ${handlerType} handler failed: ${error}`);
+        }
+    }
+    /**
+       * Process multiple output targets
+       * @param outputs - Array of output targets to process
+       * @param level - Log level
+       * @param rawMessage - Original unformatted message
+       * @param formattedMessage - Formatted message for console-based outputs
+       * @param data - Optional data
+       */
+    processOutputs(outputs, level, rawMessage, formattedMessage, data) {
+        for (const output of outputs) {
+            this.processSingleOutput(output, level, rawMessage, formattedMessage, data, false);
+        }
+    }
+    /**
+       * Process enhanced output targets
+       * @param enhancedOutputs - Array of enhanced output targets to process
+       * @param level - Log level
+       * @param rawMessage - Original unformatted message
+       * @param formattedMessage - Formatted message for console-based outputs
+       * @param data - Optional data
+       */
+    processEnhancedOutputs(enhancedOutputs, level, rawMessage, formattedMessage, data) {
+        for (const output of enhancedOutputs) {
+            this.processSingleOutput(output, level, rawMessage, formattedMessage, data, true);
+        }
+    }
+    /**
+       * 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
@@ -38,147 +162,208 @@ class Logger {
         });
     }
     /**
-     * Get current logger configuration
-     * @returns Current logger configuration
-     */
+       * 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
-     */
+       * 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)
-     */
+       * Writes log output using configured output handler or default console methods
+       * Supports single output handler, multiple outputs, and enhanced outputs
+       * Priority: outputs > enhancedOutputs > outputHandler > default console
+       * @param level - The log level as a string
+       * @param rawMessage - The original unformatted message
+       * @param formattedMessage - The pre-formatted message to output
+       * @param data - Optional data object that was logged
+       * @param isError - Whether this is an error level message (for console.error)
+       * @param isWarn - Whether this is a warning level message (for console.warn)
+       */
+    writeToOutput(level, rawMessage, formattedMessage, data, isError = false, isWarn = false) {
+        const config = this.configManager.getConfig();
+        // Multiple outputs support (highest priority - newer API)
+        if (config.outputs !== undefined) {
+            if (config.outputs.length > 0) {
+                // Process outputs array when it has actual outputs
+                this.processOutputs(config.outputs, level, rawMessage, formattedMessage, data);
+            }
+            // If outputs is explicitly set to empty array, disable all logging
+            return;
+        }
+        // Enhanced outputs with advanced configuration (second priority)
+        if (config.enhancedOutputs !== undefined && config.enhancedOutputs.length > 0) {
+            this.processEnhancedOutputs(config.enhancedOutputs, level, rawMessage, formattedMessage, data);
+            return;
+        }
+        // Single output handler (third priority - legacy compatibility)
+        if (config.outputHandler) {
+            try {
+                config.outputHandler(level, formattedMessage, data);
+            }
+            catch (error) {
+                // Fallback to console if custom handler fails
+                console.error(`[LogEngine] Output handler failed: ${error}. Falling back to console.`);
+                if (isError) {
+                    console.error(formattedMessage);
+                }
+                else if (isWarn) {
+                    console.warn(formattedMessage);
+                }
+                else {
+                    console.log(formattedMessage);
+                }
+            }
+            return;
+        }
+        // Default: Console output (unless suppressed)
+        if (!config.suppressConsoleOutput) {
+            if (isError) {
+                console.error(formattedMessage);
+            }
+            else if (isWarn) {
+                console.warn(formattedMessage);
+            }
+            else {
+                console.log(formattedMessage);
+            }
+        }
+        // If suppressConsoleOutput is true and no outputHandler/outputs, do nothing (silent)
+    }
+    /**
+       * 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);
+            this.writeToOutput('debug', message, formatted, processedData);
         }
     }
     /**
-     * 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)
-     */
+       * 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);
+            this.writeToOutput('info', message, formatted, processedData);
         }
     }
     /**
-     * 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)
-     */
+       * 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);
+            this.writeToOutput('warn', message, formatted, processedData, false, true);
         }
     }
     /**
-     * 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)
-     */
+       * 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);
+            this.writeToOutput('error', message, formatted, processedData, true, false);
         }
     }
     /**
-     * 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 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);
+            this.writeToOutput('log', message, formatted, processedData);
         }
     }
     // 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)
-     */
+       * 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);
+            this.writeToOutput('debug', message, formatted, data);
         }
     }
     /**
-     * Log an info message without data redaction
-     * @param message - The info message to log
-     * @param data - Optional data object to log (no redaction applied)
-     */
+       * 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);
+            this.writeToOutput('info', message, formatted, data);
         }
     }
     /**
-     * Log a warning message without data redaction
-     * @param message - The warning message to log
-     * @param data - Optional data object to log (no redaction applied)
-     */
+       * 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);
+            this.writeToOutput('warn', message, formatted, data, false, true);
         }
     }
     /**
-     * Log an error message without data redaction
-     * @param message - The error message to log
-     * @param data - Optional data object to log (no redaction applied)
-     */
+       * 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);
+            this.writeToOutput('error', message, formatted, data, true, false);
         }
     }
     /**
-     * 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)
-     */
+       * 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);
+            this.writeToOutput('log', message, formatted, data);
         }
     }
 }

package/dist/logger/environment.d.ts

@@ -8,29 +8,29 @@ import { LogMode } from '../types';
  */
 export declare class EnvironmentDetector {
     /**
-     * Get the normalized NODE_ENV value
-     * @returns Normalized NODE_ENV (trimmed and lowercase)
-     */
+       * 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
-     */
+       * 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'
-     */
+       * 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'
-     */
+       * 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'
-     */
+       * 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

@@ -1 +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"}
+{"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;IAC9B;;;SAGK;IACL,OAAO,CAAC,MAAM,CAAC,oBAAoB;IAInC;;;SAGK;IACL,MAAM,CAAC,kBAAkB,IAAI,OAAO;IAiBpC;;;SAGK;IACL,MAAM,CAAC,iBAAiB,IAAI,OAAO;IAInC;;;SAGK;IACL,MAAM,CAAC,wBAAwB,IAAI,OAAO;IAI1C;;;SAGK;IACL,MAAM,CAAC,uBAAuB,IAAI,OAAO;CAG1C"}

package/dist/logger/environment.js

@@ -11,16 +11,16 @@ const types_1 = require("../types");
  */
 class EnvironmentDetector {
     /**
-     * Get the normalized NODE_ENV value
-     * @returns Normalized NODE_ENV (trimmed and lowercase)
-     */
+       * 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
-     */
+       * Determines the appropriate log mode based on NODE_ENV
+       * @returns LogMode appropriate for current environment
+       */
     static getEnvironmentMode() {
         const nodeEnv = EnvironmentDetector.getNormalizedNodeEnv();
         switch (nodeEnv) {
@@ -37,23 +37,23 @@ class EnvironmentDetector {
         }
     }
     /**
-     * Check if we're in a test environment
-     * @returns true if NODE_ENV is 'test'
-     */
+       * 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'
-     */
+       * 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'
-     */
+       * Check if we're in a production environment
+       * @returns true if NODE_ENV is 'production'
+       */
     static isProductionEnvironment() {
         return EnvironmentDetector.getNormalizedNodeEnv() === 'production';
     }

package/dist/logger/filtering.d.ts

@@ -11,26 +11,26 @@ 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
-     */
+       * 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
-     */
+       * 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
-     */
+       * 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

@@ -1 +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"}
+{"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;IAEpB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,cAAc,CAMpC;IAGF,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,eAAe,CAOrC;IAEF;;;;;;;;SAQK;IACL,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,QAAQ,EAAE,WAAW,EAAE,OAAO,GAAG,OAAO;IAWhE;;;;SAIK;IACL,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM;IAW/C;;;;SAIK;IACL,MAAM,CAAC,gBAAgB,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM;CAW/C"}