@wgtechlabs/log-engine 1.2.0 → 1.3.0

package/dist/formatter/message-formatter.js

@@ -0,0 +1,87 @@
+"use strict";
+/**
+ * Core message formatting functionality
+ * Handles the main log message formatting with colors, timestamps, and levels
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageFormatter = void 0;
+const types_1 = require("../types");
+const colors_1 = require("./colors");
+const timestamp_1 = require("./timestamp");
+const data_formatter_1 = require("./data-formatter");
+/**
+ * Core message formatter class
+ * Provides the main formatting functionality for log messages
+ */
+class MessageFormatter {
+    /**
+     * Formats a log message with timestamp, level indicator, and appropriate coloring
+     * Creates a structured log entry: [ISO_TIMESTAMP][LOCAL_TIME][LEVEL]: message [data]
+     * @param level - The log level to format for
+     * @param message - The message content to format
+     * @param data - Optional data object to include in the log output
+     * @returns Formatted string with ANSI colors and timestamps
+     */
+    static format(level, message, data) {
+        const { isoTimestamp, timeString } = (0, timestamp_1.getTimestampComponents)();
+        const timestamp = (0, timestamp_1.formatTimestamp)(isoTimestamp, timeString, colors_1.colorScheme);
+        const levelName = this.getLevelName(level);
+        const levelColor = this.getLevelColor(level);
+        const coloredLevel = `${levelColor}[${levelName}]${colors_1.colors.reset}`;
+        // Format the base message
+        let formattedMessage = `${timestamp}${coloredLevel}: ${message}`;
+        // Append data if provided
+        if (data !== undefined) {
+            const dataString = (0, data_formatter_1.formatData)(data);
+            const styledData = (0, data_formatter_1.styleData)(dataString, colors_1.colorScheme);
+            formattedMessage += styledData;
+        }
+        // Always reset colors at the end of the entire log line
+        return formattedMessage + colors_1.colors.reset;
+    }
+    /**
+     * Formats a Log Engine system message with [LOG ENGINE] prefix instead of log levels
+     * Used for internal messages like deprecation warnings that should be distinguished from user logs
+     * @param message - The system message content to format
+     * @returns Formatted string with ANSI colors, timestamps, and LOG ENGINE prefix
+     */
+    static formatSystemMessage(message) {
+        const { isoTimestamp, timeString } = (0, timestamp_1.getTimestampComponents)();
+        const timestamp = (0, timestamp_1.formatTimestamp)(isoTimestamp, timeString, colors_1.colorScheme);
+        const coloredLogEngine = `${colors_1.colorScheme.system}[LOG ENGINE]${colors_1.colors.reset}`;
+        const coloredMessage = `${colors_1.colorScheme.system}${message}${colors_1.colors.reset}`;
+        return `${timestamp}${coloredLogEngine}: ${coloredMessage}`;
+    }
+    /**
+     * Converts LogLevel enum to human-readable string
+     * @param level - The LogLevel to convert
+     * @returns String representation of the log level
+     */
+    static getLevelName(level) {
+        switch (level) {
+            case types_1.LogLevel.DEBUG: return 'DEBUG';
+            case types_1.LogLevel.INFO: return 'INFO';
+            case types_1.LogLevel.WARN: return 'WARN';
+            case types_1.LogLevel.ERROR: return 'ERROR';
+            case types_1.LogLevel.LOG: return 'LOG';
+            default: return 'UNKNOWN';
+        }
+    }
+    /**
+     * Maps LogLevel to appropriate ANSI color code
+     * Colors help quickly identify message severity in console output
+     * @param level - The LogLevel to get color for
+     * @returns ANSI color escape sequence
+     */
+    static getLevelColor(level) {
+        switch (level) {
+            case types_1.LogLevel.DEBUG: return colors_1.colors.magenta; // Purple for debug info
+            case types_1.LogLevel.INFO: return colors_1.colors.blue; // Blue for general info
+            case types_1.LogLevel.WARN: return colors_1.colors.yellow; // Yellow for warnings
+            case types_1.LogLevel.ERROR: return colors_1.colors.red; // Red for errors
+            case types_1.LogLevel.LOG: return colors_1.colors.green; // Green for always-on log messages
+            default: return colors_1.colors.white; // White for unknown levels
+        }
+    }
+}
+exports.MessageFormatter = MessageFormatter;

