@bubblelab/bubble-core 0.1.10 → 0.1.12

package/dist/bubbles/service-bubble/browserbase/browserbase.d.ts

@@ -0,0 +1,542 @@
+import { type Browser, type Page } from 'puppeteer-core';
+import { ServiceBubble } from '../../../types/service-bubble-class.js';
+import type { BubbleContext } from '../../../types/bubble.js';
+import { CredentialType } from '@bubblelab/shared-schemas';
+import { type BrowserBaseParamsInput, type BrowserBaseResult } from './browserbase.schema.js';
+/**
+ * Active browser session stored in memory
+ */
+interface ActiveSession {
+    sessionId: string;
+    contextId: string;
+    browser: Browser;
+    page: Page;
+    connectUrl: string;
+}
+/**
+ * BrowserBase Service Bubble
+ *
+ * Provides browser automation capabilities using BrowserBase cloud browsers.
+ * Supports session management, navigation, clicking, typing, JavaScript
+ * execution, content extraction, screenshots, and cookie management.
+ *
+ * Features:
+ * - Cloud-based browser sessions (BrowserBase)
+ * - Session persistence via context IDs
+ * - Cookie injection for authenticated sessions
+ * - Full page automation (click, type, evaluate)
+ * - Screenshot and content extraction
+ *
+ * Use cases:
+ * - Automated shopping workflows (Amazon, etc.)
+ * - Web scraping with authentication
+ * - Form automation and submission
+ * - Browser-based testing
+ *
+ * Security Features:
+ * - Sessions are isolated in BrowserBase cloud
+ * - Credentials are handled securely
+ * - Sessions are properly closed and cleaned up
+ */
+export declare class BrowserBaseBubble<T extends BrowserBaseParamsInput = BrowserBaseParamsInput> extends ServiceBubble<T, Extract<BrowserBaseResult, {
+    operation: T['operation'];
+}>> {
+    static readonly type: "service";
+    static readonly service = "browserbase";
+    static readonly authType: "apikey";
+    static readonly bubbleName = "browserbase";
+    static readonly schema: import("zod").ZodDiscriminatedUnion<"operation", [import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"start_session">;
+        context_id: import("zod").ZodOptional<import("zod").ZodString>;
+        cookies: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            value: import("zod").ZodString;
+            domain: import("zod").ZodString;
+            path: import("zod").ZodString;
+            expires: import("zod").ZodNumber;
+            httpOnly: import("zod").ZodBoolean;
+            secure: import("zod").ZodBoolean;
+        }, "strip", import("zod").ZodTypeAny, {
+            value: string;
+            path: string;
+            name: string;
+            domain: string;
+            expires: number;
+            httpOnly: boolean;
+            secure: boolean;
+        }, {
+            value: string;
+            path: string;
+            name: string;
+            domain: string;
+            expires: number;
+            httpOnly: boolean;
+            secure: boolean;
+        }>, "many">>;
+        viewport_width: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+        viewport_height: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+        credentials: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodNativeEnum<typeof CredentialType>, import("zod").ZodString>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        operation: "start_session";
+        viewport_width: number;
+        viewport_height: number;
+        credentials?: Partial<Record<CredentialType, string>> | undefined;
+        cookies?: {
+            value: string;
+            path: string;
+            name: string;
+            domain: string;
+            expires: number;
+            httpOnly: boolean;
+            secure: boolean;
+        }[] | undefined;
+        context_id?: string | undefined;
+    }, {
+        operation: "start_session";
+        credentials?: Partial<Record<CredentialType, string>> | undefined;
+        cookies?: {
+            value: string;
+            path: string;
+            name: string;
+            domain: string;
+            expires: number;
+            httpOnly: boolean;
+            secure: boolean;
+        }[] | undefined;
+        context_id?: string | undefined;
+        viewport_width?: number | undefined;
+        viewport_height?: number | undefined;
+    }>, import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"navigate">;
+        session_id: import("zod").ZodString;
+        url: import("zod").ZodString;
+        wait_until: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<["load", "domcontentloaded", "networkidle0", "networkidle2"]>>>;
+        timeout: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+        credentials: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodNativeEnum<typeof CredentialType>, import("zod").ZodString>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        url: string;
+        timeout: number;
+        operation: "navigate";
+        session_id: string;
+        wait_until: "load" | "domcontentloaded" | "networkidle0" | "networkidle2";
+        credentials?: Partial<Record<CredentialType, string>> | undefined;
+    }, {
+        url: string;
+        operation: "navigate";
+        session_id: string;
+        credentials?: Partial<Record<CredentialType, string>> | undefined;
+        timeout?: number | undefined;
+        wait_until?: "load" | "domcontentloaded" | "networkidle0" | "networkidle2" | undefined;
+    }>, import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"click">;
+        session_id: import("zod").ZodString;
+        selector: import("zod").ZodString;
+        wait_for_navigation: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+        timeout: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+        credentials: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodNativeEnum<typeof CredentialType>, import("zod").ZodString>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        timeout: number;
+        operation: "click";
+        session_id: string;
+        selector: string;
+        wait_for_navigation: boolean;
+        credentials?: Partial<Record<CredentialType, string>> | undefined;
+    }, {
+        operation: "click";
+        session_id: string;
+        selector: string;
+        credentials?: Partial<Record<CredentialType, string>> | undefined;
+        timeout?: number | undefined;
+        wait_for_navigation?: boolean | undefined;
+    }>, import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"type">;
+        session_id: import("zod").ZodString;
+        selector: import("zod").ZodString;
+        text: import("zod").ZodString;
+        clear_first: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+        delay: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+        credentials: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodNativeEnum<typeof CredentialType>, import("zod").ZodString>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        text: string;
+        operation: "type";
+        session_id: string;
+        selector: string;
+        delay: number;
+        clear_first: boolean;
+        credentials?: Partial<Record<CredentialType, string>> | undefined;
+    }, {
+        text: string;
+        operation: "type";
+        session_id: string;
+        selector: string;
+        credentials?: Partial<Record<CredentialType, string>> | undefined;
+        delay?: number | undefined;
+        clear_first?: boolean | undefined;
+    }>, import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"evaluate">;
+        session_id: import("zod").ZodString;
+        script: import("zod").ZodString;
+        credentials: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodNativeEnum<typeof CredentialType>, import("zod").ZodString>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        script: string;
+        operation: "evaluate";
+        session_id: string;
+        credentials?: Partial<Record<CredentialType, string>> | undefined;
+    }, {
+        script: string;
+        operation: "evaluate";
+        session_id: string;
+        credentials?: Partial<Record<CredentialType, string>> | undefined;
+    }>, import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"get_content">;
+        session_id: import("zod").ZodString;
+        selector: import("zod").ZodOptional<import("zod").ZodString>;
+        content_type: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<["html", "text", "outer_html"]>>>;
+        credentials: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodNativeEnum<typeof CredentialType>, import("zod").ZodString>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        operation: "get_content";
+        content_type: "text" | "html" | "outer_html";
+        session_id: string;
+        credentials?: Partial<Record<CredentialType, string>> | undefined;
+        selector?: string | undefined;
+    }, {
+        operation: "get_content";
+        session_id: string;
+        credentials?: Partial<Record<CredentialType, string>> | undefined;
+        content_type?: "text" | "html" | "outer_html" | undefined;
+        selector?: string | undefined;
+    }>, import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"screenshot">;
+        session_id: import("zod").ZodString;
+        selector: import("zod").ZodOptional<import("zod").ZodString>;
+        full_page: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+        format: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<["png", "jpeg", "webp"]>>>;
+        quality: import("zod").ZodOptional<import("zod").ZodNumber>;
+        credentials: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodNativeEnum<typeof CredentialType>, import("zod").ZodString>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        format: "png" | "jpeg" | "webp";
+        operation: "screenshot";
+        session_id: string;
+        full_page: boolean;
+        credentials?: Partial<Record<CredentialType, string>> | undefined;
+        quality?: number | undefined;
+        selector?: string | undefined;
+    }, {
+        operation: "screenshot";
+        session_id: string;
+        format?: "png" | "jpeg" | "webp" | undefined;
+        credentials?: Partial<Record<CredentialType, string>> | undefined;
+        quality?: number | undefined;
+        selector?: string | undefined;
+        full_page?: boolean | undefined;
+    }>, import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"wait">;
+        session_id: import("zod").ZodString;
+        wait_type: import("zod").ZodEnum<["selector", "timeout", "navigation"]>;
+        selector: import("zod").ZodOptional<import("zod").ZodString>;
+        timeout: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+        credentials: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodNativeEnum<typeof CredentialType>, import("zod").ZodString>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        timeout: number;
+        operation: "wait";
+        session_id: string;
+        wait_type: "timeout" | "selector" | "navigation";
+        credentials?: Partial<Record<CredentialType, string>> | undefined;
+        selector?: string | undefined;
+    }, {
+        operation: "wait";
+        session_id: string;
+        wait_type: "timeout" | "selector" | "navigation";
+        credentials?: Partial<Record<CredentialType, string>> | undefined;
+        timeout?: number | undefined;
+        selector?: string | undefined;
+    }>, import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"get_cookies">;
+        session_id: import("zod").ZodString;
+        domain_filter: import("zod").ZodOptional<import("zod").ZodString>;
+        credentials: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodNativeEnum<typeof CredentialType>, import("zod").ZodString>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        operation: "get_cookies";
+        session_id: string;
+        credentials?: Partial<Record<CredentialType, string>> | undefined;
+        domain_filter?: string | undefined;
+    }, {
+        operation: "get_cookies";
+        session_id: string;
+        credentials?: Partial<Record<CredentialType, string>> | undefined;
+        domain_filter?: string | undefined;
+    }>, import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"end_session">;
+        session_id: import("zod").ZodString;
+        credentials: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodNativeEnum<typeof CredentialType>, import("zod").ZodString>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        operation: "end_session";
+        session_id: string;
+        credentials?: Partial<Record<CredentialType, string>> | undefined;
+    }, {
+        operation: "end_session";
+        session_id: string;
+        credentials?: Partial<Record<CredentialType, string>> | undefined;
+    }>]>;
+    static readonly resultSchema: import("zod").ZodDiscriminatedUnion<"operation", [import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"start_session">;
+        success: import("zod").ZodBoolean;
+        session_id: import("zod").ZodOptional<import("zod").ZodString>;
+        context_id: import("zod").ZodOptional<import("zod").ZodString>;
+        debug_url: import("zod").ZodOptional<import("zod").ZodString>;
+        error: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        error: string;
+        success: boolean;
+        operation: "start_session";
+        session_id?: string | undefined;
+        context_id?: string | undefined;
+        debug_url?: string | undefined;
+    }, {
+        error: string;
+        success: boolean;
+        operation: "start_session";
+        session_id?: string | undefined;
+        context_id?: string | undefined;
+        debug_url?: string | undefined;
+    }>, import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"navigate">;
+        success: import("zod").ZodBoolean;
+        url: import("zod").ZodOptional<import("zod").ZodString>;
+        error: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        error: string;
+        success: boolean;
+        operation: "navigate";
+        url?: string | undefined;
+    }, {
+        error: string;
+        success: boolean;
+        operation: "navigate";
+        url?: string | undefined;
+    }>, import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"click">;
+        success: import("zod").ZodBoolean;
+        error: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        error: string;
+        success: boolean;
+        operation: "click";
+    }, {
+        error: string;
+        success: boolean;
+        operation: "click";
+    }>, import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"type">;
+        success: import("zod").ZodBoolean;
+        error: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        error: string;
+        success: boolean;
+        operation: "type";
+    }, {
+        error: string;
+        success: boolean;
+        operation: "type";
+    }>, import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"evaluate">;
+        success: import("zod").ZodBoolean;
+        result: import("zod").ZodOptional<import("zod").ZodUnknown>;
+        error: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        error: string;
+        success: boolean;
+        operation: "evaluate";
+        result?: unknown;
+    }, {
+        error: string;
+        success: boolean;
+        operation: "evaluate";
+        result?: unknown;
+    }>, import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"get_content">;
+        success: import("zod").ZodBoolean;
+        content: import("zod").ZodOptional<import("zod").ZodString>;
+        error: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        error: string;
+        success: boolean;
+        operation: "get_content";
+        content?: string | undefined;
+    }, {
+        error: string;
+        success: boolean;
+        operation: "get_content";
+        content?: string | undefined;
+    }>, import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"screenshot">;
+        success: import("zod").ZodBoolean;
+        data: import("zod").ZodOptional<import("zod").ZodString>;
+        format: import("zod").ZodOptional<import("zod").ZodString>;
+        error: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        error: string;
+        success: boolean;
+        operation: "screenshot";
+        format?: string | undefined;
+        data?: string | undefined;
+    }, {
+        error: string;
+        success: boolean;
+        operation: "screenshot";
+        format?: string | undefined;
+        data?: string | undefined;
+    }>, import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"wait">;
+        success: import("zod").ZodBoolean;
+        error: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        error: string;
+        success: boolean;
+        operation: "wait";
+    }, {
+        error: string;
+        success: boolean;
+        operation: "wait";
+    }>, import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"get_cookies">;
+        success: import("zod").ZodBoolean;
+        cookies: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            value: import("zod").ZodString;
+            domain: import("zod").ZodString;
+            path: import("zod").ZodString;
+            expires: import("zod").ZodNumber;
+            httpOnly: import("zod").ZodBoolean;
+            secure: import("zod").ZodBoolean;
+        }, "strip", import("zod").ZodTypeAny, {
+            value: string;
+            path: string;
+            name: string;
+            domain: string;
+            expires: number;
+            httpOnly: boolean;
+            secure: boolean;
+        }, {
+            value: string;
+            path: string;
+            name: string;
+            domain: string;
+            expires: number;
+            httpOnly: boolean;
+            secure: boolean;
+        }>, "many">>;
+        error: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        error: string;
+        success: boolean;
+        operation: "get_cookies";
+        cookies?: {
+            value: string;
+            path: string;
+            name: string;
+            domain: string;
+            expires: number;
+            httpOnly: boolean;
+            secure: boolean;
+        }[] | undefined;
+    }, {
+        error: string;
+        success: boolean;
+        operation: "get_cookies";
+        cookies?: {
+            value: string;
+            path: string;
+            name: string;
+            domain: string;
+            expires: number;
+            httpOnly: boolean;
+            secure: boolean;
+        }[] | undefined;
+    }>, import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"end_session">;
+        success: import("zod").ZodBoolean;
+        error: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        error: string;
+        success: boolean;
+        operation: "end_session";
+    }, {
+        error: string;
+        success: boolean;
+        operation: "end_session";
+    }>]>;
+    static readonly shortDescription = "Browser automation service using BrowserBase cloud browsers";
+    static readonly longDescription = "\n    BrowserBase service integration for cloud-based browser automation.\n\n    Features:\n    - Cloud-based browser sessions\n    - Session persistence via context IDs\n    - Cookie injection for authenticated sessions\n    - Full page automation (click, type, evaluate)\n    - Screenshot and content extraction\n    - Cross-browser support\n\n    Use cases:\n    - Automated shopping workflows (Amazon, etc.)\n    - Web scraping with authentication\n    - Form automation and submission\n    - Browser-based testing\n\n    Security Features:\n    - Sessions are isolated in BrowserBase cloud\n    - Credentials are handled securely\n    - Sessions are properly closed and cleaned up\n  ";
+    static readonly alias = "browser";
+    private static activeSessions;
+    constructor(params?: T, context?: BubbleContext, instanceId?: string);
+    /**
+     * Get BrowserBase configuration from environment
+     */
+    private getConfig;
+    /**
+     * Make an API request to BrowserBase
+     */
+    private browserbaseApi;
+    /**
+     * Parse browser session credential data (cookies + contextId)
+     * Credential is base64-encoded JSON to avoid escaping issues
+     */
+    private parseBrowserSessionCredential;
+    testCredential(): Promise<boolean>;
+    protected performAction(context?: BubbleContext): Promise<Extract<BrowserBaseResult, {
+        operation: T['operation'];
+    }>>;
+    /**
+     * Start a new browser session
+     */
+    private startSession;
+    /**
+     * Navigate to a URL
+     */
+    private navigate;
+    /**
+     * Click an element
+     */
+    private click;
+    /**
+     * Type text into an element
+     */
+    private typeText;
+    /**
+     * Execute JavaScript in page context
+     */
+    private evaluate;
+    /**
+     * Get page or element content
+     */
+    private getContent;
+    /**
+     * Take a screenshot
+     */
+    private screenshot;
+    /**
+     * Wait for a condition
+     */
+    private waitFor;
+    /**
+     * Get cookies from the browser
+     */
+    private getCookies;
+    /**
+     * End a browser session
+     */
+    private endSession;
+    protected chooseCredential(): string | undefined;
+    /**
+     * Get an active session by ID (for use by other bubbles)
+     */
+    static getSession(sessionId: string): ActiveSession | undefined;
+    /**
+     * Check if a session is active
+     */
+    static hasSession(sessionId: string): boolean;
+}
+export {};
+//# sourceMappingURL=browserbase.d.ts.map

