appium-ios-remotexpc 0.0.2 → 0.0.4

package/build/src/lib/tunnel/packet-stream-client.js

@@ -0,0 +1,152 @@
+import { logger } from '@appium/support';
+import { EventEmitter } from 'events';
+import { createConnection } from 'net';
+const log = logger.getLogger('PacketStreamClient');
+/**
+ * Constants for packet stream protocol
+ */
+const PACKET_LENGTH_PREFIX_SIZE = 10;
+/**
+ * Client that connects to a PacketStreamServer to receive packet data
+ * Implements the PacketSource interface required by SyslogService
+ */
+export class PacketStreamClient extends EventEmitter {
+    host;
+    port;
+    socket = null;
+    packetConsumers = new Set();
+    buffer = Buffer.alloc(0);
+    connected = false;
+    constructor(host, port) {
+        super();
+        this.host = host;
+        this.port = port;
+    }
+    async connect() {
+        if (this.connected) {
+            log.info('Already connected');
+            return;
+        }
+        return new Promise((resolve, reject) => {
+            this.socket = createConnection({ host: this.host, port: this.port }, () => {
+                log.info(`Connected to packet stream server at ${this.host}:${this.port}`);
+                this.connected = true;
+                resolve();
+            });
+            this.socket.on('data', (data) => {
+                this.handleData(data);
+            });
+            this.socket.once('close', () => {
+                log.info('Disconnected from packet stream server');
+                this.connected = false;
+                this.emit('close');
+            });
+            this.socket.on('error', (err) => {
+                log.error(`Socket error: ${err}`);
+                this.connected = false;
+                if (!this.socket) {
+                    reject(err);
+                }
+                else {
+                    this.emit('error', err);
+                }
+            });
+        });
+    }
+    isConnected() {
+        return this.connected;
+    }
+    async disconnect() {
+        if (this.socket && !this.socket.destroyed) {
+            this.socket.destroy();
+            this.socket = null;
+        }
+        this.connected = false;
+        this.packetConsumers.clear();
+    }
+    addPacketConsumer(consumer) {
+        this.packetConsumers.add(consumer);
+    }
+    removePacketConsumer(consumer) {
+        this.packetConsumers.delete(consumer);
+    }
+    /**
+     * Handle incoming data from the socket
+     */
+    handleData(data) {
+        this.buffer = Buffer.concat([this.buffer, data]);
+        this.processBuffer();
+    }
+    /**
+     * Process buffered data to extract complete messages
+     */
+    processBuffer() {
+        while (this.buffer.length >= PACKET_LENGTH_PREFIX_SIZE) {
+            const messageLength = this.extractMessageLength();
+            if (messageLength === null) {
+                // Invalid length, reset buffer
+                this.buffer = Buffer.alloc(0);
+                break;
+            }
+            const totalMessageSize = PACKET_LENGTH_PREFIX_SIZE + messageLength;
+            if (this.buffer.length < totalMessageSize) {
+                // Wait for more data
+                break;
+            }
+            const messageData = this.buffer.slice(PACKET_LENGTH_PREFIX_SIZE, totalMessageSize);
+            this.buffer = this.buffer.slice(totalMessageSize);
+            this.processMessage(messageData);
+        }
+    }
+    /**
+     * Extract message length from buffer
+     * @returns Message length or null if invalid
+     */
+    extractMessageLength() {
+        const lengthStr = this.buffer
+            .slice(0, PACKET_LENGTH_PREFIX_SIZE)
+            .toString();
+        const messageLength = parseInt(lengthStr, 10);
+        if (isNaN(messageLength)) {
+            log.error('Invalid message length, clearing buffer');
+            return null;
+        }
+        return messageLength;
+    }
+    /**
+     * Process a single message
+     */
+    processMessage(messageData) {
+        try {
+            const packet = this.parsePacket(messageData);
+            this.notifyConsumers(packet);
+        }
+        catch (err) {
+            log.error(`Error processing message: ${err}`);
+        }
+    }
+    /**
+     * Parse packet data from message buffer
+     */
+    parsePacket(messageData) {
+        const packet = JSON.parse(messageData.toString());
+        // Reconstruct Buffer from JSON
+        if (packet.payload && typeof packet.payload === 'object') {
+            packet.payload = Buffer.from(packet.payload);
+        }
+        return packet;
+    }
+    /**
+     * Notify all packet consumers
+     */
+    notifyConsumers(packet) {
+        for (const consumer of this.packetConsumers) {
+            try {
+                consumer.onPacket(packet);
+            }
+            catch (err) {
+                log.error(`Error in packet consumer: ${err}`);
+            }
+        }
+    }
+}

