@zapier/zapier-sdk 0.18.3 → 0.19.0

package/dist/utils/batch-utils.test.js

@@ -1,476 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { batch } from "./batch-utils";
-// Mock the timers/promises module
-vi.mock("timers/promises", () => ({
-    setTimeout: vi.fn(() => Promise.resolve()),
-}));
-// Mock retry-utils to control backoff behavior in tests
-vi.mock("./retry-utils", () => ({
-    calculateWaitTime: vi.fn(() => 0), // No delay in tests
-    MAX_CONSECUTIVE_ERRORS: 3,
-}));
-describe("batch", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    afterEach(() => {
-        vi.clearAllMocks();
-    });
-    describe("basic functionality", () => {
-        it("should execute all tasks and return settled results", async () => {
-            const tasks = [
-                () => Promise.resolve("result1"),
-                () => Promise.resolve("result2"),
-                () => Promise.resolve("result3"),
-            ];
-            const results = await batch(tasks);
-            expect(results).toEqual([
-                { status: "fulfilled", value: "result1" },
-                { status: "fulfilled", value: "result2" },
-                { status: "fulfilled", value: "result3" },
-            ]);
-        });
-        it("should handle empty task array", async () => {
-            const results = await batch([]);
-            expect(results).toEqual([]);
-        });
-        it("should handle single task", async () => {
-            const tasks = [() => Promise.resolve("single")];
-            const results = await batch(tasks);
-            expect(results).toEqual([{ status: "fulfilled", value: "single" }]);
-        });
-        it("should maintain result order matching input order", async () => {
-            // Create tasks that resolve in reverse order but should maintain input order
-            const tasks = [
-                () => new Promise((resolve) => setTimeout(() => resolve("first"), 30)),
-                () => new Promise((resolve) => setTimeout(() => resolve("second"), 20)),
-                () => new Promise((resolve) => setTimeout(() => resolve("third"), 10)),
-            ];
-            const results = await batch(tasks);
-            expect(results[0]).toEqual({ status: "fulfilled", value: "first" });
-            expect(results[1]).toEqual({ status: "fulfilled", value: "second" });
-            expect(results[2]).toEqual({ status: "fulfilled", value: "third" });
-        });
-    });
-    describe("concurrency limiting", () => {
-        it("should limit concurrent execution", async () => {
-            let concurrentCount = 0;
-            let maxConcurrent = 0;
-            const createTask = () => () => {
-                concurrentCount++;
-                maxConcurrent = Math.max(maxConcurrent, concurrentCount);
-                return new Promise((resolve) => {
-                    setTimeout(() => {
-                        concurrentCount--;
-                        resolve("done");
-                    }, 10);
-                });
-            };
-            const tasks = Array.from({ length: 20 }, createTask);
-            await batch(tasks, { concurrency: 5 });
-            // Max concurrent should not exceed limit
-            expect(maxConcurrent).toBeLessThanOrEqual(5);
-        });
-        it("should respect custom concurrency limit", async () => {
-            let concurrentCount = 0;
-            let maxConcurrent = 0;
-            const createTask = () => () => {
-                concurrentCount++;
-                maxConcurrent = Math.max(maxConcurrent, concurrentCount);
-                return new Promise((resolve) => {
-                    setTimeout(() => {
-                        concurrentCount--;
-                        resolve("done");
-                    }, 10);
-                });
-            };
-            const tasks = Array.from({ length: 20 }, createTask);
-            await batch(tasks, { concurrency: 3 });
-            expect(maxConcurrent).toBeLessThanOrEqual(3);
-        });
-        it("should handle concurrency limit greater than task count", async () => {
-            const tasks = [() => Promise.resolve(1), () => Promise.resolve(2)];
-            const results = await batch(tasks, { concurrency: 10 });
-            expect(results).toHaveLength(2);
-        });
-    });
-    describe("error handling", () => {
-        it("should handle failing tasks without stopping batch", async () => {
-            const tasks = [
-                () => Promise.resolve("success1"),
-                () => Promise.reject(new Error("failed")),
-                () => Promise.resolve("success2"),
-            ];
-            const results = await batch(tasks, { retry: false });
-            expect(results[0]).toEqual({ status: "fulfilled", value: "success1" });
-            expect(results[1]).toEqual({
-                status: "rejected",
-                reason: expect.any(Error),
-            });
-            expect(results[2]).toEqual({ status: "fulfilled", value: "success2" });
-        });
-        it("should retry failed tasks when retry is enabled", async () => {
-            let attemptCount = 0;
-            const failTwiceThenSucceed = () => {
-                attemptCount++;
-                if (attemptCount <= 2) {
-                    return Promise.reject(new Error("temporary failure"));
-                }
-                return Promise.resolve("success");
-            };
-            const tasks = [failTwiceThenSucceed];
-            const results = await batch(tasks, { retry: true });
-            expect(results[0]).toEqual({ status: "fulfilled", value: "success" });
-            expect(attemptCount).toBe(3); // Initial + 2 retries
-        });
-        it("should give up after MAX_CONSECUTIVE_ERRORS retries", async () => {
-            let attemptCount = 0;
-            const alwaysFail = () => {
-                attemptCount++;
-                return Promise.reject(new Error("always fails"));
-            };
-            const tasks = [alwaysFail];
-            const results = await batch(tasks, { retry: true });
-            expect(results[0]).toEqual({
-                status: "rejected",
-                reason: expect.any(Error),
-            });
-            expect(attemptCount).toBe(3); // MAX_CONSECUTIVE_ERRORS
-        });
-        it("should not retry when retry is disabled", async () => {
-            let attemptCount = 0;
-            const failTask = () => {
-                attemptCount++;
-                return Promise.reject(new Error("failed"));
-            };
-            const tasks = [failTask];
-            const results = await batch(tasks, { retry: false });
-            expect(results[0]).toEqual({
-                status: "rejected",
-                reason: expect.any(Error),
-            });
-            expect(attemptCount).toBe(1); // No retries
-        });
-    });
-    describe("options validation", () => {
-        it("should throw error for invalid concurrency", async () => {
-            const tasks = [() => Promise.resolve("test")];
-            await expect(batch(tasks, { concurrency: 0 })).rejects.toThrow("Concurrency must be greater than 0");
-            await expect(batch(tasks, { concurrency: -1 })).rejects.toThrow("Concurrency must be greater than 0");
-        });
-        it("should use default options when not provided", async () => {
-            const tasks = [() => Promise.resolve("test")];
-            const results = await batch(tasks);
-            expect(results).toEqual([{ status: "fulfilled", value: "test" }]);
-        });
-    });
-    describe("mixed success and failure scenarios", () => {
-        it("should handle alternating success and failure", async () => {
-            const tasks = [
-                () => Promise.resolve("success1"),
-                () => Promise.reject(new Error("error1")),
-                () => Promise.resolve("success2"),
-                () => Promise.reject(new Error("error2")),
-                () => Promise.resolve("success3"),
-            ];
-            const results = await batch(tasks, { retry: false });
-            expect(results[0].status).toBe("fulfilled");
-            expect(results[1].status).toBe("rejected");
-            expect(results[2].status).toBe("fulfilled");
-            expect(results[3].status).toBe("rejected");
-            expect(results[4].status).toBe("fulfilled");
-        });
-        it("should handle some tasks succeeding after retry", async () => {
-            let task1Attempts = 0;
-            let task2Attempts = 0;
-            const task1 = () => {
-                task1Attempts++;
-                if (task1Attempts === 1) {
-                    return Promise.reject(new Error("task1 first attempt"));
-                }
-                return Promise.resolve("task1 success");
-            };
-            const task2 = () => {
-                task2Attempts++;
-                return Promise.resolve("task2 success");
-            };
-            const tasks = [task1, task2];
-            const results = await batch(tasks, { retry: true });
-            expect(results[0]).toEqual({
-                status: "fulfilled",
-                value: "task1 success",
-            });
-            expect(results[1]).toEqual({
-                status: "fulfilled",
-                value: "task2 success",
-            });
-            expect(task1Attempts).toBe(2); // Initial + 1 retry
-            expect(task2Attempts).toBe(1); // No retry needed
-        });
-    });
-    describe("performance characteristics", () => {
-        it("should complete faster with higher concurrency", async () => {
-            const delay = 50; // ms
-            const taskCount = 10;
-            const tasks = Array.from({ length: taskCount }, () => () => new Promise((resolve) => setTimeout(() => resolve("done"), delay)));
-            // Low concurrency (sequential-ish)
-            const start1 = Date.now();
-            await batch([...tasks], { concurrency: 1 });
-            const duration1 = Date.now() - start1;
-            // High concurrency (parallel)
-            const start2 = Date.now();
-            await batch([...tasks], { concurrency: 10 });
-            const duration2 = Date.now() - start2;
-            // High concurrency should be significantly faster
-            // Allow some margin for timing variability
-            expect(duration2).toBeLessThan(duration1 * 0.8);
-        });
-    });
-    describe("result ordering guarantees", () => {
-        it("should maintain exact order with out-of-order completion and mixed results", async () => {
-            // This is the ultimate ordering test - combining:
-            // 1. Tasks that complete in reverse order (via delays)
-            // 2. Mixed success/failure
-            // 3. High concurrency (multiple workers racing)
-            const executionLog = [];
-            const tasks = [
-                // Task 0: Slow success
-                () => new Promise((resolve) => {
-                    setTimeout(() => {
-                        executionLog.push("task0-complete");
-                        resolve("result0");
-                    }, 100);
-                }),
-                // Task 1: Fast failure
-                () => new Promise((_, reject) => {
-                    setTimeout(() => {
-                        executionLog.push("task1-complete");
-                        reject(new Error("error1"));
-                    }, 10);
-                }),
-                // Task 2: Medium success
-                () => new Promise((resolve) => {
-                    setTimeout(() => {
-                        executionLog.push("task2-complete");
-                        resolve("result2");
-                    }, 50);
-                }),
-                // Task 3: Instant failure
-                () => new Promise((_, reject) => {
-                    executionLog.push("task3-complete");
-                    reject(new Error("error3"));
-                }),
-                // Task 4: Medium-slow success
-                () => new Promise((resolve) => {
-                    setTimeout(() => {
-                        executionLog.push("task4-complete");
-                        resolve("result4");
-                    }, 75);
-                }),
-            ];
-            const results = await batch(tasks, { concurrency: 5, retry: false });
-            // Verify all tasks completed
-            expect(executionLog).toHaveLength(5);
-            expect(executionLog).toContain("task0-complete");
-            expect(executionLog).toContain("task1-complete");
-            expect(executionLog).toContain("task2-complete");
-            expect(executionLog).toContain("task3-complete");
-            expect(executionLog).toContain("task4-complete");
-            // BUT results MUST maintain input order despite out-of-order completion
-            expect(results).toHaveLength(5);
-            // Task 0: position 0, slow success
-            expect(results[0]).toEqual({
-                status: "fulfilled",
-                value: "result0",
-            });
-            // Task 1: position 1, fast failure
-            expect(results[1]).toEqual({
-                status: "rejected",
-                reason: expect.objectContaining({
-                    message: "error1",
-                }),
-            });
-            // Task 2: position 2, medium success
-            expect(results[2]).toEqual({
-                status: "fulfilled",
-                value: "result2",
-            });
-            // Task 3: position 3, instant failure
-            expect(results[3]).toEqual({
-                status: "rejected",
-                reason: expect.objectContaining({
-                    message: "error3",
-                }),
-            });
-            // Task 4: position 4, medium-slow success
-            expect(results[4]).toEqual({
-                status: "fulfilled",
-                value: "result4",
-            });
-        });
-        it("should match Promise.allSettled ordering behavior exactly", async () => {
-            // This test ensures our batch function has identical ordering to Promise.allSettled
-            const tasks = [
-                () => new Promise((resolve) => setTimeout(() => resolve("a"), 30)),
-                () => new Promise((_, reject) => setTimeout(() => reject(new Error("b")), 10)),
-                () => new Promise((resolve) => setTimeout(() => resolve("c"), 20)),
-            ];
-            // Run both in parallel
-            const [batchResults, settledResults] = await Promise.all([
-                batch(tasks.map((t) => t), { concurrency: 3, retry: false }),
-                Promise.allSettled(tasks.map((t) => t())),
-            ]);
-            // Results should have same structure
-            expect(batchResults).toHaveLength(settledResults.length);
-            // Compare each result
-            for (let i = 0; i < batchResults.length; i++) {
-                const batchResult = batchResults[i];
-                const settledResult = settledResults[i];
-                expect(batchResult.status).toBe(settledResult.status);
-                if (batchResult.status === "fulfilled" &&
-                    settledResult.status === "fulfilled") {
-                    expect(batchResult.value).toBe(settledResult.value);
-                }
-                if (batchResult.status === "rejected" &&
-                    settledResult.status === "rejected") {
-                    expect(batchResult.reason).toBeInstanceOf(Error);
-                    expect(settledResult.reason).toBeInstanceOf(Error);
-                }
-            }
-        });
-    });
-    describe("timeout handling", () => {
-        beforeEach(async () => {
-            // Unmock setTimeout for timeout tests to allow real timing
-            vi.unmock("timers/promises");
-            // Re-import batch to get the non-mocked version
-            vi.resetModules();
-        });
-        afterEach(() => {
-            // Restore mocks after timeout tests
-            vi.doMock("timers/promises", () => ({
-                setTimeout: vi.fn(() => Promise.resolve()),
-            }));
-        });
-        it("should throw error when overall batch timeout is exceeded", async () => {
-            const { batch } = await import("./batch-utils");
-            const tasks = Array.from({ length: 10 }, () => () => new Promise((resolve) => setTimeout(() => resolve("done"), 100)));
-            await expect(batch(tasks, { concurrency: 2, timeoutMs: 50 })).rejects.toThrow("Batch operation timed out");
-        });
-        it("should timeout individual tasks when taskTimeoutMs is set", async () => {
-            const { batch } = await import("./batch-utils");
-            const tasks = [
-                () => Promise.resolve("instant"), // Instant task - should not timeout
-                () => new Promise((resolve) => setTimeout(() => resolve("slow"), 500)), // Slow task - should timeout
-                () => Promise.resolve("instant2"), // Another instant task - should not timeout
-            ];
-            const results = await batch(tasks, {
-                taskTimeoutMs: 100, // 100ms timeout
-                retry: false,
-                batchDelay: 0, // Disable batch delay for timing reliability
-            });
-            expect(results[0].status).toBe("fulfilled");
-            expect(results[1].status).toBe("rejected");
-            if (results[1].status === "rejected") {
-                expect(results[1].reason).toBeInstanceOf(Error);
-                expect(results[1].reason.message).toContain("timed out");
-            }
-            expect(results[2].status).toBe("fulfilled");
-        });
-        it("should not retry tasks that timeout", async () => {
-            const { batch } = await import("./batch-utils");
-            let attemptCount = 0;
-            const slowTask = () => {
-                attemptCount++;
-                return new Promise((resolve) => setTimeout(() => resolve("done"), 200));
-            };
-            const results = await batch([slowTask], {
-                taskTimeoutMs: 50,
-                retry: true,
-            });
-            expect(results[0].status).toBe("rejected");
-            expect(attemptCount).toBe(1); // Should not retry timeout errors
-        });
-        it("should validate timeout parameters", async () => {
-            const { batch } = await import("./batch-utils");
-            const tasks = [() => Promise.resolve("test")];
-            await expect(batch(tasks, { timeoutMs: 0 })).rejects.toThrow("Timeout must be greater than 0");
-            await expect(batch(tasks, { timeoutMs: -100 })).rejects.toThrow("Timeout must be greater than 0");
-            await expect(batch(tasks, { taskTimeoutMs: 0 })).rejects.toThrow("Task timeout must be greater than 0");
-            await expect(batch(tasks, { taskTimeoutMs: -100 })).rejects.toThrow("Task timeout must be greater than 0");
-        });
-        it("should complete tasks that finish before overall timeout", async () => {
-            const { batch } = await import("./batch-utils");
-            const tasks = [
-                () => new Promise((resolve) => setTimeout(() => resolve("task1"), 10)),
-                () => new Promise((resolve) => setTimeout(() => resolve("task2"), 20)),
-                () => new Promise((resolve) => setTimeout(() => resolve("task3"), 30)),
-            ];
-            const results = await batch(tasks, {
-                timeoutMs: 100,
-                concurrency: 3,
-            });
-            expect(results).toHaveLength(3);
-            expect(results[0].status).toBe("fulfilled");
-            expect(results[1].status).toBe("fulfilled");
-            expect(results[2].status).toBe("fulfilled");
-        });
-        it("should report tasks remaining when batch timeout occurs", async () => {
-            const { batch } = await import("./batch-utils");
-            const tasks = Array.from({ length: 20 }, () => () => new Promise((resolve) => setTimeout(() => resolve("done"), 100)));
-            try {
-                await batch(tasks, { concurrency: 2, timeoutMs: 50 });
-                expect.fail("Should have thrown timeout error");
-            }
-            catch (error) {
-                expect(error).toBeInstanceOf(Error);
-                expect(error.message).toContain("task(s) not completed");
-            }
-        });
-        it("should allow taskTimeoutMs without overall timeout affecting quick tasks", async () => {
-            const { batch } = await import("./batch-utils");
-            const tasks = [
-                () => Promise.resolve("instant1"),
-                () => Promise.resolve("instant2"),
-                () => Promise.resolve("instant3"),
-            ];
-            const results = await batch(tasks, {
-                taskTimeoutMs: 1000,
-                timeoutMs: 5000,
-            });
-            expect(results).toHaveLength(3);
-            expect(results.every((r) => r.status === "fulfilled")).toBe(true);
-        });
-        it("should handle mix of timed out and successful tasks", async () => {
-            const { batch } = await import("./batch-utils");
-            const tasks = [
-                () => Promise.resolve("fast1"), // Instant - should not timeout
-                () => new Promise((resolve) => setTimeout(() => resolve("slow1"), 500)), // Slow - should timeout
-                () => Promise.resolve("fast2"), // Instant - should not timeout
-                () => new Promise((resolve) => setTimeout(() => resolve("slow2"), 500)), // Slow - should timeout
-            ];
-            const results = await batch(tasks, {
-                taskTimeoutMs: 100,
-                retry: false,
-                concurrency: 4,
-                batchDelay: 0, // Disable batch delay for timing reliability
-            });
-            expect(results[0].status).toBe("fulfilled");
-            expect(results[1].status).toBe("rejected");
-            expect(results[2].status).toBe("fulfilled");
-            expect(results[3].status).toBe("rejected");
-        });
-        it("should use default timeout when not specified", async () => {
-            const { batch } = await import("./batch-utils");
-            const tasks = [
-                () => Promise.resolve("test1"),
-                () => Promise.resolve("test2"),
-            ];
-            // Should not throw with default 3-minute timeout
-            const results = await batch(tasks);
-            expect(results).toHaveLength(2);
-            expect(results[0].status).toBe("fulfilled");
-            expect(results[1].status).toBe("fulfilled");
-        });
-    });
-});

