@pluslabs/utils 0.3.1 → 0.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@pluslabs/utils",
-    "version": "0.3.1",
+    "version": "0.4.1",
     "description": "A set of utilities used across projects",
     "keywords": [
         "javascript",
@@ -12,46 +12,74 @@
     "bugs": "https://github.com/pluslabs/utils/issues",
     "license": "MIT",
     "author": "Magic, Inc",
+    "type": "module",
     "files": [
         "dist",
         "src"
     ],
-    "main": "dist/main/index.js",
     "module": "dist/module/index.js",
     "types": "dist/module/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/module/index.d.ts",
+            "import": "./dist/module/index.js",
+            "default": "./dist/module/index.js"
+        },
+        "./stamp": {
+            "types": "./dist/module/stamp/index.d.ts",
+            "import": "./dist/module/stamp/index.js",
+            "default": "./dist/module/stamp/index.js"
+        },
+        "./logger": {
+            "types": "./dist/module/logger/index.d.ts",
+            "import": "./dist/module/logger/index.js",
+            "default": "./dist/module/logger/index.js"
+        },
+        "./langfuse-prompt-service": {
+            "types": "./dist/module/langfuse-prompt-service/index.d.ts",
+            "import": "./dist/module/langfuse-prompt-service/index.js",
+            "default": "./dist/module/langfuse-prompt-service/index.js"
+        }
+    },
     "sideEffects": false,
     "repository": "pluslabs/utils",
     "scripts": {
         "clean": "rimraf dist",
         "format": "prettier --write \"{src,test}/**/*.ts\"",
-        "build": "run-s clean format build:*",
-        "build:main": "tsc -p tsconfig.json",
-        "build:module": "tsc -p tsconfig.module.json",
+        "build": "run-s clean format && tsc -p tsconfig.json",
         "test": "run-s test:types test:run",
-        "test:run": "jest --runInBand",
+        "test:run": "jest --runInBand --passWithNoTests",
         "test:watch": "jest --watch --verbose false --silent false",
-        "test:types": "run-s build:module && tsd --files test/*.test-d.ts",
+        "test:types": "tsc -p tsconfig.json",
         "docs": "typedoc --entryPoints src/index.ts --out docs --includes src/**/*.ts",
-        "docs:json": "typedoc --entryPoints src/index.ts --includes src/**/*.ts --json docs/spec.json --excludeExternals"
+        "docs:json": "typedoc --entryPoints src/index.ts --includes src/**/*.ts --json docs/spec.json --excludeExternals",
+        "prepare": "husky"
+    },
+    "peerDependencies": {
+        "@langfuse/client": "^4.5.1",
+        "@langfuse/core": "^4.5.1",
+        "@upstash/redis": "^1.36.1",
+        "@opentelemetry/api": "^1.9.0",
+        "@opentelemetry/core": "^2.3.0"
     },
     "devDependencies": {
-        "@types/jest": "^29.2.5",
-        "husky": "^4.3.0",
-        "jest": "^29.3.1",
+        "@langfuse/client": "^4.5.1",
+        "@langfuse/core": "^4.5.1",
+        "@types/jest": "^30.0.0",
+        "@upstash/redis": "^1.36.1",
+        "@opentelemetry/api": "^1.9.0",
+        "@opentelemetry/core": "^2.3.0",
+        "husky": "^9.1.7",
+        "jest": "^30.2.0",
         "npm-run-all": "^4.1.5",
-        "prettier": "^2.5.1",
-        "pretty-quick": "^3.1.3",
-        "rimraf": "^3.0.2",
-        "ts-jest": "^29.0.5",
-        "ts-loader": "^8.0.11",
-        "ts-node": "^10.9.1",
-        "tsd": "^0.30.4",
-        "typedoc": "^0.22.16",
-        "typescript": "^4.5.5"
-    },
-    "husky": {
-        "hooks": {
-            "pre-commit": "pretty-quick --staged"
-        }
+        "prettier": "^3.7.4",
+        "pretty-quick": "^4.2.2",
+        "rimraf": "^6.1.2",
+        "ts-jest": "^29.4.6",
+        "ts-loader": "^9.5.4",
+        "ts-node": "^10.9.2",
+        "tsd": "^0.33.0",
+        "typedoc": "^0.28.15",
+        "typescript": "^5.9.3"
     }
 }