package/build/src/lib/tunnel/packet-stream-server.d.ts

@@ -0,0 +1,37 @@
+import { EventEmitter } from 'events';
+import type { PacketConsumer } from 'tuntap-bridge';
+/**
+ * Server that exposes packet streaming from a tunnel over TCP
+ * This allows cross-process access to tunnel packet streams
+ */
+export declare class PacketStreamServer extends EventEmitter {
+    private readonly port;
+    private server;
+    private readonly clients;
+    private packetConsumer;
+    constructor(port: number);
+    /**
+     * Start the packet stream server
+     * @throws {Error} If server is already started
+     */
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getPacketConsumer(): PacketConsumer | null;
+    /**
+     * Handle new client connection
+     */
+    private handleClientConnection;
+    /**
+     * Create packet consumer that broadcasts packets to all connected clients
+     */
+    private createPacketConsumer;
+    /**
+     * Broadcast packet to all connected clients
+     */
+    private broadcastPacket;
+    /**
+     * Create a message buffer with length prefix
+     */
+    private createMessage;
+}
+//# sourceMappingURL=packet-stream-server.d.ts.map

package/build/src/lib/tunnel/packet-stream-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"packet-stream-server.d.ts","sourceRoot":"","sources":["../../../../src/lib/tunnel/packet-stream-server.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAEtC,OAAO,KAAK,EAAE,cAAc,EAAc,MAAM,eAAe,CAAC;AAYhE;;;GAGG;AACH,qBAAa,kBAAmB,SAAQ,YAAY;IAKtC,OAAO,CAAC,QAAQ,CAAC,IAAI;IAJjC,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA0B;IAClD,OAAO,CAAC,cAAc,CAA+B;gBAExB,IAAI,EAAE,MAAM;IAIzC;;;OAGG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAqBtB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAgB3B,iBAAiB,IAAI,cAAc,GAAG,IAAI;IAI1C;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAe9B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAQ5B;;OAEG;IACH,OAAO,CAAC,eAAe;IAoBvB;;OAEG;IACH,OAAO,CAAC,aAAa;CAItB"}

package/build/src/lib/tunnel/packet-stream-server.js

