test-proxy-recorder 0.1.0 → 0.1.1

package/dist/proxy.js

@@ -1,8 +1,559 @@
-import { parseCliArgs } from './cli.js';
-import { ProxyServer } from './ProxyServer.js';
-const { targets, port, recordingsDir } = parseCliArgs();
-const proxy = new ProxyServer(targets, recordingsDir);
+import path from 'path';
+import { Command } from 'commander';
+import fs from 'fs/promises';
+import http from 'http';
+import httpProxy from 'http-proxy';
+import { WebSocket, WebSocketServer } from 'ws';
+
+// src/cli.ts
+var DEFAULT_PORT = 8e3;
+var DEFAULT_RECORDINGS_DIR = "./recordings";
+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(() => {
+  });
+  program.parse();
+  const targets2 = program.args;
+  const options = program.opts();
+  const port2 = Number.parseInt(options.port, 10);
+  if (Number.isNaN(port2) || port2 < 1025 || port2 > 65535) {
+    console.error("Error: Invalid port number. Must be between 1 and 65535");
+    process.exit(1);
+  }
+  if (targets2.length === 0) {
+    program.help();
+  }
+  const recordingsDir2 = path.resolve(process.cwd(), options.recordingsDir);
+  return { targets: targets2, port: port2, recordingsDir: recordingsDir2 };
+}
+
+// src/constants.ts
+var DEFAULT_TIMEOUT_MS = 120 * 1e3;
+var HTTP_STATUS_BAD_GATEWAY = 502;
+var HTTP_STATUS_OK = 200;
+var HTTP_STATUS_BAD_REQUEST = 400;
+var HTTP_STATUS_NOT_FOUND = 404;
+var CONTROL_ENDPOINT = "/__control";
+
+// src/types.ts
+var Modes = {
+  transparent: "transparent",
+  record: "record",
+  replay: "replay"
+};
+var JSON_INDENT_SPACES = 2;
+function getRecordingPath(recordingsDir2, id) {
+  return path.join(recordingsDir2, `${id}.json`);
+}
+async function loadRecordingSession(filePath) {
+  const fileContent = await fs.readFile(filePath, "utf8");
+  return JSON.parse(fileContent);
+}
+async function saveRecordingSession(recordingsDir2, session) {
+  const filePath = getRecordingPath(recordingsDir2, session.id);
+  await fs.writeFile(
+    filePath,
+    JSON.stringify(session, null, JSON_INDENT_SPACES)
+  );
+  console.log(
+    `Saved ${session.recordings.length} HTTP recordings and ${session.websocketRecordings?.length || 0} WebSocket recordings to ${filePath}`
+  );
+}
+
+// src/utils/httpHelpers.ts
+var CONTENT_TYPE_JSON = "application/json";
+async function readRequestBody(req) {
+  let body = "";
+  for await (const chunk of req) {
+    body += chunk.toString();
+  }
+  return body;
+}
+function sendJsonResponse(res, statusCode, data) {
+  res.writeHead(statusCode, { "Content-Type": CONTENT_TYPE_JSON });
+  res.end(JSON.stringify(data));
+}
+
+// src/utils/requestKeyGenerator.ts
+var QUERY_HASH_LENGTH = 8;
+function generateRequestKey(req) {
+  const urlParts = req.url.split("?");
+  const pathname = urlParts[0];
+  const query = urlParts[1] || "";
+  const normalizedPath = normalizePathname(pathname);
+  const queryHash = generateQueryHash(query);
+  return `${req.method}_${normalizedPath}${queryHash}.json`;
+}
+function normalizePathname(pathname) {
+  const normalized = pathname.replaceAll("/", "_").replace(/^_/, "");
+  return normalized || "root";
+}
+function generateQueryHash(query) {
+  if (!query) {
+    return "";
+  }
+  const hash = Buffer.from(query).toString("base64").replaceAll(/[^a-zA-Z0-9]/g, "").slice(0, Math.max(0, QUERY_HASH_LENGTH));
+  return `_${hash}`;
+}
+
+// src/ProxyServer.ts
+var ProxyServer = class {
+  targets;
+  currentTargetIndex;
+  mode;
+  recordingId;
+  replayId;
+  modeTimeout;
+  proxy;
+  currentSession;
+  recordingsDir;
+  constructor(targets2, recordingsDir2) {
+    this.targets = targets2;
+    this.currentTargetIndex = 0;
+    this.mode = Modes.transparent;
+    this.recordingId = null;
+    this.replayId = null;
+    this.modeTimeout = null;
+    this.currentSession = null;
+    this.recordingsDir = recordingsDir2;
+    this.proxy = httpProxy.createProxyServer({
+      secure: false,
+      changeOrigin: true
+    });
+    this.setupProxyEventHandlers();
+  }
+  async init() {
+    await fs.mkdir(this.recordingsDir, { recursive: true });
+  }
+  listen(port2) {
+    const server = http.createServer((req, res) => {
+      this.handleRequest(req, res);
+    });
+    server.on("upgrade", (req, socket, head) => {
+      this.handleUpgrade(req, socket, head);
+    });
+    server.listen(port2, () => {
+      this.logServerStartup(port2);
+    });
+    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) {
+    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: (/* @__PURE__ */ 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 {
+      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: (/* @__PURE__ */ new Date()).toISOString(),
+      key
+    };
+    if (this.currentSession) {
+      this.currentSession.websocketRecordings.push(wsRecording);
+    }
+    const backendWsUrl = `${target.replace("http", "ws")}${url}`;
+    const backendWs = new WebSocket(backendWsUrl);
+    const wss = new WebSocketServer({ noServer: true });
+    backendWs.on("open", () => {
+      console.log(`WebSocket recording: connected to backend ${backendWsUrl}`);
+      wss.handleUpgrade(req, clientSocket, head, (clientWs) => {
+        clientWs.on("message", (data) => {
+          const message = data.toString();
+          wsRecording.messages.push({
+            direction: "client-to-server",
+            data: message,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          if (backendWs.readyState === WebSocket.OPEN) {
+            backendWs.send(message);
+          }
+          this.saveCurrentSession().catch((error) => {
+            console.error("Failed to save WebSocket recording:", error);
+          });
+        });
+        backendWs.on("message", (data) => {
+          const message = data.toString();
+          wsRecording.messages.push({
+            direction: "server-to-client",
+            data: message,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          if (clientWs.readyState === WebSocket.OPEN) {
+            clientWs.send(message);
+          }
+          this.saveCurrentSession().catch((error) => {
+            console.error("Failed to save WebSocket recording:", error);
+          });
+        });
+        clientWs.on("error", (err) => {
+          console.error("Client WebSocket error:", err);
+        });
+        backendWs.on("error", (err) => {
+          console.error("Backend WebSocket error:", err);
+        });
+        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;
+      }
+      const wss = new WebSocketServer({ noServer: true });
+      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}`);
+        const serverMessages = wsRecording.messages.filter(
+          (m) => m.direction === "server-to-client"
+        );
+        let messageIndex = 0;
+        ws.on("message", (data) => {
+          const clientMessage = data.toString();
+          console.log(`Replay: Client sent: ${clientMessage}`);
+          if (messageIndex < serverMessages.length) {
+            setTimeout(() => {
+              if (ws.readyState === WebSocket.OPEN) {
+                ws.send(serverMessages[messageIndex].data);
+                console.log(`Replay: Sent server message ${messageIndex}`);
+                messageIndex++;
+              }
+            }, 10);
+          }
+        });
+        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(port2) {
+    console.log(`Proxy server running on http://localhost:${port2}`);
+    console.log(`Mode: ${this.mode}`);
+    console.log(`Targets: ${this.targets.join(", ")}`);
+    console.log(
+      `Control endpoint: http://localhost:${port2}${CONTROL_ENDPOINT}`
+    );
+  }
+};
+
+// src/proxy.ts
+var { targets, port, recordingsDir } = parseCliArgs();
+var proxy = new ProxyServer(targets, recordingsDir);
 await proxy.init();
 proxy.listen(port);
 console.log(`Recordings will be saved to: ${recordingsDir}`);
+//# sourceMappingURL=proxy.js.map
 //# sourceMappingURL=proxy.js.map

package/package.json

@@ -1,18 +1,20 @@
 {
   "name": "test-proxy-recorder",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "HTTP proxy server for recording and replaying network requests in testing. Works seamlessly with Playwright testing framework.",
   "type": "module",
-  "main": "dist/index.js",
+  "main": "dist/index.mjs",
   "types": "dist/index.d.ts",
   "exports": {
     ".": {
+      "require": "./dist/index.cjs",
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "default": "./dist/index.mjs"
     },
     "./playwright": {
+      "require": "./dist/playwright/index.cjs",
       "types": "./dist/playwright/index.d.ts",
-      "import": "./dist/playwright/index.js"
+      "default": "./dist/playwright/index.mjs"
     }
   },
   "bin": {
@@ -20,7 +22,10 @@
   },
   "files": [
     "dist/**/*.js",
+    "dist/**/*.mjs",
+    "dist/**/*.cjs",
     "dist/**/*.d.ts",
+    "dist/**/*.d.cts",
     "dist/**/*.d.ts.map",
     "!dist/**/*.test.*",
     "!dist/**/*.integration.test.*",
@@ -31,7 +36,7 @@
   "scripts": {
     "start": "node dist/proxy.js",
     "dev": "tsx src/proxy.ts",
-    "build": "tsc",
+    "build": "tsup",
     "prepublish": "pnpm run build && pnpm run test:run && pnpm run lint",
     "lint": "eslint src --ext .ts",
     "lint:fix": "eslint src --ext .ts --fix",
@@ -92,6 +97,7 @@
     "eslint-plugin-sonarjs": "^3.0.5",
     "eslint-plugin-unicorn": "^62.0.0",
     "prettier": "^3.6.2",
+    "tsup": "^8.5.0",
     "tsx": "^4.19.0",
     "typescript": "^5.6.0",
     "vitest": "^3.2.4",

package/dist/ProxyServer.d.ts

@@ -1,39 +0,0 @@
-import http from 'node:http';
-export declare class ProxyServer {
-    private targets;
-    private currentTargetIndex;
-    private mode;
-    private recordingId;
-    private replayId;
-    private modeTimeout;
-    private proxy;
-    private currentSession;
-    private recordingsDir;
-    constructor(targets: string[], recordingsDir: string);
-    init(): Promise<void>;
-    listen(port: number): http.Server;
-    private setupProxyEventHandlers;
-    private handleProxyError;
-    private handleProxyResponse;
-    private getTarget;
-    private handleControlRequest;
-    private clearModeTimeout;
-    private switchMode;
-    private switchToTransparentMode;
-    private switchToRecordMode;
-    private switchToReplayMode;
-    private setupModeTimeout;
-    private saveCurrentSession;
-    private saveRequestRecord;
-    private recordResponse;
-    private handleReplayRequest;
-    private handleReplayError;
-    private handleRequest;
-    private handleProxyRequest;
-    private bufferRequestForRecord;
-    private handleUpgrade;
-    private handleRecordWebSocket;
-    private handleReplayWebSocket;
-    private logServerStartup;
-}
-//# sourceMappingURL=ProxyServer.d.ts.map

package/dist/ProxyServer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ProxyServer.d.ts","sourceRoot":"","sources":["../src/ProxyServer.ts"],"names":[],"mappings":"AACA,OAAO,IAAI,MAAM,WAAW,CAAC;AA8B7B,qBAAa,WAAW;IACtB,OAAO,CAAC,OAAO,CAAW;IAC1B,OAAO,CAAC,kBAAkB,CAAS;IACnC,OAAO,CAAC,IAAI,CAAO;IACnB,OAAO,CAAC,WAAW,CAAgB;IACnC,OAAO,CAAC,QAAQ,CAAgB;IAChC,OAAO,CAAC,WAAW,CAAwB;IAC3C,OAAO,CAAC,KAAK,CAAY;IACzB,OAAO,CAAC,cAAc,CAA0B;IAChD,OAAO,CAAC,aAAa,CAAS;gBAElB,OAAO,EAAE,MAAM,EAAE,EAAE,aAAa,EAAE,MAAM;IAiB9C,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC,MAAM;IAiBjC,OAAO,CAAC,uBAAuB;IAK/B,OAAO,CAAC,gBAAgB;IAoBxB,OAAO,CAAC,mBAAmB;IAS3B,OAAO,CAAC,SAAS;YAOH,oBAAoB;IA8BlC,OAAO,CAAC,gBAAgB;YAOV,UAAU;IA8BxB,OAAO,CAAC,uBAAuB;IAQ/B,OAAO,CAAC,kBAAkB;IAW1B,OAAO,CAAC,kBAAkB;IAW1B,OAAO,CAAC,gBAAgB;YAWV,kBAAkB;YAoBlB,iBAAiB;YAuBjB,cAAc;YAmCd,mBAAmB;IA6BjC,OAAO,CAAC,iBAAiB;YAoBX,aAAa;YAeb,kBAAkB;YAclB,sBAAsB;IAepC,OAAO,CAAC,aAAa;IAqBrB,OAAO,CAAC,qBAAqB;IA2G7B,OAAO,CAAC,qBAAqB;IAqG7B,OAAO,CAAC,gBAAgB;CAQzB"}