@loop_ouroboros/mcp-hub-lite 1.0.0

package/dist/server/src/services/connection/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Connection service module index.
+ */
+export { McpConnectionManager, mcpConnectionManager } from './connection-manager.js';
+export type { ServerStatus } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/server/src/services/connection/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/services/connection/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AACrF,YAAY,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC"}

package/dist/server/src/services/connection/index.js

@@ -0,0 +1,4 @@
+/**
+ * Connection service module index.
+ */
+export { McpConnectionManager, mcpConnectionManager } from './connection-manager.js';

package/dist/server/src/services/connection/tool-cache.d.ts

@@ -0,0 +1,122 @@
+import type { Tool } from '../../../shared/models/tool.model.js';
+/**
+ * Manages tool caching for MCP connections at both server ID and server name levels.
+ *
+ * This class encapsulates all tool cache operations, providing both server ID-level
+ * and server name-level caching for efficient tool lookup while maintaining data
+ * consistency across multiple instances of the same server.
+ */
+export declare class ToolCache {
+    private toolCache;
+    private serverNameToolCache;
+    private nameToIdMap;
+    /**
+     * Sets the name-to-ID mapping for server name resolution.
+     *
+     * @param serverName - The server name
+     * @param serverId - The corresponding server instance ID
+     */
+    setNameMapping(serverName: string, serverId: string): void;
+    /**
+     * Removes the name-to-ID mapping for a server.
+     *
+     * @param serverName - The server name to remove
+     */
+    removeNameMapping(serverName: string): void;
+    /**
+     * Removes name mapping by server ID.
+     *
+     * @param serverId - The server ID to remove
+     */
+    removeNameMappingById(serverId: string): void;
+    /**
+     * Gets the server ID for a given server name.
+     *
+     * @param name - The server name
+     * @returns The server ID or undefined if not found
+     */
+    getServerIdByName(name: string): string | undefined;
+    /**
+     * Gets the server name for a given server ID.
+     *
+     * @param serverId - The server ID
+     * @returns The server name or 'unknown' if not found
+     */
+    getServerNameById(serverId: string): string;
+    /**
+     * Sets tools for a specific server instance and updates both caches.
+     *
+     * @param serverId - The server instance ID
+     * @param tools - The tools to cache
+     * @param serverName - Optional server name for name-level cache update
+     */
+    setTools(serverId: string, tools: Tool[], serverName?: string): void;
+    /**
+     * Gets tools for a specific server instance.
+     *
+     * @param serverId - The server instance ID
+     * @returns Array of tools, empty if none
+     */
+    getTools(serverId: string): Tool[];
+    /**
+     * Gets tools by server name from the server name-level cache.
+     *
+     * @param serverName - The server name
+     * @returns Array of tools, empty if none
+     */
+    getToolsByServerName(serverName: string): Tool[];
+    /**
+     * Gets a specific tool by name from the server name-level cache.
+     *
+     * @param serverName - The server name
+     * @param toolName - The tool name to find
+     * @returns The tool object or undefined if not found
+     */
+    getTool(serverName: string, toolName: string): Tool | undefined;
+    /**
+     * Gets all tools from all connected server instances.
+     *
+     * @returns Array of all tools from all servers
+     */
+    getAllTools(): Tool[];
+    /**
+     * Gets all tools from the server name-level cache.
+     *
+     * @returns Array of all tools aggregated by server name
+     */
+    getAllToolsByServerName(): Tool[];
+    /**
+     * Gets all tool cache entries.
+     *
+     * @returns Array of [serverId, tools] tuples
+     */
+    getToolCacheEntries(): [string, Tool[]][];
+    /**
+     * Returns an iterator over the tool cache entries for backward compatibility.
+     * This mimics the Map.entries() method signature.
+     *
+     * @returns Iterator of [serverId, tools] tuples
+     * @deprecated Use getToolCacheEntries() instead
+     */
+    entries(): IterableIterator<[string, Tool[]]>;
+    /**
+     * Clears tools for a specific server and updates both caches.
+     *
+     * @param serverId - The server instance ID
+     */
+    clearTools(serverId: string): void;
+    /**
+     * Updates the server name-level cache for a specific server.
+     * This aggregates tools from all instances of the same server name.
+     *
+     * @param serverName - The server name to update
+     */
+    private updateServerNameCache;
+    /**
+     * Backward compatibility: direct access to the underlying toolCache Map.
+     * This is maintained for backward compatibility with code that accesses
+     * mcpConnectionManager.toolCache directly.
+     */
+    get internalToolCache(): Map<string, Tool[]>;
+}
+//# sourceMappingURL=tool-cache.d.ts.map