@@ -0,0 +1,109 @@
+import { logger } from '@appium/support';
+import { EventEmitter } from 'events';
+import { createServer } from 'net';
+const log = logger.getLogger('PacketStreamServer');
+/**
+ * Server that exposes packet streaming from a tunnel over TCP
+ * This allows cross-process access to tunnel packet streams
+ */
+export class PacketStreamServer extends EventEmitter {
+    port;
+    server = null;
+    clients = new Set();
+    packetConsumer = null;
+    constructor(port) {
+        super();
+        this.port = port;
+    }
+    /**
+     * Start the packet stream server
+     * @throws {Error} If server is already started
+     */
+    async start() {
+        if (this.server) {
+            throw new Error('Server already started');
+        }
+        this.server = createServer((client) => {
+            this.handleClientConnection(client);
+        });
+        this.packetConsumer = this.createPacketConsumer();
+        return new Promise((resolve, reject) => {
+            this.server.listen(this.port, () => {
+                log.info(`Packet stream server listening on port ${this.port}`);
+                resolve();
+            });
+            this.server.on('error', reject);
+        });
+    }
+    async stop() {
+        for (const client of this.clients) {
+            client.destroy();
+        }
+        this.clients.clear();
+        if (this.server) {
+            return new Promise((resolve) => {
+                this.server?.close(() => {
+                    this.server = null;
+                    resolve();
+                });
+            });
+        }
+    }
+    getPacketConsumer() {
+        return this.packetConsumer;
+    }
+    /**
+     * Handle new client connection
+     */
+    handleClientConnection(client) {
+        log.info(`Client connected from ${client.remoteAddress}`);
+        this.clients.add(client);
+        client.on('close', () => {
+            log.info(`Client disconnected from ${client.remoteAddress}`);
+            this.clients.delete(client);
+        });
+        client.on('error', (err) => {
+            log.error(`Client error: ${err}`);
+            this.clients.delete(client);
+        });
+    }
+    /**
+     * Create packet consumer that broadcasts packets to all connected clients
+     */
+    createPacketConsumer() {
+        return {
+            onPacket: (packet) => {
+                this.broadcastPacket(packet);
+            },
+        };
+    }
+    /**
+     * Broadcast packet to all connected clients
+     */
+    broadcastPacket(packet) {
+        try {
+            const serialized = JSON.stringify(packet);
+            const message = this.createMessage(serialized);
+            for (const client of this.clients) {
+                if (!client.destroyed) {
+                    client.write(message, (err) => {
+                        if (err) {
+                            log.error(`Failed to write to client: ${err}`);
+                            this.clients.delete(client);
+                        }
+                    });
+                }
+            }
+        }
+        catch (err) {
+            log.error(`Failed to broadcast packet: ${err}`);
+        }
+    }
+    /**
+     * Create a message buffer with length prefix
+     */
+    createMessage(data) {
+        const lengthPrefix = data.length.toString().padStart(10, '0');
+        return Buffer.concat([Buffer.from(lengthPrefix), Buffer.from(data)]);
+    }
+}

package/build/src/lib/tunnel/tunnel-api-client.d.ts

@@ -0,0 +1,85 @@
+import type { TunnelRegistry, TunnelRegistryEntry } from '../types.js';
+/**
+ * API client for tunnel registry operations
+ * This client handles communication with the API server for tunnel data
+ */
+export declare class TunnelApiClient {
+    private apiBaseUrl;
+    /**
+     * Create a new TunnelApiClient
+     * @param apiBaseUrl - Base URL for the API server
+     */
+    constructor(apiBaseUrl?: string);
+    /**
+     * Set the API base URL
+     * @param url - New base URL for the API server
+     */
+    setApiBaseUrl(url: string): void;
+    /**
+     * Get the API base URL
+     * @returns The current API base URL
+     */
+    getApiBaseUrl(): string;
+    /**
+     * Fetch all tunnel registry data from the API server
+     * @returns The complete tunnel registry
+     */
+    fetchRegistry(): Promise<TunnelRegistry>;
+    /**
+     * Get a specific tunnel by UDID
+     * @param udid - Device UDID
+     * @returns Tunnel registry entry or null if not found
+     */
+    getTunnelByUdid(udid: string): Promise<TunnelRegistryEntry | null>;
+    /**
+     * Get tunnel by device ID
+     * @param deviceId - Device ID
+     * @returns Tunnel registry entry or null if not found
+     */
+    getTunnelByDeviceId(deviceId: number): Promise<TunnelRegistryEntry | null>;
+    /**
+     * Get all tunnels
+     * @returns Array of tunnel registry entries
+     */
+    getAllTunnels(): Promise<TunnelRegistryEntry[]>;
+    /**
+     * Check if a tunnel exists for a specific UDID
+     * @param udid - Device UDID
+     * @returns True if tunnel exists, false otherwise
+     */
+    hasTunnel(udid: string): Promise<boolean>;
+    /**
+     * Get registry metadata
+     * @returns Registry metadata
+     */
+    getMetadata(): Promise<TunnelRegistry['metadata']>;
+    /**
+     * Get tunnel connection details formatted for easy use
+     * @param udid - Device UDID
+     * @returns Connection details or null if tunnel not found
+     */
+    getTunnelConnection(udid: string): Promise<{
+        host: string;
+        port: number;
+        udid: string;
+        packetStreamPort: number;
+    } | null>;
+    /**
+     * List all available device UDIDs with tunnels
+     * @returns Array of device UDIDs
+     */
+    getAvailableDevices(): Promise<string[]>;
+    /**
+     * Update or create a tunnel entry
+     * @param entry - Tunnel registry entry to update or create
+     * @returns True if successful, false otherwise
+     */
+    updateTunnel(entry: TunnelRegistryEntry): Promise<boolean>;
+    /**
+     * Delete a tunnel entry
+     * @param udid - Device UDID
+     * @returns True if successful, false otherwise
+     */
+    deleteTunnel(udid: string): Promise<boolean>;
+}
+//# sourceMappingURL=tunnel-api-client.d.ts.map

