@casys/mcp-bridge 0.2.0

package/esm/adapters/telegram/types.js

@@ -0,0 +1,6 @@
+/**
+ * Telegram Mini App specific types.
+ *
+ * @see https://core.telegram.org/bots/webapps
+ */
+export {};

package/esm/client/bridge.js

@@ -0,0 +1,424 @@
+/**
+ * MCP Apps Bridge — Client-side runtime.
+ *
+ * Injected by the resource server into MCP App HTML pages.
+ * Intercepts postMessage calls from the MCP App class, routes them
+ * to the resource server via WebSocket, and dispatches responses
+ * back as MessageEvents.
+ *
+ * Query parameters (set by the resource server on the <script> tag):
+ *   - platform: "telegram" | "line"
+ *   - session: session ID (created by the resource server)
+ *
+ * @module bridge.js
+ */
+(function () {
+  "use strict";
+
+  // ---------------------------------------------------------------------------
+  // Read configuration from script tag query params
+  // ---------------------------------------------------------------------------
+
+  var currentScript = document.currentScript;
+  if (!currentScript) {
+    console.error("[bridge.js] Cannot find own <script> element.");
+    return;
+  }
+
+  var scriptUrl = new URL(currentScript.src);
+  var PLATFORM = scriptUrl.searchParams.get("platform") || "unknown";
+  var SESSION_ID = scriptUrl.searchParams.get("session");
+  if (!SESSION_ID) {
+    console.error("[bridge.js] Missing 'session' query parameter.");
+    return;
+  }
+
+  var WS_BASE = scriptUrl.origin;
+  var WS_URL = WS_BASE.replace(/^http/, "ws") + "/bridge?session=" + SESSION_ID;
+  var DEBUG = scriptUrl.searchParams.get("debug") === "1";
+
+  function log() {
+    if (DEBUG) {
+      console.log.apply(console, ["[bridge.js]"].concat(Array.prototype.slice.call(arguments)));
+    }
+  }
+
+  log("Platform:", PLATFORM, "Session:", SESSION_ID);
+
+  // ---------------------------------------------------------------------------
+  // JSON-RPC helpers
+  // ---------------------------------------------------------------------------
+
+  function isJsonRpc(msg) {
+    return msg && typeof msg === "object" && msg.jsonrpc === "2.0";
+  }
+
+  function isRequest(msg) {
+    return "method" in msg && "id" in msg;
+  }
+
+  function isResponse(msg) {
+    return ("result" in msg || "error" in msg) && "id" in msg;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Platform detection: Telegram theme
+  // ---------------------------------------------------------------------------
+
+  function getTelegramTheme() {
+    var tg = window.Telegram && window.Telegram.WebApp;
+    if (!tg) {
+      return {
+        theme: "light",
+        styles: { variables: {} },
+        platform: "mobile",
+      };
+    }
+
+    var isDark = tg.colorScheme === "dark";
+    var tp = tg.themeParams || {};
+    var variables = {};
+    var keys = Object.keys(tp);
+    for (var i = 0; i < keys.length; i++) {
+      variables["--tg-" + keys[i].replace(/_/g, "-")] = tp[keys[i]];
+    }
+
+    return {
+      theme: isDark ? "dark" : "light",
+      styles: { variables: variables },
+      platform: "mobile",
+      locale: tg.initDataUnsafe && tg.initDataUnsafe.user
+        ? tg.initDataUnsafe.user.language_code
+        : undefined,
+    };
+  }
+
+  // ---------------------------------------------------------------------------
+  // Request tracking (for matching responses to outgoing requests)
+  // ---------------------------------------------------------------------------
+
+  var pendingRequests = {}; // id -> { resolve, reject, timer }
+  var REQUEST_TIMEOUT_MS = 30000;
+  var appInitialized = false;
+  var earlyNotifications = []; // notifications received before ui/initialize
+
+  function trackRequest(id) {
+    return new Promise(function (resolve, reject) {
+      var timer = setTimeout(function () {
+        delete pendingRequests[id];
+        reject(new Error("Request " + id + " timed out after " + REQUEST_TIMEOUT_MS + "ms"));
+      }, REQUEST_TIMEOUT_MS);
+
+      pendingRequests[id] = { resolve: resolve, reject: reject, timer: timer };
+    });
+  }
+
+  function resolveRequest(id, result) {
+    var entry = pendingRequests[id];
+    if (entry) {
+      clearTimeout(entry.timer);
+      delete pendingRequests[id];
+      entry.resolve(result);
+    }
+  }
+
+  function rejectRequest(id, error) {
+    var entry = pendingRequests[id];
+    if (entry) {
+      clearTimeout(entry.timer);
+      delete pendingRequests[id];
+      entry.reject(error);
+    }
+  }
+
+  // ---------------------------------------------------------------------------
+  // ui/initialize handler (synthesized locally)
+  // ---------------------------------------------------------------------------
+
+  function handleInitialize(requestId) {
+    var hostCtx = getTelegramTheme();
+
+    var response = {
+      jsonrpc: "2.0",
+      id: requestId,
+      result: {
+        protocolVersion: "2025-11-25",
+        hostInfo: {
+          name: "@casys/mcp-apps-bridge",
+          version: "0.1.0",
+        },
+        hostCapabilities: {
+          serverTools: { listChanged: false },
+          serverResources: { listChanged: false },
+          logging: {},
+          openLinks: {},
+        },
+        hostContext: hostCtx,
+      },
+    };
+
+    dispatchToApp(response);
+
+    // App is now ready — flush any notifications received before init
+    appInitialized = true;
+    if (earlyNotifications.length > 0) {
+      log("Flushing", earlyNotifications.length, "early notification(s)");
+      for (var i = 0; i < earlyNotifications.length; i++) {
+        dispatchToApp(earlyNotifications[i]);
+      }
+      earlyNotifications = [];
+    }
+  }
+
+  // ---------------------------------------------------------------------------
+  // Dispatch to App (via MessageEvent on window)
+  // ---------------------------------------------------------------------------
+
+  function dispatchToApp(message) {
+    log("-> App:", message.method || ("id" in message ? "response#" + message.id : "?"));
+    // Use real postMessage so event.source === window (=== window.parent in standalone).
+    // The MCP Apps SDK checks event.source — dispatchEvent leaves it null.
+    // Use the script origin as targetOrigin instead of "*" to prevent message leaking.
+    _realPostMessage(message, scriptUrl.origin);
+  }
+
+  // ---------------------------------------------------------------------------
+  // WebSocket connection
+  // ---------------------------------------------------------------------------
+
+  var ws = null;
+  var reconnectAttempts = 0;
+  var MAX_RECONNECT = 5;
+  var authenticated = false;
+
+  function connectWs() {
+    log("Connecting to", WS_URL);
+    ws = new WebSocket(WS_URL);
+
+    ws.onopen = function () {
+      log("WebSocket connected");
+      reconnectAttempts = 0;
+
+      // Send auth immediately if Telegram SDK is available
+      var tg = window.Telegram && window.Telegram.WebApp;
+      if (tg && tg.initData) {
+        log("Sending Telegram auth...");
+        ws.send(JSON.stringify({ type: "auth", initData: tg.initData }));
+      } else {
+        // No Telegram SDK — server will decide if auth is required
+        log("No Telegram SDK, dispatching ready without auth");
+        authenticated = true;
+        window.dispatchEvent(new CustomEvent("mcp-bridge-ready", {
+          detail: { platform: PLATFORM, session: SESSION_ID },
+        }));
+      }
+    };
+
+    ws.onmessage = function (event) {
+      try {
+        var msg = JSON.parse(event.data);
+        // Handle auth responses (non-JSON-RPC)
+        if (msg && msg.type === "auth_ok") {
+          log("Authenticated, userId:", msg.userId);
+          authenticated = true;
+          window.dispatchEvent(new CustomEvent("mcp-bridge-ready", {
+            detail: { platform: PLATFORM, session: SESSION_ID, userId: msg.userId },
+          }));
+          return;
+        }
+
+        if (msg && msg.type === "auth_error") {
+          console.error("[bridge.js] Authentication failed:", msg.error);
+          window.dispatchEvent(new CustomEvent("mcp-bridge-auth-error", {
+            detail: { error: msg.error },
+          }));
+          return;
+        }
+
+        if (!isJsonRpc(msg)) return;
+
+        // Responses: resolve tracked requests
+        if (isResponse(msg)) {
+          if ("error" in msg) {
+            rejectRequest(msg.id, msg.error);
+          } else {
+            resolveRequest(msg.id, msg.result);
+          }
+          // The trackRequest().then() will call dispatchToApp
+          return;
+        }
+
+        // Notifications from server
+        if ("method" in msg && !("id" in msg)) {
+          if (!appInitialized) {
+            log("Queuing early notification:", msg.method);
+            earlyNotifications.push(msg);
+          } else {
+            dispatchToApp(msg);
+          }
+        }
+      } catch (err) {
+        console.warn("[bridge.js] Failed to parse WS message:", err);
+      }
+    };
+
+    ws.onclose = function () {
+      log("WebSocket disconnected");
+      ws = null;
+      if (reconnectAttempts < MAX_RECONNECT) {
+        reconnectAttempts++;
+        var delay = Math.min(1000 * Math.pow(2, reconnectAttempts - 1), 10000);
+        log("Reconnecting in", delay, "ms (attempt", reconnectAttempts + ")");
+        setTimeout(connectWs, delay);
+      }
+    };
+
+    ws.onerror = function () {
+      log("WebSocket error");
+    };
+  }
+
+  function sendToServer(message) {
+    if (!ws || ws.readyState !== WebSocket.OPEN) {
+      console.warn("[bridge.js] WebSocket not connected. Dropping message:", message);
+      return;
+    }
+    if (!authenticated) {
+      console.warn("[bridge.js] Not authenticated yet. Dropping message:", message);
+      return;
+    }
+    ws.send(JSON.stringify(message));
+  }
+
+  // ---------------------------------------------------------------------------
+  // Intercept postMessage (App -> Bridge)
+  // ---------------------------------------------------------------------------
+
+  // Save the REAL postMessage before we monkey-patch it.
+  // Used by dispatchToApp() so that event.source === window,
+  // which the MCP Apps SDK checks (event.source === window.parent).
+  var _realPostMessage = window.postMessage.bind(window);
+
+  var originalPostMessage = window.parent !== window
+    ? window.parent.postMessage.bind(window.parent)
+    : null;
+
+  function interceptPostMessage() {
+    if (window.parent === window) {
+      // Not in a frame — intercept window.postMessage instead for standalone mode
+      log("Intercepting window.postMessage (standalone mode)");
+      var origSelf = window.postMessage.bind(window);
+      window.postMessage = function (message, targetOrigin, transfer) {
+        if (isJsonRpc(message)) {
+          handleOutgoing(message);
+        } else {
+          origSelf(message, targetOrigin, transfer);
+        }
+      };
+      return;
+    }
+
+    log("Intercepting window.parent.postMessage (iframe mode)");
+    window.parent.postMessage = function (message, targetOrigin, transfer) {
+      if (isJsonRpc(message)) {
+        handleOutgoing(message);
+      } else if (originalPostMessage) {
+        originalPostMessage(message, targetOrigin, transfer);
+      }
+    };
+  }
+
+  function handleOutgoing(message) {
+    log("<- App:", message.method || "response");
+
+    // ui/initialize — handle locally
+    if (message.method === "ui/initialize" && "id" in message) {
+      handleInitialize(message.id);
+      return;
+    }
+
+    // ui/open-link — handle locally via Telegram API or fallback
+    if (message.method === "ui/open-link" && "id" in message) {
+      var url = message.params && message.params.url;
+      if (url) {
+        var tg = window.Telegram && window.Telegram.WebApp;
+        if (tg && tg.openLink) {
+          tg.openLink(url);
+        } else {
+          window.open(url, "_blank");
+        }
+      }
+      dispatchToApp({ jsonrpc: "2.0", id: message.id, result: {} });
+      return;
+    }
+
+    // Forward to resource server via WebSocket
+    sendToServer(message);
+
+    // Track requests for response matching
+    if (isRequest(message)) {
+      trackRequest(message.id)
+        .then(function (result) {
+          dispatchToApp({ jsonrpc: "2.0", id: message.id, result: result });
+        })
+        .catch(function (err) {
+          dispatchToApp({
+            jsonrpc: "2.0",
+            id: message.id,
+            error: { code: -32603, message: err.message || String(err) },
+          });
+        });
+    }
+  }
+
+  // ---------------------------------------------------------------------------
+  // Telegram lifecycle events
+  // ---------------------------------------------------------------------------
+
+  function setupTelegramEvents() {
+    var tg = window.Telegram && window.Telegram.WebApp;
+    if (!tg) return;
+
+    // Tell Telegram we're ready
+    tg.ready();
+    if (!tg.isExpanded) tg.expand();
+
+    // Theme changes
+    if (typeof tg.onEvent === "function") {
+      tg.onEvent("themeChanged", function () {
+        var ctx = getTelegramTheme();
+        dispatchToApp({
+          jsonrpc: "2.0",
+          method: "ui/notifications/host-context-changed",
+          params: { theme: ctx.theme, styles: ctx.styles },
+        });
+      });
+
+      tg.onEvent("viewportChanged", function () {
+        dispatchToApp({
+          jsonrpc: "2.0",
+          method: "ui/notifications/host-context-changed",
+          params: {
+            containerDimensions: {
+              width: window.innerWidth,
+              height: tg.viewportStableHeight || window.innerHeight,
+            },
+          },
+        });
+      });
+    }
+  }
+
+  // ---------------------------------------------------------------------------
+  // Boot
+  // ---------------------------------------------------------------------------
+
+  interceptPostMessage();
+  connectWs();
+
+  if (PLATFORM === "telegram") {
+    setupTelegramEvents();
+  }
+
+  log("Bridge initialized for", PLATFORM);
+})();

package/esm/core/adapter.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Abstract adapter interfaces for platform integrations.
+ *
+ * Two adapter levels:
+ * - `McpAppsAdapter`: Low-level message transport (postMessage replacement).
+ * - `PlatformAdapter`: High-level platform SDK abstraction (theme, viewport,
+ *   native UI, auth). Used by BridgeClient to synthesize HostContext and
+ *   translate platform events into MCP notifications.
+ */
+import type { AdapterConfig, ContainerDimensions, HostContext, LifecycleEvent, McpAppsMessage } from "./types.js";
+/** Handler function invoked when the host sends a message to the MCP App. */
+export type MessageHandler = (message: McpAppsMessage) => void;
+/**
+ * Low-level transport adapter contract.
+ *
+ * Replaces the iframe postMessage channel with a platform-specific
+ * communication mechanism. Each platform implements this to bridge
+ * JSON-RPC messages between the MCP App and the resource server.
+ *
+ * Lifecycle: `init()` -> use -> `destroy()`.
+ */
+export interface McpAppsAdapter {
+    /** Unique platform identifier (e.g. `"telegram"`, `"line"`). */
+    readonly platform: string;
+    /**
+     * Initialize the adapter with platform-specific configuration.
+     * Must be called before any other method.
+     */
+    init(config: AdapterConfig): Promise<void>;
+    /**
+     * Send a JSON-RPC message from the MCP App to the host.
+     * Throws if the adapter has not been initialized.
+     */
+    sendToHost(message: McpAppsMessage): void;
+    /**
+     * Register a handler that is called when the host sends a message
+     * to the MCP App.
+     */
+    onMessageFromHost(handler: MessageHandler): void;
+    /**
+     * Tear down the adapter, releasing all resources and listeners.
+     * After calling `destroy()`, the adapter must not be reused.
+     */
+    destroy(): void;
+}
+/** Handler for platform lifecycle events. */
+export type LifecycleEventHandler = (event: LifecycleEvent) => void;
+/**
+ * High-level platform adapter contract.
+ *
+ * Abstracts platform-specific SDK features (theme, viewport, native UI,
+ * auth) into a uniform interface that the BridgeClient uses to:
+ * - Build the initial `HostContext` for `ui/initialize`
+ * - Map platform events to `ui/notifications/host-context-changed`
+ * - Execute platform-specific actions (open link, expand viewport)
+ */
+export interface PlatformAdapter {
+    /** Platform name (e.g. `"telegram"`, `"line"`). */
+    readonly name: string;
+    /**
+     * Initialize the platform SDK and return the initial host context.
+     * This is called once during BridgeClient startup.
+     */
+    initialize(): Promise<HostContext>;
+    /** Get the current theme from the platform. */
+    getTheme(): "light" | "dark";
+    /** Get the current container dimensions from the platform. */
+    getContainerDimensions(): ContainerDimensions;
+    /**
+     * Subscribe to platform lifecycle events (theme change, viewport
+     * resize, activation, teardown).
+     */
+    onLifecycleEvent(handler: LifecycleEventHandler): void;
+    /** Open an external link using the platform's native method. */
+    openLink(url: string): Promise<void>;
+    /**
+     * Send a message via the platform's native messaging (if supported).
+     *
+     * WARNING (Telegram): `sendData()` closes the Mini App. Use with caution.
+     */
+    sendMessage?(text: string): Promise<void>;
+    /**
+     * Get platform-specific auth data for forwarding to the MCP server.
+     * E.g. Telegram `initData`, LIFF access token.
+     */
+    getAuthData?(): Record<string, unknown>;
+}
+//# sourceMappingURL=adapter.d.ts.map

package/esm/core/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../src/core/adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EACV,aAAa,EACb,mBAAmB,EACnB,WAAW,EACX,cAAc,EACd,cAAc,EACf,MAAM,YAAY,CAAC;AAMpB,6EAA6E;AAC7E,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,EAAE,cAAc,KAAK,IAAI,CAAC;AAE/D;;;;;;;;GAQG;AACH,MAAM,WAAW,cAAc;IAC7B,gEAAgE;IAChE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAE1B;;;OAGG;IACH,IAAI,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE3C;;;OAGG;IACH,UAAU,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI,CAAC;IAE1C;;;OAGG;IACH,iBAAiB,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI,CAAC;IAEjD;;;OAGG;IACH,OAAO,IAAI,IAAI,CAAC;CACjB;AAMD,6CAA6C;AAC7C,MAAM,MAAM,qBAAqB,GAAG,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,CAAC;AAEpE;;;;;;;;GAQG;AACH,MAAM,WAAW,eAAe;IAC9B,mDAAmD;IACnD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB;;;OAGG;IACH,UAAU,IAAI,OAAO,CAAC,WAAW,CAAC,CAAC;IAEnC,+CAA+C;IAC/C,QAAQ,IAAI,OAAO,GAAG,MAAM,CAAC;IAE7B,8DAA8D;IAC9D,sBAAsB,IAAI,mBAAmB,CAAC;IAE9C;;;OAGG;IACH,gBAAgB,CAAC,OAAO,EAAE,qBAAqB,GAAG,IAAI,CAAC;IAEvD,gEAAgE;IAChE,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAErC;;;;OAIG;IACH,WAAW,CAAC,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE1C;;;OAGG;IACH,WAAW,CAAC,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACzC"}

package/esm/core/adapter.js

@@ -0,0 +1,10 @@
+/**
+ * Abstract adapter interfaces for platform integrations.
+ *
+ * Two adapter levels:
+ * - `McpAppsAdapter`: Low-level message transport (postMessage replacement).
+ * - `PlatformAdapter`: High-level platform SDK abstraction (theme, viewport,
+ *   native UI, auth). Used by BridgeClient to synthesize HostContext and
+ *   translate platform events into MCP notifications.
+ */
+export {};

package/esm/core/bridge-client.d.ts

@@ -0,0 +1,77 @@
+import type { PlatformAdapter } from "./adapter.js";
+import type { BridgeTransport } from "./transport.js";
+import type { HostContext } from "./types.js";
+/** Options for creating a BridgeClient. */
+export interface BridgeClientOptions {
+    /** WebSocket URL of the resource server bridge endpoint. */
+    readonly serverUrl: string;
+    /** Platform adapter instance (Telegram, LINE, etc.). */
+    readonly platform: PlatformAdapter;
+    /** Transport implementation. Defaults to WebSocketTransport if not provided. */
+    readonly transport: BridgeTransport;
+    /** Session ID assigned by the resource server. */
+    readonly sessionId: string;
+    /** Bridge name/version reported in ui/initialize. */
+    readonly bridgeInfo?: {
+        readonly name: string;
+        readonly version: string;
+    };
+    /** Request timeout in ms. Defaults to 30_000. */
+    readonly requestTimeoutMs?: number;
+}
+/**
+ * The MCP Apps Bridge client.
+ *
+ * Injected into the MCP App HTML by the resource server (`bridge.js`).
+ * Intercepts postMessage, routes via WebSocket, translates platform events.
+ */
+export declare class BridgeClient {
+    private readonly platform;
+    private readonly transport;
+    private readonly router;
+    private readonly options;
+    private hostContext;
+    private started;
+    private originalPostMessage;
+    constructor(options: BridgeClientOptions);
+    /**
+     * Start the bridge:
+     * 1. Initialize the platform adapter to get HostContext
+     * 2. Connect transport to resource server
+     * 3. Intercept postMessage from App class
+     * 4. Listen for platform lifecycle events
+     * 5. Register ui/initialize handler to synthesize response
+     */
+    start(): Promise<void>;
+    /** Stop the bridge, restore postMessage, disconnect transport. */
+    destroy(): void;
+    /** Whether the bridge is currently running. */
+    get isStarted(): boolean;
+    /** The current host context (null before start). */
+    get currentHostContext(): HostContext | null;
+    private interceptPostMessage;
+    private restorePostMessage;
+    /**
+     * Handle an outgoing message from the MCP App (intercepted from postMessage).
+     *
+     * Requests that the bridge handles locally (ui/initialize, ui/open-link)
+     * are dispatched to the router. All other messages are forwarded to the
+     * resource server via transport.
+     */
+    private handleOutgoingMessage;
+    /**
+     * Handle an incoming message from the resource server.
+     *
+     * Responses are routed to the pending request tracker (which resolves the
+     * Promise created in handleOutgoingMessage — that Promise already calls
+     * dispatchToApp, so we must NOT dispatch responses again here).
+     *
+     * Notifications are dispatched directly to the App class.
+     */
+    private handleIncomingMessage;
+    /** Dispatch a message to the MCP App class as a MessageEvent. */
+    private dispatchToApp;
+    private handleInitialize;
+    private handleLifecycleEvent;
+}
+//# sourceMappingURL=bridge-client.d.ts.map

package/esm/core/bridge-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridge-client.d.ts","sourceRoot":"","sources":["../../src/core/bridge-client.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAOpD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACtD,OAAO,KAAK,EAEV,WAAW,EAIZ,MAAM,YAAY,CAAC;AAGpB,2CAA2C;AAC3C,MAAM,WAAW,mBAAmB;IAClC,4DAA4D;IAC5D,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,wDAAwD;IACxD,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAC;IACnC,gFAAgF;IAChF,QAAQ,CAAC,SAAS,EAAE,eAAe,CAAC;IACpC,kDAAkD;IAClD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,qDAAqD;IACrD,QAAQ,CAAC,UAAU,CAAC,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAC1E,iDAAiD;IACjD,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;CACpC;AAED;;;;;GAKG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAkB;IAC3C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAkB;IAC5C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgB;IACvC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAsB;IAE9C,OAAO,CAAC,WAAW,CAA4B;IAC/C,OAAO,CAAC,OAAO,CAAS;IAGxB,OAAO,CAAC,mBAAmB,CAA0F;gBAEzG,OAAO,EAAE,mBAAmB;IAOxC;;;;;;;OAOG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IA2C5B,kEAAkE;IAClE,OAAO,IAAI,IAAI;IAOf,+CAA+C;IAC/C,IAAI,SAAS,IAAI,OAAO,CAEvB;IAED,oDAAoD;IACpD,IAAI,kBAAkB,IAAI,WAAW,GAAG,IAAI,CAE3C;IAMD,OAAO,CAAC,oBAAoB;IAyB5B,OAAO,CAAC,kBAAkB;IAe1B;;;;;;OAMG;YACW,qBAAqB;IAiDnC;;;;;;;;OAQG;YACW,qBAAqB;IAenC,iEAAiE;IACjE,OAAO,CAAC,aAAa;IAiBrB,OAAO,CAAC,gBAAgB;IAoCxB,OAAO,CAAC,oBAAoB;CA0C7B"}