@hamak/logging 0.5.1

package/dist/impl/core/log-manager.js

@@ -0,0 +1,278 @@
+import { ContextLogger } from './context-logger';
+import { EventEmitter } from '../utils/event-emitter';
+/**
+ * Central log manager implementation
+ *
+ * Manages transports, creates loggers, and dispatches log entries.
+ */
+export class LogManager {
+    constructor(config = {}) {
+        Object.defineProperty(this, "transports", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "transportConfigs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "loggers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "buffer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "eventEmitter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new EventEmitter()
+        });
+        Object.defineProperty(this, "flushTimer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.config = {
+            globalLevel: config.globalLevel ?? 2, // LogLevel.INFO
+            bufferSize: config.bufferSize ?? 1000,
+            flushInterval: config.flushInterval ?? 5000,
+            defaultTransports: config.defaultTransports ?? [],
+            pluginLevels: config.pluginLevels ?? {},
+            moduleLevels: config.moduleLevels ?? {},
+        };
+        if (this.config.flushInterval > 0) {
+            this.startFlushTimer();
+        }
+    }
+    registerTransport(transport, config) {
+        this.transports.set(transport.id, transport);
+        if (config) {
+            this.transportConfigs.set(transport.id, {
+                enabled: true,
+                ...config,
+            });
+        }
+        else {
+            this.transportConfigs.set(transport.id, {
+                id: transport.id,
+                enabled: true,
+            });
+        }
+    }
+    unregisterTransport(id) {
+        const transport = this.transports.get(id);
+        if (transport && transport.close) {
+            transport.close().catch((error) => {
+                this.handleTransportError(transport, error);
+            });
+        }
+        this.transports.delete(id);
+        this.transportConfigs.delete(id);
+    }
+    getTransport(id) {
+        return this.transports.get(id);
+    }
+    listTransports() {
+        return Array.from(this.transports.values());
+    }
+    createLogger(context) {
+        const level = this.resolveLevel(context);
+        return new ContextLogger(this, context, level);
+    }
+    getLogger(context) {
+        const key = this.createCacheKey(context);
+        let logger = this.loggers.get(key);
+        if (!logger) {
+            logger = this.createLogger(context);
+            this.loggers.set(key, logger);
+        }
+        return logger;
+    }
+    setGlobalLevel(level) {
+        this.config.globalLevel = level;
+    }
+    setPluginLevel(plugin, level) {
+        this.config.pluginLevels[plugin] = level;
+    }
+    setModuleLevel(module, level) {
+        this.config.moduleLevels[module] = level;
+    }
+    async flush() {
+        const entries = this.buffer.splice(0);
+        if (entries.length === 0) {
+            return;
+        }
+        await Promise.all(entries.map(entry => this.dispatchToTransports(entry)));
+        await Promise.all(Array.from(this.transports.values())
+            .filter(t => t.flush)
+            .map(t => {
+            try {
+                return t.flush();
+            }
+            catch (error) {
+                this.handleTransportError(t, error);
+                return Promise.resolve();
+            }
+        }));
+        this.eventEmitter.emit('flush', entries.length);
+    }
+    clearBuffer() {
+        this.buffer = [];
+    }
+    on(event, handler) {
+        this.eventEmitter.on(event, handler);
+    }
+    off(event, handler) {
+        this.eventEmitter.off(event, handler);
+    }
+    dispatch(entry) {
+        this.buffer.push(entry);
+        this.eventEmitter.emit('log', entry);
+        // Immediate dispatch for high-priority logs
+        if (entry.level >= 4) { // LogLevel.ERROR
+            this.dispatchToTransports(entry).catch(error => {
+                console.error('[LogManager] Error dispatching log entry:', error);
+            });
+        }
+        // Flush if buffer is full
+        if (this.buffer.length >= this.config.bufferSize) {
+            this.flush().catch(error => {
+                console.error('[LogManager] Error flushing buffer:', error);
+            });
+        }
+    }
+    /**
+     * Clean up resources
+     */
+    async destroy() {
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+            this.flushTimer = undefined;
+        }
+        await this.flush();
+        await Promise.all(Array.from(this.transports.values())
+            .filter(t => t.close)
+            .map(t => t.close()));
+        this.transports.clear();
+        this.transportConfigs.clear();
+        this.loggers.clear();
+        this.eventEmitter.clear();
+    }
+    async dispatchToTransports(entry) {
+        const promises = [];
+        for (const [id, transport] of this.transports) {
+            const config = this.transportConfigs.get(id);
+            if (!this.shouldDispatch(entry, config, transport)) {
+                continue;
+            }
+            try {
+                const result = transport.log(entry);
+                if (result instanceof Promise) {
+                    promises.push(result.catch(error => {
+                        this.handleTransportError(transport, error);
+                    }));
+                }
+            }
+            catch (error) {
+                this.handleTransportError(transport, error);
+            }
+        }
+        await Promise.all(promises);
+    }
+    shouldDispatch(entry, config, transport) {
+        if (config && config.enabled === false) {
+            return false;
+        }
+        if (config?.minLevel !== undefined && entry.level < config.minLevel) {
+            return false;
+        }
+        if (config?.maxLevel !== undefined && entry.level > config.maxLevel) {
+            return false;
+        }
+        if (config?.plugins && config.plugins.length > 0) {
+            if (!entry.context.plugin || !config.plugins.includes(entry.context.plugin)) {
+                return false;
+            }
+        }
+        if (config?.modules && config.modules.length > 0) {
+            if (!entry.context.module || !config.modules.includes(entry.context.module)) {
+                return false;
+            }
+        }
+        if (config?.tags && config.tags.length > 0) {
+            if (!entry.metadata?.tags || !config.tags.some(tag => entry.metadata.tags.includes(tag))) {
+                return false;
+            }
+        }
+        if (config?.filter && !config.filter(entry)) {
+            return false;
+        }
+        if (transport?.shouldLog && !transport.shouldLog(entry)) {
+            return false;
+        }
+        return true;
+    }
+    resolveLevel(context) {
+        if (context?.plugin) {
+            const pluginLevel = this.config.pluginLevels[context.plugin];
+            if (pluginLevel !== undefined) {
+                return pluginLevel;
+            }
+        }
+        if (context?.module) {
+            const moduleLevel = this.config.moduleLevels[context.module];
+            if (moduleLevel !== undefined) {
+                return moduleLevel;
+            }
+        }
+        return this.config.globalLevel;
+    }
+    createCacheKey(context) {
+        if (!context) {
+            return '__default__';
+        }
+        return JSON.stringify({
+            plugin: context.plugin,
+            module: context.module,
+            component: context.component,
+        });
+    }
+    startFlushTimer() {
+        this.flushTimer = setInterval(() => {
+            this.flush().catch(error => {
+                console.error('[LogManager] Error in flush timer:', error);
+            });
+        }, this.config.flushInterval);
+    }
+    handleTransportError(transport, error) {
+        this.eventEmitter.emit('error', { transport: transport.id, error });
+        if (transport.onError) {
+            try {
+                transport.onError(error);
+            }
+            catch (handlerError) {
+                console.error('[LogManager] Error in transport error handler:', handlerError);
+            }
+        }
+        else {
+            console.error(`[LogManager] Transport '${transport.id}' error:`, error);
+        }
+    }
+}