package/build/src/lib/tunnel/tunnel-api-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tunnel-api-client.d.ts","sourceRoot":"","sources":["../../../../src/lib/tunnel/tunnel-api-client.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAIvE;;;GAGG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,UAAU,CAAS;IAE3B;;;OAGG;gBACS,UAAU,GAAE,MAAmD;IAI3E;;;OAGG;IACH,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAIhC;;;OAGG;IACH,aAAa,IAAI,MAAM;IAIvB;;;OAGG;IACG,aAAa,IAAI,OAAO,CAAC,cAAc,CAAC;IAuB9C;;;;OAIG;IACG,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC;IAmBxE;;;;OAIG;IACG,mBAAmB,CACvB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC;IAmBtC;;;OAGG;IACG,aAAa,IAAI,OAAO,CAAC,mBAAmB,EAAE,CAAC;IAUrD;;;;OAIG;IACG,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAK/C;;;OAGG;IACG,WAAW,IAAI,OAAO,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;IAcxD;;;;OAIG;IACG,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;QAC/C,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;QACb,gBAAgB,EAAE,MAAM,CAAC;KAC1B,GAAG,IAAI,CAAC;IAcT;;;OAGG;IACG,mBAAmB,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAU9C;;;;OAIG;IACG,YAAY,CAAC,KAAK,EAAE,mBAAmB,GAAG,OAAO,CAAC,OAAO,CAAC;IAiBhE;;;;OAIG;IACG,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;CAYnD"}

package/build/src/lib/tunnel/tunnel-api-client.js

