test-proxy-recorder 0.1.0

package/dist/ProxyServer.js

@@ -0,0 +1,464 @@
+import fs from 'node:fs/promises';
+import http from 'node:http';
+import httpProxy from 'http-proxy';
+import { WebSocket, WebSocketServer } from 'ws';
+import { CONTROL_ENDPOINT, DEFAULT_TIMEOUT_MS, HTTP_STATUS_BAD_GATEWAY, HTTP_STATUS_BAD_REQUEST, HTTP_STATUS_NOT_FOUND, HTTP_STATUS_OK, } from './constants.js';
+import { Modes, } from './types.js';
+import { getRecordingPath, loadRecordingSession, saveRecordingSession, } from './utils/fileUtils.js';
+import { readRequestBody, sendJsonResponse } from './utils/httpHelpers.js';
+import { generateRequestKey } from './utils/requestKeyGenerator.js';
+export class ProxyServer {
+    targets;
+    currentTargetIndex;
+    mode;
+    recordingId;
+    replayId;
+    modeTimeout;
+    proxy;
+    currentSession;
+    recordingsDir;
+    constructor(targets, recordingsDir) {
+        this.targets = targets;
+        this.currentTargetIndex = 0;
+        this.mode = Modes.transparent;
+        this.recordingId = null;
+        this.replayId = null;
+        this.modeTimeout = null;
+        this.currentSession = null;
+        this.recordingsDir = recordingsDir;
+        this.proxy = httpProxy.createProxyServer({
+            secure: false,
+            changeOrigin: true,
+        });
+        this.setupProxyEventHandlers();
+    }
+    async init() {
+        await fs.mkdir(this.recordingsDir, { recursive: true });
+    }
+    listen(port) {
+        const server = http.createServer((req, res) => {
+            this.handleRequest(req, res);
+        });
+        // Handle WebSocket upgrade requests
+        server.on('upgrade', (req, socket, head) => {
+            this.handleUpgrade(req, socket, head);
+        });
+        server.listen(port, () => {
+            this.logServerStartup(port);
+        });
+        return server;
+    }
+    setupProxyEventHandlers() {
+        this.proxy.on('error', this.handleProxyError.bind(this));
+        this.proxy.on('proxyRes', this.handleProxyResponse.bind(this));
+    }
+    handleProxyError(err, _req, res) {
+        console.error('Proxy error:', err);
+        if (!(res instanceof http.ServerResponse)) {
+            return;
+        }
+        if (!res.headersSent) {
+            res.writeHead(HTTP_STATUS_BAD_GATEWAY, {
+                'Content-Type': 'application/json',
+            });
+        }
+        res.end(JSON.stringify({ error: 'Proxy error', message: err.message }));
+    }
+    handleProxyResponse(proxyRes, req) {
+        if (this.mode === Modes.record && this.recordingId) {
+            this.recordResponse(req, proxyRes);
+        }
+    }
+    getTarget() {
+        const target = this.targets[this.currentTargetIndex];
+        this.currentTargetIndex =
+            (this.currentTargetIndex + 1) % this.targets.length;
+        return target;
+    }
+    async handleControlRequest(req, res) {
+        try {
+            const body = await readRequestBody(req);
+            console.log('MODE CHANGE', body);
+            const data = JSON.parse(body);
+            const { mode, id, timeout: requestTimeout } = data;
+            const timeout = requestTimeout ?? DEFAULT_TIMEOUT_MS;
+            this.clearModeTimeout();
+            await this.switchMode(mode, id);
+            this.setupModeTimeout(timeout);
+            sendJsonResponse(res, HTTP_STATUS_OK, {
+                success: true,
+                mode: this.mode,
+                id: this.recordingId || this.replayId,
+                timeout,
+            });
+        }
+        catch (error) {
+            console.error('Control request error:', error);
+            sendJsonResponse(res, HTTP_STATUS_BAD_REQUEST, {
+                error: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    }
+    clearModeTimeout() {
+        if (this.modeTimeout) {
+            clearTimeout(this.modeTimeout);
+            this.modeTimeout = null;
+        }
+    }
+    async switchMode(mode, id) {
+        // Save current session before switching
+        if (this.currentSession) {
+            console.log('Switching mode, saving current session first');
+            await this.saveCurrentSession();
+            console.log('Session saved, continuing with mode switch');
+        }
+        switch (mode) {
+            case Modes.transparent: {
+                this.switchToTransparentMode();
+                break;
+            }
+            case Modes.record: {
+                this.switchToRecordMode(id);
+                break;
+            }
+            case Modes.replay: {
+                this.switchToReplayMode(id);
+                break;
+            }
+            default: {
+                throw new Error('Invalid mode. Use: transparent, record, or replay');
+            }
+        }
+    }
+    switchToTransparentMode() {
+        this.mode = Modes.transparent;
+        this.recordingId = null;
+        this.replayId = null;
+        this.currentSession = null;
+        console.log('Switched to transparent mode');
+    }
+    switchToRecordMode(id) {
+        if (!id) {
+            throw new Error('Record ID is required');
+        }
+        this.mode = Modes.record;
+        this.recordingId = id;
+        this.replayId = null;
+        this.currentSession = { id, recordings: [], websocketRecordings: [] };
+        console.log(`Switched to record mode with ID: ${id}`);
+    }
+    switchToReplayMode(id) {
+        if (!id) {
+            throw new Error('Replay ID is required');
+        }
+        this.mode = Modes.replay;
+        this.replayId = id;
+        this.recordingId = null;
+        this.currentSession = null;
+        console.log(`Switched to replay mode with ID: ${id}`);
+    }
+    setupModeTimeout(timeout) {
+        if (timeout && timeout > 0) {
+            this.modeTimeout = setTimeout(async () => {
+                console.log('Timeout reached, switching back to transparent mode');
+                await this.saveCurrentSession();
+                this.switchToTransparentMode();
+                this.modeTimeout = null;
+            }, timeout);
+        }
+    }
+    async saveCurrentSession() {
+        if (!this.currentSession) {
+            console.log('No current session to save');
+            return;
+        }
+        if (this.currentSession.recordings.length === 0 &&
+            this.currentSession.websocketRecordings.length === 0) {
+            console.log('Session has no recordings, skipping save');
+            return;
+        }
+        console.log(`Saving session with ${this.currentSession.recordings.length} HTTP and ${this.currentSession.websocketRecordings.length} WebSocket recordings`);
+        await saveRecordingSession(this.recordingsDir, this.currentSession);
+    }
+    async saveRequestRecord(req, body) {
+        if (!this.currentSession) {
+            return;
+        }
+        const key = generateRequestKey(req);
+        const record = {
+            request: {
+                method: req.method,
+                url: req.url,
+                headers: req.headers,
+                body: body || null,
+            },
+            timestamp: new Date().toISOString(),
+            key,
+        };
+        this.currentSession.recordings.push(record);
+    }
+    async recordResponse(req, proxyRes) {
+        if (!this.currentSession) {
+            return;
+        }
+        const key = generateRequestKey(req);
+        const record = this.currentSession.recordings.find((r) => r.key === key);
+        if (!record) {
+            console.error('Request record not found for response:', key);
+            return;
+        }
+        const chunks = [];
+        proxyRes.on('data', (chunk) => {
+            chunks.push(chunk);
+        });
+        proxyRes.on('end', async () => {
+            const body = Buffer.concat(chunks).toString('utf8');
+            record.response = {
+                statusCode: proxyRes.statusCode,
+                headers: proxyRes.headers,
+                body: body || null,
+            };
+            await this.saveCurrentSession();
+            console.log(`Recorded: ${req.method} ${req.url}`);
+        });
+    }
+    async handleReplayRequest(req, res) {
+        const key = generateRequestKey(req);
+        const filePath = getRecordingPath(this.recordingsDir, this.replayId);
+        try {
+            const session = await loadRecordingSession(filePath);
+            const record = session.recordings.find((r) => r.key === key);
+            if (!record) {
+                throw new Error(`No recording found for ${key}`);
+            }
+            if (!record.response) {
+                throw new Error('No response recorded for this request');
+            }
+            const { statusCode, headers, body } = record.response;
+            res.writeHead(statusCode, headers);
+            res.end(body);
+            console.log(`Replayed: ${req.method} ${req.url}`);
+        }
+        catch (error) {
+            this.handleReplayError(res, error, key, filePath);
+        }
+    }
+    handleReplayError(res, err, key, filePath) {
+        const isFileNotFound = err instanceof Error && 'code' in err && err.code === 'ENOENT';
+        console.error('Replay error:', err);
+        sendJsonResponse(res, HTTP_STATUS_NOT_FOUND, {
+            error: isFileNotFound
+                ? 'Recording file not found'
+                : 'Recording not found',
+            message: err instanceof Error ? err.message : 'Unknown error',
+            key,
+            filePath,
+        });
+    }
+    async handleRequest(req, res) {
+        if (req.url === CONTROL_ENDPOINT) {
+            return this.handleControlRequest(req, res);
+        }
+        if (this.mode === Modes.replay) {
+            return this.handleReplayRequest(req, res);
+        }
+        await this.handleProxyRequest(req, res);
+    }
+    async handleProxyRequest(req, res) {
+        const target = this.getTarget();
+        console.log(`[${this.mode}] ${req.method} ${req.url} -> ${target}`);
+        if (this.mode === Modes.record) {
+            await this.bufferRequestForRecord(req);
+        }
+        this.proxy.web(req, res, { target });
+    }
+    async bufferRequestForRecord(req) {
+        const chunks = [];
+        req.on('data', (chunk) => {
+            chunks.push(chunk);
+        });
+        req.on('end', async () => {
+            const body = Buffer.concat(chunks).toString('utf8');
+            await this.saveRequestRecord(req, body);
+        });
+    }
+    handleUpgrade(req, socket, head) {
+        if (this.mode === Modes.replay) {
+            this.handleReplayWebSocket(req, socket);
+            return;
+        }
+        const target = this.getTarget();
+        console.log(`[${this.mode}] WebSocket upgrade ${req.url} -> ${target}`);
+        if (this.mode === Modes.record) {
+            this.handleRecordWebSocket(req, socket, head, target);
+        }
+        else {
+            // Transparent mode - just proxy through
+            this.proxy.ws(req, socket, head, { target });
+        }
+    }
+    handleRecordWebSocket(req, clientSocket, head, target) {
+        const url = req.url || '/';
+        const key = `WS_${url.replaceAll('/', '_')}`;
+        const wsRecording = {
+            url,
+            messages: [],
+            timestamp: new Date().toISOString(),
+            key,
+        };
+        if (this.currentSession) {
+            this.currentSession.websocketRecordings.push(wsRecording);
+        }
+        // Create WebSocket connection to backend
+        const backendWsUrl = `${target.replace('http', 'ws')}${url}`;
+        const backendWs = new WebSocket(backendWsUrl);
+        // Create WebSocket server for client
+        const wss = new WebSocketServer({ noServer: true });
+        // Wait for backend connection before accepting client
+        backendWs.on('open', () => {
+            console.log(`WebSocket recording: connected to backend ${backendWsUrl}`);
+            wss.handleUpgrade(req, clientSocket, head, (clientWs) => {
+                // Forward messages from client to backend
+                clientWs.on('message', (data) => {
+                    const message = data.toString();
+                    // Record client message
+                    wsRecording.messages.push({
+                        direction: 'client-to-server',
+                        data: message,
+                        timestamp: new Date().toISOString(),
+                    });
+                    // Forward to backend if connected
+                    if (backendWs.readyState === WebSocket.OPEN) {
+                        backendWs.send(message);
+                    }
+                    this.saveCurrentSession().catch((error) => {
+                        console.error('Failed to save WebSocket recording:', error);
+                    });
+                });
+                // Forward messages from backend to client
+                backendWs.on('message', (data) => {
+                    const message = data.toString();
+                    // Record server message
+                    wsRecording.messages.push({
+                        direction: 'server-to-client',
+                        data: message,
+                        timestamp: new Date().toISOString(),
+                    });
+                    // Forward to client
+                    if (clientWs.readyState === WebSocket.OPEN) {
+                        clientWs.send(message);
+                    }
+                    this.saveCurrentSession().catch((error) => {
+                        console.error('Failed to save WebSocket recording:', error);
+                    });
+                });
+                // Handle errors
+                clientWs.on('error', (err) => {
+                    console.error('Client WebSocket error:', err);
+                });
+                backendWs.on('error', (err) => {
+                    console.error('Backend WebSocket error:', err);
+                });
+                // Handle close
+                clientWs.on('close', () => {
+                    backendWs.close();
+                    console.log('Client WebSocket closed');
+                });
+                backendWs.on('close', () => {
+                    clientWs.close();
+                    console.log('Backend WebSocket closed');
+                });
+            });
+        });
+        backendWs.on('error', (err) => {
+            console.error('Backend WebSocket connection error:', err);
+            clientSocket.write('HTTP/1.1 502 Bad Gateway\r\n\r\n');
+            clientSocket.destroy();
+        });
+        wss.on('error', (err) => {
+            console.error('WebSocket server error:', err);
+        });
+    }
+    handleReplayWebSocket(req, socket) {
+        const url = req.url || '/';
+        const key = `WS_${url.replaceAll('/', '_')}`;
+        const filePath = getRecordingPath(this.recordingsDir, this.replayId);
+        loadRecordingSession(filePath)
+            .then((session) => {
+            const wsRecording = session.websocketRecordings.find((r) => r.key === key);
+            if (!wsRecording) {
+                socket.write('HTTP/1.1 404 Not Found\r\n\r\n');
+                socket.destroy();
+                console.log(`No WebSocket recording found for ${key}`);
+                return;
+            }
+            // Create WebSocket server for replay
+            const wss = new WebSocketServer({ noServer: true });
+            // Fake upgrade request with proper headers
+            const fakeReq = Object.assign(req, {
+                headers: {
+                    ...req.headers,
+                    'sec-websocket-key': req.headers['sec-websocket-key'] || 'replay-key',
+                    'sec-websocket-version': '13',
+                },
+            });
+            wss.handleUpgrade(fakeReq, socket, Buffer.alloc(0), (ws) => {
+                console.log(`Replaying WebSocket: ${url}`);
+                // Replay server-to-client messages
+                const serverMessages = wsRecording.messages.filter((m) => m.direction === 'server-to-client');
+                let messageIndex = 0;
+                // Handle client messages and send corresponding server responses
+                ws.on('message', (data) => {
+                    const clientMessage = data.toString();
+                    console.log(`Replay: Client sent: ${clientMessage}`);
+                    // Send next server message if available
+                    if (messageIndex < serverMessages.length) {
+                        setTimeout(() => {
+                            if (ws.readyState === WebSocket.OPEN) {
+                                ws.send(serverMessages[messageIndex].data);
+                                console.log(`Replay: Sent server message ${messageIndex}`);
+                                messageIndex++;
+                            }
+                        }, 10);
+                    }
+                });
+                // Send initial server messages (those sent before any client message)
+                let initialMessagesSent = 0;
+                for (let i = 0; i < wsRecording.messages.length; i++) {
+                    const msg = wsRecording.messages[i];
+                    if (msg.direction === 'client-to-server') {
+                        break;
+                    }
+                    if (msg.direction === 'server-to-client') {
+                        setTimeout(() => {
+                            if (ws.readyState === WebSocket.OPEN) {
+                                ws.send(msg.data);
+                                console.log(`Replay: Sent initial server message: ${msg.data}`);
+                                messageIndex++;
+                                initialMessagesSent++;
+                            }
+                        }, 10 * (initialMessagesSent + 1));
+                    }
+                }
+                ws.on('error', (err) => {
+                    console.error('Replay WebSocket error:', err);
+                });
+                ws.on('close', () => {
+                    console.log('Replay WebSocket closed');
+                });
+            });
+        })
+            .catch((error) => {
+            console.error('Replay error:', error);
+            socket.write('HTTP/1.1 404 Not Found\r\n\r\n');
+            socket.destroy();
+        });
+    }
+    logServerStartup(port) {
+        console.log(`Proxy server running on http://localhost:${port}`);
+        console.log(`Mode: ${this.mode}`);
+        console.log(`Targets: ${this.targets.join(', ')}`);
+        console.log(`Control endpoint: http://localhost:${port}${CONTROL_ENDPOINT}`);
+    }
+}
+//# sourceMappingURL=ProxyServer.js.map

package/dist/cli.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+export interface CliOptions {
+    targets: string[];
+    port: number;
+    recordingsDir: string;
+}
+export declare function parseCliArgs(): CliOptions;
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AASA,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,wBAAgB,YAAY,IAAI,UAAU,CA6CzC"}

package/dist/cli.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+import path from 'node:path';
+import { Command } from 'commander';
+const DEFAULT_PORT = 8000;
+const DEFAULT_RECORDINGS_DIR = './recordings';
+export function parseCliArgs() {
+    const program = new Command();
+    program
+        .name('dev-proxy')
+        .description('Development proxy server with recording and replay capabilities')
+        .argument('<targets...>', 'Target API service URLs (e.g., http://localhost:3000)')
+        .option('-p, --port <number>', 'Port number for the proxy server', String(DEFAULT_PORT))
+        .option('-r, --recordings-dir <path>', 'Directory to store recordings (relative to CWD)', DEFAULT_RECORDINGS_DIR)
+        .action(() => {
+        // Action handled after parse
+    });
+    program.parse();
+    const targets = program.args;
+    const options = program.opts();
+    const port = Number.parseInt(options.port, 10);
+    if (Number.isNaN(port) || port < 1025 || port > 65_535) {
+        console.error('Error: Invalid port number. Must be between 1 and 65535');
+        process.exit(1);
+    }
+    if (targets.length === 0) {
+        program.help();
+    }
+    // Resolve recordings directory relative to the current working directory (where the command is run)
+    const recordingsDir = path.resolve(process.cwd(), options.recordingsDir);
+    return { targets, port, recordingsDir };
+}
+//# sourceMappingURL=cli.js.map

package/dist/constants.d.ts

@@ -0,0 +1,7 @@
+export declare const DEFAULT_TIMEOUT_MS: number;
+export declare const HTTP_STATUS_BAD_GATEWAY = 502;
+export declare const HTTP_STATUS_OK = 200;
+export declare const HTTP_STATUS_BAD_REQUEST = 400;
+export declare const HTTP_STATUS_NOT_FOUND = 404;
+export declare const CONTROL_ENDPOINT = "/__control";
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB,QAAa,CAAC;AAC7C,eAAO,MAAM,uBAAuB,MAAM,CAAC;AAC3C,eAAO,MAAM,cAAc,MAAM,CAAC;AAClC,eAAO,MAAM,uBAAuB,MAAM,CAAC;AAC3C,eAAO,MAAM,qBAAqB,MAAM,CAAC;AACzC,eAAO,MAAM,gBAAgB,eAAe,CAAC"}

package/dist/constants.js

@@ -0,0 +1,7 @@
+export const DEFAULT_TIMEOUT_MS = 120 * 1000;
+export const HTTP_STATUS_BAD_GATEWAY = 502;
+export const HTTP_STATUS_OK = 200;
+export const HTTP_STATUS_BAD_REQUEST = 400;
+export const HTTP_STATUS_NOT_FOUND = 404;
+export const CONTROL_ENDPOINT = '/__control';
+//# sourceMappingURL=constants.js.map

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { ProxyServer } from './ProxyServer';
+export type { ControlRequest, Mode, Recording, RecordingSession, WebSocketRecording, } from './types';
+export type { PlaywrightTestInfo, ProxyMode } from './playwright';
+export { generateSessionId, playwrightProxy, setProxyMode, startRecording, startReplay, stopProxy, } from './playwright';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,YAAY,EACV,cAAc,EACd,IAAI,EACJ,SAAS,EACT,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,SAAS,CAAC;AAGjB,YAAY,EAAE,kBAAkB,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAClE,OAAO,EACL,iBAAiB,EACjB,eAAe,EACf,YAAY,EACZ,cAAc,EACd,WAAW,EACX,SAAS,GACV,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,3 @@
+export { ProxyServer } from './ProxyServer';
+export { generateSessionId, playwrightProxy, setProxyMode, startRecording, startReplay, stopProxy, } from './playwright';
+//# sourceMappingURL=index.js.map

package/dist/playwright/index.d.ts

@@ -0,0 +1,48 @@
+import type { TestInfo } from '@playwright/test';
+export type ProxyMode = 'recording' | 'replay' | 'transparent';
+export type PlaywrightTestInfo = Pick<TestInfo, 'title'>;
+/**
+ * Set the proxy mode for a given session
+ * @param mode - The proxy mode to set (recording, replay, transparent)
+ * @param sessionId - Unique identifier for the session
+ * @param timeout - Optional timeout in milliseconds
+ */
+export declare function setProxyMode(mode: ProxyMode, sessionId: string, timeout?: number): Promise<void>;
+/**
+ * Generate a session ID from test info
+ * @param testInfo - Playwright test info object
+ */
+export declare function generateSessionId(testInfo: PlaywrightTestInfo): string;
+/**
+ * Start recording for a test
+ * @param testInfo - Playwright test info object
+ */
+export declare function startRecording(testInfo: PlaywrightTestInfo): Promise<void>;
+/**
+ * Start replay for a test
+ * @param testInfo - Playwright test info object
+ */
+export declare function startReplay(testInfo: PlaywrightTestInfo): Promise<void>;
+/**
+ * Stop recording/replay and return to transparent mode
+ * @param testInfo - Playwright test info object
+ */
+export declare function stopProxy(testInfo: PlaywrightTestInfo): Promise<void>;
+/**
+ * Playwright test fixture helper for managing proxy mode
+ * Use this in beforeEach/afterEach hooks
+ */
+export declare const playwrightProxy: {
+    /**
+     * Setup before test - sets the proxy mode
+     * @param testInfo - Playwright test info object
+     * @param mode - The proxy mode to use for this test
+     */
+    before(testInfo: PlaywrightTestInfo, mode: ProxyMode): Promise<void>;
+    /**
+     * Cleanup after test - returns to transparent mode
+     * @param testInfo - Playwright test info object
+     */
+    after(testInfo: PlaywrightTestInfo): Promise<void>;
+};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/playwright/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAKjD,MAAM,MAAM,SAAS,GAAG,WAAW,GAAG,QAAQ,GAAG,aAAa,CAAC;AAE/D,MAAM,MAAM,kBAAkB,GAAG,IAAI,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;AAQzD;;;;;GAKG;AACH,wBAAsB,YAAY,CAChC,IAAI,EAAE,SAAS,EACf,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,IAAI,CAAC,CA+Bf;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,kBAAkB,GAAG,MAAM,CAEtE;AAED;;;GAGG;AACH,wBAAsB,cAAc,CAClC,QAAQ,EAAE,kBAAkB,GAC3B,OAAO,CAAC,IAAI,CAAC,CAGf;AAED;;;GAGG;AACH,wBAAsB,WAAW,CAAC,QAAQ,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAG7E;AAED;;;GAGG;AACH,wBAAsB,SAAS,CAAC,QAAQ,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAG3E;AAED;;;GAGG;AACH,eAAO,MAAM,eAAe;IAC1B;;;;OAIG;qBACoB,kBAAkB,QAAQ,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;IAM1E;;;OAGG;oBACmB,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;CAIzD,CAAC"}