package/dist/formatter/timestamp.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Timestamp formatting utilities
+ * Handles ISO timestamp and local time formatting for log messages
+ */
+/**
+ * Generates the current timestamp as both an ISO 8601 string and a compact US English local time string.
+ *
+ * @returns An object containing `isoTimestamp` (ISO 8601 format) and `timeString` (localized time string without spaces)
+ */
+export declare function getTimestampComponents(): {
+    isoTimestamp: string;
+    timeString: string;
+};
+/**
+ * Returns a formatted string combining an ISO timestamp and a local time string, each wrapped with specified color codes for console output.
+ *
+ * @param isoTimestamp - The ISO 8601 formatted timestamp to display
+ * @param timeString - The local time string to display
+ * @param colors - An object containing color codes for the timestamp, time string, and reset sequence
+ * @returns The combined, colorized timestamp string suitable for log messages
+ */
+export declare function formatTimestamp(isoTimestamp: string, timeString: string, colors: {
+    timestamp: string;
+    timeString: string;
+    reset: string;
+}): string;
+//# sourceMappingURL=timestamp.d.ts.map

package/dist/formatter/timestamp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timestamp.d.ts","sourceRoot":"","sources":["../../src/formatter/timestamp.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;GAIG;AACH,wBAAgB,sBAAsB,IAAI;IACtC,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;CACtB,CAaA;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC3B,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GACjE,MAAM,CAKR"}

package/dist/formatter/timestamp.js

@@ -0,0 +1,39 @@
+"use strict";
+/**
+ * Timestamp formatting utilities
+ * Handles ISO timestamp and local time formatting for log messages
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTimestampComponents = getTimestampComponents;
+exports.formatTimestamp = formatTimestamp;
+/**
+ * Generates the current timestamp as both an ISO 8601 string and a compact US English local time string.
+ *
+ * @returns An object containing `isoTimestamp` (ISO 8601 format) and `timeString` (localized time string without spaces)
+ */
+function getTimestampComponents() {
+    const now = new Date();
+    const isoTimestamp = now.toISOString();
+    const timeString = now.toLocaleTimeString('en-US', {
+        hour: 'numeric',
+        minute: '2-digit',
+        hour12: true
+    }).replace(/\s+/g, '');
+    return {
+        isoTimestamp,
+        timeString
+    };
+}
+/**
+ * Returns a formatted string combining an ISO timestamp and a local time string, each wrapped with specified color codes for console output.
+ *
+ * @param isoTimestamp - The ISO 8601 formatted timestamp to display
+ * @param timeString - The local time string to display
+ * @param colors - An object containing color codes for the timestamp, time string, and reset sequence
+ * @returns The combined, colorized timestamp string suitable for log messages
+ */
+function formatTimestamp(isoTimestamp, timeString, colors) {
+    const coloredTimestamp = `${colors.timestamp}[${isoTimestamp}]${colors.reset}`;
+    const coloredTimeString = `${colors.timeString}[${timeString}]${colors.reset}`;
+    return `${coloredTimestamp}${coloredTimeString}`;
+}

package/dist/formatter.d.ts

