better-auth-studio 1.1.2-beta.2 → 1.1.2-beta.20

package/dist/utils/database-hook-injector.js

@@ -1,141 +1,145 @@
-import { emitEvent } from './event-ingestion.js';
+import { emitEvent } from "./event-ingestion.js";
 export function wrapDatabaseHooks(auth, eventsConfig) {
-    if (!auth || !eventsConfig?.enabled) {
-        return;
+  if (!auth || !eventsConfig?.enabled) {
+    return;
+  }
+  try {
+    // Ensure auth.options exists
+    if (!auth.options) {
+      auth.options = {};
+    }
+    // Only proceed if auth.options is a valid object
+    if (typeof auth.options !== "object" || auth.options === null) {
+      console.warn("[Database Hooks] auth.options is not a valid object");
+      return;
+    }
+    const capturedConfig = eventsConfig;
+    // Initialize databaseHooks if it doesn't exist
+    if (!auth.options.databaseHooks) {
+      auth.options.databaseHooks = {};
+    }
+    // Check if already wrapped
+    if (auth.options.databaseHooks.__studio_wrapped) {
+      return;
+    }
+    // Ensure databaseHooks is an object
+    if (typeof auth.options.databaseHooks !== "object" || auth.options.databaseHooks === null) {
+      console.warn("[Database Hooks] databaseHooks is not a valid object");
+      return;
     }
     try {
-        // Ensure auth.options exists
-        if (!auth.options) {
-            auth.options = {};
-        }
-        // Only proceed if auth.options is a valid object
-        if (typeof auth.options !== 'object' || auth.options === null) {
-            console.warn('[Database Hooks] auth.options is not a valid object');
-            return;
+      const existingAccountHooks = auth.options.databaseHooks.account || {};
+      const existingCreateHooks = existingAccountHooks.create || {};
+      const existingAfter = existingCreateHooks.after;
+      const oauthAccountAfter = async (account, context) => {
+        // Validate context and internalAdapter exist
+        if (!context || !context.internalAdapter) {
+          console.warn("[OAuth DB Hook] Context or internalAdapter is missing");
+          return;
         }
-        const capturedConfig = eventsConfig;
-        // Initialize databaseHooks if it doesn't exist
-        if (!auth.options.databaseHooks) {
-            auth.options.databaseHooks = {};
+        // Validate account exists
+        if (!account || !account.userId || !account.providerId) {
+          return;
         }
-        // Check if already wrapped
-        if (auth.options.databaseHooks.__studio_wrapped) {
-            return;
-        }
-        // Ensure databaseHooks is an object
-        if (typeof auth.options.databaseHooks !== 'object' || auth.options.databaseHooks === null) {
-            console.warn('[Database Hooks] databaseHooks is not a valid object');
-            return;
-        }
-        try {
-            const existingAccountHooks = auth.options.databaseHooks.account || {};
-            const existingCreateHooks = existingAccountHooks.create || {};
-            const existingAfter = existingCreateHooks.after;
-            const oauthAccountAfter = async (account, context) => {
-                // Validate context and internalAdapter exist
-                if (!context || !context.internalAdapter) {
-                    console.warn('[OAuth DB Hook] Context or internalAdapter is missing');
-                    return;
-                }
-                // Validate account exists
-                if (!account || !account.userId || !account.providerId) {
-                    return;
-                }
-                console.log('OAuth account created', account);
-                if (account.providerId !== 'credential') {
-                    try {
-                        // Ensure internalAdapter methods exist
-                        if (typeof context.internalAdapter.findUserById !== 'function' ||
-                            typeof context.internalAdapter.findAccounts !== 'function') {
-                            console.warn('[OAuth DB Hook] internalAdapter methods are missing');
-                            return;
-                        }
-                        const user = await context.internalAdapter.findUserById(account.userId);
-                        if (user) {
-                            const existingAccounts = await context.internalAdapter.findAccounts(account.userId);
-                            const isLinking = existingAccounts && existingAccounts.length > 1; // More than just this new account
-                            if (isLinking) {
-                                await emitEvent('oauth.linked', {
-                                    status: 'success',
-                                    userId: account.userId,
-                                    metadata: {
-                                        provider: account.providerId,
-                                        providerId: account.providerId,
-                                        userEmail: user.email,
-                                        email: user.email,
-                                        name: user.name,
-                                        accountId: account.accountId,
-                                        linkedAt: new Date().toISOString(),
-                                    },
-                                }, capturedConfig).catch(() => { });
-                            }
-                            else {
-                                await emitEvent('oauth.sign_in', {
-                                    status: 'success',
-                                    userId: account.userId,
-                                    metadata: {
-                                        provider: account.providerId,
-                                        providerId: account.providerId,
-                                        userEmail: user.email,
-                                        email: user.email,
-                                        name: user.name,
-                                        emailVerified: user.emailVerified,
-                                        accountId: account.accountId,
-                                        createdAt: user.createdAt
-                                            ? new Date(user.createdAt).toISOString()
-                                            : new Date().toISOString(),
-                                    },
-                                }, capturedConfig).catch(() => { });
-                            }
-                        }
-                    }
-                    catch (error) {
-                        console.error('[OAuth DB Hook] Error:', error);
-                    }
-                }
-            };
-            // Safely assign the hook - wrap in try-catch to prevent any Better Auth initialization errors
-            try {
-                auth.options.databaseHooks.account = {
-                    ...existingAccountHooks,
-                    create: {
-                        ...existingCreateHooks,
-                        before: existingCreateHooks.before,
-                        after: async (account, context) => {
-                            try {
-                                // Call existing hook first if it exists
-                                if (existingAfter && typeof existingAfter === 'function') {
-                                    await existingAfter(account, context);
-                                }
-                                // Then call our OAuth tracking hook
-                                await oauthAccountAfter(account, context);
-                            }
-                            catch (error) {
-                                // Don't let hook errors break the flow
-                                console.error('[Database Hook] Error in after hook:', error);
-                                // Re-throw only if it's not a reloadNavigation error (Better Auth internal issue)
-                                if (error instanceof Error && !error.message.includes('reloadNavigation')) {
-                                    throw error;
-                                }
-                            }
-                        },
-                    },
-                };
-                auth.options.databaseHooks.__studio_wrapped = true;
+        console.log("OAuth account created", account);
+        if (account.providerId !== "credential") {
+          try {
+            // Ensure internalAdapter methods exist
+            if (
+              typeof context.internalAdapter.findUserById !== "function" ||
+              typeof context.internalAdapter.findAccounts !== "function"
+            ) {
+              console.warn("[OAuth DB Hook] internalAdapter methods are missing");
+              return;
             }
-            catch (assignError) {
-                // If assignment fails, log but don't crash
-                console.error('[Database Hooks] Error assigning hooks:', assignError);
-                // Don't mark as wrapped if assignment failed
+            const user = await context.internalAdapter.findUserById(account.userId);
+            if (user) {
+              const existingAccounts = await context.internalAdapter.findAccounts(account.userId);
+              const isLinking = existingAccounts && existingAccounts.length > 1; // More than just this new account
+              if (isLinking) {
+                await emitEvent(
+                  "oauth.linked",
+                  {
+                    status: "success",
+                    userId: account.userId,
+                    metadata: {
+                      provider: account.providerId,
+                      providerId: account.providerId,
+                      userEmail: user.email,
+                      email: user.email,
+                      name: user.name,
+                      accountId: account.accountId,
+                      linkedAt: new Date().toISOString(),
+                    },
+                  },
+                  capturedConfig,
+                ).catch(() => {});
+              } else {
+                await emitEvent(
+                  "oauth.sign_in",
+                  {
+                    status: "success",
+                    userId: account.userId,
+                    metadata: {
+                      provider: account.providerId,
+                      providerId: account.providerId,
+                      userEmail: user.email,
+                      email: user.email,
+                      name: user.name,
+                      emailVerified: user.emailVerified,
+                      accountId: account.accountId,
+                      createdAt: user.createdAt
+                        ? new Date(user.createdAt).toISOString()
+                        : new Date().toISOString(),
+                    },
+                  },
+                  capturedConfig,
+                ).catch(() => {});
+              }
             }
+          } catch (error) {
+            console.error("[OAuth DB Hook] Error:", error);
+          }
         }
-        catch (hookError) {
-            console.error('[Database Hooks] Error setting up hooks:', hookError);
-            // Don't mark as wrapped if there was an error
-        }
-    }
-    catch (error) {
-        console.error('[Database Hooks] Failed to wrap:', error);
+      };
+      // Safely assign the hook - wrap in try-catch to prevent any Better Auth initialization errors
+      try {
+        auth.options.databaseHooks.account = {
+          ...existingAccountHooks,
+          create: {
+            ...existingCreateHooks,
+            before: existingCreateHooks.before,
+            after: async (account, context) => {
+              try {
+                // Call existing hook first if it exists
+                if (existingAfter && typeof existingAfter === "function") {
+                  await existingAfter(account, context);
+                }
+                // Then call our OAuth tracking hook
+                await oauthAccountAfter(account, context);
+              } catch (error) {
+                // Don't let hook errors break the flow
+                console.error("[Database Hook] Error in after hook:", error);
+                // Re-throw only if it's not a reloadNavigation error (Better Auth internal issue)
+                if (error instanceof Error && !error.message.includes("reloadNavigation")) {
+                  throw error;
+                }
+              }
+            },
+          },
+        };
+        auth.options.databaseHooks.__studio_wrapped = true;
+      } catch (assignError) {
+        // If assignment fails, log but don't crash
+        console.error("[Database Hooks] Error assigning hooks:", assignError);
+        // Don't mark as wrapped if assignment failed
+      }
+    } catch (hookError) {
+      console.error("[Database Hooks] Error setting up hooks:", hookError);
+      // Don't mark as wrapped if there was an error
     }
+  } catch (error) {
+    console.error("[Database Hooks] Failed to wrap:", error);
+  }
 }
-//# sourceMappingURL=database-hook-injector.js.map
+//# sourceMappingURL=database-hook-injector.js.map

package/dist/utils/email-otp-hooks-injector.d.ts

@@ -1,4 +1,4 @@
-import type { StudioConfig } from '../types/handler.js';
+import type { StudioConfig } from "../types/handler.js";
 /**
  * Wraps email-otp plugin callbacks to automatically emit events
  * This wraps the sendVerificationOTP callback similar to how organization hooks work
@@ -7,15 +7,27 @@ import type { StudioConfig } from '../types/handler.js';
  * @param existingCallback - The original sendVerificationOTP callback
  * @param passwordResetMethodMap - Optional shared Map to track password reset method (OTP vs token)
  */
-export declare function wrapEmailOTPPluginCallbacks(eventsConfig: StudioConfig['events'], existingCallback?: (data: {
-    email: string;
-    otp: string;
-    type: 'sign-in' | 'email-verification' | 'forget-password';
-}, ctx?: any) => Promise<void>, passwordResetMethodMap?: Map<string, 'otp' | 'token'>): ((data: {
-    email: string;
-    otp: string;
-    type: 'sign-in' | 'email-verification' | 'forget-password';
-}, ctx?: any) => Promise<void>) | undefined;
+export declare function wrapEmailOTPPluginCallbacks(
+  eventsConfig: StudioConfig["events"],
+  existingCallback?: (
+    data: {
+      email: string;
+      otp: string;
+      type: "sign-in" | "email-verification" | "forget-password";
+    },
+    ctx?: any,
+  ) => Promise<void>,
+  passwordResetMethodMap?: Map<string, "otp" | "token">,
+):
+  | ((
+      data: {
+        email: string;
+        otp: string;
+        type: "sign-in" | "email-verification" | "forget-password";
+      },
+      ctx?: any,
+    ) => Promise<void>)
+  | undefined;
 /**
  * Automatically wraps email-otp plugin callbacks to emit events
  * This should be called during Better Auth initialization
@@ -25,5 +37,9 @@ export declare function wrapEmailOTPPluginCallbacks(eventsConfig: StudioConfig['
  * @param eventsConfig - The events configuration
  * @param passwordResetMethodMap - Optional shared Map to track password reset method (OTP vs token)
  */
-export declare function wrapEmailOTPPluginHooks(auth: any, eventsConfig: StudioConfig['events'], passwordResetMethodMap?: Map<string, 'otp' | 'token'>): void;
-//# sourceMappingURL=email-otp-hooks-injector.d.ts.map
+export declare function wrapEmailOTPPluginHooks(
+  auth: any,
+  eventsConfig: StudioConfig["events"],
+  passwordResetMethodMap?: Map<string, "otp" | "token">,
+): void;
+//# sourceMappingURL=email-otp-hooks-injector.d.ts.map

package/dist/utils/email-otp-hooks-injector.js

@@ -1,40 +1,37 @@
-import { emitEvent } from './event-ingestion.js';
+import { emitEvent } from "./event-ingestion.js";
 /**
  * Helper to extract request info from Better Auth request object
  */
 function getRequestInfo(request) {
-    const headersObj = {};
-    let ip;
-    if (request) {
-        try {
-            if (request instanceof Request) {
-                request.headers.forEach((value, key) => {
-                    headersObj[key] = value;
-                });
-                ip =
-                    request.headers.get('x-forwarded-for') || request.headers.get('x-real-ip') || undefined;
-            }
-            else if (request.headers) {
-                if (typeof request.headers.get === 'function') {
-                    ip =
-                        request.headers.get('x-forwarded-for') || request.headers.get('x-real-ip') || undefined;
-                    request.headers.forEach?.((value, key) => {
-                        headersObj[key] = value;
-                    });
-                }
-                else {
-                    ip = request.headers['x-forwarded-for'] || request.headers['x-real-ip'] || undefined;
-                    Object.entries(request.headers).forEach(([key, value]) => {
-                        headersObj[key] = String(value);
-                    });
-                }
-            }
-        }
-        catch (e) {
-            // Ignore errors
+  const headersObj = {};
+  let ip;
+  if (request) {
+    try {
+      if (request instanceof Request) {
+        request.headers.forEach((value, key) => {
+          headersObj[key] = value;
+        });
+        ip =
+          request.headers.get("x-forwarded-for") || request.headers.get("x-real-ip") || undefined;
+      } else if (request.headers) {
+        if (typeof request.headers.get === "function") {
+          ip =
+            request.headers.get("x-forwarded-for") || request.headers.get("x-real-ip") || undefined;
+          request.headers.forEach?.((value, key) => {
+            headersObj[key] = value;
+          });
+        } else {
+          ip = request.headers["x-forwarded-for"] || request.headers["x-real-ip"] || undefined;
+          Object.entries(request.headers).forEach(([key, value]) => {
+            headersObj[key] = String(value);
+          });
         }
+      }
+    } catch (e) {
+      // Ignore errors
     }
-    return { headers: headersObj, ip };
+  }
+  return { headers: headersObj, ip };
 }
 // Share password reset method tracking with auth-callbacks-injector
 // This is used to determine if password reset was via OTP or token
@@ -50,45 +47,52 @@ function getRequestInfo(request) {
  * @param existingCallback - The original sendVerificationOTP callback
  * @param passwordResetMethodMap - Optional shared Map to track password reset method (OTP vs token)
  */
-export function wrapEmailOTPPluginCallbacks(eventsConfig, existingCallback, passwordResetMethodMap) {
-    if (!eventsConfig?.enabled) {
-        return existingCallback;
-    }
-    if (!existingCallback) {
-        return undefined;
+export function wrapEmailOTPPluginCallbacks(
+  eventsConfig,
+  existingCallback,
+  passwordResetMethodMap,
+) {
+  if (!eventsConfig?.enabled) {
+    return existingCallback;
+  }
+  if (!existingCallback) {
+    return undefined;
+  }
+  const capturedConfig = eventsConfig;
+  return async (data, ctx) => {
+    const requestInfo = getRequestInfo(ctx?.request || ctx);
+    // Call the original callback first
+    const originalPromise = existingCallback(data, ctx);
+    // Track and emit event for password reset OTP
+    if (data.type === "forget-password") {
+      const email = data.email.toLowerCase();
+      // Track that this is an OTP-based password reset
+      // This will be checked by onPasswordReset in auth-callbacks-injector
+      if (passwordResetMethodMap) {
+        passwordResetMethodMap.set(email, "otp");
+      }
+      // Emit event for password reset OTP requested
+      const eventPromise = emitEvent(
+        "password.reset_requested_otp",
+        {
+          status: "success",
+          metadata: {
+            email: data.email,
+            type: "forget-password",
+            requestedAt: new Date().toISOString(),
+          },
+          request: requestInfo,
+        },
+        capturedConfig,
+      ).catch(() => {});
+      // Wait for original callback to complete
+      await originalPromise;
+      // Don't wait for event emission to avoid blocking
+      eventPromise.catch(() => {});
+    } else {
+      await originalPromise;
     }
-    const capturedConfig = eventsConfig;
-    return async (data, ctx) => {
-        const requestInfo = getRequestInfo(ctx?.request || ctx);
-        // Call the original callback first
-        const originalPromise = existingCallback(data, ctx);
-        // Track and emit event for password reset OTP
-        if (data.type === 'forget-password') {
-            const email = data.email.toLowerCase();
-            // Track that this is an OTP-based password reset
-            // This will be checked by onPasswordReset in auth-callbacks-injector
-            if (passwordResetMethodMap) {
-                passwordResetMethodMap.set(email, 'otp');
-            }
-            // Emit event for password reset OTP requested
-            const eventPromise = emitEvent('password.reset_requested_otp', {
-                status: 'success',
-                metadata: {
-                    email: data.email,
-                    type: 'forget-password',
-                    requestedAt: new Date().toISOString(),
-                },
-                request: requestInfo,
-            }, capturedConfig).catch(() => { });
-            // Wait for original callback to complete
-            await originalPromise;
-            // Don't wait for event emission to avoid blocking
-            eventPromise.catch(() => { });
-        }
-        else {
-            await originalPromise;
-        }
-    };
+  };
 }
 /**
  * Automatically wraps email-otp plugin callbacks to emit events
@@ -100,35 +104,38 @@ export function wrapEmailOTPPluginCallbacks(eventsConfig, existingCallback, pass
  * @param passwordResetMethodMap - Optional shared Map to track password reset method (OTP vs token)
  */
 export function wrapEmailOTPPluginHooks(auth, eventsConfig, passwordResetMethodMap) {
-    if (!auth || !eventsConfig?.enabled) {
-        return;
+  if (!auth || !eventsConfig?.enabled) {
+    return;
+  }
+  try {
+    const plugins = auth.options?.plugins || [];
+    const emailOtpPlugin = plugins.find((p) => p?.id === "email-otp");
+    if (!emailOtpPlugin) {
+      return;
     }
-    try {
-        const plugins = auth.options?.plugins || [];
-        const emailOtpPlugin = plugins.find((p) => p?.id === 'email-otp');
-        if (!emailOtpPlugin) {
-            return;
-        }
-        // Check if already wrapped to avoid double wrapping
-        if (emailOtpPlugin.__studio_callbacks_wrapped) {
-            return;
-        }
-        // Wrap the sendVerificationOTP callback
-        const existingSendVerificationOTP = emailOtpPlugin.options?.sendVerificationOTP;
-        if (existingSendVerificationOTP) {
-            const wrappedCallback = wrapEmailOTPPluginCallbacks(eventsConfig, existingSendVerificationOTP, passwordResetMethodMap);
-            if (wrappedCallback) {
-                if (!emailOtpPlugin.options) {
-                    emailOtpPlugin.options = {};
-                }
-                emailOtpPlugin.options.sendVerificationOTP = wrappedCallback;
-            }
-        }
-        // Mark as wrapped to prevent double wrapping
-        emailOtpPlugin.__studio_callbacks_wrapped = true;
+    // Check if already wrapped to avoid double wrapping
+    if (emailOtpPlugin.__studio_callbacks_wrapped) {
+      return;
     }
-    catch (error) {
-        console.error('[Email OTP Callbacks] Failed to wrap callbacks:', error);
+    // Wrap the sendVerificationOTP callback
+    const existingSendVerificationOTP = emailOtpPlugin.options?.sendVerificationOTP;
+    if (existingSendVerificationOTP) {
+      const wrappedCallback = wrapEmailOTPPluginCallbacks(
+        eventsConfig,
+        existingSendVerificationOTP,
+        passwordResetMethodMap,
+      );
+      if (wrappedCallback) {
+        if (!emailOtpPlugin.options) {
+          emailOtpPlugin.options = {};
+        }
+        emailOtpPlugin.options.sendVerificationOTP = wrappedCallback;
+      }
     }
+    // Mark as wrapped to prevent double wrapping
+    emailOtpPlugin.__studio_callbacks_wrapped = true;
+  } catch (error) {
+    console.error("[Email OTP Callbacks] Failed to wrap callbacks:", error);
+  }
 }
-//# sourceMappingURL=email-otp-hooks-injector.js.map
+//# sourceMappingURL=email-otp-hooks-injector.js.map

package/dist/utils/event-ingestion.d.ts

@@ -1,14 +1,14 @@
-import type { AuthEventType, EventIngestionProvider } from '../types/events.js';
-import type { StudioConfig } from '../types/handler.js';
+import type { AuthEventType, EventIngestionProvider } from "../types/events.js";
+import type { StudioConfig } from "../types/handler.js";
 /**
  * Initialize event ingestion
  */
-export declare function initializeEventIngestion(eventsConfig: StudioConfig['events']): void;
+export declare function initializeEventIngestion(eventsConfig: StudioConfig["events"]): void;
 /**
  * Emit an event
  */
 export declare function emitEvent(type: AuthEventType, data: {
-    status: 'success' | 'failed';
+    status: "success" | "failed";
     userId?: string;
     sessionId?: string;
     organizationId?: string;
@@ -17,7 +17,7 @@ export declare function emitEvent(type: AuthEventType, data: {
         headers: Record<string, string>;
         ip?: string;
     };
-}, eventsConfig?: StudioConfig['events']): Promise<void>;
+}, eventsConfig?: StudioConfig["events"]): Promise<void>;
 export declare function shutdownEventIngestion(): Promise<void>;
 /**
  * Health check

package/dist/utils/event-ingestion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"event-ingestion.d.ts","sourceRoot":"","sources":["../../src/utils/event-ingestion.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAEV,aAAa,EACb,sBAAsB,EAGvB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AASxD;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,YAAY,EAAE,YAAY,CAAC,QAAQ,CAAC,GAAG,IAAI,CAiEnF;AAED;;GAEG;AACH,wBAAsB,SAAS,CAC7B,IAAI,EAAE,aAAa,EACnB,IAAI,EAAE;IACJ,MAAM,EAAE,SAAS,GAAG,QAAQ,CAAC;IAC7B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC/B,OAAO,CAAC,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAAC,EAAE,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAC5D,EACD,YAAY,CAAC,EAAE,YAAY,CAAC,QAAQ,CAAC,GACpC,OAAO,CAAC,IAAI,CAAC,CA6Ef;AAuBD,wBAAsB,sBAAsB,IAAI,OAAO,CAAC,IAAI,CAAC,CAmB5D;AAED;;GAEG;AACH,wBAAsB,yBAAyB,IAAI,OAAO,CAAC,OAAO,CAAC,CAUlE;AAED;;GAEG;AACH,wBAAgB,2BAA2B,IAAI,OAAO,CAErD;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,CAE1C;AAED;;GAEG;AACH,wBAAgB,yBAAyB,IAAI,sBAAsB,GAAG,IAAI,CAEzE"}
+{"version":3,"file":"event-ingestion.d.ts","sourceRoot":"","sources":["../../src/utils/event-ingestion.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAEV,aAAa,EACb,sBAAsB,EAGvB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AASxD;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,YAAY,EAAE,YAAY,CAAC,QAAQ,CAAC,GAAG,IAAI,CAiEnF;AAED;;GAEG;AACH,wBAAsB,SAAS,CAC7B,IAAI,EAAE,aAAa,EACnB,IAAI,EAAE;IACJ,MAAM,EAAE,SAAS,GAAG,QAAQ,CAAC;IAC7B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC/B,OAAO,CAAC,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAAC,EAAE,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAC5D,EACD,YAAY,CAAC,EAAE,YAAY,CAAC,QAAQ,CAAC,GACpC,OAAO,CAAC,IAAI,CAAC,CAuFf;AAiCD,wBAAsB,sBAAsB,IAAI,OAAO,CAAC,IAAI,CAAC,CAmB5D;AAED;;GAEG;AACH,wBAAsB,yBAAyB,IAAI,OAAO,CAAC,OAAO,CAAC,CAUlE;AAED;;GAEG;AACH,wBAAgB,2BAA2B,IAAI,OAAO,CAErD;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,CAE1C;AAED;;GAEG;AACH,wBAAgB,yBAAyB,IAAI,sBAAsB,GAAG,IAAI,CAEzE"}