integrate-sdk 0.6.6 → 0.6.8

package/dist/adapters/svelte-kit.js

@@ -14,7 +14,7 @@ async function svelteKitHandler({
   authConfig,
   event,
   resolve,
-  basePath = "/api/auth"
+  basePath = "/api/integrate"
 }) {
   const { url } = event;
   const baseUrl = new URL(basePath, url.origin);

package/dist/index.js

@@ -2043,7 +2043,7 @@ async function svelteKitHandler({
   authConfig,
   event,
   resolve,
-  basePath = "/api/auth"
+  basePath = "/api/integrate"
 }) {
   const { url } = event;
   const baseUrl = new URL(basePath, url.origin);
@@ -2072,6 +2072,33 @@ var createTanStackOAuthHandler = toTanStackStartHandler;
 // src/index.ts
 init_errors();
 
+// src/utils/env.ts
+function getEnv(key) {
+  try {
+    const getMetaEnv = () => {
+      try {
+        return typeof import.meta !== "undefined" ? import.meta.env : undefined;
+      } catch {
+        return;
+      }
+    };
+    const metaEnv = getMetaEnv();
+    if (metaEnv && typeof metaEnv === "object" && metaEnv !== null) {
+      const value = metaEnv[key];
+      if (value !== undefined && value !== null && value !== "") {
+        return String(value);
+      }
+    }
+  } catch {}
+  if (typeof process !== "undefined" && process.env) {
+    const value = process.env[key];
+    if (value !== undefined && value !== null && value !== "") {
+      return value;
+    }
+  }
+  return;
+}
+
 // src/plugins/github.ts
 var GITHUB_TOOLS = [
   "github_create_issue",
@@ -2096,8 +2123,8 @@ var GITHUB_TOOLS = [
 function githubPlugin(config = {}) {
   const oauth = {
     provider: "github",
-    clientId: config.clientId ?? process.env.GITHUB_CLIENT_ID,
-    clientSecret: config.clientSecret ?? process.env.GITHUB_CLIENT_SECRET,
+    clientId: config.clientId ?? getEnv("GITHUB_CLIENT_ID"),
+    clientSecret: config.clientSecret ?? getEnv("GITHUB_CLIENT_SECRET"),
     scopes: config.scopes || ["repo", "user"],
     redirectUri: config.redirectUri,
     config: {
@@ -2127,8 +2154,8 @@ var GMAIL_TOOLS = [
 function gmailPlugin(config = {}) {
   const oauth = {
     provider: "gmail",
-    clientId: config.clientId ?? process.env.GMAIL_CLIENT_ID,
-    clientSecret: config.clientSecret ?? process.env.GMAIL_CLIENT_SECRET,
+    clientId: config.clientId ?? getEnv("GMAIL_CLIENT_ID"),
+    clientSecret: config.clientSecret ?? getEnv("GMAIL_CLIENT_SECRET"),
     scopes: config.scopes || [
       "https://www.googleapis.com/auth/gmail.send",
       "https://www.googleapis.com/auth/gmail.readonly",
@@ -2155,8 +2182,8 @@ function genericOAuthPlugin(config) {
   const providerUpper = config.provider.toUpperCase().replace(/[^A-Z0-9]/g, "_");
   const oauth = {
     provider: config.provider,
-    clientId: config.clientId ?? process.env[`${providerUpper}_CLIENT_ID`],
-    clientSecret: config.clientSecret ?? process.env[`${providerUpper}_CLIENT_SECRET`],
+    clientId: config.clientId ?? getEnv(`${providerUpper}_CLIENT_ID`),
+    clientSecret: config.clientSecret ?? getEnv(`${providerUpper}_CLIENT_SECRET`),
     scopes: config.scopes,
     redirectUri: config.redirectUri,
     config
@@ -6152,7 +6179,7 @@ var coerce = {
   date: (arg) => ZodDate.create({ ...arg, coerce: true })
 };
 var NEVER = INVALID;
-// src/integrations/vercel-ai.ts
+// src/integrations/utils.ts
 function getProviderForTool(client, toolName) {
   return client.getProviderForTool?.(toolName);
 }
@@ -6266,33 +6293,43 @@ function jsonSchemaToZod(schema) {
   }
   return exports_external.object({});
 }
+async function executeToolWithToken(client, toolName, args, options) {
+  if (options?.providerTokens) {
+    const provider = getProviderForTool(client, toolName);
+    if (provider && options.providerTokens[provider]) {
+      const transport = client.transport;
+      if (transport && typeof transport.setHeader === "function") {
+        const previousAuthHeader = transport.headers?.["Authorization"];
+        try {
+          transport.setHeader("Authorization", `Bearer ${options.providerTokens[provider]}`);
+          const result2 = await client._callToolByName(toolName, args);
+          return result2;
+        } finally {
+          if (previousAuthHeader) {
+            transport.setHeader("Authorization", previousAuthHeader);
+          } else if (transport.removeHeader) {
+            transport.removeHeader("Authorization");
+          }
+        }
+      }
+    }
+  }
+  const result = await client._callToolByName(toolName, args);
+  return result;
+}
+async function ensureClientConnected(client) {
+  if (!client.isConnected()) {
+    await client.connect();
+  }
+}
+
+// src/integrations/vercel-ai.ts
 function convertMCPToolToVercelAI(mcpTool, client, options) {
   return {
     description: mcpTool.description || `Execute ${mcpTool.name}`,
     inputSchema: jsonSchemaToZod(mcpTool.inputSchema),
     execute: async (args) => {
-      if (options?.providerTokens) {
-        const provider = getProviderForTool(client, mcpTool.name);
-        if (provider && options.providerTokens[provider]) {
-          const transport = client.transport;
-          if (transport && typeof transport.setHeader === "function") {
-            const previousAuthHeader = transport.headers?.["Authorization"];
-            try {
-              transport.setHeader("Authorization", `Bearer ${options.providerTokens[provider]}`);
-              const result2 = await client._callToolByName(mcpTool.name, args);
-              return result2;
-            } finally {
-              if (previousAuthHeader) {
-                transport.setHeader("Authorization", previousAuthHeader);
-              } else if (transport.removeHeader) {
-                transport.removeHeader("Authorization");
-              }
-            }
-          }
-        }
-      }
-      const result = await client._callToolByName(mcpTool.name, args);
-      return result;
+      return await executeToolWithToken(client, mcpTool.name, args, options);
     }
   };
 }
@@ -6305,9 +6342,7 @@ function convertMCPToolsToVercelAI(client, options) {
   return vercelTools;
 }
 async function getVercelAITools(client, options) {
-  if (!client.isConnected()) {
-    await client.connect();
-  }
+  await ensureClientConnected(client);
   return convertMCPToolsToVercelAI(client, options);
 }
 export {

package/dist/server.js

@@ -1852,6 +1852,33 @@ function createNextOAuthHandler(config) {
   return handlers;
 }
 
+// src/utils/env.ts
+function getEnv(key) {
+  try {
+    const getMetaEnv = () => {
+      try {
+        return typeof import.meta !== "undefined" ? import.meta.env : undefined;
+      } catch {
+        return;
+      }
+    };
+    const metaEnv = getMetaEnv();
+    if (metaEnv && typeof metaEnv === "object" && metaEnv !== null) {
+      const value = metaEnv[key];
+      if (value !== undefined && value !== null && value !== "") {
+        return String(value);
+      }
+    }
+  } catch {}
+  if (typeof process !== "undefined" && process.env) {
+    const value = process.env[key];
+    if (value !== undefined && value !== null && value !== "") {
+      return value;
+    }
+  }
+  return;
+}
+
 // src/plugins/github.ts
 var GITHUB_TOOLS = [
   "github_create_issue",
@@ -1876,8 +1903,8 @@ var GITHUB_TOOLS = [
 function githubPlugin(config = {}) {
   const oauth = {
     provider: "github",
-    clientId: config.clientId ?? process.env.GITHUB_CLIENT_ID,
-    clientSecret: config.clientSecret ?? process.env.GITHUB_CLIENT_SECRET,
+    clientId: config.clientId ?? getEnv("GITHUB_CLIENT_ID"),
+    clientSecret: config.clientSecret ?? getEnv("GITHUB_CLIENT_SECRET"),
     scopes: config.scopes || ["repo", "user"],
     redirectUri: config.redirectUri,
     config: {
@@ -1907,8 +1934,8 @@ var GMAIL_TOOLS = [
 function gmailPlugin(config = {}) {
   const oauth = {
     provider: "gmail",
-    clientId: config.clientId ?? process.env.GMAIL_CLIENT_ID,
-    clientSecret: config.clientSecret ?? process.env.GMAIL_CLIENT_SECRET,
+    clientId: config.clientId ?? getEnv("GMAIL_CLIENT_ID"),
+    clientSecret: config.clientSecret ?? getEnv("GMAIL_CLIENT_SECRET"),
     scopes: config.scopes || [
       "https://www.googleapis.com/auth/gmail.send",
       "https://www.googleapis.com/auth/gmail.readonly",
@@ -1935,8 +1962,8 @@ function genericOAuthPlugin(config) {
   const providerUpper = config.provider.toUpperCase().replace(/[^A-Z0-9]/g, "_");
   const oauth = {
     provider: config.provider,
-    clientId: config.clientId ?? process.env[`${providerUpper}_CLIENT_ID`],
-    clientSecret: config.clientSecret ?? process.env[`${providerUpper}_CLIENT_SECRET`],
+    clientId: config.clientId ?? getEnv(`${providerUpper}_CLIENT_ID`),
+    clientSecret: config.clientSecret ?? getEnv(`${providerUpper}_CLIENT_SECRET`),
     scopes: config.scopes,
     redirectUri: config.redirectUri,
     config
@@ -1966,11 +1993,13 @@ function getDefaultRedirectUri() {
   if (typeof window !== "undefined") {
     return `${window.location.origin}/api/integrate/oauth/callback`;
   }
-  if (process.env.INTEGRATE_URL) {
-    return `${process.env.INTEGRATE_URL}/api/integrate/oauth/callback`;
+  const integrateUrl = getEnv("INTEGRATE_URL");
+  if (integrateUrl) {
+    return `${integrateUrl}/api/integrate/oauth/callback`;
   }
-  if (process.env.VERCEL_URL) {
-    return `https://${process.env.VERCEL_URL}/api/integrate/oauth/callback`;
+  const vercelUrl = getEnv("VERCEL_URL");
+  if (vercelUrl) {
+    return `https://${vercelUrl}/api/integrate/oauth/callback`;
   }
   return "http://localhost:3000/api/integrate/oauth/callback";
 }
@@ -2027,10 +2056,37 @@ function createMCPServer(config) {
     serverUrl: config.serverUrl,
     apiKey: config.apiKey
   });
+  const handler = async (request, context) => {
+    const method = request.method.toUpperCase();
+    let action;
+    if (context?.params?.action) {
+      action = context.params.action;
+    } else if (context?.params?.all) {
+      const all = context.params.all;
+      if (Array.isArray(all)) {
+        action = all[all.length - 1];
+      } else if (typeof all === "string") {
+        action = all.split("/").pop();
+      }
+    } else {
+      const url = new URL(request.url);
+      const pathParts = url.pathname.split("/").filter(Boolean);
+      action = pathParts[pathParts.length - 1] || "callback";
+    }
+    const handlerContext = { params: { action: action || "callback" } };
+    if (method === "POST") {
+      return POST(request, handlerContext);
+    } else if (method === "GET") {
+      return GET(request, handlerContext);
+    } else {
+      return Response.json({ error: `Method ${method} not allowed` }, { status: 405 });
+    }
+  };
   return {
     client,
     POST,
-    GET
+    GET,
+    handler
   };
 }
 function createOAuthRouteHandlers(config) {

package/dist/src/adapters/node.d.ts

@@ -35,7 +35,7 @@ export declare function fromNodeHeaders(nodeHeaders: IncomingHttpHeaders): Heade
  * });
  *
  * createServer(async (req, res) => {
- *   if (req.url?.startsWith('/api/auth/')) {
+ *   if (req.url?.startsWith('/api/integrate/')) {
  *     await handler(req, res);
  *   } else {
  *     res.statusCode = 404;

package/dist/src/adapters/solid-start.d.ts

@@ -25,7 +25,7 @@
  *   ],
  * });
  *
- * // src/routes/api/auth/[...all].ts
+ * // src/routes/api/integrate/[...all].ts
  * import { toSolidStartHandler } from 'integrate-sdk/adapters/solid-start';
  * import { handler } from '@/lib/integrate-server';
  *

package/dist/src/adapters/svelte-kit.d.ts

@@ -12,7 +12,7 @@ type ResolveFunction = any;
  * @param authConfig - Handler function from createMCPServer
  * @param event - SvelteKit RequestEvent
  * @param resolve - SvelteKit resolve function
- * @param basePath - Base path for OAuth routes (default: '/api/auth')
+ * @param basePath - Base path for OAuth routes (default: '/api/integrate')
  * @returns Response from OAuth handler or resolved request
  *
  * @example
@@ -67,7 +67,7 @@ export declare function svelteKitHandler({ authConfig, event, resolve, basePath,
  *   ],
  * });
  *
- * // routes/api/auth/[...all]/+server.ts
+ * // routes/api/integrate/[...all]/+server.ts
  * import { toSvelteKitHandler } from 'integrate-sdk/adapters/svelte-kit';
  * import { handler } from '$lib/integrate-server';
  *

package/dist/src/adapters/svelte-kit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"svelte-kit.d.ts","sourceRoot":"","sources":["../../../src/adapters/svelte-kit.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,KAAK,YAAY,GAAG,GAAG,CAAC;AACxB,KAAK,eAAe,GAAG,GAAG,CAAC;AAE3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAsB,gBAAgB,CAAC,EACnC,UAAU,EACV,KAAK,EACL,OAAO,EACP,QAAsB,GACzB,EAAE;IACC,UAAU,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;IACpD,KAAK,EAAE,YAAY,CAAC;IACpB,OAAO,EAAE,eAAe,CAAC;IACzB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACrB,GAAG,OAAO,CAAC,QAAQ,CAAC,CAWpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,IACrE,OAAO,YAAY,KAAG,OAAO,CAAC,QAAQ,CAAC,CAGxD"}
+{"version":3,"file":"svelte-kit.d.ts","sourceRoot":"","sources":["../../../src/adapters/svelte-kit.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,KAAK,YAAY,GAAG,GAAG,CAAC;AACxB,KAAK,eAAe,GAAG,GAAG,CAAC;AAE3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAsB,gBAAgB,CAAC,EACnC,UAAU,EACV,KAAK,EACL,OAAO,EACP,QAA2B,GAC9B,EAAE;IACC,UAAU,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;IACpD,KAAK,EAAE,YAAY,CAAC;IACpB,OAAO,EAAE,eAAe,CAAC;IACzB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACrB,GAAG,OAAO,CAAC,QAAQ,CAAC,CAWpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,IACrE,OAAO,YAAY,KAAG,OAAO,CAAC,QAAQ,CAAC,CAGxD"}

package/dist/src/adapters/tanstack-start.d.ts

@@ -25,13 +25,13 @@
  *   ],
  * });
  *
- * // app/routes/api/auth/$.ts
+ * // app/routes/api/integrate/$.ts
  * import { toTanStackStartHandler } from 'integrate-sdk/adapters/tanstack-start';
  * import { handler } from '@/lib/integrate-server';
  *
  * const handlers = toTanStackStartHandler(handler);
  *
- * export const Route = createFileRoute('/api/auth/$')({
+ * export const Route = createFileRoute('/api/integrate/$')({
  *   server: {
  *     handlers: {
  *       GET: handlers.GET,

package/dist/src/integrations/anthropic.d.ts

@@ -0,0 +1,208 @@
+/**
+ * Anthropic Claude Integration
+ *
+ * Helper functions to convert MCP tools to Anthropic Claude API format
+ */
+import type { MCPClient } from "../client.js";
+import type { MCPTool } from "../protocol/messages.js";
+import { type AIToolsOptions } from "./utils.js";
+/**
+ * Anthropic tool definition
+ * Compatible with Anthropic's Claude API
+ */
+export interface AnthropicTool {
+    name: string;
+    description: string;
+    input_schema: {
+        type: 'object';
+        properties?: Record<string, unknown>;
+        required?: string[];
+        [key: string]: unknown;
+    };
+}
+/**
+ * Options for converting MCP tools to Anthropic format
+ */
+export interface AnthropicToolsOptions extends AIToolsOptions {
+}
+/**
+ * Anthropic tool use block from message content
+ */
+export interface AnthropicToolUseBlock {
+    type: 'tool_use';
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+}
+/**
+ * Anthropic tool result block for responses
+ */
+export interface AnthropicToolResultBlock {
+    type: 'tool_result';
+    tool_use_id: string;
+    content: string;
+}
+/**
+ * Convert a single MCP tool to Anthropic Claude API format
+ *
+ * @param mcpTool - The MCP tool definition
+ * @param client - The MCP client instance (used for executing the tool)
+ * @param options - Optional configuration including provider tokens
+ * @returns Anthropic compatible tool definition
+ *
+ * @example
+ * ```typescript
+ * const anthropicTool = convertMCPToolToAnthropic(mcpTool, client);
+ * ```
+ */
+export declare function convertMCPToolToAnthropic(mcpTool: MCPTool, _client: MCPClient<any>, _options?: AnthropicToolsOptions): AnthropicTool;
+/**
+ * Convert all enabled MCP tools to Anthropic Claude API format
+ *
+ * @param client - The MCP client instance (must be connected)
+ * @param options - Optional configuration including provider tokens
+ * @returns Array of Anthropic compatible tool definitions
+ *
+ * @example
+ * ```typescript
+ * // Client-side usage
+ * const tools = convertMCPToolsToAnthropic(mcpClient);
+ *
+ * // Server-side with provider tokens
+ * const tools = convertMCPToolsToAnthropic(serverClient, {
+ *   providerTokens: { github: 'ghp_...', gmail: 'ya29...' }
+ * });
+ * ```
+ */
+export declare function convertMCPToolsToAnthropic(client: MCPClient<any>, options?: AnthropicToolsOptions): AnthropicTool[];
+/**
+ * Execute a tool call from Anthropic's response
+ *
+ * @param client - The MCP client instance
+ * @param toolUse - The tool use block from Anthropic response
+ * @param options - Optional configuration including provider tokens
+ * @returns Tool execution result as JSON string
+ *
+ * @example
+ * ```typescript
+ * const result = await executeAnthropicToolCall(client, {
+ *   type: 'tool_use',
+ *   id: 'toolu_123',
+ *   name: 'github_create_issue',
+ *   input: { owner: 'user', repo: 'repo', title: 'Bug' }
+ * }, { providerTokens });
+ * ```
+ */
+export declare function executeAnthropicToolCall(client: MCPClient<any>, toolUse: AnthropicToolUseBlock, options?: AnthropicToolsOptions): Promise<string>;
+/**
+ * Handle all tool calls from Anthropic's message response
+ * Executes all tool use blocks and returns tool result blocks
+ *
+ * @param client - The MCP client instance
+ * @param messageContent - Array of content blocks from Anthropic message
+ * @param options - Optional configuration including provider tokens
+ * @returns Array of tool result blocks ready to send back to Claude
+ *
+ * @example
+ * ```typescript
+ * const response = await anthropic.messages.create({
+ *   model: 'claude-3-5-sonnet-20241022',
+ *   max_tokens: 1024,
+ *   tools,
+ *   messages: [{ role: 'user', content: 'Create a GitHub issue' }]
+ * });
+ *
+ * // Handle tool calls
+ * const toolResults = await handleAnthropicToolCalls(
+ *   client,
+ *   response.content,
+ *   { providerTokens }
+ * );
+ *
+ * // Continue conversation with tool results
+ * const finalResponse = await anthropic.messages.create({
+ *   model: 'claude-3-5-sonnet-20241022',
+ *   max_tokens: 1024,
+ *   tools,
+ *   messages: [
+ *     { role: 'user', content: 'Create a GitHub issue' },
+ *     { role: 'assistant', content: response.content },
+ *     { role: 'user', content: toolResults }
+ *   ]
+ * });
+ * ```
+ */
+export declare function handleAnthropicToolCalls(client: MCPClient<any>, messageContent: Array<{
+    type: string;
+    [key: string]: any;
+}>, options?: AnthropicToolsOptions): Promise<AnthropicToolResultBlock[]>;
+/**
+ * Get tools in a format compatible with Anthropic Claude API
+ *
+ * Automatically connects the client if not already connected.
+ *
+ * @param client - The MCP client instance
+ * @param options - Optional configuration including provider tokens for server-side usage
+ * @returns Array of tools ready to pass to Claude API
+ *
+ * @example
+ * ```typescript
+ * // Client-side usage
+ * import { createMCPClient, githubPlugin } from 'integrate-sdk';
+ * import { getAnthropicTools } from 'integrate-sdk/integrations/anthropic';
+ * import Anthropic from '@anthropic-ai/sdk';
+ *
+ * const client = createMCPClient({
+ *   plugins: [githubPlugin({ clientId: '...' })],
+ * });
+ *
+ * const tools = await getAnthropicTools(client);
+ * const anthropic = new Anthropic({ apiKey: '...' });
+ *
+ * const message = await anthropic.messages.create({
+ *   model: 'claude-3-5-sonnet-20241022',
+ *   max_tokens: 1024,
+ *   tools,
+ *   messages: [{ role: 'user', content: 'Create a GitHub issue' }]
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Server-side usage with tokens from client
+ * import { createMCPServer, githubPlugin } from 'integrate-sdk/server';
+ * import { getAnthropicTools, handleAnthropicToolCalls } from 'integrate-sdk/integrations/anthropic';
+ *
+ * const { client: serverClient } = createMCPServer({
+ *   plugins: [githubPlugin({
+ *     clientId: '...',
+ *     clientSecret: '...'
+ *   })],
+ * });
+ *
+ * // In your API route
+ * export async function POST(req: Request) {
+ *   const providerTokens = JSON.parse(req.headers.get('x-integrate-tokens') || '{}');
+ *   const tools = await getAnthropicTools(serverClient, { providerTokens });
+ *
+ *   const anthropic = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
+ *   const message = await anthropic.messages.create({
+ *     model: 'claude-3-5-sonnet-20241022',
+ *     max_tokens: 1024,
+ *     tools,
+ *     messages: [{ role: 'user', content: 'Create a GitHub issue' }]
+ *   });
+ *
+ *   // Handle any tool calls
+ *   const toolResults = await handleAnthropicToolCalls(
+ *     serverClient,
+ *     message.content,
+ *     { providerTokens }
+ *   );
+ *
+ *   return Response.json({ message, toolResults });
+ * }
+ * ```
+ */
+export declare function getAnthropicTools(client: MCPClient<any>, options?: AnthropicToolsOptions): Promise<AnthropicTool[]>;
+//# sourceMappingURL=anthropic.d.ts.map

package/dist/src/integrations/anthropic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic.d.ts","sourceRoot":"","sources":["../../../src/integrations/anthropic.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAA+C,KAAK,cAAc,EAAE,MAAM,YAAY,CAAC;AAE9F;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE;QACZ,IAAI,EAAE,QAAQ,CAAC;QACf,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACrC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;QACpB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;KACxB,CAAC;CACH;AAED;;GAEG;AACH,MAAM,WAAW,qBAAsB,SAAQ,cAAc;CAAI;AAEjE;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,UAAU,CAAC;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC;AAED;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,aAAa,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,SAAS,CAAC,GAAG,CAAC,EACvB,QAAQ,CAAC,EAAE,qBAAqB,GAC/B,aAAa,CAUf;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,qBAAqB,GAC9B,aAAa,EAAE,CAGjB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,EAAE,qBAAqB,EAC9B,OAAO,CAAC,EAAE,qBAAqB,GAC9B,OAAO,CAAC,MAAM,CAAC,CAGjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,cAAc,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAA,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,CAAC,EAC1D,OAAO,CAAC,EAAE,qBAAqB,GAC9B,OAAO,CAAC,wBAAwB,EAAE,CAAC,CAkCrC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AACH,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,qBAAqB,GAC9B,OAAO,CAAC,aAAa,EAAE,CAAC,CAG1B"}