package/dist/server/src/services/connection/tool-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-cache.d.ts","sourceRoot":"","sources":["../../../../../src/services/connection/tool-cache.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,8BAA8B,CAAC;AAEzD;;;;;;GAMG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,SAAS,CAAkC;IACnD,OAAO,CAAC,mBAAmB,CAAkC;IAC7D,OAAO,CAAC,WAAW,CAAkC;IAErD;;;;;OAKG;IACH,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAI1D;;;;OAIG;IACH,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAI3C;;;;OAIG;IACH,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAS7C;;;;;OAKG;IACH,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAInD;;;;;OAKG;IACH,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAS3C;;;;;;OAMG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI;IAkBpE;;;;;OAKG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,EAAE;IAUlC;;;;;OAKG;IACH,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,EAAE;IAIhD;;;;;;OAMG;IACH,OAAO,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS;IAK/D;;;;OAIG;IACH,WAAW,IAAI,IAAI,EAAE;IAQrB;;;;OAIG;IACH,uBAAuB,IAAI,IAAI,EAAE;IAQjC;;;;OAIG;IACH,mBAAmB,IAAI,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE;IAIzC;;;;;;OAMG;IACH,OAAO,IAAI,gBAAgB,CAAC,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC;IAI7C;;;;OAIG;IACH,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAclC;;;;;OAKG;IACH,OAAO,CAAC,qBAAqB;IAiB7B;;;;OAIG;IACH,IAAI,iBAAiB,IAAI,GAAG,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,CAE3C;CACF"}

package/dist/server/src/services/connection/tool-cache.js