package/dist/impl/formatters/dev-formatter.d.ts

@@ -0,0 +1,20 @@
+import type { ILogFormatter, LogEntry, ConsoleTransportConfig } from '../../api/index';
+/**
+ * Development formatter with colors and emojis
+ *
+ * Provides rich, human-readable console output for development.
+ */
+export declare class DevFormatter implements ILogFormatter {
+    private config;
+    constructor(config?: ConsoleTransportConfig);
+    format(entry: LogEntry): string;
+    formatBatch(entries: LogEntry[]): string;
+    private formatTimestamp;
+    private formatLevel;
+    private getLevelEmoji;
+    private getLevelLabel;
+    private colorize;
+    private formatContext;
+    private formatMetadata;
+}
+//# sourceMappingURL=dev-formatter.d.ts.map

package/dist/impl/formatters/dev-formatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev-formatter.d.ts","sourceRoot":"","sources":["../../../src/impl/formatters/dev-formatter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAqC,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AAE1H;;;;GAIG;AACH,qBAAa,YAAa,YAAW,aAAa;IACpC,OAAO,CAAC,MAAM;gBAAN,MAAM,GAAE,sBAA2B;IASvD,MAAM,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM;IA+B/B,WAAW,CAAC,OAAO,EAAE,QAAQ,EAAE,GAAG,MAAM;IAIxC,OAAO,CAAC,eAAe;IAMvB,OAAO,CAAC,WAAW;IAQnB,OAAO,CAAC,aAAa;IAYrB,OAAO,CAAC,aAAa;IAYrB,OAAO,CAAC,QAAQ;IAehB,OAAO,CAAC,aAAa;IAkCrB,OAAO,CAAC,cAAc;CAiCvB"}

package/dist/impl/formatters/dev-formatter.js

