integrate-sdk 0.1.5 → 0.2.0

package/dist/index.js

@@ -1,3 +1,153 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/errors.ts
+var exports_errors = {};
+__export(exports_errors, {
+  parseServerError: () => parseServerError,
+  isTokenExpiredError: () => isTokenExpiredError,
+  isAuthorizationError: () => isAuthorizationError,
+  isAuthError: () => isAuthError,
+  ToolCallError: () => ToolCallError,
+  TokenExpiredError: () => TokenExpiredError,
+  IntegrateSDKError: () => IntegrateSDKError,
+  ConnectionError: () => ConnectionError,
+  AuthorizationError: () => AuthorizationError,
+  AuthenticationError: () => AuthenticationError
+});
+function isAuthError(error) {
+  return error instanceof AuthenticationError;
+}
+function isTokenExpiredError(error) {
+  return error instanceof TokenExpiredError;
+}
+function isAuthorizationError(error) {
+  return error instanceof AuthorizationError;
+}
+function parseServerError(error, context) {
+  if (error && typeof error === "object" && "jsonrpcError" in error) {
+    const jsonrpcError = error.jsonrpcError;
+    if (jsonrpcError && typeof jsonrpcError === "object") {
+      return parseServerError(jsonrpcError, context);
+    }
+  }
+  if (error && typeof error === "object" && "code" in error && "message" in error) {
+    const code = error.code;
+    const message = error.message || "Unknown error";
+    if (code === -32600) {
+      return new IntegrateSDKError(`Invalid request: ${message}`);
+    }
+    if (code === -32601) {
+      return new IntegrateSDKError(`Method not found: ${message}`);
+    }
+    if (code === -32602) {
+      return new IntegrateSDKError(`Invalid params: ${message}`);
+    }
+    if (code === 401 || code === -32001) {
+      if (message.toLowerCase().includes("expired") || message.toLowerCase().includes("token")) {
+        return new TokenExpiredError(message, context?.provider);
+      }
+      return new AuthenticationError(message, 401, context?.provider);
+    }
+    if (code === 403 || code === -32002) {
+      return new AuthorizationError(message, 403);
+    }
+    if (context?.toolName) {
+      return new ToolCallError(message, context.toolName, error);
+    }
+    return new IntegrateSDKError(message);
+  }
+  if (error instanceof Error) {
+    const message = error.message;
+    const statusCode = error.statusCode;
+    if (statusCode === 401) {
+      if (message.toLowerCase().includes("expired") || message.toLowerCase().includes("token")) {
+        return new TokenExpiredError(message, context?.provider);
+      }
+      return new AuthenticationError(message, 401, context?.provider);
+    }
+    if (statusCode === 403) {
+      return new AuthorizationError(message, 403);
+    }
+    if (message.includes("401") || message.includes("Unauthorized") || message.includes("unauthenticated")) {
+      if (message.toLowerCase().includes("expired") || message.toLowerCase().includes("token")) {
+        return new TokenExpiredError(message, context?.provider);
+      }
+      return new AuthenticationError(message, 401, context?.provider);
+    }
+    if (message.includes("403") || message.includes("Forbidden") || message.includes("unauthorized")) {
+      return new AuthorizationError(message, 403);
+    }
+    if (context?.toolName) {
+      return new ToolCallError(message, context.toolName, error);
+    }
+    return new IntegrateSDKError(message);
+  }
+  return new IntegrateSDKError(String(error));
+}
+var IntegrateSDKError, AuthenticationError, AuthorizationError, TokenExpiredError, ConnectionError, ToolCallError;
+var init_errors = __esm(() => {
+  IntegrateSDKError = class IntegrateSDKError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "IntegrateSDKError";
+    }
+  };
+  AuthenticationError = class AuthenticationError extends IntegrateSDKError {
+    statusCode;
+    provider;
+    constructor(message, statusCode, provider) {
+      super(message);
+      this.name = "AuthenticationError";
+      this.statusCode = statusCode;
+      this.provider = provider;
+    }
+  };
+  AuthorizationError = class AuthorizationError extends IntegrateSDKError {
+    statusCode;
+    requiredScopes;
+    constructor(message, statusCode, requiredScopes) {
+      super(message);
+      this.name = "AuthorizationError";
+      this.statusCode = statusCode;
+      this.requiredScopes = requiredScopes;
+    }
+  };
+  TokenExpiredError = class TokenExpiredError extends AuthenticationError {
+    constructor(message, provider) {
+      super(message, 401, provider);
+      this.name = "TokenExpiredError";
+    }
+  };
+  ConnectionError = class ConnectionError extends IntegrateSDKError {
+    statusCode;
+    constructor(message, statusCode) {
+      super(message);
+      this.name = "ConnectionError";
+      this.statusCode = statusCode;
+    }
+  };
+  ToolCallError = class ToolCallError extends IntegrateSDKError {
+    toolName;
+    originalError;
+    constructor(message, toolName, originalError) {
+      super(message);
+      this.name = "ToolCallError";
+      this.toolName = toolName;
+      this.originalError = originalError;
+    }
+  };
+});
+
 // src/protocol/jsonrpc.ts
 function parseMessage(message) {
   try {
@@ -55,7 +205,9 @@ class HttpSessionTransport {
       });
       clearTimeout(timeoutId);
       if (!response.ok) {
-        throw new Error(`Request failed: ${response.statusText}`);
+        const error = new Error(`Request failed: ${response.statusText}`);
+        error.statusCode = response.status;
+        throw error;
       }
       if (!this.sessionId) {
         const sid = response.headers.get("mcp-session-id");
@@ -67,11 +219,25 @@ class HttpSessionTransport {
       }
       const jsonResponse = await response.json();
       if ("error" in jsonResponse) {
-        throw new Error(`JSON-RPC Error ${jsonResponse.error.code}: ${jsonResponse.error.message}`);
+        const error = new Error(`JSON-RPC Error ${jsonResponse.error.code}: ${jsonResponse.error.message}`);
+        error.code = jsonResponse.error.code;
+        if (jsonResponse.error.data) {
+          error.data = jsonResponse.error.data;
+        }
+        error.jsonrpcError = jsonResponse.error;
+        throw error;
       }
       return jsonResponse.result;
     } catch (error) {
-      throw error;
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          const timeoutError = new Error("Request timeout");
+          timeoutError.code = -32000;
+          throw timeoutError;
+        }
+        throw error;
+      }
+      throw new Error(String(error));
     }
   }
   async startSSEListener() {
@@ -183,6 +349,18 @@ var MCPMethod;
   MCPMethod2["PROMPTS_GET"] = "prompts/get";
 })(MCPMethod ||= {});
 