@@ -0,0 +1,207 @@
+import { logger } from '@appium/support';
+const log = logger.getLogger('TunnelApiClient');
+/**
+ * API client for tunnel registry operations
+ * This client handles communication with the API server for tunnel data
+ */
+export class TunnelApiClient {
+    apiBaseUrl;
+    /**
+     * Create a new TunnelApiClient
+     * @param apiBaseUrl - Base URL for the API server
+     */
+    constructor(apiBaseUrl = 'http://localhost:42314/remotexpc/tunnels') {
+        this.apiBaseUrl = apiBaseUrl;
+    }
+    /**
+     * Set the API base URL
+     * @param url - New base URL for the API server
+     */
+    setApiBaseUrl(url) {
+        this.apiBaseUrl = url;
+    }
+    /**
+     * Get the API base URL
+     * @returns The current API base URL
+     */
+    getApiBaseUrl() {
+        return this.apiBaseUrl;
+    }
+    /**
+     * Fetch all tunnel registry data from the API server
+     * @returns The complete tunnel registry
+     */
+    async fetchRegistry() {
+        try {
+            const response = await fetch(this.apiBaseUrl);
+            if (!response.ok) {
+                throw new Error(`API request failed with status: ${response.status}`);
+            }
+            return (await response.json());
+        }
+        catch (error) {
+            log.warn(`Failed to fetch tunnel registry from API: ${error}`);
+            // Return empty registry as fallback
+            return {
+                tunnels: {},
+                metadata: {
+                    lastUpdated: new Date().toISOString(),
+                    totalTunnels: 0,
+                    activeTunnels: 0,
+                },
+            };
+        }
+    }
+    /**
+     * Get a specific tunnel by UDID
+     * @param udid - Device UDID
+     * @returns Tunnel registry entry or null if not found
+     */
+    async getTunnelByUdid(udid) {
+        try {
+            const response = await fetch(`${this.apiBaseUrl}/${udid}`);
+            if (response.status === 404) {
+                return null;
+            }
+            if (!response.ok) {
+                throw new Error(`API request failed with status: ${response.status}`);
+            }
+            return (await response.json());
+        }
+        catch (error) {
+            log.warn(`Failed to fetch tunnel for UDID ${udid}: ${error}`);
+            return null;
+        }
+    }
+    /**
+     * Get tunnel by device ID
+     * @param deviceId - Device ID
+     * @returns Tunnel registry entry or null if not found
+     */
+    async getTunnelByDeviceId(deviceId) {
+        try {
+            const response = await fetch(`${this.apiBaseUrl}/device/${deviceId}`);
+            if (response.status === 404) {
+                return null;
+            }
+            if (!response.ok) {
+                throw new Error(`API request failed with status: ${response.status}`);
+            }
+            return (await response.json());
+        }
+        catch (error) {
+            log.warn(`Failed to fetch tunnel for device ID ${deviceId}: ${error}`);
+            return null;
+        }
+    }
+    /**
+     * Get all tunnels
+     * @returns Array of tunnel registry entries
+     */
+    async getAllTunnels() {
+        try {
+            const registry = await this.fetchRegistry();
+            return Object.values(registry.tunnels);
+        }
+        catch (error) {
+            log.warn(`Failed to fetch all tunnels: ${error}`);
+            return [];
+        }
+    }
+    /**
+     * Check if a tunnel exists for a specific UDID
+     * @param udid - Device UDID
+     * @returns True if tunnel exists, false otherwise
+     */
+    async hasTunnel(udid) {
+        const tunnel = await this.getTunnelByUdid(udid);
+        return tunnel !== null;
+    }
+    /**
+     * Get registry metadata
+     * @returns Registry metadata
+     */
+    async getMetadata() {
+        try {
+            const registry = await this.fetchRegistry();
+            return registry.metadata;
+        }
+        catch (error) {
+            log.warn(`Failed to fetch registry metadata: ${error}`);
+            return {
+                lastUpdated: new Date().toISOString(),
+                totalTunnels: 0,
+                activeTunnels: 0,
+            };
+        }
+    }
+    /**
+     * Get tunnel connection details formatted for easy use
+     * @param udid - Device UDID
+     * @returns Connection details or null if tunnel not found
+     */
+    async getTunnelConnection(udid) {
+        const tunnel = await this.getTunnelByUdid(udid);
+        if (!tunnel) {
+            return null;
+        }
+        return {
+            host: tunnel.address,
+            port: tunnel.rsdPort,
+            udid: tunnel.udid,
+            packetStreamPort: tunnel.packetStreamPort,
+        };
+    }
+    /**
+     * List all available device UDIDs with tunnels
+     * @returns Array of device UDIDs
+     */
+    async getAvailableDevices() {
+        try {
+            const registry = await this.fetchRegistry();
+            return Object.keys(registry.tunnels);
+        }
+        catch (error) {
+            log.warn(`Failed to fetch available devices: ${error}`);
+            return [];
+        }
+    }
+    /**
+     * Update or create a tunnel entry
+     * @param entry - Tunnel registry entry to update or create
+     * @returns True if successful, false otherwise
+     */
+    async updateTunnel(entry) {
+        try {
+            const response = await fetch(`${this.apiBaseUrl}/${entry.udid}`, {
+                method: 'PUT',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(entry),
+            });
+            return response.ok;
+        }
+        catch (error) {
+            log.error(`Failed to update tunnel for UDID ${entry.udid}: ${error}`);
+            return false;
+        }
+    }
+    /**
+     * Delete a tunnel entry
+     * @param udid - Device UDID
+     * @returns True if successful, false otherwise
+     */
+    async deleteTunnel(udid) {
+        try {
+            const response = await fetch(`${this.apiBaseUrl}/${udid}`, {
+                method: 'DELETE',
+            });
+            return response.ok;
+        }
+        catch (error) {
+            log.error(`Failed to delete tunnel for UDID ${udid}: ${error}`);
+            return false;
+        }
+    }
+}