@@ -0,0 +1,145 @@
+/**
+ * Development formatter with colors and emojis
+ *
+ * Provides rich, human-readable console output for development.
+ */
+export class DevFormatter {
+    constructor(config = {}) {
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: config
+        });
+        this.config = {
+            colors: config.colors ?? true,
+            emojis: config.emojis ?? true,
+            timestamps: config.timestamps ?? true,
+            showContext: config.showContext ?? true,
+        };
+    }
+    format(entry) {
+        const parts = [];
+        // Timestamp
+        if (this.config.timestamps) {
+            parts.push(this.formatTimestamp(entry.timestamp));
+        }
+        // Level with emoji and color
+        parts.push(this.formatLevel(entry.level));
+        // Context (plugin/module/component)
+        if (this.config.showContext) {
+            const context = this.formatContext(entry.context);
+            if (context) {
+                parts.push(context);
+            }
+        }
+        // Message
+        parts.push(entry.message);
+        // Metadata
+        const metadata = this.formatMetadata(entry.metadata);
+        if (metadata) {
+            parts.push(metadata);
+        }
+        return parts.join(' ');
+    }
+    formatBatch(entries) {
+        return entries.map(e => this.format(e)).join('\n');
+    }
+    formatTimestamp(timestamp) {
+        const date = new Date(timestamp);
+        const time = date.toISOString().split('T')[1].split('.')[0];
+        return this.config.colors ? `\x1b[90m${time}\x1b[0m` : time;
+    }
+    formatLevel(level) {
+        const emoji = this.config.emojis ? this.getLevelEmoji(level) : '';
+        const label = this.getLevelLabel(level);
+        const colored = this.config.colors ? this.colorize(label, level) : label;
+        return emoji ? `${emoji} ${colored}` : colored;
+    }
+    getLevelEmoji(level) {
+        switch (level) {
+            case 0: return '🔍'; // TRACE
+            case 1: return '🐛'; // DEBUG
+            case 2: return 'ℹ️ '; // INFO
+            case 3: return '⚠️ '; // WARN
+            case 4: return '❌'; // ERROR
+            case 5: return '💀'; // FATAL
+            default: return '';
+        }
+    }
+    getLevelLabel(level) {
+        switch (level) {
+            case 0: return 'TRACE';
+            case 1: return 'DEBUG';
+            case 2: return 'INFO ';
+            case 3: return 'WARN ';
+            case 4: return 'ERROR';
+            case 5: return 'FATAL';
+            default: return 'UNKNW';
+        }
+    }
+    colorize(text, level) {
+        const colors = {
+            0: '\x1b[90m', // TRACE - Gray
+            1: '\x1b[36m', // DEBUG - Cyan
+            2: '\x1b[32m', // INFO - Green
+            3: '\x1b[33m', // WARN - Yellow
+            4: '\x1b[31m', // ERROR - Red
+            5: '\x1b[35m', // FATAL - Magenta
+        };
+        const color = colors[level] || '\x1b[0m';
+        const reset = '\x1b[0m';
+        return `${color}${text}${reset}`;
+    }
+    formatContext(context) {
+        const parts = [];
+        if (context.plugin) {
+            parts.push(this.config.colors
+                ? `\x1b[35m[${context.plugin}]\x1b[0m`
+                : `[${context.plugin}]`);
+        }
+        if (context.module) {
+            parts.push(this.config.colors
+                ? `\x1b[34m{${context.module}}\x1b[0m`
+                : `{${context.module}}`);
+        }
+        if (context.component) {
+            parts.push(this.config.colors
+                ? `\x1b[36m<${context.component}>\x1b[0m`
+                : `<${context.component}>`);
+        }
+        if (context.operation) {
+            parts.push(this.config.colors
+                ? `\x1b[90m(${context.operation})\x1b[0m`
+                : `(${context.operation})`);
+        }
+        return parts.join(' ');
+    }
+    formatMetadata(metadata) {
+        if (!metadata || Object.keys(metadata).length === 0) {
+            return '';
+        }
+        const { error, stack, tags, duration, ...rest } = metadata;
+        const parts = [];
+        // Duration
+        if (duration !== undefined) {
+            const color = this.config.colors ? '\x1b[33m' : '';
+            const reset = this.config.colors ? '\x1b[0m' : '';
+            parts.push(`${color}⏱  ${duration}ms${reset}`);
+        }
+        // Tags
+        if (tags && tags.length > 0) {
+            const tagString = tags.map(t => `#${t}`).join(' ');
+            const color = this.config.colors ? '\x1b[90m' : '';
+            const reset = this.config.colors ? '\x1b[0m' : '';
+            parts.push(`${color}${tagString}${reset}`);
+        }
+        // Other metadata
+        if (Object.keys(rest).length > 0) {
+            const color = this.config.colors ? '\x1b[90m' : '';
+            const reset = this.config.colors ? '\x1b[0m' : '';
+            parts.push(`${color}${JSON.stringify(rest)}${reset}`);
+        }
+        return parts.length > 0 ? parts.join(' ') : '';
+    }
+}