@@ -11,12 +11,13 @@ export declare class LogFormatter {
     private static readonly colors;
     /**
      * Formats a log message with timestamp, level indicator, and appropriate coloring
-     * Creates a structured log entry: [ISO_TIMESTAMP][LOCAL_TIME][LEVEL]: message
+     * Creates a structured log entry: [ISO_TIMESTAMP][LOCAL_TIME][LEVEL]: message [data]
      * @param level - The log level to format for
      * @param message - The message content to format
+     * @param data - Optional data object to include in the log output
      * @returns Formatted string with ANSI colors and timestamps
      */
-    static format(level: LogLevel, message: string): string;
+    static format(level: LogLevel, message: string, data?: any): string;
     /**
      * Formats a Log Engine system message with [LOG ENGINE] prefix instead of log levels
      * Used for internal messages like deprecation warnings that should be distinguished from user logs
@@ -24,6 +25,13 @@ export declare class LogFormatter {
      * @returns Formatted string with ANSI colors, timestamps, and LOG ENGINE prefix
      */
     static formatSystemMessage(message: string): string;
+    /**
+     * Formats data objects for log output
+     * Converts objects to readable JSON string format
+     * @param data - Data to format
+     * @returns Formatted string representation of the data
+     */
+    private static formatData;
     /**
      * Converts LogLevel enum to human-readable string
      * @param level - The LogLevel to convert

package/dist/formatter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"formatter.d.ts","sourceRoot":"","sources":["../src/formatter.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEnC;;;GAGG;AACH,qBAAa,YAAY;IAErB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAW5B;IAEF;;;;;;OAMG;IACH,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM;IAoBvD;;;;;OAKG;IACH,MAAM,CAAC,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IAkBnD;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,YAAY;IAW3B;;;;;OAKG;IACH,OAAO,CAAC,MAAM,CAAC,aAAa;CAU/B"}
+{"version":3,"file":"formatter.d.ts","sourceRoot":"","sources":["../src/formatter.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEnC;;;GAGG;AACH,qBAAa,YAAY;IAErB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAW5B;IAEF;;;;;;;OAOG;IACH,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,GAAG,MAAM;IA+BnE;;;;;OAKG;IACH,MAAM,CAAC,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IAkBnD;;;;;OAKG;IACH,OAAO,CAAC,MAAM,CAAC,UAAU;IAyBzB;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,YAAY;IAW3B;;;;;OAKG;IACH,OAAO,CAAC,MAAM,CAAC,aAAa;CAU/B"}

package/dist/formatter.js

@@ -13,26 +13,36 @@ const types_1 = require("./types");
 class LogFormatter {
     /**
      * Formats a log message with timestamp, level indicator, and appropriate coloring
-     * Creates a structured log entry: [ISO_TIMESTAMP][LOCAL_TIME][LEVEL]: message
+     * Creates a structured log entry: [ISO_TIMESTAMP][LOCAL_TIME][LEVEL]: message [data]
      * @param level - The log level to format for
      * @param message - The message content to format
+     * @param data - Optional data object to include in the log output
      * @returns Formatted string with ANSI colors and timestamps
      */
-    static format(level, message) {
+    static format(level, message, data) {
         const now = new Date();
         const isoTimestamp = now.toISOString();
         const timeString = now.toLocaleTimeString('en-US', {
             hour: 'numeric',
             minute: '2-digit',
             hour12: true
-        });
+        }).replace(/\s+/g, '');
         const levelName = this.getLevelName(level);
         const levelColor = this.getLevelColor(level);
         // Apply colors to each component for better readability
         const coloredTimestamp = `${this.colors.gray}[${isoTimestamp}]${this.colors.reset}`;
         const coloredTimeString = `${this.colors.cyan}[${timeString}]${this.colors.reset}`;
         const coloredLevel = `${levelColor}[${levelName}]${this.colors.reset}`;
-        return `${coloredTimestamp}${coloredTimeString}${coloredLevel}: ${message}`;
+        // Format the base message
+        let formattedMessage = `${coloredTimestamp}${coloredTimeString}${coloredLevel}: ${message}`;
+        // Append data if provided
+        if (data !== undefined) {
+            const dataString = this.formatData(data);
+            if (dataString) {
+                formattedMessage += ` ${this.colors.dim}${dataString}${this.colors.reset}`;
+            }
+        }
+        return formattedMessage;
     }
     /**
      * Formats a Log Engine system message with [LOG ENGINE] prefix instead of log levels
@@ -47,7 +57,7 @@ class LogFormatter {
             hour: 'numeric',
             minute: '2-digit',
             hour12: true
-        });
+        }).replace(/\s+/g, '');
         // Apply colors to each component for better readability
         const coloredTimestamp = `${LogFormatter.colors.gray}[${isoTimestamp}]${LogFormatter.colors.reset}`;
         const coloredTimeString = `${LogFormatter.colors.cyan}[${timeString}]${LogFormatter.colors.reset}`;
@@ -55,6 +65,33 @@ class LogFormatter {
         const coloredMessage = `${LogFormatter.colors.yellow}${message}${LogFormatter.colors.reset}`;
         return `${coloredTimestamp}${coloredTimeString}${coloredLogEngine}: ${coloredMessage}`;
     }
+    /**
+     * Formats data objects for log output
+     * Converts objects to readable JSON string format
+     * @param data - Data to format
+     * @returns Formatted string representation of the data
+     */
+    static formatData(data) {
+        if (data === null) {
+            return 'null';
+        }
+        if (data === undefined) {
+            return '';
+        }
+        if (typeof data === 'string') {
+            return data;
+        }
+        if (typeof data === 'number' || typeof data === 'boolean') {
+            return String(data);
+        }
+        try {
+            return JSON.stringify(data, null, 0);
+        }
+        catch (error) {
+            // Fallback for objects that can't be stringified (e.g., circular references)
+            return '[Object]';
+        }
+    }
     /**
      * Converts LogLevel enum to human-readable string
      * @param level - The LogLevel to convert

package/dist/index.d.ts

@@ -1,84 +1,186 @@
 /**
- * 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]' }
+ * ```
  */
-import { LoggerConfig } from './types';
+import type { LoggerConfig, RedactionConfig } from './types';
 /**
- * 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
  */
 export declare const 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: Partial<LoggerConfig>) => void;
     /**
-     * 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: string) => void;
+    debug: (message: string, data?: any) => void;
     /**
-     * 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: string) => void;
+    info: (message: string, data?: any) => void;
     /**
-     * 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: string) => void;
+    warn: (message: string, data?: any) => void;
     /**
-     * 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: string) => void;
+    error: (message: string, data?: any) => void;
     /**
-     * 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 up');
-     * LogEngine.log('Server listening on port 3000');
-     * LogEngine.log('Graceful shutdown initiated');
+     * LogEngine.log('Application starting', { version: '1.0.0' });
      * ```
      */
