integrate-sdk 0.7.48 → 0.7.49

package/dist/adapters/index.js

@@ -10,6 +10,280 @@ var __export = (target, all) => {
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
+// session-detector.ts
+var exports_session_detector = {};
+__export(exports_session_detector, {
+  tryDecodeJWT: () => tryDecodeJWT,
+  detectSessionContext: () => detectSessionContext
+});
+function tryDecodeJWT(token) {
+  try {
+    const parts = token.split(".");
+    if (parts.length !== 3) {
+      return;
+    }
+    const payloadPart = parts[1];
+    if (!payloadPart) {
+      return;
+    }
+    const base64 = payloadPart.replace(/-/g, "+").replace(/_/g, "/");
+    const jsonPayload = decodeURIComponent(atob(base64).split("").map((c) => "%" + ("00" + c.charCodeAt(0).toString(16)).slice(-2)).join(""));
+    return JSON.parse(jsonPayload);
+  } catch (error) {
+    return;
+  }
+}
+function getCookies(request) {
+  const cookies = new Map;
+  const cookieHeader = request.headers.get("cookie");
+  if (!cookieHeader) {
+    return cookies;
+  }
+  const pairs = cookieHeader.split(";");
+  for (const pair of pairs) {
+    const [name, ...valueParts] = pair.split("=");
+    if (name && valueParts.length > 0) {
+      const trimmedName = name.trim();
+      const value = valueParts.join("=").trim();
+      cookies.set(trimmedName, value);
+    }
+  }
+  return cookies;
+}
+function tryBetterAuth(cookies) {
+  const sessionToken = cookies.get("better-auth.session_token");
+  if (!sessionToken) {
+    return;
+  }
+  const payload = tryDecodeJWT(sessionToken);
+  if (!payload) {
+    return;
+  }
+  const userId = payload.sub || payload.userId || payload.user_id || payload.id;
+  if (!userId) {
+    return;
+  }
+  return {
+    userId,
+    sessionId: payload.jti || payload.sessionId
+  };
+}
+function tryNextAuth(cookies) {
+  const sessionToken = cookies.get("__Secure-next-auth.session-token") || cookies.get("next-auth.session-token");
+  if (!sessionToken) {
+    return;
+  }
+  if (sessionToken.includes(".")) {
+    const payload = tryDecodeJWT(sessionToken);
+    if (payload) {
+      return {
+        userId: payload.sub || payload.userId || payload.user_id || payload.id,
+        sessionId: payload.jti
+      };
+    }
+  }
+  return;
+}
+function tryClerk(cookies) {
+  const sessionToken = cookies.get("__session");
+  if (!sessionToken) {
+    return;
+  }
+  const payload = tryDecodeJWT(sessionToken);
+  if (!payload) {
+    return;
+  }
+  return {
+    userId: payload.sub || payload.userId,
+    organizationId: payload.org_id || payload.organizationId,
+    sessionId: payload.sid || payload.sessionId
+  };
+}
+function tryLucia(cookies) {
+  const sessionToken = cookies.get("lucia_session");
+  if (!sessionToken) {
+    return;
+  }
+  return {
+    sessionId: sessionToken
+  };
+}
+function tryGenericSession(cookies) {
+  const sessionToken = cookies.get("auth_session") || cookies.get("session");
+  if (!sessionToken) {
+    return;
+  }
+  if (sessionToken.includes(".")) {
+    const payload = tryDecodeJWT(sessionToken);
+    if (payload) {
+      return {
+        userId: payload.sub || payload.userId || payload.user_id || payload.id,
+        sessionId: payload.jti || payload.sessionId || payload.sid
+      };
+    }
+  }
+  return {
+    sessionId: sessionToken
+  };
+}
+async function detectSessionContext(request) {
+  const cookies = getCookies(request);
+  let context;
+  context = tryBetterAuth(cookies);
+  if (context?.userId) {
+    return context;
+  }
+  context = tryNextAuth(cookies);
+  if (context?.userId) {
+    return context;
+  }
+  context = tryClerk(cookies);
+  if (context?.userId) {
+    return context;
+  }
+  context = tryLucia(cookies);
+  if (context?.userId) {
+    return context;
+  }
+  context = tryGenericSession(cookies);
+  if (context?.userId) {
+    return context;
+  }
+  return;
+}
+
+// context-cookie.ts
+var exports_context_cookie = {};
+__export(exports_context_cookie, {
+  readContextCookie: () => readContextCookie,
+  getSetCookieHeader: () => getSetCookieHeader,
+  getContextCookieFromRequest: () => getContextCookieFromRequest,
+  getClearCookieHeader: () => getClearCookieHeader,
+  createContextCookie: () => createContextCookie,
+  CONTEXT_COOKIE_NAME: () => CONTEXT_COOKIE_NAME,
+  CONTEXT_COOKIE_MAX_AGE: () => CONTEXT_COOKIE_MAX_AGE
+});
+async function deriveKey(secret) {
+  const encoder = new TextEncoder;
+  const secretData = encoder.encode(secret);
+  const keyMaterial = await crypto.subtle.importKey("raw", secretData, { name: "PBKDF2" }, false, ["deriveBits", "deriveKey"]);
+  const salt = encoder.encode("integrate-oauth-context-v1");
+  return await crypto.subtle.deriveKey({
+    name: "PBKDF2",
+    salt,
+    iterations: 1e5,
+    hash: "SHA-256"
+  }, keyMaterial, { name: "AES-GCM", length: 256 }, false, ["encrypt", "decrypt"]);
+}
+async function encryptPayload(payload, secret) {
+  const key = await deriveKey(secret);
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+  const encoder = new TextEncoder;
+  const data = encoder.encode(JSON.stringify(payload));
+  const encrypted = await crypto.subtle.encrypt({
+    name: "AES-GCM",
+    iv
+  }, key, data);
+  const combined = new Uint8Array(iv.length + encrypted.byteLength);
+  combined.set(iv, 0);
+  combined.set(new Uint8Array(encrypted), iv.length);
+  return base64UrlEncode(combined);
+}
+async function decryptPayload(cookieValue, secret) {
+  try {
+    const combined = base64UrlDecode(cookieValue);
+    const iv = combined.slice(0, 12);
+    const encrypted = combined.slice(12);
+    const key = await deriveKey(secret);
+    const decrypted = await crypto.subtle.decrypt({
+      name: "AES-GCM",
+      iv
+    }, key, encrypted);
+    const decoder = new TextDecoder;
+    const json = decoder.decode(decrypted);
+    const payload = JSON.parse(json);
+    const age = Date.now() - payload.timestamp;
+    if (age > CONTEXT_COOKIE_MAX_AGE * 1000) {
+      return;
+    }
+    return payload;
+  } catch (error) {
+    return;
+  }
+}
+function base64UrlEncode(data) {
+  const base64 = btoa(String.fromCharCode(...data));
+  return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+function base64UrlDecode(str) {
+  let base64 = str.replace(/-/g, "+").replace(/_/g, "/");
+  const padding = base64.length % 4;
+  if (padding) {
+    base64 += "=".repeat(4 - padding);
+  }
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0;i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+async function createContextCookie(context, provider, secret) {
+  const payload = {
+    context,
+    provider,
+    timestamp: Date.now()
+  };
+  return await encryptPayload(payload, secret);
+}
+async function readContextCookie(cookieValue, secret) {
+  const payload = await decryptPayload(cookieValue, secret);
+  if (!payload) {
+    return;
+  }
+  return {
+    context: payload.context,
+    provider: payload.provider
+  };
+}
+function getSetCookieHeader(cookieValue, maxAge = CONTEXT_COOKIE_MAX_AGE) {
+  const attributes = [
+    `${CONTEXT_COOKIE_NAME}=${cookieValue}`,
+    `Max-Age=${maxAge}`,
+    "HttpOnly",
+    "Secure",
+    "SameSite=Lax",
+    "Path=/"
+  ];
+  return attributes.join("; ");
+}
+function getClearCookieHeader() {
+  const attributes = [
+    `${CONTEXT_COOKIE_NAME}=`,
+    "Max-Age=0",
+    "HttpOnly",
+    "Secure",
+    "SameSite=Lax",
+    "Path=/"
+  ];
+  return attributes.join("; ");
+}
+function getContextCookieFromRequest(request) {
+  const cookieHeader = request.headers.get("cookie");
+  if (!cookieHeader) {
+    return;
+  }
+  const cookies = cookieHeader.split(";");
+  for (const cookie of cookies) {
+    const [name, ...valueParts] = cookie.split("=");
+    if (name && name.trim() === CONTEXT_COOKIE_NAME) {
+      return valueParts.join("=").trim();
+    }
+  }
+  return;
+}
+var CONTEXT_COOKIE_NAME = "__integrate_oauth_ctx", CONTEXT_COOKIE_MAX_AGE = 300;
+
 // base-handler.ts
 class OAuthHandler {
   config;
@@ -33,25 +307,35 @@ class OAuthHandler {
     return headers;
   }
   async handleAuthorize(request) {
-    const providerConfig = this.config.providers[request.provider];
+    let webRequest;
+    let authorizeRequest;
+    if (request instanceof Request) {
+      webRequest = request;
+      authorizeRequest = await request.json();
+    } else if (typeof request === "object" && "json" in request && typeof request.json === "function") {
+      authorizeRequest = await request.json();
+    } else {
+      authorizeRequest = request;
+    }
+    const providerConfig = this.config.providers[authorizeRequest.provider];
     if (!providerConfig) {
-      throw new Error(`Provider ${request.provider} not configured. Add OAuth credentials to your API route configuration.`);
+      throw new Error(`Provider ${authorizeRequest.provider} not configured. Add OAuth credentials to your API route configuration.`);
     }
     if (!providerConfig.clientId || !providerConfig.clientSecret) {
-      throw new Error(`Missing OAuth credentials for ${request.provider}. Check your environment variables.`);
+      throw new Error(`Missing OAuth credentials for ${authorizeRequest.provider}. Check your environment variables.`);
     }
     const url = new URL("/oauth/authorize", this.serverUrl);
-    url.searchParams.set("provider", request.provider);
+    url.searchParams.set("provider", authorizeRequest.provider);
     url.searchParams.set("client_id", providerConfig.clientId);
     url.searchParams.set("client_secret", providerConfig.clientSecret);
-    const scopes = request.scopes || providerConfig.scopes || [];
+    const scopes = authorizeRequest.scopes || providerConfig.scopes || [];
     if (scopes.length > 0) {
       url.searchParams.set("scope", scopes.join(","));
     }
-    url.searchParams.set("state", request.state);
-    url.searchParams.set("code_challenge", request.codeChallenge);
-    url.searchParams.set("code_challenge_method", request.codeChallengeMethod);
-    const redirectUri = request.redirectUri || providerConfig.redirectUri;
+    url.searchParams.set("state", authorizeRequest.state);
+    url.searchParams.set("code_challenge", authorizeRequest.codeChallenge);
+    url.searchParams.set("code_challenge_method", authorizeRequest.codeChallengeMethod);
+    const redirectUri = authorizeRequest.redirectUri || providerConfig.redirectUri;
     if (redirectUri) {
       url.searchParams.set("redirect_uri", redirectUri);
     }
@@ -64,15 +348,62 @@ class OAuthHandler {
       throw new Error(`MCP server failed to generate authorization URL: ${error}`);
     }
     const data = await response.json();
-    return data;
+    const result = data;
+    if (webRequest) {
+      try {
+        const { detectSessionContext: detectSessionContext2 } = await Promise.resolve().then(() => exports_session_detector);
+        const { createContextCookie: createContextCookie2, getSetCookieHeader: getSetCookieHeader2 } = await Promise.resolve().then(() => exports_context_cookie);
+        let context;
+        if (this.config.getSessionContext) {
+          context = await this.config.getSessionContext(webRequest);
+        }
+        if (!context || !context.userId) {
+          context = await detectSessionContext2(webRequest);
+        }
+        if (context && context.userId) {
+          const secret = this.apiKey || providerConfig.clientSecret;
+          const cookieValue = await createContextCookie2(context, authorizeRequest.provider, secret);
+          result.setCookie = getSetCookieHeader2(cookieValue);
+        }
+      } catch (error) {
+        console.warn("[OAuth] Failed to capture user context:", error);
+      }
+    }
+    return result;
   }
   async handleCallback(request) {
-    const providerConfig = this.config.providers[request.provider];
+    let webRequest;
+    let callbackRequest;
+    if (request instanceof Request) {
+      webRequest = request;
+      callbackRequest = await request.json();
+    } else if (typeof request === "object" && "json" in request && typeof request.json === "function") {
+      callbackRequest = await request.json();
+    } else {
+      callbackRequest = request;
+    }
+    const providerConfig = this.config.providers[callbackRequest.provider];
     if (!providerConfig) {
-      throw new Error(`Provider ${request.provider} not configured. Add OAuth credentials to your API route configuration.`);
+      throw new Error(`Provider ${callbackRequest.provider} not configured. Add OAuth credentials to your API route configuration.`);
     }
     if (!providerConfig.clientId || !providerConfig.clientSecret) {
-      throw new Error(`Missing OAuth credentials for ${request.provider}. Check your environment variables.`);
+      throw new Error(`Missing OAuth credentials for ${callbackRequest.provider}. Check your environment variables.`);
+    }
+    let context;
+    if (webRequest) {
+      try {
+        const { getContextCookieFromRequest: getContextCookieFromRequest2, readContextCookie: readContextCookie2 } = await Promise.resolve().then(() => exports_context_cookie);
+        const cookieValue = getContextCookieFromRequest2(webRequest);
+        if (cookieValue) {
+          const secret = this.apiKey || providerConfig.clientSecret;
+          const contextData = await readContextCookie2(cookieValue, secret);
+          if (contextData && contextData.provider === callbackRequest.provider) {
+            context = contextData.context;
+          }
+        }
+      } catch (error) {
+        console.warn("[OAuth] Failed to restore user context:", error);
+      }
     }
     const url = new URL("/oauth/callback", this.serverUrl);
     const response = await fetch(url.toString(), {
@@ -81,10 +412,10 @@ class OAuthHandler {
         "Content-Type": "application/json"
       }),
       body: JSON.stringify({
-        provider: request.provider,
-        code: request.code,
-        code_verifier: request.codeVerifier,
-        state: request.state,
+        provider: callbackRequest.provider,
+        code: callbackRequest.code,
+        code_verifier: callbackRequest.codeVerifier,
+        state: callbackRequest.state,
         client_id: providerConfig.clientId,
         client_secret: providerConfig.clientSecret,
         redirect_uri: providerConfig.redirectUri
@@ -95,7 +426,26 @@ class OAuthHandler {
       throw new Error(`MCP server failed to exchange authorization code: ${error}`);
     }
     const data = await response.json();
-    return data;
+    const result = data;
+    if (this.config.setProviderToken && context) {
+      try {
+        const tokenData = {
+          accessToken: result.accessToken,
+          refreshToken: result.refreshToken,
+          tokenType: result.tokenType,
+          expiresIn: result.expiresIn,
+          expiresAt: result.expiresAt
+        };
+        await this.config.setProviderToken(callbackRequest.provider, tokenData, context);
+      } catch (error) {
+        console.error("[OAuth] Failed to save provider token:", error);
+      }
+    }
+    if (webRequest) {
+      const { getClearCookieHeader: getClearCookieHeader2 } = await Promise.resolve().then(() => exports_context_cookie);
+      result.clearCookie = getClearCookieHeader2();
+    }
+    return result;
   }
   async handleStatus(provider, accessToken) {
     const url = new URL("/oauth/status", this.serverUrl);
@@ -196,7 +546,7 @@ function generateCodeVerifier() {
   } else {
     throw new Error("crypto.getRandomValues is not available. Please use Node.js 19+ or a modern browser.");
   }
-  return base64UrlEncode(array);
+  return base64UrlEncode2(array);
 }
 async function generateCodeChallenge(verifier) {
   const encoder = new TextEncoder;
@@ -209,7 +559,7 @@ async function generateCodeChallenge(verifier) {
   } else {
     throw new Error("crypto.subtle.digest is not available. Please use Node.js 19+ or a modern browser.");
   }
-  return base64UrlEncode(new Uint8Array(hashBuffer));
+  return base64UrlEncode2(new Uint8Array(hashBuffer));
 }
 function generateState() {
   const array = new Uint8Array(16);
@@ -220,18 +570,18 @@ function generateState() {
   } else {
     throw new Error("crypto.getRandomValues is not available. Please use Node.js 19+ or a modern browser.");
   }
-  return base64UrlEncode(array);
+  return base64UrlEncode2(array);
 }
 function generateStateWithReturnUrl(returnUrl) {
   const csrf = generateState();
   const stateData = returnUrl ? { csrf, returnUrl } : { csrf };
   const encoder = new TextEncoder;
   const jsonBytes = encoder.encode(JSON.stringify(stateData));
-  return base64UrlEncode(jsonBytes);
+  return base64UrlEncode2(jsonBytes);
 }
 function parseState(state) {
   try {
-    const decoded = base64UrlDecode(state);
+    const decoded = base64UrlDecode2(state);
     const parsed = JSON.parse(decoded);
     if (typeof parsed === "string") {
       return { csrf: parsed };
@@ -246,7 +596,7 @@ function parseState(state) {
     return { csrf: state };
   }
 }
-function base64UrlEncode(array) {
+function base64UrlEncode2(array) {
   let base64 = "";
   if (typeof Buffer !== "undefined") {
     base64 = Buffer.from(array).toString("base64");
@@ -256,7 +606,7 @@ function base64UrlEncode(array) {
   }
   return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
 }
-function base64UrlDecode(str) {
+function base64UrlDecode2(str) {
   let base64 = str.replace(/-/g, "+").replace(/_/g, "/");
   while (base64.length % 4 !== 0) {
     base64 += "=";
@@ -418,9 +768,12 @@ function createNextOAuthHandler(config) {
   const handlers = {
     async authorize(req) {
       try {
-        const body = await req.json();
-        const result = await handler.handleAuthorize(body);
-        return Response.json(result);
+        const result = await handler.handleAuthorize(req);
+        const response = Response.json(result);
+        if (result.setCookie) {
+          response.headers.set("Set-Cookie", result.setCookie);
+        }
+        return response;
       } catch (error) {
         console.error("[OAuth Authorize] Error:", error);
         return Response.json({ error: error.message || "Failed to get authorization URL" }, { status: 500 });
@@ -428,9 +781,12 @@ function createNextOAuthHandler(config) {
     },
     async callback(req) {
       try {
-        const body = await req.json();
-        const result = await handler.handleCallback(body);
-        return Response.json(result);
+        const result = await handler.handleCallback(req);
+        const response = Response.json(result);
+        if (result.clearCookie) {
+          response.headers.set("Set-Cookie", result.clearCookie);
+        }
+        return response;
       } catch (error) {
         console.error("[OAuth Callback] Error:", error);
         return Response.json({ error: error.message || "Failed to exchange authorization code" }, { status: 500 });
@@ -647,18 +1003,24 @@ function toNodeHandler(config) {
       let webRes;
       if (req.method === "POST") {
         if (action === "authorize") {
-          const body = await webReq.json();
-          const result = await oauthHandler.handleAuthorize(body);
+          const result = await oauthHandler.handleAuthorize(webReq);
+          const headers = { "Content-Type": "application/json" };
+          if (result.setCookie) {
+            headers["Set-Cookie"] = result.setCookie;
+          }
           webRes = new Response(JSON.stringify(result), {
             status: 200,
-            headers: { "Content-Type": "application/json" }
+            headers
           });
         } else if (action === "callback") {
-          const body = await webReq.json();
-          const result = await oauthHandler.handleCallback(body);
+          const result = await oauthHandler.handleCallback(webReq);
+          const headers = { "Content-Type": "application/json" };
+          if (result.clearCookie) {
+            headers["Set-Cookie"] = result.clearCookie;
+          }
           webRes = new Response(JSON.stringify(result), {
             status: 200,
-            headers: { "Content-Type": "application/json" }
+            headers
           });
         } else if (action === "disconnect") {
           const authHeader = webReq.headers.get("authorization");

package/dist/adapters/nextjs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nextjs.d.ts","sourceRoot":"","sources":["../../../src/adapters/nextjs.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAgB,KAAK,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAG1E,KAAK,WAAW,GAAG,GAAG,CAAC;AACvB,KAAK,YAAY,GAAG,GAAG,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,kBAAkB;IAI7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwCG;mBACkB,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;IAcxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAyCG;kBACiB,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;IAcvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;gBACe,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;IA+BrD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAuCG;oBACmB,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;IAiCzD;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;;QAGC;;WAEG;kBAEI,WAAW,WACP;YAAE,MAAM,EAAE;gBAAE,MAAM,EAAE,MAAM,CAAA;aAAE,GAAG,OAAO,CAAC;gBAAE,MAAM,EAAE,MAAM,CAAA;aAAE,CAAC,CAAA;SAAE,GACpE,OAAO,CAAC,YAAY,CAAC;QA2BxB;;WAEG;iBAEI,WAAW,WACP;YAAE,MAAM,EAAE;gBAAE,MAAM,EAAE,MAAM,CAAA;aAAE,GAAG,OAAO,CAAC;gBAAE,MAAM,EAAE,MAAM,CAAA;aAAE,CAAC,CAAA;SAAE,GACpE,OAAO,CAAC,YAAY,CAAC;;IAiB5B;;;;;;;;;;;;;;;;;;;;;;;OAuBG;aACY,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;IAelD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;qCAC8B;QAC/B,6DAA6D;QAC7D,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,iEAAiE;QACjE,gBAAgB,CAAC,EAAE,MAAM,CAAC;KAC3B;QAKG;;WAEG;kBAEI,WAAW,WACP;YAAE,MAAM,EAAE;gBAAE,GAAG,EAAE,MAAM,EAAE,CAAA;aAAE,GAAG,OAAO,CAAC;gBAAE,GAAG,EAAE,MAAM,EAAE,CAAA;aAAE,CAAC,CAAA;SAAE,GAClE,OAAO,CAAC,YAAY,CAAC;QAsCxB;;WAEG;iBAEI,WAAW,WACP;YAAE,MAAM,EAAE;gBAAE,GAAG,EAAE,MAAM,EAAE,CAAA;aAAE,GAAG,OAAO,CAAC;gBAAE,GAAG,EAAE,MAAM,EAAE,CAAA;aAAE,CAAC,CAAA;SAAE,GAClE,OAAO,CAAC,YAAY,CAAC;;EA+F/B"}
+{"version":3,"file":"nextjs.d.ts","sourceRoot":"","sources":["../../../src/adapters/nextjs.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAgB,KAAK,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAG1E,KAAK,WAAW,GAAG,GAAG,CAAC;AACvB,KAAK,YAAY,GAAG,GAAG,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,kBAAkB;IAI7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwCG;mBACkB,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;IAuBxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAyCG;kBACiB,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;IAuBvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;gBACe,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;IA+BrD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAuCG;oBACmB,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;IAiCzD;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;;QAGC;;WAEG;kBAEI,WAAW,WACP;YAAE,MAAM,EAAE;gBAAE,MAAM,EAAE,MAAM,CAAA;aAAE,GAAG,OAAO,CAAC;gBAAE,MAAM,EAAE,MAAM,CAAA;aAAE,CAAC,CAAA;SAAE,GACpE,OAAO,CAAC,YAAY,CAAC;QA2BxB;;WAEG;iBAEI,WAAW,WACP;YAAE,MAAM,EAAE;gBAAE,MAAM,EAAE,MAAM,CAAA;aAAE,GAAG,OAAO,CAAC;gBAAE,MAAM,EAAE,MAAM,CAAA;aAAE,CAAC,CAAA;SAAE,GACpE,OAAO,CAAC,YAAY,CAAC;;IAiB5B;;;;;;;;;;;;;;;;;;;;;;;OAuBG;aACY,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;IAelD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;qCAC8B;QAC/B,6DAA6D;QAC7D,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,iEAAiE;QACjE,gBAAgB,CAAC,EAAE,MAAM,CAAC;KAC3B;QAKG;;WAEG;kBAEI,WAAW,WACP;YAAE,MAAM,EAAE;gBAAE,GAAG,EAAE,MAAM,EAAE,CAAA;aAAE,GAAG,OAAO,CAAC;gBAAE,GAAG,EAAE,MAAM,EAAE,CAAA;aAAE,CAAC,CAAA;SAAE,GAClE,OAAO,CAAC,YAAY,CAAC;QAsCxB;;WAEG;iBAEI,WAAW,WACP;YAAE,MAAM,EAAE;gBAAE,GAAG,EAAE,MAAM,EAAE,CAAA;aAAE,GAAG,OAAO,CAAC;gBAAE,GAAG,EAAE,MAAM,EAAE,CAAA;aAAE,CAAC,CAAA;SAAE,GAClE,OAAO,CAAC,YAAY,CAAC;;EA+F/B"}