@hazeljs/websocket 0.2.0-beta.1

package/dist/src/sse/sse.handler.js

@@ -0,0 +1,209 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SSEHandler = void 0;
+exports.createSSEResponse = createSSEResponse;
+exports.sendSSEMessage = sendSSEMessage;
+const core_1 = __importDefault(require("@hazeljs/core"));
+/**
+ * Server-Sent Events (SSE) handler
+ */
+class SSEHandler {
+    constructor() {
+        this.connections = new Map();
+        this.keepAliveIntervals = new Map();
+    }
+    /**
+     * Initialize SSE connection
+     */
+    initConnection(req, res, options = {}) {
+        const connectionId = this.generateConnectionId();
+        // Set SSE headers
+        res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            Connection: 'keep-alive',
+            'Access-Control-Allow-Origin': '*',
+            'X-Accel-Buffering': 'no', // Disable nginx buffering
+        });
+        // Send initial retry interval
+        if (options.retry) {
+            res.write(`retry: ${options.retry}\n\n`);
+        }
+        // Store connection
+        this.connections.set(connectionId, res);
+        // Setup keep-alive
+        const keepAliveInterval = options.keepAlive || 30000;
+        const interval = setInterval(() => {
+            if (this.connections.has(connectionId)) {
+                res.write(': keep-alive\n\n');
+            }
+            else {
+                clearInterval(interval);
+            }
+        }, keepAliveInterval);
+        this.keepAliveIntervals.set(connectionId, interval);
+        // Handle connection close
+        req.on('close', () => {
+            this.closeConnection(connectionId);
+        });
+        core_1.default.debug(`SSE connection initialized: ${connectionId}`);
+        return connectionId;
+    }
+    /**
+     * Send message to a specific connection
+     */
+    send(connectionId, message) {
+        const res = this.connections.get(connectionId);
+        if (!res) {
+            return false;
+        }
+        try {
+            let output = '';
+            // Add event type
+            if (message.event) {
+                output += `event: ${message.event}\n`;
+            }
+            // Add ID
+            if (message.id) {
+                output += `id: ${message.id}\n`;
+            }
+            // Add retry
+            if (message.retry) {
+                output += `retry: ${message.retry}\n`;
+            }
+            // Add data (can be multi-line)
+            const data = typeof message.data === 'string' ? message.data : JSON.stringify(message.data);
+            const lines = data.split('\n');
+            for (const line of lines) {
+                output += `data: ${line}\n`;
+            }
+            output += '\n';
+            res.write(output);
+            return true;
+        }
+        catch (error) {
+            core_1.default.error(`Failed to send SSE message to ${connectionId}:`, error);
+            return false;
+        }
+    }
+    /**
+     * Broadcast message to all connections
+     */
+    broadcast(message) {
+        for (const connectionId of this.connections.keys()) {
+            this.send(connectionId, message);
+        }
+        core_1.default.debug(`SSE broadcast: ${message.event || 'message'}`);
+    }
+    /**
+     * Close a specific connection
+     */
+    closeConnection(connectionId) {
+        const res = this.connections.get(connectionId);
+        if (res) {
+            res.end();
+            this.connections.delete(connectionId);
+        }
+        const interval = this.keepAliveIntervals.get(connectionId);
+        if (interval) {
+            clearInterval(interval);
+            this.keepAliveIntervals.delete(connectionId);
+        }
+        core_1.default.debug(`SSE connection closed: ${connectionId}`);
+    }
+    /**
+     * Close all connections
+     */
+    closeAll() {
+        for (const connectionId of this.connections.keys()) {
+            this.closeConnection(connectionId);
+        }
+        core_1.default.info('All SSE connections closed');
+    }
+    /**
+     * Get active connection count
+     */
+    getConnectionCount() {
+        return this.connections.size;
+    }
+    /**
+     * Check if connection exists
+     */
+    hasConnection(connectionId) {
+        return this.connections.has(connectionId);
+    }
+    /**
+     * Get all connection IDs
+     */
+    getConnectionIds() {
+        return Array.from(this.connections.keys());
+    }
+    /**
+     * Generate unique connection ID
+     */
+    generateConnectionId() {
+        return `sse-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+    /**
+     * Create a stream for continuous data
+     */
+    async *createStream(connectionId, dataSource, options = {}) {
+        try {
+            for await (const data of dataSource) {
+                const transformedData = options.transform ? options.transform(data) : data;
+                const sent = this.send(connectionId, {
+                    event: options.event,
+                    data: transformedData,
+                });
+                yield sent;
+                if (!sent) {
+                    break;
+                }
+            }
+        }
+        catch (error) {
+            core_1.default.error(`SSE stream error for ${connectionId}:`, error);
+        }
+    }
+}
+exports.SSEHandler = SSEHandler;
+/**
+ * Helper function to create SSE response
+ */
+function createSSEResponse(res, options = {}) {
+    res.writeHead(200, {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        Connection: 'keep-alive',
+        'Access-Control-Allow-Origin': '*',
+        'X-Accel-Buffering': 'no',
+    });
+    if (options.retry) {
+        res.write(`retry: ${options.retry}\n\n`);
+    }
+}
+/**
+ * Helper function to send SSE message
+ */
+function sendSSEMessage(res, message) {
+    let output = '';
+    if (message.event) {
+        output += `event: ${message.event}\n`;
+    }
+    if (message.id) {
+        output += `id: ${message.id}\n`;
+    }
+    if (message.retry) {
+        output += `retry: ${message.retry}\n`;
+    }
+    const data = typeof message.data === 'string' ? message.data : JSON.stringify(message.data);
+    const lines = data.split('\n');
+    for (const line of lines) {
+        output += `data: ${line}\n`;
+    }
+    output += '\n';
+    res.write(output);
+}

package/dist/src/websocket.gateway.d.ts

@@ -0,0 +1,94 @@
+import { WebSocketClient, WebSocketMessage, WebSocketStats, WebSocketServerOptions } from './websocket.types';
+import { RoomManager } from './room/room.manager';
+import { Server as HttpServer } from 'http';
+import { WebSocketServer } from 'ws';
+/**
+ * Base WebSocket Gateway class
+ */
+export declare class WebSocketGateway {
+    protected clients: Map<string, WebSocketClient>;
+    protected roomManager: RoomManager;
+    protected wss: WebSocketServer | null;
+    protected stats: WebSocketStats;
+    /**
+     * Attach WebSocket server to an existing HTTP server
+     */
+    attachToServer(server: HttpServer, options?: WebSocketServerOptions): WebSocketServer;
+    /**
+     * Create a standalone WebSocket server (without HTTP server)
+     */
+    listen(port: number, options?: WebSocketServerOptions): WebSocketServer;
+    /**
+     * Close the WebSocket server
+     */
+    close(): Promise<void>;
+    /**
+     * Handle client connection
+     */
+    protected handleConnection(client: WebSocketClient): void;
+    /**
+     * Handle client disconnection
+     */
+    protected handleDisconnection(clientId: string): void;
+    /**
+     * Handle incoming message
+     */
+    protected handleMessage(clientId: string, message: WebSocketMessage): void;
+    /**
+     * Send message to a specific client
+     */
+    sendToClient(clientId: string, event: string, data: unknown): boolean;
+    /**
+     * Broadcast message to all clients
+     */
+    broadcast(event: string, data: unknown, excludeClientId?: string): void;
+    /**
+     * Broadcast to a specific room
+     */
+    broadcastToRoom(roomName: string, event: string, data: unknown, excludeClientId?: string): void;
+    /**
+     * Add client to room
+     */
+    joinRoom(clientId: string, roomName: string): void;
+    /**
+     * Remove client from room
+     */
+    leaveRoom(clientId: string, roomName: string): void;
+    /**
+     * Get all clients
+     */
+    getClients(): WebSocketClient[];
+    /**
+     * Get client by ID
+     */
+    getClient(clientId: string): WebSocketClient | undefined;
+    /**
+     * Get connected client count
+     */
+    getClientCount(): number;
+    /**
+     * Get room clients
+     */
+    getRoomClients(roomName: string): string[];
+    /**
+     * Get client rooms
+     */
+    getClientRooms(clientId: string): string[];
+    /**
+     * Get statistics
+     */
+    getStats(): WebSocketStats;
+    /**
+     * Disconnect a client
+     */
+    disconnectClient(clientId: string): void;
+    /**
+     * Disconnect all clients
+     */
+    disconnectAll(): void;
+}
+/**
+ * Create a WebSocket client wrapper
+ */
+export declare function createWebSocketClient(socket: unknown, id: string): WebSocketClient;
+//# sourceMappingURL=websocket.gateway.d.ts.map

package/dist/src/websocket.gateway.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket.gateway.d.ts","sourceRoot":"","sources":["../../src/websocket.gateway.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,cAAc,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAC9G,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAElD,OAAO,EAAE,MAAM,IAAI,UAAU,EAAmB,MAAM,MAAM,CAAC;AAC7D,OAAkB,EAAE,eAAe,EAAE,MAAM,IAAI,CAAC;AAGhD;;GAEG;AACH,qBAAa,gBAAgB;IAC3B,SAAS,CAAC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,CAAa;IAC5D,SAAS,CAAC,WAAW,EAAE,WAAW,CAAqB;IACvD,SAAS,CAAC,GAAG,EAAE,eAAe,GAAG,IAAI,CAAQ;IAC7C,SAAS,CAAC,KAAK,EAAE,cAAc,CAQ7B;IAEF;;OAEG;IACH,cAAc,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,GAAE,sBAA2B,GAAG,eAAe;IAyCzF;;OAEG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,sBAA2B,GAAG,eAAe;IAqC3E;;OAEG;IACH,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAkBtB;;OAEG;IACH,SAAS,CAAC,gBAAgB,CAAC,MAAM,EAAE,eAAe,GAAG,IAAI;IAMzD;;OAEG;IACH,SAAS,CAAC,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAWrD;;OAEG;IACH,SAAS,CAAC,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,gBAAgB,GAAG,IAAI;IAM1E;;OAEG;IACH,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,OAAO;IAYrE;;OAEG;IACH,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI;IAavE;;OAEG;IACH,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI;IAK/F;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IASlD;;OAEG;IACH,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IASnD;;OAEG;IACH,UAAU,IAAI,eAAe,EAAE;IAI/B;;OAEG;IACH,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;IAIxD;;OAEG;IACH,cAAc,IAAI,MAAM;IAIxB;;OAEG;IACH,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE;IAI1C;;OAEG;IACH,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE;IAI1C;;OAEG;IACH,QAAQ,IAAI,cAAc;IAQ1B;;OAEG;IACH,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAQxC;;OAEG;IACH,aAAa,IAAI,IAAI;CAUtB;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,OAAO,EAAE,EAAE,EAAE,MAAM,GAAG,eAAe,CAsClF"}

package/dist/src/websocket.gateway.js

@@ -0,0 +1,309 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketGateway = void 0;
+exports.createWebSocketClient = createWebSocketClient;
+const room_manager_1 = require("./room/room.manager");
+const core_1 = __importDefault(require("@hazeljs/core"));
+const ws_1 = require("ws");
+const crypto_1 = require("crypto");
+/**
+ * Base WebSocket Gateway class
+ */
+class WebSocketGateway {
+    constructor() {
+        this.clients = new Map();
+        this.roomManager = new room_manager_1.RoomManager();
+        this.wss = null;
+        this.stats = {
+            connectedClients: 0,
+            totalRooms: 0,
+            messagesSent: 0,
+            messagesReceived: 0,
+            bytesSent: 0,
+            bytesReceived: 0,
+            uptime: Date.now(),
+        };
+    }
+    /**
+     * Attach WebSocket server to an existing HTTP server
+     */
+    attachToServer(server, options = {}) {
+        this.wss = new ws_1.WebSocketServer({
+            server,
+            path: options.path || '/ws',
+            perMessageDeflate: options.perMessageDeflate ?? false,
+            maxPayload: options.maxPayload || 1048576, // 1MB default
+            clientTracking: options.clientTracking ?? true,
+        });
+        this.wss.on('connection', (socket, request) => {
+            const clientId = (0, crypto_1.randomUUID)();
+            const client = createWebSocketClient(socket, clientId);
+            this.handleConnection(client);
+            socket.on('message', (data) => {
+                try {
+                    const parsed = JSON.parse(data.toString());
+                    this.handleMessage(clientId, parsed);
+                }
+                catch {
+                    core_1.default.warn(`Invalid WebSocket message from ${clientId}`);
+                }
+            });
+            socket.on('close', () => {
+                this.handleDisconnection(clientId);
+            });
+            socket.on('error', (error) => {
+                core_1.default.error(`WebSocket error for client ${clientId}:`, error);
+            });
+        });
+        this.wss.on('error', (error) => {
+            core_1.default.error('WebSocket server error:', error);
+        });
+        core_1.default.info(`WebSocket server attached at path: ${options.path || '/ws'}`);
+        return this.wss;
+    }
+    /**
+     * Create a standalone WebSocket server (without HTTP server)
+     */
+    listen(port, options = {}) {
+        this.wss = new ws_1.WebSocketServer({
+            port,
+            path: options.path,
+            perMessageDeflate: options.perMessageDeflate ?? false,
+            maxPayload: options.maxPayload || 1048576,
+            clientTracking: options.clientTracking ?? true,
+        });
+        this.wss.on('connection', (socket, request) => {
+            const clientId = (0, crypto_1.randomUUID)();
+            const client = createWebSocketClient(socket, clientId);
+            this.handleConnection(client);
+            socket.on('message', (data) => {
+                try {
+                    const parsed = JSON.parse(data.toString());
+                    this.handleMessage(clientId, parsed);
+                }
+                catch {
+                    core_1.default.warn(`Invalid WebSocket message from ${clientId}`);
+                }
+            });
+            socket.on('close', () => {
+                this.handleDisconnection(clientId);
+            });
+            socket.on('error', (error) => {
+                core_1.default.error(`WebSocket error for client ${clientId}:`, error);
+            });
+        });
+        core_1.default.info(`WebSocket server listening on port ${port}`);
+        return this.wss;
+    }
+    /**
+     * Close the WebSocket server
+     */
+    close() {
+        return new Promise((resolve, reject) => {
+            if (!this.wss) {
+                resolve();
+                return;
+            }
+            this.disconnectAll();
+            this.wss.close((err) => {
+                if (err)
+                    reject(err);
+                else {
+                    this.wss = null;
+                    core_1.default.info('WebSocket server closed');
+                    resolve();
+                }
+            });
+        });
+    }
+    /**
+     * Handle client connection
+     */
+    handleConnection(client) {
+        this.clients.set(client.id, client);
+        this.stats.connectedClients = this.clients.size;
+        core_1.default.info(`WebSocket client connected: ${client.id}`);
+    }
+    /**
+     * Handle client disconnection
+     */
+    handleDisconnection(clientId) {
+        const client = this.clients.get(clientId);
+        if (client) {
+            // Remove from all rooms
+            this.roomManager.removeClientFromAllRooms(clientId);
+            this.clients.delete(clientId);
+            this.stats.connectedClients = this.clients.size;
+            core_1.default.info(`WebSocket client disconnected: ${clientId}`);
+        }
+    }
+    /**
+     * Handle incoming message
+     */
+    handleMessage(clientId, message) {
+        this.stats.messagesReceived++;
+        this.stats.bytesReceived += JSON.stringify(message).length;
+        core_1.default.debug(`Message received from ${clientId}: ${message.event}`);
+    }
+    /**
+     * Send message to a specific client
+     */
+    sendToClient(clientId, event, data) {
+        const client = this.clients.get(clientId);
+        if (!client) {
+            return false;
+        }
+        client.send(event, data);
+        this.stats.messagesSent++;
+        this.stats.bytesSent += JSON.stringify(data).length;
+        return true;
+    }
+    /**
+     * Broadcast message to all clients
+     */
+    broadcast(event, data, excludeClientId) {
+        for (const [clientId, client] of this.clients) {
+            if (excludeClientId && clientId === excludeClientId) {
+                continue;
+            }
+            client.send(event, data);
+        }
+        this.stats.messagesSent += this.clients.size;
+        this.stats.bytesSent += JSON.stringify(data).length * this.clients.size;
+        core_1.default.debug(`Broadcast: ${event} to ${this.clients.size} clients`);
+    }
+    /**
+     * Broadcast to a specific room
+     */
+    broadcastToRoom(roomName, event, data, excludeClientId) {
+        this.roomManager.broadcastToRoom(roomName, event, data, this.clients, excludeClientId);
+        this.stats.messagesSent++;
+    }
+    /**
+     * Add client to room
+     */
+    joinRoom(clientId, roomName) {
+        const client = this.clients.get(clientId);
+        if (client) {
+            client.join(roomName);
+            this.roomManager.addClientToRoom(clientId, roomName);
+            this.stats.totalRooms = this.roomManager.getRoomCount();
+        }
+    }
+    /**
+     * Remove client from room
+     */
+    leaveRoom(clientId, roomName) {
+        const client = this.clients.get(clientId);
+        if (client) {
+            client.leave(roomName);
+            this.roomManager.removeClientFromRoom(clientId, roomName);
+            this.stats.totalRooms = this.roomManager.getRoomCount();
+        }
+    }
+    /**
+     * Get all clients
+     */
+    getClients() {
+        return Array.from(this.clients.values());
+    }
+    /**
+     * Get client by ID
+     */
+    getClient(clientId) {
+        return this.clients.get(clientId);
+    }
+    /**
+     * Get connected client count
+     */
+    getClientCount() {
+        return this.clients.size;
+    }
+    /**
+     * Get room clients
+     */
+    getRoomClients(roomName) {
+        return this.roomManager.getRoomClients(roomName);
+    }
+    /**
+     * Get client rooms
+     */
+    getClientRooms(clientId) {
+        return this.roomManager.getClientRooms(clientId);
+    }
+    /**
+     * Get statistics
+     */
+    getStats() {
+        return {
+            ...this.stats,
+            uptime: Date.now() - this.stats.uptime,
+            totalRooms: this.roomManager.getRoomCount(),
+        };
+    }
+    /**
+     * Disconnect a client
+     */
+    disconnectClient(clientId) {
+        const client = this.clients.get(clientId);
+        if (client) {
+            client.disconnect();
+            this.handleDisconnection(clientId);
+        }
+    }
+    /**
+     * Disconnect all clients
+     */
+    disconnectAll() {
+        for (const client of this.clients.values()) {
+            client.disconnect();
+        }
+        this.clients.clear();
+        this.roomManager.clear();
+        this.stats.connectedClients = 0;
+        this.stats.totalRooms = 0;
+        core_1.default.info('All WebSocket clients disconnected');
+    }
+}
+exports.WebSocketGateway = WebSocketGateway;
+/**
+ * Create a WebSocket client wrapper
+ */
+function createWebSocketClient(socket, id) {
+    const client = {
+        id,
+        socket,
+        metadata: new Map(),
+        rooms: new Set(),
+        send(event, data) {
+            try {
+                const message = JSON.stringify({ event, data, timestamp: Date.now() });
+                socket.send(message);
+            }
+            catch (error) {
+                core_1.default.error(`Failed to send message to client ${id}:`, error);
+            }
+        },
+        disconnect() {
+            try {
+                socket.close();
+            }
+            catch (error) {
+                core_1.default.error(`Failed to disconnect client ${id}:`, error);
+            }
+        },
+        join(room) {
+            this.rooms.add(room);
+        },
+        leave(room) {
+            this.rooms.delete(room);
+        },
+        inRoom(room) {
+            return this.rooms.has(room);
+        },
+    };
+    return client;
+}

package/dist/src/websocket.module.d.ts

@@ -0,0 +1,57 @@
+import { WebSocketServerOptions } from './websocket.types';
+import { SSEHandler } from './sse/sse.handler';
+import { RoomManager } from './room/room.manager';
+/**
+ * WebSocket module options
+ */
+export interface WebSocketModuleOptions extends WebSocketServerOptions {
+    /**
+     * Whether this is a global module
+     * @default true
+     */
+    isGlobal?: boolean;
+    /**
+     * Enable SSE support
+     * @default true
+     */
+    enableSSE?: boolean;
+    /**
+     * Enable room management
+     * @default true
+     */
+    enableRooms?: boolean;
+}
+/**
+ * WebSocket module for HazelJS
+ */
+export declare class WebSocketModule {
+    /**
+     * Configure WebSocket module
+     */
+    static forRoot(options?: WebSocketModuleOptions): {
+        module: typeof WebSocketModule;
+        providers: Array<{
+            provide: typeof SSEHandler | typeof RoomManager;
+            useValue: SSEHandler | RoomManager;
+        }>;
+        exports: Array<typeof SSEHandler | typeof RoomManager>;
+        global: boolean;
+    };
+    /**
+     * Configure WebSocket module asynchronously
+     */
+    static forRootAsync(options: {
+        useFactory: (...args: unknown[]) => Promise<WebSocketModuleOptions> | WebSocketModuleOptions;
+        inject?: unknown[];
+    }): {
+        module: typeof WebSocketModule;
+        providers: Array<{
+            provide: string | typeof SSEHandler | typeof RoomManager;
+            useFactory: unknown;
+            inject?: unknown[];
+        }>;
+        exports: Array<typeof SSEHandler | typeof RoomManager>;
+        global: boolean;
+    };
+}
+//# sourceMappingURL=websocket.module.d.ts.map

package/dist/src/websocket.module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket.module.d.ts","sourceRoot":"","sources":["../../src/websocket.module.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAGlD;;GAEG;AACH,MAAM,WAAW,sBAAuB,SAAQ,sBAAsB;IACpE;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IAEpB;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED;;GAEG;AACH,qBAIa,eAAe;IAC1B;;OAEG;IACH,MAAM,CAAC,OAAO,CAAC,OAAO,GAAE,sBAA2B,GAAG;QACpD,MAAM,EAAE,OAAO,eAAe,CAAC;QAC/B,SAAS,EAAE,KAAK,CAAC;YACf,OAAO,EAAE,OAAO,UAAU,GAAG,OAAO,WAAW,CAAC;YAChD,QAAQ,EAAE,UAAU,GAAG,WAAW,CAAC;SACpC,CAAC,CAAC;QACH,OAAO,EAAE,KAAK,CAAC,OAAO,UAAU,GAAG,OAAO,WAAW,CAAC,CAAC;QACvD,MAAM,EAAE,OAAO,CAAC;KACjB;IAkCD;;OAEG;IACH,MAAM,CAAC,YAAY,CAAC,OAAO,EAAE;QAC3B,UAAU,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,sBAAsB,CAAC,GAAG,sBAAsB,CAAC;QAC7F,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC;KACpB,GAAG;QACF,MAAM,EAAE,OAAO,eAAe,CAAC;QAC/B,SAAS,EAAE,KAAK,CAAC;YACf,OAAO,EAAE,MAAM,GAAG,OAAO,UAAU,GAAG,OAAO,WAAW,CAAC;YACzD,UAAU,EAAE,OAAO,CAAC;YACpB,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC;SACpB,CAAC,CAAC;QACH,OAAO,EAAE,KAAK,CAAC,OAAO,UAAU,GAAG,OAAO,WAAW,CAAC,CAAC;QACvD,MAAM,EAAE,OAAO,CAAC;KACjB;CA4BF"}