@@ -0,0 +1,202 @@
+import { logger, LOG_MODULES } from '../../utils/logger.js';
+/**
+ * Manages tool caching for MCP connections at both server ID and server name levels.
+ *
+ * This class encapsulates all tool cache operations, providing both server ID-level
+ * and server name-level caching for efficient tool lookup while maintaining data
+ * consistency across multiple instances of the same server.
+ */
+export class ToolCache {
+    toolCache = new Map();
+    serverNameToolCache = new Map();
+    nameToIdMap = new Map();
+    /**
+     * Sets the name-to-ID mapping for server name resolution.
+     *
+     * @param serverName - The server name
+     * @param serverId - The corresponding server instance ID
+     */
+    setNameMapping(serverName, serverId) {
+        this.nameToIdMap.set(serverName, serverId);
+    }
+    /**
+     * Removes the name-to-ID mapping for a server.
+     *
+     * @param serverName - The server name to remove
+     */
+    removeNameMapping(serverName) {
+        this.nameToIdMap.delete(serverName);
+    }
+    /**
+     * Removes name mapping by server ID.
+     *
+     * @param serverId - The server ID to remove
+     */
+    removeNameMappingById(serverId) {
+        for (const [name, id] of this.nameToIdMap.entries()) {
+            if (id === serverId) {
+                this.nameToIdMap.delete(name);
+                break;
+            }
+        }
+    }
+    /**
+     * Gets the server ID for a given server name.
+     *
+     * @param name - The server name
+     * @returns The server ID or undefined if not found
+     */
+    getServerIdByName(name) {
+        return this.nameToIdMap.get(name);
+    }
+    /**
+     * Gets the server name for a given server ID.
+     *
+     * @param serverId - The server ID
+     * @returns The server name or 'unknown' if not found
+     */
+    getServerNameById(serverId) {
+        for (const [name, id] of this.nameToIdMap.entries()) {
+            if (id === serverId) {
+                return name;
+            }
+        }
+        return 'unknown';
+    }
+    /**
+     * Sets tools for a specific server instance and updates both caches.
+     *
+     * @param serverId - The server instance ID
+     * @param tools - The tools to cache
+     * @param serverName - Optional server name for name-level cache update
+     */
+    setTools(serverId, tools, serverName) {
+        this.toolCache.set(serverId, tools);
+        if (serverName) {
+            this.updateServerNameCache(serverName);
+        }
+        else {
+            const resolvedName = this.getServerNameById(serverId);
+            if (resolvedName !== 'unknown') {
+                this.updateServerNameCache(resolvedName);
+            }
+        }
+        logger.debug(`ToolCache: Set ${tools.length} tools for server [${serverId}]`, LOG_MODULES.CONNECTION_MANAGER);
+    }
+    /**
+     * Gets tools for a specific server instance.
+     *
+     * @param serverId - The server instance ID
+     * @returns Array of tools, empty if none
+     */
+    getTools(serverId) {
+        const tools = this.toolCache.get(serverId) || [];
+        const fromCache = this.toolCache.has(serverId);
+        logger.debug(`ToolCache: getTools for [${serverId}]: returned ${tools.length} tools (${fromCache ? 'from cache' : 'no cache'})`, LOG_MODULES.CONNECTION_MANAGER);
+        return tools;
+    }
+    /**
+     * Gets tools by server name from the server name-level cache.
+     *
+     * @param serverName - The server name
+     * @returns Array of tools, empty if none
+     */
+    getToolsByServerName(serverName) {
+        return this.serverNameToolCache.get(serverName) || [];
+    }
+    /**
+     * Gets a specific tool by name from the server name-level cache.
+     *
+     * @param serverName - The server name
+     * @param toolName - The tool name to find
+     * @returns The tool object or undefined if not found
+     */
+    getTool(serverName, toolName) {
+        const tools = this.serverNameToolCache.get(serverName);
+        return tools?.find((t) => t.name === toolName);
+    }
+    /**
+     * Gets all tools from all connected server instances.
+     *
+     * @returns Array of all tools from all servers
+     */
+    getAllTools() {
+        const allTools = [];
+        for (const tools of this.toolCache.values()) {
+            allTools.push(...tools);
+        }
+        return allTools;
+    }
+    /**
+     * Gets all tools from the server name-level cache.
+     *
+     * @returns Array of all tools aggregated by server name
+     */
+    getAllToolsByServerName() {
+        const allTools = [];
+        for (const tools of this.serverNameToolCache.values()) {
+            allTools.push(...tools);
+        }
+        return allTools;
+    }
+    /**
+     * Gets all tool cache entries.
+     *
+     * @returns Array of [serverId, tools] tuples
+     */
+    getToolCacheEntries() {
+        return Array.from(this.toolCache.entries());
+    }
+    /**
+     * Returns an iterator over the tool cache entries for backward compatibility.
+     * This mimics the Map.entries() method signature.
+     *
+     * @returns Iterator of [serverId, tools] tuples
+     * @deprecated Use getToolCacheEntries() instead
+     */
+    entries() {
+        return this.toolCache.entries();
+    }
+    /**
+     * Clears tools for a specific server and updates both caches.
+     *
+     * @param serverId - The server instance ID
+     */
+    clearTools(serverId) {
+        const serverName = this.getServerNameById(serverId);
+        this.toolCache.delete(serverId);
+        if (serverName !== 'unknown') {
+            this.updateServerNameCache(serverName);
+        }
+        logger.debug(`ToolCache: Cleared tools for server [${serverId}]`, LOG_MODULES.CONNECTION_MANAGER);
+    }
+    /**
+     * Updates the server name-level cache for a specific server.
+     * This aggregates tools from all instances of the same server name.
+     *
+     * @param serverName - The server name to update
+     */
+    updateServerNameCache(serverName) {
+        const allToolsForServer = [];
+        for (const [id, cachedTools] of this.toolCache.entries()) {
+            const instanceServerName = this.getServerNameById(id);
+            if (instanceServerName === serverName) {
+                allToolsForServer.push(...cachedTools);
+            }
+        }
+        if (allToolsForServer.length > 0) {
+            this.serverNameToolCache.set(serverName, allToolsForServer);
+        }
+        else {
+            this.serverNameToolCache.delete(serverName);
+        }
+    }
+    /**
+     * Backward compatibility: direct access to the underlying toolCache Map.
+     * This is maintained for backward compatibility with code that accesses
+     * mcpConnectionManager.toolCache directly.
+     */
+    get internalToolCache() {
+        return this.toolCache;
+    }
+}