package/dist/bubbles/service-bubble/browserbase/browserbase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browserbase.d.ts","sourceRoot":"","sources":["../../../../src/bubbles/service-bubble/browserbase/browserbase.ts"],"names":[],"mappings":"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"}

package/dist/bubbles/service-bubble/browserbase/browserbase.integration.flow.d.ts

@@ -0,0 +1,37 @@
+import { BubbleFlow, type WebhookEvent } from '@bubblelab/bubble-core';
+export interface Output {
+    sessionId: string;
+    testResults: {
+        operation: string;
+        success: boolean;
+        details?: string;
+    }[];
+}
+/**
+ * Payload for the BrowserBase Integration Test workflow.
+ */
+export interface BrowserBaseTestPayload extends WebhookEvent {
+    /**
+     * URL to navigate to for testing
+     * @canBeFile false
+     */
+    testUrl?: string;
+    /**
+     * Selector to click for testing
+     * @canBeFile false
+     */
+    testSelector?: string;
+}
+export declare class BrowserBaseIntegrationTest extends BubbleFlow<'webhook/http'> {
+    private sessionId;
+    private startSession;
+    private navigateTo;
+    private getContent;
+    private evaluate;
+    private screenshot;
+    private waitForSelector;
+    private getCookies;
+    private endSession;
+    handle(payload: BrowserBaseTestPayload): Promise<Output>;
+}
+//# sourceMappingURL=browserbase.integration.flow.d.ts.map

package/dist/bubbles/service-bubble/browserbase/browserbase.integration.flow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browserbase.integration.flow.d.ts","sourceRoot":"","sources":["../../../../src/bubbles/service-bubble/browserbase/browserbase.integration.flow.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EAEV,KAAK,YAAY,EAClB,MAAM,wBAAwB,CAAC;AAEhC,MAAM,WAAW,MAAM;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE;QACX,SAAS,EAAE,MAAM,CAAC;QAClB,OAAO,EAAE,OAAO,CAAC;QACjB,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,EAAE,CAAC;CACL;AAED;;GAEG;AACH,MAAM,WAAW,sBAAuB,SAAQ,YAAY;IAC1D;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,qBAAa,0BAA2B,SAAQ,UAAU,CAAC,cAAc,CAAC;IACxE,OAAO,CAAC,SAAS,CAAuB;YAG1B,YAAY;YAoBZ,UAAU;YAmBV,UAAU;YAkBV,QAAQ;YAiBR,UAAU;YAkBV,eAAe;YAmBf,UAAU;YAiBV,UAAU;IAelB,MAAM,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,MAAM,CAAC;CAuF/D"}