-    log: (message: string) => void;
+    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)
+     */
+    logRaw: (message: string, data?: any) => void;
+    /**
+     * Configure data redaction settings
+     * @param config - Partial redaction configuration to apply
+     */
+    configureRedaction: (config: Partial<RedactionConfig>) => void;
+    /**
+     * Refresh redaction configuration from environment variables
+     * Useful for picking up runtime environment changes
+     */
+    refreshRedactionConfig: () => void;
+    /**
+     * Reset redaction configuration to defaults
+     */
+    resetRedactionConfig: () => void;
+    /**
+     * Get current redaction configuration
+     * @returns Current redaction configuration
+     */
+    getRedactionConfig: () => RedactionConfig;
+    /**
+     * Add custom regex patterns for advanced field detection
+     * @param patterns - Array of regex patterns to add
+     */
+    addCustomRedactionPatterns: (patterns: RegExp[]) => void;
+    /**
+     * Clear all custom redaction patterns
+     */
+    clearCustomRedactionPatterns: () => void;
+    /**
+     * Add custom sensitive field names to the existing list
+     * @param fields - Array of field names to add
+     */
+    addSensitiveFields: (fields: string[]) => void;
+    /**
+     * 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: string) => boolean;
+    /**
+     * Temporarily disable redaction for a specific logging call
+     * @returns LogEngine instance with redaction bypassed
+     * @example
+     * ```typescript
+     * LogEngine.withoutRedaction().info('Debug data', sensitiveObject);
+     * ```
+     */
+    withoutRedaction: () => {
+        debug: (message: string, data?: any) => void;
+        info: (message: string, data?: any) => void;
+        warn: (message: string, data?: any) => void;
+        error: (message: string, data?: any) => void;
+        log: (message: string, data?: any) => void;
+    };
 };
-export { LogLevel, LogMode, LoggerConfig } from './types';
+export { LogMode, LogLevel } from './types';
+export type { LoggerConfig, RedactionConfig } from './types';
+export { DataRedactor, defaultRedactionConfig, RedactionController } from './redaction';
+export default LogEngine;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAW,YAAY,EAAE,MAAM,SAAS,CAAC;AAiChD;;;GAGG;AACH,eAAO,MAAM,SAAS;IAClB;;;;;;;;OAQG;wBACiB,OAAO,CAAC,YAAY,CAAC;IAEzC;;;;;;;;;;OAUG;qBACc,MAAM;IAEvB;;;;;;;;;;OAUG;oBACa,MAAM;IAEtB;;;;;;;;;;OAUG;oBACa,MAAM;IAEtB;;;;;;;;;;OAUG;qBACc,MAAM;IAEvB;;;;;;;;;;;OAWG;mBACY,MAAM;CACxB,CAAC;AAEF,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAIH,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAM7D;;;GAGG;AACH,eAAO,MAAM,SAAS;IAClB;;;;;;;OAOG;wBACiB,OAAO,CAAC,YAAY,CAAC;IAGzC;;;;;;;;;OASG;qBACc,MAAM,SAAS,GAAG;IAEnC;;;;;;;;;OASG;oBACa,MAAM,SAAS,GAAG;IAElC;;;;;;;;;OASG;oBACa,MAAM,SAAS,GAAG;IAElC;;;;;;;;;OASG;qBACc,MAAM,SAAS,GAAG;IAEnC;;;;;;;;;OASG;mBACY,MAAM,SAAS,GAAG;IAGjC;;;;;OAKG;wBACiB,MAAM,SAAS,GAAG;IAEtC;;;;;OAKG;uBACgB,MAAM,SAAS,GAAG;IAErC;;;;;OAKG;uBACgB,MAAM,SAAS,GAAG;IAErC;;;;;OAKG;wBACiB,MAAM,SAAS,GAAG;IAEtC;;;;;OAKG;sBACe,MAAM,SAAS,GAAG;IAGpC;;;OAGG;iCAC0B,OAAO,CAAC,eAAe,CAAC;IAErD;;;OAGG;;IAGH;;OAEG;;IAGH;;;OAGG;;IAIH;;;OAGG;2CACoC,MAAM,EAAE;IAE/C;;OAEG;;IAGH;;;OAGG;iCAC0B,MAAM,EAAE;IAErC;;;;OAIG;oCAC6B,MAAM;IAEtC;;;;;;;OAOG;;yBAEkB,MAAM,SAAS,GAAG;wBACnB,MAAM,SAAS,GAAG;wBAClB,MAAM,SAAS,GAAG;yBACjB,MAAM,SAAS,GAAG;uBACpB,MAAM,SAAS,GAAG;;CAExC,CAAC;AAGF,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC5C,YAAY,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAC7D,OAAO,EAAE,YAAY,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAGxF,eAAe,SAAS,CAAC"}