package/dist/server/src/services/connection/types.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Represents the connection status and metadata of an MCP server instance.
+ *
+ * This interface tracks the operational state of connected MCP servers,
+ * including connection status, error information, resource counts, and
+ * process-level details for stdio-based servers.
+ *
+ * @interface ServerStatus
+ * @property {boolean} connected - Whether the server is currently connected
+ * @property {string} [error] - Error message if connection failed or was lost
+ * @property {number} lastCheck - Timestamp (milliseconds) of last status check
+ * @property {number} toolsCount - Number of tools available from this server
+ * @property {number} resourcesCount - Number of resources available from this server
+ * @property {number} [pid] - Process ID for stdio-based servers
+ * @property {number} [startTime] - Server startup timestamp (milliseconds)
+ * @property {string} [version] - Server version string from MCP protocol
+ * @property {string} [hash] - Unique identifier hash for the server instance
+ */
+export interface ServerStatus {
+    connected: boolean;
+    error?: string;
+    lastCheck: number;
+    toolsCount: number;
+    resourcesCount: number;
+    pid?: number;
+    startTime?: number;
+    version?: string;
+    hash?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/server/src/services/connection/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/services/connection/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf"}

package/dist/server/src/services/connection/types.js

@@ -0,0 +1 @@
+export {};

package/dist/server/src/services/event-bus.service.d.ts

@@ -0,0 +1,169 @@
+/**
+ * Event Bus Service
+ *
+ * Centralized event management system for decoupled communication between different modules
+ * throughout the MCP Hub Lite application. This service implements the publish-subscribe
+ * pattern to enable loose coupling between components while maintaining efficient
+ * event-driven architecture.
+ *
+ * The event bus handles various types of events including server status changes,
+ * connection state updates, tool registry changes, log entries, configuration updates,
+ * and system health notifications. It provides thread-safe operations with error
+ * handling for listener callbacks to prevent cascading failures.
+ *
+ * Usage scenarios:
+ * - Server management modules publish server lifecycle events
+ * - Connection managers notify about connection state changes
+ * - UI components subscribe to relevant events for real-time updates
+ * - Logging services broadcast log entries to interested parties
+ * - Configuration services announce configuration changes
+ *
+ * All public methods are safe to call from any part of the application, and the service
+ * automatically manages memory by cleaning up empty event type entries when all listeners
+ * are unsubscribed.
+ */
+import type { EventData } from '../models/event.model.js';
+/**
+ * Interface representing a published event with its type and associated data.
+ *
+ * @interface EventBusEvent
+ * @property {string} type - The event type identifier (e.g., 'server-connected', 'tools-updated')
+ * @property {EventData} data - The event payload containing relevant data for the event
+ */
+export interface EventBusEvent {
+    type: string;
+    data: EventData;
+}
+export declare class EventBusService {
+    private listeners;
+    /**
+     * Publishes an event to all subscribed listeners for the specified event type.
+     *
+     * This method notifies all registered listeners for the given event type by
+     * invoking their callback functions with the provided event data. Each listener
+     * is executed in a try-catch block to prevent errors in one listener from
+     * affecting other listeners or the publisher.
+     *
+     * @param {string} eventType - The type of event to publish (e.g., EventTypes.SERVER_CONNECTED)
+     * @param {EventData} data - The event payload data to be passed to all listeners
+     * @throws {Error} - Never throws; errors in listeners are caught and logged to console.error
+     *
+     * @example
+     * ```typescript
+     * eventBus.publish(EventTypes.SERVER_CONNECTED, { serverId: 'server-1', timestamp: Date.now() });
+     * ```
+     */
+    publish(eventType: string, data: EventData): void;
+    /**
+     * Subscribes a listener function to receive events of the specified type.
+     *
+     * Registers the provided listener callback to be invoked whenever an event
+     * of the specified type is published. Returns an unsubscribe function that
+     * can be called to remove the listener registration.
+     *
+     * The service automatically creates a new listener set for the event type
+     * if it doesn't already exist, ensuring safe concurrent access.
+     *
+     * @param {string} eventType - The event type to subscribe to (e.g., EventTypes.TOOLS_UPDATED)
+     * @param {(data: EventData) => void} listener - The callback function to invoke when the event is published
+     * @returns {() => void} A function that, when called, unsubscribes the listener from the event type
+     *
+     * @example
+     * ```typescript
+     * const unsubscribe = eventBus.subscribe(EventTypes.SERVER_DISCONNECTED, (data) => {
+     *   console.log('Server disconnected:', data.serverId);
+     * });
+     * // Later, to unsubscribe:
+     * unsubscribe();
+     * ```
+     */
+    subscribe(eventType: string, listener: (data: EventData) => void): () => void;
+    /**
+     * Unsubscribes a listener from receiving events of the specified type.
+     *
+     * Removes the specified listener from the registry for the given event type.
+     * If this was the last listener for the event type, the entire event type
+     * entry is removed from the registry to free memory.
+     *
+     * This method is private and should only be called internally by the
+     * unsubscribe function returned by the subscribe method.
+     *
+     * @param {string} eventType - The event type to unsubscribe from
+     * @param {(data: EventData) => void} listener - The listener function to remove
+     * @access private
+     */
+    private unsubscribe;
+    /**
+     * Unsubscribes all listeners from all event types.
+     *
+     * Clears the entire listener registry, effectively removing all subscriptions
+     * across all event types. This is typically used during application shutdown
+     * or when a complete reset of the event system is required.
+     *
+     * @returns {void}
+     *
+     * @example
+     * ```typescript
+     * // Clean up all event subscriptions before application shutdown
+     * eventBus.unsubscribeAll();
+     * ```
+     */
+    unsubscribeAll(): void;
+    /**
+     * Retrieves all currently registered event types that have active listeners.
+     *
+     * Returns an array of event type strings that currently have at least one
+     * subscribed listener. This can be useful for debugging, monitoring, or
+     * introspection purposes.
+     *
+     * @returns {string[]} Array of event type strings with active listeners
+     *
+     * @example
+     * ```typescript
+     * const activeEventTypes = eventBus.getEventTypes();
+     * console.log('Active event types:', activeEventTypes);
+     * ```
+     */
+    getEventTypes(): string[];
+    /**
+     * Gets the number of active listeners subscribed to a specific event type.
+     *
+     * Returns the count of listener functions currently registered for the
+     * specified event type. Returns 0 if no listeners are registered for
+     * the event type or if the event type doesn't exist.
+     *
+     * @param {string} eventType - The event type to check listener count for
+     * @returns {number} The number of active listeners for the event type (0 if none)
+     *
+     * @example
+     * ```typescript
+     * const listenerCount = eventBus.getListenerCount(EventTypes.LOG_ENTRY);
+     * console.log(`There are ${listenerCount} listeners for log entries`);
+     * ```
+     */
+    getListenerCount(eventType: string): number;
+}
+export declare const EventTypes: {
+    readonly SERVER_STATUS_CHANGE: "server-status";
+    readonly SERVER_CONNECTED: "server-connected";
+    readonly SERVER_DISCONNECTED: "server-disconnected";
+    readonly SERVER_ADDED: "server-added";
+    readonly SERVER_UPDATED: "server-updated";
+    readonly SERVER_DELETED: "server-deleted";
+    readonly SERVER_INSTANCE_ADDED: "server-instance-added";
+    readonly SERVER_INSTANCE_UPDATED: "server-instance-updated";
+    readonly SERVER_INSTANCE_DELETED: "server-instance-deleted";
+    readonly TOOLS_UPDATED: "tools";
+    readonly TOOL_CALL_STARTED: "tool-call-started";
+    readonly TOOL_CALL_COMPLETED: "tool-call-completed";
+    readonly TOOL_CALL_ERROR: "tool-call-error";
+    readonly RESOURCES_UPDATED: "resources";
+    readonly LOG_ENTRY: "log";
+    readonly LOGS_CLEARED: "logs-cleared";
+    readonly SYSTEM_HEALTH: "system-health";
+    readonly CONFIGURATION_UPDATED: "configuration-updated";
+    readonly CLIENT_CONNECTED: "client-connected";
+    readonly CLIENT_DISCONNECTED: "client-disconnected";
+};
+export declare const eventBus: EventBusService;
+//# sourceMappingURL=event-bus.service.d.ts.map

package/dist/server/src/services/event-bus.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-bus.service.d.ts","sourceRoot":"","sources":["../../../../src/services/event-bus.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAExD;;;;;;GAMG;AACH,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,SAAS,CAAC;CACjB;AAED,qBAAa,eAAe;IAC1B,OAAO,CAAC,SAAS,CAAqD;IAEtE;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,GAAG,IAAI;IAajD;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,SAAS,KAAK,IAAI,GAAG,MAAM,IAAI;IAU7E;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,WAAW;IAWnB;;;;;;;;;;;;;;OAcG;IACH,cAAc,IAAI,IAAI;IAItB;;;;;;;;;;;;;;OAcG;IACH,aAAa,IAAI,MAAM,EAAE;IAIzB;;;;;;;;;;;;;;;OAeG;IACH,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;CAI5C;AAGD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;CAkCb,CAAC;AAGX,eAAO,MAAM,QAAQ,iBAAwB,CAAC"}