package/dist/impl/formatters/index.d.ts

@@ -0,0 +1,3 @@
+export * from './dev-formatter';
+export * from './json-formatter';
+//# sourceMappingURL=index.d.ts.map

package/dist/impl/formatters/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/impl/formatters/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC"}

package/dist/impl/formatters/index.js

@@ -0,0 +1,2 @@
+export * from './dev-formatter';
+export * from './json-formatter';

package/dist/impl/formatters/json-formatter.d.ts

@@ -0,0 +1,24 @@
+import type { ILogFormatter, LogEntry } from '../../api/index';
+/**
+ * JSON formatter for structured logging
+ *
+ * Outputs logs as JSON for easy parsing by log aggregation tools.
+ */
+export declare class JsonFormatter implements ILogFormatter {
+    private config;
+    constructor(config?: JsonFormatterConfig);
+    format(entry: LogEntry): string;
+    formatBatch(entries: LogEntry[]): string;
+    private toObject;
+    private getLevelName;
+}
+/**
+ * Configuration for JSON formatter
+ */
+export interface JsonFormatterConfig {
+    /** Pretty print JSON (with indentation) */
+    pretty?: boolean;
+    /** Include stack traces for errors */
+    includeStack?: boolean;
+}
+//# sourceMappingURL=json-formatter.d.ts.map

package/dist/impl/formatters/json-formatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-formatter.d.ts","sourceRoot":"","sources":["../../../src/impl/formatters/json-formatter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAE/D;;;;GAIG;AACH,qBAAa,aAAc,YAAW,aAAa;IACrC,OAAO,CAAC,MAAM;gBAAN,MAAM,GAAE,mBAAwB;IAQpD,MAAM,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM;IAO/B,WAAW,CAAC,OAAO,EAAE,QAAQ,EAAE,GAAG,MAAM;IAOxC,OAAO,CAAC,QAAQ;IAiChB,OAAO,CAAC,YAAY;CAWrB;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,2CAA2C;IAC3C,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,sCAAsC;IACtC,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB"}

package/dist/impl/formatters/json-formatter.js

@@ -0,0 +1,70 @@
+/**
+ * JSON formatter for structured logging
+ *
+ * Outputs logs as JSON for easy parsing by log aggregation tools.
+ */
+export class JsonFormatter {
+    constructor(config = {}) {
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: config
+        });
+        this.config = {
+            pretty: config.pretty ?? false,
+            includeStack: config.includeStack ?? true,
+            ...config,
+        };
+    }
+    format(entry) {
+        const logObject = this.toObject(entry);
+        return this.config.pretty
+            ? JSON.stringify(logObject, null, 2)
+            : JSON.stringify(logObject);
+    }
+    formatBatch(entries) {
+        const logObjects = entries.map(e => this.toObject(e));
+        return this.config.pretty
+            ? JSON.stringify(logObjects, null, 2)
+            : JSON.stringify(logObjects);
+    }
+    toObject(entry) {
+        const obj = {
+            timestamp: entry.timestamp,
+            level: this.getLevelName(entry.level),
+            message: entry.message,
+        };
+        // Add context
+        if (entry.context && Object.keys(entry.context).length > 0) {
+            obj.context = entry.context;
+        }
+        // Add metadata
+        if (entry.metadata) {
+            const { error, stack, ...rest } = entry.metadata;
+            if (Object.keys(rest).length > 0) {
+                obj.metadata = rest;
+            }
+            // Handle error separately
+            if (error) {
+                obj.error = {
+                    name: error.name,
+                    message: error.message,
+                    ...(this.config.includeStack && stack ? { stack } : {}),
+                };
+            }
+        }
+        return obj;
+    }
+    getLevelName(level) {
+        switch (level) {
+            case 0: return 'TRACE';
+            case 1: return 'DEBUG';
+            case 2: return 'INFO';
+            case 3: return 'WARN';
+            case 4: return 'ERROR';
+            case 5: return 'FATAL';
+            default: return 'UNKNOWN';
+        }
+    }
+}

