@frontmcp/testing 1.8.7 → 1.9.1-rc.1

package/perf/index.js

@@ -1308,8 +1308,453 @@ function isInterceptedError(err) {
   return typeof err === "object" && err !== null && interceptedErrors.has(err);
 }
 
-// libs/testing/src/transport/streamable-http.transport.ts
+// libs/testing/src/transport/sse.transport.ts
 var DEFAULT_TIMEOUT = 3e4;
+var SseTransport = class {
+  baseUrl;
+  entryPath;
+  timeout;
+  authHeaders;
+  publicMode;
+  debug;
+  clientInfo;
+  notificationHandler;
+  interceptors;
+  elicitationHandler;
+  state = "disconnected";
+  authToken;
+  sessionId;
+  messageEndpoint;
+  stream;
+  pending = /* @__PURE__ */ new Map();
+  connectionCount = 0;
+  reconnectCount = 0;
+  lastRequestHeaders = {};
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/$/, "");
+    this.entryPath = config.entryPath;
+    this.timeout = config.timeout ?? DEFAULT_TIMEOUT;
+    this.authHeaders = config.auth?.headers ?? {};
+    this.authToken = config.auth?.token;
+    this.publicMode = config.publicMode ?? false;
+    this.debug = config.debug ?? false;
+    this.clientInfo = config.clientInfo;
+    this.notificationHandler = config.notificationHandler;
+    this.interceptors = config.interceptors;
+    this.elicitationHandler = config.elicitationHandler;
+  }
+  async connect() {
+    this.state = "connecting";
+    this.connectionCount++;
+    try {
+      if (!this.publicMode && !this.authToken) {
+        await this.requestAnonymousToken();
+      }
+      await this.openStream();
+      this.state = "connected";
+      this.log(`Connected; messages go to ${this.messageEndpoint}`);
+    } catch (error) {
+      this.state = "error";
+      this.stream?.abort();
+      this.stream = void 0;
+      throw error;
+    }
+  }
+  async request(message) {
+    this.ensureConnected();
+    const startTime = Date.now();
+    if (this.interceptors) {
+      const intercepted = await this.interceptors.processRequest(message, {
+        timestamp: /* @__PURE__ */ new Date(),
+        transport: "sse",
+        sessionId: this.sessionId
+      });
+      switch (intercepted.type) {
+        case "mock":
+          return await this.interceptors.processResponse(
+            message,
+            intercepted.response,
+            Date.now() - startTime
+          );
+        case "error":
+          throw markInterceptedError(intercepted.error);
+        case "continue":
+          message = intercepted.request;
+          break;
+      }
+    }
+    let response;
+    if (message.id === void 0) {
+      await this.post(JSON.stringify(message));
+      response = { jsonrpc: "2.0", id: null, result: void 0 };
+    } else {
+      response = await this.postAndAwait(message.id, JSON.stringify(message));
+    }
+    if (this.interceptors) {
+      response = await this.interceptors.processResponse(message, response, Date.now() - startTime);
+    }
+    return response;
+  }
+  async notify(message) {
+    this.ensureConnected();
+    const result = await this.post(JSON.stringify(message));
+    if (!result.ok) this.log(`HTTP ${result.status} on notification: ${result.body}`);
+  }
+  async sendRaw(data) {
+    this.ensureConnected();
+    let id;
+    try {
+      const parsed = JSON.parse(data);
+      if (typeof parsed.id === "string" || typeof parsed.id === "number") id = parsed.id;
+    } catch {
+    }
+    if (id !== void 0) return this.postAndAwait(id, data);
+    const result = await this.post(data);
+    if (!result.ok) {
+      return { jsonrpc: "2.0", id: null, error: { code: -32700, message: "Parse error", data: result.body } };
+    }
+    return { jsonrpc: "2.0", id: null, result: void 0 };
+  }
+  async close() {
+    this.closeStream("Transport closed");
+    this.state = "disconnected";
+    this.sessionId = void 0;
+    this.messageEndpoint = void 0;
+    this.log("SSE transport closed");
+  }
+  isConnected() {
+    return this.state === "connected";
+  }
+  getState() {
+    return this.state;
+  }
+  getSessionId() {
+    return this.sessionId;
+  }
+  setAuthToken(token) {
+    this.authToken = token;
+  }
+  setTimeout(ms) {
+    this.timeout = ms;
+  }
+  getMessageEndpoint() {
+    return this.messageEndpoint;
+  }
+  getConnectionCount() {
+    return this.connectionCount;
+  }
+  getReconnectCount() {
+    return this.reconnectCount;
+  }
+  getLastRequestHeaders() {
+    return { ...this.lastRequestHeaders };
+  }
+  setInterceptors(interceptors2) {
+    this.interceptors = interceptors2;
+  }
+  getInterceptors() {
+    return this.interceptors;
+  }
+  setElicitationHandler(handler) {
+    this.elicitationHandler = handler;
+  }
+  async simulateDisconnect() {
+    this.closeStream("Simulated disconnect");
+    this.state = "disconnected";
+    this.sessionId = void 0;
+    this.messageEndpoint = void 0;
+  }
+  async waitForReconnect(timeoutMs) {
+    this.reconnectCount++;
+    let timer;
+    try {
+      await Promise.race([
+        this.connect(),
+        new Promise((_, reject) => {
+          timer = setTimeout(() => reject(new Error("Timeout waiting for reconnection")), timeoutMs);
+        })
+      ]);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  // ═══════════════════════════════════════════════════════════════════
+  // STREAM
+  // ═══════════════════════════════════════════════════════════════════
+  /** Open `GET <entry>/sse` and wait for the `endpoint` event. */
+  async openStream() {
+    const controller = new AbortController();
+    this.stream = controller;
+    const url = this.sseUrl();
+    const { "Content-Type": _contentType, ...headers } = this.buildHeaders();
+    this.log(`GET ${url}`);
+    const connectTimer = setTimeout(() => controller.abort(), this.timeout);
+    let response;
+    try {
+      response = await fetch(url, {
+        method: "GET",
+        headers: { ...headers, Accept: "text/event-stream" },
+        signal: controller.signal
+      });
+    } catch (error) {
+      clearTimeout(connectTimer);
+      throw new Error(
+        isAbortError(error) ? `SSE connection to ${url} timed out after ${this.timeout}ms` : `SSE connection to ${url} failed: ${errorMessage(error)}`,
+        { cause: error }
+      );
+    }
+    const isEventStream = response.headers.get("content-type")?.includes("text/event-stream") ?? false;
+    if (!response.ok || !response.body || !isEventStream) {
+      clearTimeout(connectTimer);
+      const body = await response.text().catch(() => "");
+      throw new Error(
+        `SSE connection to ${url} failed: HTTP ${response.status} ${response.statusText}${body ? ` \u2014 ${body}` : ""}. The legacy HTTP+SSE transport needs a server that serves it (@FrontMcp({ transport: { protocol: { legacy: true } } })).`
+      );
+    }
+    const endpoint = new Promise((resolve, reject) => {
+      const reader = response.body?.getReader();
+      if (!reader) {
+        reject(new Error(`SSE connection to ${url} has no body`));
+        return;
+      }
+      void this.readStream(controller, reader, resolve, reject);
+    });
+    try {
+      const data = await endpoint;
+      const messageUrl = new URL(data, url);
+      this.messageEndpoint = messageUrl.toString();
+      this.sessionId = messageUrl.searchParams.get("sessionId") ?? void 0;
+    } finally {
+      clearTimeout(connectTimer);
+    }
+  }
+  async readStream(controller, reader, onEndpoint, onEndpointError) {
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let endpointSeen = false;
+    try {
+      for (let chunk = await reader.read(); !chunk.done; chunk = await reader.read()) {
+        const { completeEvents, remainder } = splitSSEEvents(buffer + decoder.decode(chunk.value, { stream: true }));
+        buffer = remainder;
+        for (const text of completeEvents) {
+          const event = parseSSEEvent(text);
+          if (!event) continue;
+          if (event.type === "endpoint") {
+            if (!endpointSeen) {
+              endpointSeen = true;
+              onEndpoint(event.data);
+            }
+            continue;
+          }
+          await this.handleMessage(event.data);
+        }
+      }
+    } catch (error) {
+      if (!controller.signal.aborted) this.log("SSE stream failed:", error);
+    } finally {
+      reader.releaseLock();
+    }
+    if (!endpointSeen) {
+      onEndpointError(
+        new Error(
+          controller.signal.aborted ? `SSE stream at ${this.sseUrl()} sent no endpoint event within ${this.timeout}ms` : `SSE stream at ${this.sseUrl()} ended before the server sent its endpoint`
+        )
+      );
+    }
+    if (this.stream === controller) {
+      this.stream = void 0;
+      this.rejectPending("SSE stream closed by the server");
+      if (this.state === "connected") this.state = "disconnected";
+    }
+  }
+  async handleMessage(data) {
+    let message;
+    try {
+      message = JSON.parse(data);
+    } catch {
+      this.log("Ignoring SSE event that is not JSON:", data);
+      return;
+    }
+    if (!message || typeof message !== "object") return;
+    if (typeof message.method === "string") {
+      const request = message;
+      if (request.id === void 0 || request.id === null) {
+        this.notificationHandler?.(request);
+        return;
+      }
+      await this.answerServerRequest(request);
+      return;
+    }
+    if (message.id !== void 0 && message.id !== null) {
+      const pending = this.pending.get(message.id);
+      if (pending) {
+        clearTimeout(pending.timer);
+        this.pending.delete(message.id);
+        pending.resolve(message);
+      }
+    }
+  }
+  /** Server→client requests: elicitation goes to the handler, `ping` is answered, the rest refused. */
+  async answerServerRequest(request) {
+    const id = request.id;
+    let reply;
+    if (request.method === "elicitation/create") {
+      reply = { jsonrpc: "2.0", id, result: await this.elicit(request.params) };
+    } else if (request.method === "ping") {
+      reply = { jsonrpc: "2.0", id, result: {} };
+    } else {
+      reply = { jsonrpc: "2.0", id, error: { code: -32601, message: `Method not found: ${request.method}` } };
+    }
+    const result = await this.post(JSON.stringify(reply));
+    if (!result.ok) this.log(`HTTP ${result.status} answering ${request.method}: ${result.body}`);
+  }
+  async elicit(params) {
+    if (!this.elicitationHandler) return { action: "decline" };
+    try {
+      return await this.elicitationHandler(params);
+    } catch (error) {
+      this.log("Elicitation handler error:", error);
+      return { action: "cancel" };
+    }
+  }
+  closeStream(reason) {
+    const controller = this.stream;
+    this.stream = void 0;
+    controller?.abort();
+    this.rejectPending(reason);
+  }
+  rejectPending(reason) {
+    for (const [id, pending] of this.pending) {
+      clearTimeout(pending.timer);
+      pending.resolve({ jsonrpc: "2.0", id, error: { code: -32e3, message: reason } });
+    }
+    this.pending.clear();
+  }
+  // ═══════════════════════════════════════════════════════════════════
+  // POSTING
+  // ═══════════════════════════════════════════════════════════════════
+  /** POST a message and resolve with the response the stream carries for `id`. */
+  async postAndAwait(id, body) {
+    const answer = new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        resolve({ jsonrpc: "2.0", id, error: { code: -32e3, message: `Request timeout after ${this.timeout}ms` } });
+      }, this.timeout);
+      this.pending.set(id, { resolve, timer });
+    });
+    const result = await this.post(body);
+    if (!result.ok) {
+      const pending = this.pending.get(id);
+      if (pending) {
+        clearTimeout(pending.timer);
+        this.pending.delete(id);
+      }
+      return {
+        jsonrpc: "2.0",
+        id,
+        error: { code: -32e3, message: `HTTP ${result.status}: ${result.statusText}`, data: result.body }
+      };
+    }
+    return answer;
+  }
+  async post(body) {
+    const endpoint = this.messageEndpoint;
+    if (!endpoint) throw new Error("SSE transport has no message endpoint. Call connect() first.");
+    const headers = this.buildHeaders();
+    this.lastRequestHeaders = headers;
+    this.log(`POST ${endpoint}`, body);
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(endpoint, { method: "POST", headers, body, signal: controller.signal });
+      const text = await response.text();
+      return { ok: response.ok, status: response.status, statusText: response.statusText, body: text };
+    } catch (error) {
+      if (isAbortError(error)) {
+        return { ok: false, status: 0, statusText: `timeout after ${this.timeout}ms`, body: "" };
+      }
+      throw error;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  // ═══════════════════════════════════════════════════════════════════
+  // HELPERS
+  // ═══════════════════════════════════════════════════════════════════
+  async requestAnonymousToken() {
+    const url = new URL(this.baseUrl);
+    url.pathname = `${url.pathname.replace(/\/+$/, "")}/oauth/token`;
+    url.search = "";
+    const tokenUrl = url.toString();
+    try {
+      const response = await fetch(tokenUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ grant_type: "anonymous", client_id: crypto.randomUUID(), resource: this.baseUrl })
+      });
+      if (!response.ok) {
+        this.log(`No anonymous token (HTTP ${response.status})`);
+        return;
+      }
+      const token = await response.json();
+      if (token.access_token) this.authToken = token.access_token;
+    } catch (error) {
+      this.log("Error requesting anonymous token:", error);
+    }
+  }
+  /** `<baseUrl><entryPath>/sse`, built from URL parts so query params on `baseUrl` survive. */
+  sseUrl() {
+    const url = new URL(this.baseUrl);
+    const entry = (this.entryPath ?? "").replace(/^\/+|\/+$/g, "");
+    const basePath = url.pathname.replace(/\/+$/, "");
+    url.pathname = entry ? `${basePath}/${entry}/sse` : `${basePath}/sse`;
+    return url.toString();
+  }
+  buildHeaders() {
+    const headers = {
+      "Content-Type": "application/json",
+      Accept: "application/json, text/event-stream"
+    };
+    if (this.clientInfo) headers["User-Agent"] = `${this.clientInfo.name}/${this.clientInfo.version}`;
+    if (this.authToken) headers["Authorization"] = `Bearer ${this.authToken}`;
+    if (this.sessionId) headers["mcp-session-id"] = this.sessionId;
+    Object.assign(headers, this.authHeaders);
+    return headers;
+  }
+  ensureConnected() {
+    if (this.state !== "connected") {
+      throw new Error("Transport not connected. Call connect() first.");
+    }
+  }
+  log(message, data) {
+    if (this.debug) {
+      console.log(`[SSE] ${message}`, data ?? "");
+    }
+  }
+};
+function splitSSEEvents(buffer) {
+  const endsWithCarriageReturn = buffer.endsWith("\r");
+  const normalized = (endsWithCarriageReturn ? buffer.slice(0, -1) : buffer).replace(/\r\n?/g, "\n");
+  const completeEvents = normalized.split("\n\n");
+  const remainder = completeEvents.pop() ?? "";
+  return { completeEvents, remainder: endsWithCarriageReturn ? `${remainder}\r` : remainder };
+}
+function parseSSEEvent(text) {
+  let type = "message";
+  const data = [];
+  for (const line of text.split("\n")) {
+    if (line.startsWith(":")) continue;
+    const colon = line.indexOf(":");
+    const field = colon === -1 ? line : line.slice(0, colon);
+    const value = colon === -1 ? "" : line.slice(colon + 1).replace(/^ /, "");
+    if (field === "event") type = value;
+    else if (field === "data") data.push(value);
+  }
+  return data.length > 0 ? { type, data: data.join("\n") } : void 0;
+}
+
+// libs/testing/src/transport/streamable-http.transport.ts
+var DEFAULT_TIMEOUT2 = 3e4;
 var NOTIFICATION_STREAM_REOPEN_DELAY_MS = 250;
 var StreamableHttpTransport = class {
   config;
@@ -1331,7 +1776,7 @@ var StreamableHttpTransport = class {
       baseUrl: config.baseUrl.replace(/\/$/, ""),
       // Remove trailing slash
       entryPath: config.entryPath,
-      timeout: config.timeout ?? DEFAULT_TIMEOUT,
+      timeout: config.timeout ?? DEFAULT_TIMEOUT2,
       auth: config.auth ?? {},
       publicMode: config.publicMode ?? false,
       debug: config.debug ?? false,
@@ -1671,7 +2116,7 @@ var StreamableHttpTransport = class {
     let buffer = "";
     try {
       for (let chunk = await reader.read(); !chunk.done; chunk = await reader.read()) {
-        const { completeEvents, remainder } = splitSSEEvents(buffer + decoder.decode(chunk.value, { stream: true }));
+        const { completeEvents, remainder } = splitSSEEvents2(buffer + decoder.decode(chunk.value, { stream: true }));
         buffer = remainder;
         for (const eventText of completeEvents) {
           for (const event of this.parseSSEEvents(eventText, void 0).events) {
@@ -2005,7 +2450,7 @@ var StreamableHttpTransport = class {
     };
   }
 };
-function splitSSEEvents(buffer) {
+function splitSSEEvents2(buffer) {
   const endsWithCarriageReturn = buffer.endsWith("\r");
   const normalized = (endsWithCarriageReturn ? buffer.slice(0, -1) : buffer).replace(/\r\n?/g, "\n");
   const completeEvents = normalized.split("\n\n");
@@ -2243,7 +2688,7 @@ var McpTestClientBuilder = class {
 };
 
 // libs/testing/src/client/mcp-test-client.ts
-var DEFAULT_TIMEOUT2 = 3e4;
+var DEFAULT_TIMEOUT3 = 3e4;
 var DEFAULT_PROTOCOL_VERSION = "2025-06-18";
 var UNSUPPORTED_PROTOCOL_VERSIONS = ["2026-07-28"];
 var DEFAULT_CLIENT_INFO = {
@@ -2313,7 +2758,7 @@ var McpTestClient = class {
       transport: config.transport ?? "streamable-http",
       auth: config.auth ?? {},
       publicMode: config.publicMode ?? false,
-      timeout: config.timeout ?? DEFAULT_TIMEOUT2,
+      timeout: config.timeout ?? DEFAULT_TIMEOUT3,
       debug: config.debug ?? false,
       protocolVersion: config.protocolVersion ?? DEFAULT_PROTOCOL_VERSION,
       clientInfo: config.clientInfo ?? DEFAULT_CLIENT_INFO,
@@ -3079,7 +3524,18 @@ var McpTestClient = class {
           notificationHandler: this.recordNotification
         });
       case "sse":
-        throw new Error("SSE transport not yet implemented");
+        return new SseTransport({
+          baseUrl,
+          entryPath: this.config.entryPath,
+          timeout: this.config.timeout,
+          auth: this.config.auth,
+          publicMode: this.config.publicMode,
+          debug: this.config.debug,
+          interceptors: this._interceptors,
+          clientInfo: this.config.clientInfo,
+          elicitationHandler: this._elicitationHandler,
+          notificationHandler: this.recordNotification
+        });
       default:
         throw new Error(`Unknown transport type: ${this.config.transport}`);
     }

package/transport/index.d.ts

@@ -4,4 +4,5 @@
  */
 export type { McpTransport, TransportConfig, TransportState, JsonRpcRequest, JsonRpcResponse, NotificationHandler, } from './transport.interface';
 export { StreamableHttpTransport } from './streamable-http.transport';
+export { SseTransport } from './sse.transport';
 //# sourceMappingURL=index.d.ts.map

package/transport/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/transport/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,YAAY,EACV,YAAY,EACZ,eAAe,EACf,cAAc,EACd,cAAc,EACd,eAAe,EACf,mBAAmB,GACpB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/transport/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,YAAY,EACV,YAAY,EACZ,eAAe,EACf,cAAc,EACd,cAAc,EACd,eAAe,EACf,mBAAmB,GACpB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AACtE,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC"}

package/transport/sse.transport.d.ts

@@ -0,0 +1,80 @@
+/**
+ * @file sse.transport.ts
+ * @description Legacy HTTP+SSE transport (MCP 2024-11-05) for the MCP Test Client
+ *
+ * The client opens a long-lived `GET <entry>/sse` stream. The server's first event, `endpoint`,
+ * names the URL to POST JSON-RPC messages to (`<entry>/message?sessionId=…`). Every POST is
+ * answered `202 Accepted`; the JSON-RPC response arrives later as a `message` event on the
+ * stream, as do notifications and server→client requests (e.g. `elicitation/create`).
+ */
+import type { ElicitationHandler } from '../client/mcp-test-client.types';
+import type { InterceptorChain } from '../interceptor';
+import type { JsonRpcRequest, JsonRpcResponse, McpTransport, TransportConfig, TransportState } from './transport.interface';
+/**
+ * Legacy HTTP+SSE transport.
+ *
+ * Needs a server that serves the legacy SSE endpoints (`transport.protocol` with `legacy: true`,
+ * or `sse: true`). Requests are correlated with their responses by JSON-RPC id.
+ */
+export declare class SseTransport implements McpTransport {
+    private readonly baseUrl;
+    private readonly entryPath?;
+    private timeout;
+    private readonly authHeaders;
+    private readonly publicMode;
+    private readonly debug;
+    private readonly clientInfo?;
+    private readonly notificationHandler?;
+    private interceptors?;
+    private elicitationHandler?;
+    private state;
+    private authToken;
+    private sessionId;
+    private messageEndpoint;
+    private stream;
+    private readonly pending;
+    private connectionCount;
+    private reconnectCount;
+    private lastRequestHeaders;
+    constructor(config: TransportConfig);
+    connect(): Promise<void>;
+    request<T = unknown>(message: JsonRpcRequest): Promise<JsonRpcResponse & {
+        result?: T;
+    }>;
+    notify(message: JsonRpcRequest): Promise<void>;
+    sendRaw(data: string): Promise<JsonRpcResponse>;
+    close(): Promise<void>;
+    isConnected(): boolean;
+    getState(): TransportState;
+    getSessionId(): string | undefined;
+    setAuthToken(token: string): void;
+    setTimeout(ms: number): void;
+    getMessageEndpoint(): string | undefined;
+    getConnectionCount(): number;
+    getReconnectCount(): number;
+    getLastRequestHeaders(): Record<string, string>;
+    setInterceptors(interceptors: InterceptorChain): void;
+    getInterceptors(): InterceptorChain | undefined;
+    setElicitationHandler(handler: ElicitationHandler | undefined): void;
+    simulateDisconnect(): Promise<void>;
+    waitForReconnect(timeoutMs: number): Promise<void>;
+    /** Open `GET <entry>/sse` and wait for the `endpoint` event. */
+    private openStream;
+    private readStream;
+    private handleMessage;
+    /** Server→client requests: elicitation goes to the handler, `ping` is answered, the rest refused. */
+    private answerServerRequest;
+    private elicit;
+    private closeStream;
+    private rejectPending;
+    /** POST a message and resolve with the response the stream carries for `id`. */
+    private postAndAwait;
+    private post;
+    private requestAnonymousToken;
+    /** `<baseUrl><entryPath>/sse`, built from URL parts so query params on `baseUrl` survive. */
+    private sseUrl;
+    private buildHeaders;
+    private ensureConnected;
+    private log;
+}
+//# sourceMappingURL=sse.transport.d.ts.map

package/transport/sse.transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sse.transport.d.ts","sourceRoot":"","sources":["../../src/transport/sse.transport.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAwC,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AAChH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAEvD,OAAO,KAAK,EACV,cAAc,EACd,eAAe,EACf,YAAY,EAEZ,eAAe,EACf,cAAc,EACf,MAAM,uBAAuB,CAAC;AAc/B;;;;;GAKG;AACH,qBAAa,YAAa,YAAW,YAAY;IAC/C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAS;IACpC,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAyB;IACrD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAU;IACrC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAU;IAChC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAa;IACzC,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAC,CAAsB;IAC3D,OAAO,CAAC,YAAY,CAAC,CAAmB;IACxC,OAAO,CAAC,kBAAkB,CAAC,CAAqB;IAEhD,OAAO,CAAC,KAAK,CAAkC;IAC/C,OAAO,CAAC,SAAS,CAAqB;IACtC,OAAO,CAAC,SAAS,CAAqB;IACtC,OAAO,CAAC,eAAe,CAAqB;IAC5C,OAAO,CAAC,MAAM,CAA8B;IAC5C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA8C;IACtE,OAAO,CAAC,eAAe,CAAK;IAC5B,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,kBAAkB,CAA8B;gBAE5C,MAAM,EAAE,eAAe;IAc7B,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAkBxB,OAAO,CAAC,CAAC,GAAG,OAAO,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,eAAe,GAAG;QAAE,MAAM,CAAC,EAAE,CAAC,CAAA;KAAE,CAAC;IAuCxF,MAAM,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAM9C,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;IAkB/C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ5B,WAAW,IAAI,OAAO;IAItB,QAAQ,IAAI,cAAc;IAI1B,YAAY,IAAI,MAAM,GAAG,SAAS;IAIlC,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAIjC,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAI5B,kBAAkB,IAAI,MAAM,GAAG,SAAS;IAIxC,kBAAkB,IAAI,MAAM;IAI5B,iBAAiB,IAAI,MAAM;IAI3B,qBAAqB,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAI/C,eAAe,CAAC,YAAY,EAAE,gBAAgB,GAAG,IAAI;IAIrD,eAAe,IAAI,gBAAgB,GAAG,SAAS;IAI/C,qBAAqB,CAAC,OAAO,EAAE,kBAAkB,GAAG,SAAS,GAAG,IAAI;IAI9D,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC;IAOnC,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBxD,gEAAgE;YAClD,UAAU;YAsDV,UAAU;YAgDV,aAAa;IA8B3B,qGAAqG;YACvF,mBAAmB;YAcnB,MAAM;IAYpB,OAAO,CAAC,WAAW;IAOnB,OAAO,CAAC,aAAa;IAYrB,gFAAgF;YAClE,YAAY;YAyBZ,IAAI;YA2BJ,qBAAqB;IAuBnC,6FAA6F;IAC7F,OAAO,CAAC,MAAM;IAQd,OAAO,CAAC,YAAY;IAYpB,OAAO,CAAC,eAAe;IAMvB,OAAO,CAAC,GAAG;CAKZ"}