+// src/client.ts
+init_errors();
+
+// src/utils/naming.ts
+function camelToSnake(str) {
+  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+function methodToToolName(methodName, pluginId) {
+  const snakeCaseMethod = camelToSnake(methodName);
+  return `${pluginId}_${snakeCaseMethod}`;
+}
+
 // src/client.ts
 var MCP_SERVER_URL = "https://mcp.integrate.dev/api/v1/mcp";
 
@@ -193,6 +371,12 @@ class MCPClient {
   enabledToolNames = new Set;
   initialized = false;
   clientInfo;
+  onReauthRequired;
+  maxReauthRetries;
+  authState = new Map;
+  github;
+  gmail;
+  server;
   constructor(config) {
     this.transport = new HttpSessionTransport({
       url: MCP_SERVER_URL,
@@ -204,13 +388,61 @@ class MCPClient {
       name: "integrate-sdk",
       version: "0.1.0"
     };
+    this.onReauthRequired = config.onReauthRequired;
+    this.maxReauthRetries = config.maxReauthRetries ?? 1;
     for (const plugin of this.plugins) {
       for (const toolName of plugin.tools) {
         this.enabledToolNames.add(toolName);
       }
+      if (plugin.oauth) {
+        this.authState.set(plugin.oauth.provider, { authenticated: true });
+      }
     }
+    this.github = this.createPluginProxy("github");
+    this.gmail = this.createPluginProxy("gmail");
+    this.server = this.createServerProxy();
     this.initializePlugins();
   }
+  createPluginProxy(pluginId) {
+    return new Proxy({}, {
+      get: (_target, methodName) => {
+        return async (args) => {
+          const toolName = methodToToolName(methodName, pluginId);
+          return await this.callToolWithRetry(toolName, args, 0);
+        };
+      }
+    });
+  }
+  createServerProxy() {
+    return new Proxy({}, {
+      get: (_target, methodName) => {
+        return async (args) => {
+          const toolName = methodToToolName(methodName, "");
+          const finalToolName = toolName.startsWith("_") ? toolName.substring(1) : toolName;
+          return await this.callServerToolInternal(finalToolName, args);
+        };
+      }
+    });
+  }
+  async callServerToolInternal(name, args) {
+    if (!this.initialized) {
+      throw new Error("Client not initialized. Call connect() first.");
+    }
+    if (!this.availableTools.has(name)) {
+      throw new Error(`Tool "${name}" is not available on the server. Available tools: ${Array.from(this.availableTools.keys()).join(", ")}`);
+    }
+    const params = {
+      name,
+      arguments: args
+    };
+    try {
+      const response = await this.transport.sendRequest("tools/call" /* TOOLS_CALL */, params);
+      return response;
+    } catch (error) {
+      const parsedError = parseServerError(error, { toolName: name });
+      throw parsedError;
+    }
+  }
   async initializePlugins() {
     for (const plugin of this.plugins) {
       if (plugin.onInit) {
@@ -253,7 +485,29 @@ class MCPClient {
     const enabledTools = response.tools.filter((tool) => this.enabledToolNames.has(tool.name));
     console.log(`Discovered ${response.tools.length} tools, ${enabledTools.length} enabled by plugins`);
   }
-  async callTool(name, args) {
+  async _callToolByName(name, args) {
+    return await this.callToolWithRetry(name, args, 0);
+  }
+  async callServerTool(name, args) {
+    if (!this.initialized) {
+      throw new Error("Client not initialized. Call connect() first.");
+    }
+    if (!this.availableTools.has(name)) {
+      throw new Error(`Tool "${name}" is not available on the server. Available tools: ${Array.from(this.availableTools.keys()).join(", ")}`);
+    }
+    const params = {
+      name,
+      arguments: args
+    };
+    try {
+      const response = await this.transport.sendRequest("tools/call" /* TOOLS_CALL */, params);
+      return response;
+    } catch (error) {
+      const parsedError = parseServerError(error, { toolName: name });
+      throw parsedError;
+    }
+  }
+  async callToolWithRetry(name, args, retryCount = 0) {
     if (!this.initialized) {
       throw new Error("Client not initialized. Call connect() first.");
     }
@@ -267,7 +521,44 @@ class MCPClient {
       name,
       arguments: args
     };
-    return await this.transport.sendRequest("tools/call" /* TOOLS_CALL */, params);
+    try {
+      const response = await this.transport.sendRequest("tools/call" /* TOOLS_CALL */, params);
+      const provider = this.getProviderForTool(name);
+      if (provider) {
+        this.authState.set(provider, { authenticated: true });
+      }
+      return response;
+    } catch (error) {
+      const provider = this.getProviderForTool(name);
+      const parsedError = parseServerError(error, { toolName: name, provider });
+      if (isAuthError(parsedError) && retryCount < this.maxReauthRetries) {
+        if (provider) {
+          this.authState.set(provider, {
+            authenticated: false,
+            lastError: parsedError
+          });
+        }
+        if (this.onReauthRequired && provider) {
+          const reauthSuccess = await this.onReauthRequired({
+            provider,
+            error: parsedError,
+            toolName: name
+          });
+          if (reauthSuccess) {
+            return await this.callToolWithRetry(name, args, retryCount + 1);
+          }
+        }
+      }
+      throw parsedError;
+    }
+  }
+  getProviderForTool(toolName) {
+    for (const plugin of this.plugins) {
+      if (plugin.tools.includes(toolName) && plugin.oauth) {
+        return plugin.oauth.provider;
+      }
+    }
+    return;
   }
   getTool(name) {
     return this.availableTools.get(name);
@@ -309,10 +600,38 @@ class MCPClient {
   isInitialized() {
     return this.initialized;
   }
+  getAuthState(provider) {
+    return this.authState.get(provider);
+  }
+  isProviderAuthenticated(provider) {
+    return this.authState.get(provider)?.authenticated ?? false;
+  }
+  async reauthenticate(provider) {
+    const state = this.authState.get(provider);
+    if (!state) {
+      throw new Error(`Provider "${provider}" not found in configured plugins`);
+    }
+    if (!this.onReauthRequired) {
+      throw new Error("No re-authentication handler configured. Set onReauthRequired in client config.");
+    }
+    const lastError = state.lastError || new (await Promise.resolve().then(() => (init_errors(), exports_errors))).AuthenticationError("Manual re-authentication requested", undefined, provider);
+    const success = await this.onReauthRequired({
+      provider,
+      error: lastError
+    });
+    if (success) {
+      this.authState.set(provider, { authenticated: true });
+    }
+    return success;
+  }
 }
 function createMCPClient(config) {
   return new MCPClient(config);
 }
+
+// src/index.ts
+init_errors();
+
 // src/plugins/github.ts
 var GITHUB_TOOLS = [
   "github_create_issue",
@@ -440,7 +759,7 @@ function convertMCPToolToVercelAI(mcpTool, client) {
     description: mcpTool.description || `Execute ${mcpTool.name}`,
     parameters: convertMCPSchemaToParameters(mcpTool.inputSchema),
     execute: async (args) => {
-      const result = await client.callTool(mcpTool.name, args);
+      const result = await client._callToolByName(mcpTool.name, args);
       return result;
     }
   };
@@ -457,6 +776,10 @@ function getVercelAITools(client) {
   return convertMCPToolsToVercelAI(client);
 }
 export {
+  parseServerError,
+  isTokenExpiredError,
+  isAuthorizationError,
+  isAuthError,
   gmailPlugin,
   githubPlugin,
   getVercelAITools,
@@ -465,7 +788,13 @@ export {
   createMCPClient,
   convertMCPToolsToVercelAI,
   convertMCPToolToVercelAI,
+  ToolCallError,
+  TokenExpiredError,
   MCPMethod,
   MCPClient,
-  HttpSessionTransport
+  IntegrateSDKError,
+  HttpSessionTransport,
+  ConnectionError,
+  AuthorizationError,
+  AuthenticationError
 };

package/dist/integrations/vercel-ai.d.ts

@@ -42,7 +42,7 @@ export declare function convertMCPToolToVercelAI(mcpTool: MCPTool, client: MCPCl
  * const tools = convertMCPToolsToVercelAI(mcpClient);
  *
  * const result = await generateText({
- *   model: openai('gpt-4'),
+ *   model: openai('gpt-5'),
  *   prompt: 'Create a GitHub issue in my repo',
  *   tools,
  * });

package/dist/integrations/vercel-ai.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vercel-ai.d.ts","sourceRoot":"","sources":["../../src/integrations/vercel-ai.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AAEvD;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACpC,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CAC9D;AAcD;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,SAAS,GAChB,YAAY,CASd;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,SAAS,GAChB,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAS9B;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,gCAEjD"}
+{"version":3,"file":"vercel-ai.d.ts","sourceRoot":"","sources":["../../src/integrations/vercel-ai.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AAEvD;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACpC,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CAC9D;AAcD;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,SAAS,GAChB,YAAY,CAUd;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,SAAS,GAChB,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAS9B;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,gCAEjD"}

package/dist/plugins/generic.d.ts

@@ -1,13 +1,13 @@
 /**
  * Generic OAuth Plugin
- * Template for creating custom OAuth provider plugins
+ * Configure OAuth and enable tools for any integration supported by the server
  */
 import type { MCPPlugin } from "./types.js";
 /**
  * Generic OAuth plugin configuration
  */
 export interface GenericOAuthPluginConfig {
-    /** Plugin unique identifier */
+    /** Plugin unique identifier (must match the integration ID on the server) */
     id: string;
     /** OAuth provider name */
     provider: string;
@@ -17,7 +17,7 @@ export interface GenericOAuthPluginConfig {
     clientSecret: string;
     /** OAuth scopes */
     scopes: string[];
-    /** Tool names to enable */
+    /** Tool names to enable from the server (must exist on the server) */
     tools: string[];
     /** OAuth redirect URI */
     redirectUri?: string;
@@ -33,10 +33,13 @@ export interface GenericOAuthPluginConfig {
 /**
  * Generic OAuth Plugin
  *
- * Use this to create custom plugins for any OAuth provider
+ * Configure OAuth and enable tools for any integration supported by the Integrate MCP server.
+ * Note: This does NOT create new tools - it only configures access to existing server-side tools.
+ * All tools must be implemented on the server and exposed via the MCP protocol.
  *
  * @example
  * ```typescript
+ * // Configure Slack integration (assuming server supports Slack tools)
  * const slackPlugin = genericOAuthPlugin({
  *   id: 'slack',
  *   provider: 'slack',
@@ -44,28 +47,32 @@ export interface GenericOAuthPluginConfig {
  *   clientSecret: process.env.SLACK_CLIENT_SECRET!,
  *   scopes: ['chat:write', 'channels:read'],
  *   tools: [
- *     'slack/sendMessage',
- *     'slack/listChannels',
- *     'slack/getChannel',
+ *     'slack_send_message',      // Must exist on server
+ *     'slack_list_channels',     // Must exist on server
  *   ],
  * });
  *
  * const client = createMCPClient({
- *   serverUrl: 'http://localhost:3000/mcp',
  *   plugins: [slackPlugin],
  * });
+ *
+ * await client.connect();
+ * // Call server tools using _callToolByName
+ * await client._callToolByName('slack_send_message', { channel: '#general', text: 'Hello' });
  * ```
  */
 export declare function genericOAuthPlugin(config: GenericOAuthPluginConfig): MCPPlugin;
 /**
  * Create a simple plugin without OAuth
- * Useful for plugins that just enable certain tools without authentication
+ * Enable server-provided tools that don't require authentication
+ * Note: Tools must exist on the server - this does not create new tools
  *
  * @example
  * ```typescript
+ * // Enable server-provided math tools (if they exist on the server)
  * const mathPlugin = createSimplePlugin({
  *   id: 'math',
- *   tools: ['math/add', 'math/subtract', 'math/multiply', 'math/divide'],
+ *   tools: ['math_add', 'math_subtract', 'math_multiply', 'math_divide'],
  * });
  * ```
  */

package/dist/plugins/generic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generic.d.ts","sourceRoot":"","sources":["../../src/plugins/generic.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAe,MAAM,YAAY,CAAC;AAEzD;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,+BAA+B;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,0BAA0B;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,sBAAsB;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,0BAA0B;IAC1B,YAAY,EAAE,MAAM,CAAC;IACrB,mBAAmB;IACnB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,2BAA2B;IAC3B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,yBAAyB;IACzB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,iDAAiD;IACjD,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,uCAAuC;IACvC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAC/C,sCAAsC;IACtC,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IACvD,mCAAmC;IACnC,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CACtD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,wBAAwB,GAC/B,SAAS,CAmBX;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE;IACzC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAC/C,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IACvD,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CACtD,GAAG,SAAS,CAQZ"}
+{"version":3,"file":"generic.d.ts","sourceRoot":"","sources":["../../src/plugins/generic.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAe,MAAM,YAAY,CAAC;AAEzD;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,6EAA6E;IAC7E,EAAE,EAAE,MAAM,CAAC;IACX,0BAA0B;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,sBAAsB;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,0BAA0B;IAC1B,YAAY,EAAE,MAAM,CAAC;IACrB,mBAAmB;IACnB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,sEAAsE;IACtE,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,yBAAyB;IACzB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,iDAAiD;IACjD,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,uCAAuC;IACvC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAC/C,sCAAsC;IACtC,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IACvD,mCAAmC;IACnC,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CACtD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,wBAAwB,GAC/B,SAAS,CAmBX;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE;IACzC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAC/C,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IACvD,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CACtD,GAAG,SAAS,CAQZ"}