package/dist/impl/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @hamak/logging (impl)
+ *
+ * Core implementation of the pluggable logging system.
+ * Provides LogManager, ContextLogger, transports, and formatters.
+ *
+ * @packageDocumentation
+ */
+export * from './core/index';
+export * from './transports/index';
+export * from './formatters/index';
+export * from './plugin/index';
+export * from './utils/index';
+export type { ILogger, ILogTransport, ILogFormatter, ILogManager, LogLevel, LogEntry, LogContext, LogMetadata, TransportConfig, LogManagerConfig, ConsoleTransportConfig, RemoteTransportConfig, } from '../api/index';
+export { LOG_MANAGER_TOKEN, LOGGER_TOKEN, LOG_CONFIG_TOKEN, } from '../api/index';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/impl/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,cAAc,cAAc,CAAC;AAG7B,cAAc,oBAAoB,CAAC;AAGnC,cAAc,oBAAoB,CAAC;AAGnC,cAAc,gBAAgB,CAAC;AAG/B,cAAc,eAAe,CAAC;AAG9B,YAAY,EACV,OAAO,EACP,aAAa,EACb,aAAa,EACb,WAAW,EACX,QAAQ,EACR,QAAQ,EACR,UAAU,EACV,WAAW,EACX,eAAe,EACf,gBAAgB,EAChB,sBAAsB,EACtB,qBAAqB,GACtB,MAAM,cAAc,CAAC;AAEtB,OAAO,EACL,iBAAiB,EACjB,YAAY,EACZ,gBAAgB,GACjB,MAAM,cAAc,CAAC"}

package/dist/impl/index.js

@@ -0,0 +1,19 @@
+/**
+ * @hamak/logging (impl)
+ *
+ * Core implementation of the pluggable logging system.
+ * Provides LogManager, ContextLogger, transports, and formatters.
+ *
+ * @packageDocumentation
+ */
+// Export core implementations
+export * from './core/index';
+// Export transports
+export * from './transports/index';
+// Export formatters
+export * from './formatters/index';
+// Export plugin factory
+export * from './plugin/index';
+// Export utilities
+export * from './utils/index';
+export { LOG_MANAGER_TOKEN, LOGGER_TOKEN, LOG_CONFIG_TOKEN, } from '../api/index';

package/dist/impl/plugin/index.d.ts

@@ -0,0 +1,2 @@
+export * from './logging-plugin-factory';
+//# sourceMappingURL=index.d.ts.map

package/dist/impl/plugin/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/impl/plugin/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC"}

package/dist/impl/plugin/index.js

@@ -0,0 +1 @@
+export * from './logging-plugin-factory';

package/dist/impl/plugin/logging-plugin-factory.d.ts

@@ -0,0 +1,37 @@
+import type { PluginModule } from '@hamak/microkernel-spi';
+import type { LogManagerConfig } from '../../api/index';
+/**
+ * Configuration for the logging plugin
+ */
+export interface LoggingPluginConfig extends LogManagerConfig {
+    /** Use development formatter (rich console output) */
+    devFormatter?: boolean;
+    /** Remote transport configuration */
+    remoteTransport?: any;
+    /**
+     * Intercept console.log/warn/error and route through logging system
+     * @default true - Enabled by default, set to false to disable
+     */
+    interceptConsole?: boolean;
+}
+/**
+ * Create a logging plugin for the microkernel
+ *
+ * @example
+ * ```typescript
+ * import { createLoggingPlugin } from '@hamak/logging-impl';
+ *
+ * const loggingPlugin = createLoggingPlugin({
+ *   globalLevel: LogLevel.DEBUG,
+ *   pluginLevels: {
+ *     'my-plugin': LogLevel.TRACE
+ *   }
+ * });
+ *
+ * const host = createHost({
+ *   plugins: [loggingPlugin, myPlugin]
+ * });
+ * ```
+ */
+export declare function createLoggingPlugin(config?: LoggingPluginConfig): PluginModule;
+//# sourceMappingURL=logging-plugin-factory.d.ts.map

package/dist/impl/plugin/logging-plugin-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logging-plugin-factory.d.ts","sourceRoot":"","sources":["../../../src/impl/plugin/logging-plugin-factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAyB,MAAM,wBAAwB,CAAC;AAElF,OAAO,KAAK,EAAW,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAQjE;;GAEG;AACH,MAAM,WAAW,mBAAoB,SAAQ,gBAAgB;IAC3D,sDAAsD;IACtD,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,qCAAqC;IACrC,eAAe,CAAC,EAAE,GAAG,CAAC;IACtB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,GAAE,mBAAwB,GAAG,YAAY,CAyGlF"}