package/src/index.ts

@@ -1,7 +1,7 @@
-import * as gpt from './gpt';
-import createCacheKeysManager from './cache';
+import * as gpt from './gpt/index.js';
+import createCacheKeysManager from './cache/index.js';
 
-export * from './stamp';
-export * from './cache';
+export * from './stamp/index.js';
+export * from './cache/index.js';
 
 export { gpt, createCacheKeysManager };

package/src/langfuse-prompt-service/index.ts

@@ -0,0 +1,469 @@
+import { LangfuseClient, TextPromptClient, ChatPromptClient } from '@langfuse/client';
+import type { PromptMeta } from '@langfuse/core';
+import { Redis } from '@upstash/redis';
+// ESM best-practice: keep relative imports but use `.js` specifiers.
+// With `moduleResolution: "NodeNext"`, TS resolves this to the TS sources and
+// preserves `.js` in emitted output (required by Node ESM / Turbopack).
+import { createStamp } from '../stamp/index.js';
+import { logger } from '../logger/index.js';
+
+export type LangfusePromptClient = TextPromptClient | ChatPromptClient;
+
+export type TPrompt = {
+    id: string;
+    prompt: string;
+    version: string;
+    version_label?: string;
+};
+
+export type ToolPromptWithClient = TPrompt & {
+    langfusePrompt: LangfusePromptClient;
+};
+
+export type PromptVersionInfo = {
+    id: string;
+    version: number;
+    version_label: string | null;
+    labels: string[];
+    config: LangfusePromptConfig | null;
+};
+
+export type PromptVersionsResult = {
+    name: string;
+    activePrompt: PromptVersionInfo | null;
+    versions: PromptVersionInfo[];
+};
+
+export type LangfusePromptConfig = {
+    model?: string;
+    model_parameters?: {
+        reasoning_effort?: string;
+    };
+};
+
+const DEFAULT_CACHE_TTL_SECONDS = 60 * 1; // 1 minute
+
+const createRedisFromEnv = (): Redis =>
+    new Redis({
+        url: process.env.REDIS_UPSTASH_KV_REST_API_URL!,
+        token: process.env.REDIS_UPSTASH_KV_REST_API_TOKEN!
+    });
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Generic Redis Cache Helper
+// ─────────────────────────────────────────────────────────────────────────────
+
+type CacheOptions<T, S> = {
+    cacheKey: string;
+    fetcher: () => Promise<T>;
+    ttlSeconds?: number;
+    serialize: (value: T) => S;
+    hydrate: (serialized: S) => T;
+    logContext: string;
+};
+
+/**
+ * Generic Redis cache wrapper with custom serialization/hydration.
+ * If Redis is not configured, this is a passthrough that simply calls the fetcher.
+ */
+async function withRedisCache<T, S>(
+    redis: Redis,
+    {
+        cacheKey,
+        fetcher,
+        ttlSeconds = DEFAULT_CACHE_TTL_SECONDS,
+        serialize,
+        hydrate,
+        logContext
+    }: CacheOptions<T, S>
+): Promise<T> {
+    try {
+        const cached = await redis.get<S | string>(cacheKey);
+        if (cached) {
+            const parsed: S = typeof cached === 'string' ? JSON.parse(cached) : cached;
+            logger.log(`[langfuse-prompt-service] [${logContext}] [cache-hit]`, cacheKey);
+            return hydrate(parsed);
+        }
+    } catch (cacheError) {
+        logger.warn(`[langfuse-prompt-service] [${logContext}] [cache-get-error]`, cacheError);
+    }
+
+    const result = await fetcher();
+    logger.log(`[langfuse-prompt-service] [${logContext}] [cache-miss]`, cacheKey);
+
+    try {
+        await redis.setex(cacheKey, ttlSeconds, JSON.stringify(serialize(result)));
+        logger.log(`[langfuse-prompt-service] [${logContext}] [cache-set]`, cacheKey);
+    } catch (err) {
+        logger.warn(`[langfuse-prompt-service] [${logContext}] [cache-set-error]`, err);
+    }
+
+    return result;
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Langfuse Prompt Serialization
+// ─────────────────────────────────────────────────────────────────────────────
+
+type SerializedPrompt = {
+    type: 'text' | 'chat';
+    promptResponse: Record<string, unknown>;
+    isFallback: boolean;
+};
+
+/**
+ * Build a stable Redis cache key for a Langfuse prompt.
+ */
+const buildPromptCacheKey = (promptName: string, version?: string | number): string => {
+    const versionPart = version !== undefined ? `v${version}` : 'production';
+    return `langfuse:prompt:${promptName}:${versionPart}`;
+};
+
+/**
+ * Serialize a Langfuse prompt client to a plain object for Redis storage.
+ */
+const serializePromptClient = (client: LangfusePromptClient): SerializedPrompt => {
+    const isText = client instanceof TextPromptClient;
+    return {
+        type: isText ? 'text' : 'chat',
+        promptResponse: (client as TextPromptClient | ChatPromptClient)
+            .promptResponse as unknown as Record<string, unknown>,
+        isFallback: client.isFallback
+    };
+};
+
+/**
+ * Hydrate a serialized prompt back into a Langfuse prompt client instance.
+ */
+const hydratePromptClient = (serialized: SerializedPrompt): LangfusePromptClient => {
+    if (serialized.type === 'text') {
+        return new TextPromptClient(
+            serialized.promptResponse as unknown as ConstructorParameters<
+                typeof TextPromptClient
+            >[0],
+            serialized.isFallback
+        );
+    }
+    return new ChatPromptClient(
+        serialized.promptResponse as unknown as ConstructorParameters<typeof ChatPromptClient>[0],
+        serialized.isFallback
+    );
+};
+
+export type LangfusePromptServiceOptions = {
+    /**
+     * Optional Langfuse client instance. If omitted, a new client is created.
+     */
+    client?: LangfuseClient;
+    /**
+     * Optional Redis client for caching. If omitted, tries to auto-configure Upstash Redis from env.
+     * If env vars are missing, caching is disabled.
+     */
+    redis?: Redis;
+    /**
+     * Default cache TTL (seconds) for prompt caching.
+     */
+    cacheTtlSeconds?: number;
+    /**
+     * Optional tool prompt mapping (toolId -> promptName).
+     * If omitted, tool prompt names fall back to `tools/${toolId}`.
+     */
+    toolPromptMap?: Record<string, string>;
+};
+
+export class LangfusePromptService {
+    private client: LangfuseClient;
+    private redis: Redis;
+    private cacheTtlSeconds: number;
+    private toolPromptMap?: Record<string, string>;
+
+    constructor(options: LangfusePromptServiceOptions = {}) {
+        this.client = options.client ?? new LangfuseClient();
+        this.redis = options.redis ?? createRedisFromEnv();
+        this.cacheTtlSeconds = options.cacheTtlSeconds ?? DEFAULT_CACHE_TTL_SECONDS;
+        this.toolPromptMap = options.toolPromptMap;
+    }
+
+    /**
+     * Get tool prompt name for a given tool ID.
+     */
+    private getToolPromptName(toolId: string): string {
+        if (this.toolPromptMap && toolId in this.toolPromptMap) {
+            return this.toolPromptMap[toolId]!;
+        }
+
+        // Default: tool prompts are stored under `tools/<toolId>`
+        return `tools/${toolId}`;
+    }
+
+    /**
+     * Fetch a prompt by Langfuse prompt name with optional version.
+     * Uses Redis cache (when configured) to avoid repeated Langfuse API calls.
+     */
+    async getPrompt({
+        promptName,
+        version
+    }: {
+        promptName: string;
+        version?: string;
+    }): Promise<TextPromptClient> {
+        const { stamp } = createStamp(`langfuse.getPrompt[${promptName}]`);
+
+        try {
+            const result = await withRedisCache<LangfusePromptClient, SerializedPrompt>(
+                this.redis,
+                {
+                    cacheKey: buildPromptCacheKey(promptName, version),
+                    fetcher: async () => {
+                        // When version is specified, fetch by version number
+                        // Otherwise, fetch by 'production' label to ensure we get the correct promoted version
+                        const prompt = await this.client.prompt.get(promptName, {
+                            ...(version
+                                ? { version: parseInt(version, 10) }
+                                : { label: 'production' })
+                        });
+                        stamp('fetched');
+                        return prompt;
+                    },
+                    ttlSeconds: this.cacheTtlSeconds,
+                    serialize: serializePromptClient,
+                    hydrate: hydratePromptClient,
+                    logContext: 'getPrompt'
+                }
+            );
+
+            return result as TextPromptClient;
+        } catch (error) {
+            logger.error(
+                '[langfuse-prompt-service] [getPrompt]',
+                `[promptName=${promptName}]`,
+                `[error=${JSON.stringify(error)}]`
+            );
+            throw error;
+        } finally {
+            stamp('end').end();
+        }
+    }
+
+    /**
+     * Fetch a tool prompt by tool ID with optional version override.
+     */
+    async getToolPrompt({ toolId, version }: { toolId: string; version?: number }) {
+        try {
+            const promptName = this.getToolPromptName(toolId);
+            const langfusePrompt = await this.getPrompt({
+                promptName,
+                version: version?.toString()
+            });
+            return langfusePrompt;
+        } catch (error) {
+            logger.warn(
+                '[langfuse-prompt-service] [getToolPrompt]',
+                `[toolId=${toolId}]`,
+                `[error=${JSON.stringify(error)}]`
+            );
+            return null;
+        }
+    }
+
+    /**
+     * Fetch multiple tool prompts with optional overrides.
+     * Uses a single composite Redis cache key for the entire tool set (when Redis configured).
+     */
+    async getToolPrompts({
+        toolIds,
+        toolOverrides
+    }: {
+        toolIds: string[];
+        toolOverrides?: Record<string, number>;
+    }): Promise<LangfusePromptClient[]> {
+        const { stamp } = createStamp(`langfuse.getToolPrompts[${toolIds.join(',')}]`);
+
+        // Build composite cache key from sorted tool IDs + versions
+        const keyParts = toolIds
+            .slice()
+            .sort()
+            .map((id) => {
+                const v = toolOverrides?.[id];
+                return v !== undefined ? `${id}:v${v}` : id;
+            });
+
+        try {
+            return await withRedisCache<LangfusePromptClient[], SerializedPrompt[]>(this.redis, {
+                cacheKey: `langfuse:toolprompts:${keyParts.join('|')}`,
+                fetcher: async () => {
+                    // `getToolPrompt` is already fail-safe (returns null on errors), so `Promise.all` is fine here.
+                    const results = await Promise.all(
+                        toolIds.map((toolId) => {
+                            const version = toolOverrides?.[toolId];
+                            return this.getToolPrompt({ toolId, version });
+                        })
+                    );
+
+                    const toolPrompts = results.filter(
+                        (p): p is TextPromptClient => p !== null
+                    ) as LangfusePromptClient[];
+                    stamp('fetched');
+                    return toolPrompts;
+                },
+                ttlSeconds: this.cacheTtlSeconds,
+                serialize: (prompts) => prompts.map(serializePromptClient),
+                hydrate: (serialized) => serialized.map(hydratePromptClient),
+                logContext: 'getToolPrompts'
+            });
+        } finally {
+            stamp('end').end();
+        }
+    }
+
+    /**
+     * Fetch tool prompts and convert to ToolPromptWithClient format.
+     */
+    async getToolPromptsWithClients({
+        toolIds,
+        toolOverrides
+    }: {
+        toolIds: string[];
+        toolOverrides?: Record<string, number>;
+    }): Promise<ToolPromptWithClient[]> {
+        const langfusePrompts = await this.getToolPrompts({ toolIds, toolOverrides });
+
+        return langfusePrompts.map((lp) => ({
+            id: `langfuse-${lp.version}`,
+            prompt: lp.prompt as string,
+            active: true,
+            version: lp.version.toString(),
+            langfusePrompt: lp
+        }));
+    }
+
+    /**
+     * Return every version for each prompt, including per-version labels and configs.
+     * Missing prompt names are simply omitted.
+     */
+    async listPromptVersionsWithConfigs(
+        promptNames: string[],
+        concurrency = 8
+    ): Promise<Record<string, PromptVersionsResult>> {
+        const targetNames = new Set(promptNames);
+        const results: Record<string, PromptVersionsResult> = {};
+
+        // Single page fetch with generous limit; adjust if prompt library grows beyond 200.
+        const response = await this.client.api.prompts.list({
+            page: 1,
+            limit: 100
+        });
+
+        const promptMetas: PromptMeta[] = (response.data || []).filter((p: PromptMeta) =>
+            targetNames.has(p.name)
+        );
+
+        // Pre-allocate container for version details per prompt
+        const versionBuckets: Record<string, PromptVersionInfo[]> = {};
+        for (const p of promptMetas) {
+            versionBuckets[p.name] = [];
+        }
+
+        // Build work items (promptName + version) and process with bounded concurrency
+        type WorkItem = { promptName: string; version: number };
+        const work: WorkItem[] = [];
+
+        for (const p of promptMetas) {
+            for (const version of p.versions) {
+                work.push({
+                    promptName: p.name,
+                    version
+                });
+            }
+        }
+
+        let cursor = 0;
+        const runWorker = async () => {
+            while (cursor < work.length) {
+                const idx = cursor++;
+                const item = work[idx];
+                const prompt = await this.client.prompt.get(item.promptName, {
+                    version: item.version
+                });
+
+                versionBuckets[item.promptName].push({
+                    id: `${item.promptName}-v${item.version}`,
+                    version: item.version,
+                    version_label:
+                        prompt.labels.find((l: string) => l !== 'production' && l !== 'latest') ||
+                        null,
+                    labels: prompt.labels,
+                    config: prompt.config as LangfusePromptConfig
+                });
+            }
+        };
+
+        const workers = Array.from({ length: Math.min(concurrency, work.length) }, () =>
+            runWorker()
+        );
+
+        await Promise.all(workers);
+
+        // Build final result per prompt
+        for (const p of promptMetas) {
+            const versionDetails = versionBuckets[p.name].sort((a, b) => a.version - b.version);
+
+            const activePrompt =
+                versionDetails.find((v) => v.labels.indexOf('production') !== -1) ??
+                versionDetails[versionDetails.length - 1] ??
+                null;
+
+            results[p.name] = {
+                name: p.name,
+                activePrompt,
+                versions: versionDetails
+            };
+        }
+
+        return results;
+    }
+
+    /**
+     * Cached wrapper around listPromptVersionsWithConfigs.
+     * Uses Redis with a short TTL to avoid repeated Langfuse list/get bursts.
+     */
+    async listPromptVersionsWithConfigsCached(
+        promptNames: string[],
+        concurrency = 8,
+        ttlSeconds = 60,
+        forceRefresh = false
+    ): Promise<Record<string, PromptVersionsResult>> {
+        const cacheKey = `langfuse:prompt_versions:${promptNames
+            .slice()
+            .sort()
+            .join('|')}:c${concurrency}`;
+
+        // Force refresh bypasses cache read
+        if (forceRefresh) {
+            const fresh = await this.listPromptVersionsWithConfigs(promptNames, concurrency);
+            this.redis
+                .setex(cacheKey, ttlSeconds, JSON.stringify(fresh))
+                .catch((error: unknown) =>
+                    logger.warn(
+                        '[langfuse-prompt-service] [listPromptVersionsWithConfigsCached] [cache-set-error]',
+                        error
+                    )
+                );
+            return fresh;
+        }
+
+        return withRedisCache<
+            Record<string, PromptVersionsResult>,
+            Record<string, PromptVersionsResult>
+        >(this.redis, {
+            cacheKey,
+            fetcher: () => this.listPromptVersionsWithConfigs(promptNames, concurrency),
+            ttlSeconds,
+            serialize: (v) => v,
+            hydrate: (v) => v,
+            logContext: 'listPromptVersionsWithConfigsCached'
+        });
+    }
+}
+
+export const langfusePromptService = new LangfusePromptService();

package/src/logger/index.ts

@@ -0,0 +1,29 @@
+const levels = ['all', 'info', 'warn', 'error'];
+
+/**
+ * Utility for logging messages at different levels in different environments.
+ * Logging a lot of data in production adds costs to log ingestion.
+ */
+export const logger = {
+    level: levels.indexOf(process.env.NODE_ENV !== 'development' ? 'info' : 'all'),
+    log: (...messages: unknown[]) => {
+        if (levels.indexOf('all') >= logger.level) {
+            console.log(...messages);
+        }
+    },
+    info: (...messages: unknown[]) => {
+        if (levels.indexOf('info') >= logger.level) {
+            console.log(...messages);
+        }
+    },
+    warn: (...messages: unknown[]) => {
+        if (levels.indexOf('warn') >= logger.level) {
+            console.warn(...messages);
+        }
+    },
+    error: (...messages: unknown[]) => {
+        if (levels.indexOf('error') >= logger.level) {
+            console.error('\x1b[31m', ...messages, '\x1b[0m');
+        }
+    }
+};

package/dist/main/cache/index.d.ts

@@ -1,42 +0,0 @@
-declare class CacheKey {
-    private key;
-    /**
-     * The time to live for the cache key in seconds
-     */
-    ttl: number;
-    constructor(prefix: string, ...args: string[]);
-    setTtl(ttl: number): this;
-    add(...values: (string | number | boolean)[]): this;
-    get(): string;
-}
-type CacheKeysManagerOptions<R extends Record<string, readonly string[]>> = {
-    registry: R;
-    namespace: string;
-    redisClient?: {
-        get<T = string>(key: string): Promise<T | null>;
-        set<T = string>(key: string, value: T, options: {
-            ex: number;
-        }): Promise<void>;
-        del(key: string): Promise<void>;
-        [key: string]: any;
-    };
-};
-/**
- * Creates a cache keys manager
- * @param options - The options for the cache keys manager
- * @param options.registry - The registry of cache keys
- * @param options.namespace - The namespace for the cache keys
- * @param options.redisClient - The redis client to use for the cache keys manager
- * @returns The cache keys manager
- */
-declare function createCacheKeysManager<R extends Record<string, readonly string[]>>(options: CacheKeysManagerOptions<R>): {
-    getCacheKey: <K extends keyof R, V extends R[K][number], Args extends (string | number | boolean)[]>(root: K, node: V, ...identifiers: Args) => CacheKey;
-    invalidateCacheKey: <K_1 extends keyof R, V_1 extends R[K_1][number], Args_1 extends (string | number | boolean)[]>(root: K_1, key: V_1, ...identifiers: Args_1) => Promise<void>;
-    getCachedData: <T, K_2 extends keyof R, V_2 extends R[K_2][number]>(options: {
-        cacheKey: string | (() => [K_2, V_2, ...(string | number | boolean)[]]);
-        queryFn: () => Promise<T | null>;
-        ttl?: number | undefined;
-    }) => Promise<T | null>;
-};
-export default createCacheKeysManager;
-//# sourceMappingURL=index.d.ts.map

package/dist/main/cache/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/cache/index.ts"],"names":[],"mappings":"AAEA,cAAM,QAAQ;IACV,OAAO,CAAC,GAAG,CAAW;IAEtB;;OAEG;IACI,GAAG,EAAE,MAAM,CAAe;gBAErB,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,MAAM,EAAE;IAI7C,MAAM,CAAC,GAAG,EAAE,MAAM;IAKlB,GAAG,CAAC,GAAG,MAAM,EAAE,CAAC,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,EAAE;IAK5C,GAAG;CAGN;AAED,KAAK,uBAAuB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,IAAI;IACxE,QAAQ,EAAE,CAAC,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE;QACV,GAAG,CAAC,CAAC,GAAG,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;QAChD,GAAG,CAAC,CAAC,GAAG,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE;YAAE,EAAE,EAAE,MAAM,CAAA;SAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;QAC/E,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;QAChC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;KACtB,CAAC;CACL,CAAC;AAEF;;;;;;;GAOG;AACH,iBAAS,sBAAsB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,EACvE,OAAO,EAAE,uBAAuB,CAAC,CAAC,CAAC;;wKAqBO,QAAQ,IAAI,CAAC;;;;;;EA0F1D;AAED,eAAe,sBAAsB,CAAC"}