package/build/src/lib/tunnel/tunnel-registry-server.d.ts

@@ -0,0 +1,68 @@
+import type { TunnelRegistry } from '../types.js';
+/**
+ * Tunnel Registry Server - provides API endpoints for tunnel registry operations
+ */
+export declare class TunnelRegistryServer {
+    private server?;
+    port: number;
+    tunnelsInfo?: TunnelRegistry;
+    private registry;
+    /**
+     * Create a new TunnelRegistryServer
+     * @param tunnelsInfo - Registry data object
+     * @param port - Port to listen on
+     */
+    constructor(tunnelsInfo: TunnelRegistry | undefined, port: number);
+    /**
+     * Get tunnels from registry
+     */
+    private get tunnels();
+    /**
+     * Get auto-calculated metadata
+     */
+    private get metadata();
+    /**
+     * Get a complete registry with tunnels and metadata
+     */
+    private get fullRegistry();
+    /**
+     * Start the server
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the server
+     */
+    stop(): Promise<void>;
+    /**
+     * Main request handler
+     */
+    private handleRequest;
+    /**
+     * Handler for getting all tunnels
+     */
+    private getAllTunnels;
+    /**
+     * Handler for getting a tunnel by UDID
+     */
+    private getTunnelByUdid;
+    /**
+     * Handler for getting a tunnel by device ID
+     */
+    private getTunnelByDeviceId;
+    /**
+     * Handler for updating a tunnel
+     */
+    private updateTunnel;
+    /**
+     * Load the registry from provided data
+     */
+    private loadRegistry;
+}
+/**
+ * Create and start a TunnelRegistryServer instance
+ * @param tunnelInfos - Registry data object
+ * @param port - Port to listen on
+ * @returns The started TunnelRegistryServer instance
+ */
+export declare function startTunnelRegistryServer(tunnelInfos: TunnelRegistry | undefined, port?: number): Promise<TunnelRegistryServer>;
+//# sourceMappingURL=tunnel-registry-server.d.ts.map

package/build/src/lib/tunnel/tunnel-registry-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tunnel-registry-server.d.ts","sourceRoot":"","sources":["../../../../src/lib/tunnel/tunnel-registry-server.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAuB,MAAM,aAAa,CAAC;AAuDvE;;GAEG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,MAAM,CAAC,CAAc;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,cAAc,CAAC;IACpC,OAAO,CAAC,QAAQ,CAOd;IAEF;;;;OAIG;gBACS,WAAW,EAAE,cAAc,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM;IAKjE;;OAEG;IACH,OAAO,KAAK,OAAO,GAElB;IAED;;OAEG;IACH,OAAO,KAAK,QAAQ,GAOnB;IAED;;OAEG;IACH,OAAO,KAAK,YAAY,GAKvB;IAED;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAgC5B;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAuB3B;;OAEG;YACW,aAAa;IA6D3B;;OAEG;YACW,aAAa;IAY3B;;OAEG;YACW,eAAe;IAwB7B;;OAEG;YACW,mBAAmB;IAgCjC;;OAEG;YACW,YAAY;IAqD1B;;OAEG;YACW,YAAY;CAmB3B;AAED;;;;;GAKG;AACH,wBAAsB,yBAAyB,CAC7C,WAAW,EAAE,cAAc,GAAG,SAAS,EACvC,IAAI,GAAE,MAAqC,GAC1C,OAAO,CAAC,oBAAoB,CAAC,CAI/B"}