package/dist/utils/domain-utils.d.ts

@@ -1,66 +0,0 @@
-/**
- * Domain utility functions for working with app identifiers and data normalization
- */
-import type { Action, ImplementationMeta } from "../api/types";
-import type { ActionItem, AppItem } from "../types/domain";
-/**
- * Splits a versioned key to extract the base key and version
- *
- * @param versionedKey - Versioned key in format "KeyName@version" (e.g., "SlackCLIAPI@1.21.1")
- * @returns Tuple of [baseKey, version] or [versionedKey, undefined] if no @ symbol
- *
- * @example
- * splitVersionedKey("SlackCLIAPI@1.21.1") // ["SlackCLIAPI", "1.21.1"]
- * splitVersionedKey("SomeAPI") // ["SomeAPI", undefined]
- */
-export declare function splitVersionedKey(versionedKey: string): [string, string | undefined];
-/**
- * Converts a lightweight ImplementationMeta to a slimmed AppItem
- *
- * @param implementationMeta - Raw ImplementationMeta from API
- * @returns Normalized AppItem with essential fields only
- */
-export declare function normalizeImplementationMetaToAppItem(implementationMeta: ImplementationMeta): AppItem;
-export declare function normalizeActionItem(action: Action): ActionItem;
-/**
- * Groups app keys by their type based on format patterns
- *
- * @param appKeys Array of app key strings to categorize
- * @returns Object with arrays of keys grouped by type: selectedApi (CLI APIs), slug (everything else)
- *
- * @example
- * groupVersionedAppKeysByType([
- *   'FormatterCLIAPI@1.0.0',
- *   'slack',
- *   'AnotherAPI'
- * ])
- * // Returns: {
- * //   selectedApi: ['FormatterCLIAPI@1.0.0', 'AnotherAPI'],
- * //   slug: ['slack']
- * // }
- */
-export declare function groupVersionedAppKeysByType(appKeys: string[]): {
-    selectedApi: string[];
-    slug: string[];
-};
-export declare function groupAppKeysByType(appKeys: string[]): {
-    selectedApi: string[];
-    slug: string[];
-};
-export declare function isSlug(slug: string): boolean;
-export declare function isSnakeCasedSlug(slug: string): boolean;
-export declare function dashifySnakeCasedSlug(slug: string): string;
-export interface AppLocator {
-    lookupAppKey: string;
-    slug?: string;
-    implementationName?: string;
-    version?: string;
-}
-export interface ResolvedAppLocator extends AppLocator {
-    implementationName: string;
-}
-export declare function isUuid(appKey: string): boolean;
-export declare function toAppLocator(appKey: string): AppLocator;
-export declare function isResolvedAppLocator(appLocator: AppLocator): appLocator is ResolvedAppLocator;
-export declare function toImplementationId(appLocator: ResolvedAppLocator): string;
-//# sourceMappingURL=domain-utils.d.ts.map

package/dist/utils/domain-utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"domain-utils.d.ts","sourceRoot":"","sources":["../../src/utils/domain-utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAC/D,OAAO,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAE3D;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAC/B,YAAY,EAAE,MAAM,GACnB,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAQ9B;AAED;;;;;GAKG;AACH,wBAAgB,oCAAoC,CAClD,kBAAkB,EAAE,kBAAkB,GACrC,OAAO,CAYT;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAsB9D;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG;IAC9D,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB,CAgCA;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG;IACrD,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB,CAUA;AAED,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE5C;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAOtD;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAY1D;AAED,MAAM,WAAW,UAAU;IACzB,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AACD,MAAM,WAAW,kBAAmB,SAAQ,UAAU;IACpD,kBAAkB,EAAE,MAAM,CAAC;CAC5B;AAED,wBAAgB,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAI9C;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAkBvD;AAED,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,UAAU,GACrB,UAAU,IAAI,kBAAkB,CAElC;AAED,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,kBAAkB,GAAG,MAAM,CAEzE"}