veryfront 0.0.82 → 0.0.84

package/README.md

@@ -1,25 +1,26 @@
-# Veryfront
+# Veryfront Code
 
-[![npm version](https://img.shields.io/npm/v/veryfront.svg)](https://www.npmjs.com/package/veryfront)
-[![CI/CD](https://github.com/veryfront/veryfront-renderer/actions/workflows/ci.yml/badge.svg)](https://github.com/veryfront/veryfront-renderer/actions/workflows/ci.yml)
-[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
-
-The all-in-one React framework for building AI-powered applications and agents.
-
-## Features
-
-- **Zero config** — Auto-discovery from file structure
-- **Multi-runtime** — Deno, Node.js, Bun, Cloudflare Workers
-- **Full-stack React** — SSR, SSG, ISR, streaming
-- **MCP built-in** — Model Context Protocol server
-- **Production-ready** — Rate limiting, caching, observability
-
-## Quick Start
+The simplest way to build AI-powered apps.
 
 ```bash
-npx veryfront demo
+npx veryfront
 ```
 
+```
+  ○ ○ ○ ○ ○ ○ ○
+  ○ ● ● ● ○ ○ ○   Veryfront Code is running
+  ○ ● ● ● ○ ○ ○
+  ○ ● ● ○ ● ● ○   Url  http://veryfront.me:3000
+  ○ ○ ○ ● ● ● ○   Mcp  http://veryfront.me:3002/mcp
+  ○ ○ ○ ● ● ● ○
+  ○ ○ ○ ○ ○ ○ ○
+
+  ✓ Server ready
+  ✓ MCP ready
+```
+
+One command. Zero config. Just build.
+
 ## Project Structure
 
 ```

package/esm/deno.js

@@ -1,6 +1,6 @@
 export default {
     "name": "veryfront",
-    "version": "0.0.82",
+    "version": "0.0.84",
     "nodeModulesDir": "auto",
     "exclude": [
         "npm/",

package/esm/proxy/cache/index.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Token Cache Module
+ *
+ * Provides configurable caching for OAuth tokens.
+ * Supports in-memory (single instance) and Redis (distributed) backends.
+ * Redis cache includes automatic fallback to memory when Redis is unavailable.
+ */
+export type { CacheOptions, CacheStats, MemoryCacheOptions, RedisCacheOptions, TokenCache, TokenCacheEntry, } from "./types.js";
+export { MemoryCache } from "./memory-cache.js";
+export { RedisCache } from "./redis-cache.js";
+export { ResilientCache } from "./resilient-cache.js";
+import type { CacheOptions, TokenCache } from "./types.js";
+/**
+ * Create a token cache based on configuration.
+ *
+ * @example
+ * ```typescript
+ * // In-memory cache (default)
+ * const cache = createCache({ type: "memory" });
+ *
+ * // Redis cache for distributed deployments
+ * const cache = createCache({
+ *   type: "redis",
+ *   options: { url: "redis://localhost:6379" }
+ * });
+ * ```
+ */
+export declare function createCache(options: CacheOptions): Promise<TokenCache>;
+/**
+ * Create cache from environment variables.
+ *
+ * Environment variables:
+ * - CACHE_TYPE: "memory" or "redis" (default: "memory")
+ * - REDIS_URL: Redis connection URL (required if CACHE_TYPE=redis)
+ * - REDIS_PREFIX: Key prefix (default: "vf:token:")
+ *
+ * When CACHE_TYPE=redis, automatically wraps with ResilientCache for
+ * graceful fallback to memory when Redis is unavailable.
+ */
+export declare function createCacheFromEnv(): Promise<TokenCache>;
+//# sourceMappingURL=index.d.ts.map

package/esm/proxy/cache/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/proxy/cache/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,YAAY,EACV,YAAY,EACZ,UAAU,EACV,kBAAkB,EAClB,iBAAiB,EACjB,UAAU,EACV,eAAe,GAChB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEtD,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAU3D;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,UAAU,CAAC,CAU5E;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,UAAU,CAAC,CAwB9D"}

package/esm/proxy/cache/index.js

@@ -0,0 +1,75 @@
+/**
+ * Token Cache Module
+ *
+ * Provides configurable caching for OAuth tokens.
+ * Supports in-memory (single instance) and Redis (distributed) backends.
+ * Redis cache includes automatic fallback to memory when Redis is unavailable.
+ */
+export { MemoryCache } from "./memory-cache.js";
+export { RedisCache } from "./redis-cache.js";
+export { ResilientCache } from "./resilient-cache.js";
+import { MemoryCache } from "./memory-cache.js";
+import { RedisCache } from "./redis-cache.js";
+import { ResilientCache } from "./resilient-cache.js";
+import { getEnv } from "../../src/platform/compat/process.js";
+import { proxyLogger } from "../logger.js";
+import { withSpan } from "../tracing.js";
+const logger = proxyLogger.child({ module: "cache" });
+/**
+ * Create a token cache based on configuration.
+ *
+ * @example
+ * ```typescript
+ * // In-memory cache (default)
+ * const cache = createCache({ type: "memory" });
+ *
+ * // Redis cache for distributed deployments
+ * const cache = createCache({
+ *   type: "redis",
+ *   options: { url: "redis://localhost:6379" }
+ * });
+ * ```
+ */
+export async function createCache(options) {
+    return withSpan("cache.create", async () => {
+        switch (options.type) {
+            case "redis":
+                return new RedisCache(options.options);
+            case "memory":
+            default:
+                return new MemoryCache(options.options);
+        }
+    }, { "cache.type": options.type });
+}
+/**
+ * Create cache from environment variables.
+ *
+ * Environment variables:
+ * - CACHE_TYPE: "memory" or "redis" (default: "memory")
+ * - REDIS_URL: Redis connection URL (required if CACHE_TYPE=redis)
+ * - REDIS_PREFIX: Key prefix (default: "vf:token:")
+ *
+ * When CACHE_TYPE=redis, automatically wraps with ResilientCache for
+ * graceful fallback to memory when Redis is unavailable.
+ */
+export async function createCacheFromEnv() {
+    return withSpan("cache.createFromEnv", async () => {
+        const cacheType = getEnv("CACHE_TYPE") || "memory";
+        if (cacheType === "redis") {
+            const url = getEnv("REDIS_URL");
+            if (!url) {
+                logger.warn("[Cache] CACHE_TYPE=redis but REDIS_URL not set, falling back to memory");
+                return new MemoryCache();
+            }
+            const redisCache = new RedisCache({
+                url,
+                prefix: getEnv("REDIS_PREFIX") || "vf:token:",
+            });
+            // Wrap Redis with resilient fallback to memory cache
+            // This ensures the proxy continues to function when Redis is unavailable
+            logger.info("[Cache] Using Redis with memory fallback (ResilientCache)");
+            return new ResilientCache(redisCache, new MemoryCache());
+        }
+        return new MemoryCache();
+    }, { "cache.type": getEnv("CACHE_TYPE") || "memory" });
+}

package/esm/proxy/cache/memory-cache.d.ts

@@ -0,0 +1,18 @@
+import type { CacheStats, MemoryCacheOptions, TokenCache, TokenCacheEntry } from "./types.js";
+export declare class MemoryCache implements TokenCache {
+    private cache;
+    private hits;
+    private misses;
+    private maxSize;
+    private cleanupTimer;
+    constructor(options?: MemoryCacheOptions);
+    get(key: string): Promise<TokenCacheEntry | null>;
+    set(key: string, entry: TokenCacheEntry): Promise<void>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+    has(key: string): Promise<boolean>;
+    stats(): Promise<CacheStats>;
+    close(): Promise<void>;
+    private cleanup;
+}
+//# sourceMappingURL=memory-cache.d.ts.map

package/esm/proxy/cache/memory-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-cache.d.ts","sourceRoot":"","sources":["../../../src/proxy/cache/memory-cache.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAE,kBAAkB,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAM9F,qBAAa,WAAY,YAAW,UAAU;IAC5C,OAAO,CAAC,KAAK,CAAsC;IACnD,OAAO,CAAC,IAAI,CAAK;IACjB,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,YAAY,CAAuD;gBAE/D,OAAO,GAAE,kBAAuB;IAM5C,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC;IAoBjD,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAYvD,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAMlC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAQtB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAclC,KAAK,IAAI,OAAO,CAAC,UAAU,CAAC;IAS5B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAUtB,OAAO,CAAC,OAAO;CAehB"}

package/esm/proxy/cache/memory-cache.js

@@ -0,0 +1,100 @@
+/**
+ * In-Memory Token Cache - single-instance deployments.
+ */
+import * as dntShim from "../../_dnt.shims.js";
+import { withSpan } from "../tracing.js";
+const DEFAULT_MAX_SIZE = 1000;
+const DEFAULT_CLEANUP_INTERVAL = 60_000;
+export class MemoryCache {
+    cache = new Map();
+    hits = 0;
+    misses = 0;
+    maxSize;
+    cleanupTimer = null;
+    constructor(options = {}) {
+        this.maxSize = options.maxSize ?? DEFAULT_MAX_SIZE;
+        const interval = options.cleanupInterval ?? DEFAULT_CLEANUP_INTERVAL;
+        this.cleanupTimer = dntShim.setInterval(() => this.cleanup(), interval);
+    }
+    get(key) {
+        return withSpan("cache.memory.get", async () => {
+            const entry = this.cache.get(key);
+            if (!entry) {
+                this.misses++;
+                return null;
+            }
+            if (Date.now() >= entry.expiresAt) {
+                this.cache.delete(key);
+                this.misses++;
+                return null;
+            }
+            this.hits++;
+            return entry;
+        }, { "cache.key": key });
+    }
+    set(key, entry) {
+        return withSpan("cache.memory.set", async () => {
+            if (this.cache.size >= this.maxSize) {
+                const firstKey = this.cache.keys().next().value;
+                if (firstKey) {
+                    this.cache.delete(firstKey);
+                }
+            }
+            this.cache.set(key, entry);
+        }, { "cache.key": key });
+    }
+    delete(key) {
+        return withSpan("cache.memory.delete", async () => {
+            this.cache.delete(key);
+        }, { "cache.key": key });
+    }
+    clear() {
+        return withSpan("cache.memory.clear", async () => {
+            this.cache.clear();
+            this.hits = 0;
+            this.misses = 0;
+        });
+    }
+    has(key) {
+        return withSpan("cache.memory.has", async () => {
+            const entry = this.cache.get(key);
+            if (!entry)
+                return false;
+            if (Date.now() >= entry.expiresAt) {
+                this.cache.delete(key);
+                return false;
+            }
+            return true;
+        }, { "cache.key": key });
+    }
+    stats() {
+        return withSpan("cache.memory.stats", async () => ({
+            hits: this.hits,
+            misses: this.misses,
+            size: this.cache.size,
+            type: "memory",
+        }));
+    }
+    close() {
+        return withSpan("cache.memory.close", async () => {
+            if (this.cleanupTimer) {
+                clearInterval(this.cleanupTimer);
+                this.cleanupTimer = null;
+            }
+            this.cache.clear();
+        });
+    }
+    cleanup() {
+        const now = Date.now();
+        let cleaned = 0;
+        for (const [key, entry] of this.cache.entries()) {
+            if (now >= entry.expiresAt) {
+                this.cache.delete(key);
+                cleaned++;
+            }
+        }
+        if (cleaned > 0) {
+            console.log(`[MemoryCache] Cleaned ${cleaned} expired entries`);
+        }
+    }
+}

package/esm/proxy/cache/redis-cache.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Redis Token Cache
+ *
+ * Uses the standard `redis` package for cross-runtime compatibility.
+ * Works in Deno, Node.js, and Bun.
+ */
+import type { CacheStats, RedisCacheOptions, TokenCache, TokenCacheEntry } from "./types.js";
+export declare class RedisCache implements TokenCache {
+    private client;
+    private prefix;
+    private url;
+    private connectTimeout;
+    private hits;
+    private misses;
+    private connected;
+    constructor(options: RedisCacheOptions);
+    private key;
+    get(key: string): Promise<TokenCacheEntry | null>;
+    set(key: string, entry: TokenCacheEntry): Promise<void>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+    has(key: string): Promise<boolean>;
+    stats(): Promise<CacheStats>;
+    close(): Promise<void>;
+    private ensureConnected;
+}
+//# sourceMappingURL=redis-cache.d.ts.map

package/esm/proxy/cache/redis-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis-cache.d.ts","sourceRoot":"","sources":["../../../src/proxy/cache/redis-cache.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,iBAAiB,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAO7F,qBAAa,UAAW,YAAW,UAAU;IAC3C,OAAO,CAAC,MAAM,CAAgC;IAC9C,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,IAAI,CAAK;IACjB,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,SAAS,CAAS;gBAEd,OAAO,EAAE,iBAAiB;IAMtC,OAAO,CAAC,GAAG;IAIL,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC;IA8BjD,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAevD,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAalC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAmCtB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAclC,KAAK,IAAI,OAAO,CAAC,UAAU,CAAC;IAe5B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;YAcd,eAAe;CAgC9B"}

package/esm/proxy/cache/redis-cache.js

@@ -0,0 +1,183 @@
+/**
+ * Redis Token Cache
+ *
+ * Uses the standard `redis` package for cross-runtime compatibility.
+ * Works in Deno, Node.js, and Bun.
+ */
+import { createClient } from "redis";
+import { withSpan } from "../tracing.js";
+const DEFAULT_PREFIX = "vf:token:";
+const DEFAULT_CONNECT_TIMEOUT = 5000;
+const DEFAULT_SCAN_COUNT = 100;
+export class RedisCache {
+    client = null;
+    prefix;
+    url;
+    connectTimeout;
+    hits = 0;
+    misses = 0;
+    connected = false;
+    constructor(options) {
+        this.url = options.url;
+        this.prefix = options.prefix ?? DEFAULT_PREFIX;
+        this.connectTimeout = options.connectTimeout ?? DEFAULT_CONNECT_TIMEOUT;
+    }
+    key(k) {
+        return `${this.prefix}${k}`;
+    }
+    async get(key) {
+        return withSpan("cache.redis.get", async () => {
+            try {
+                await this.ensureConnected();
+                const data = await this.client.get(this.key(key));
+                if (!data) {
+                    this.misses++;
+                    return null;
+                }
+                const entry = JSON.parse(data);
+                if (Date.now() >= entry.expiresAt) {
+                    await this.client.del(this.key(key));
+                    this.misses++;
+                    return null;
+                }
+                this.hits++;
+                return entry;
+            }
+            catch (error) {
+                console.error("[RedisCache] Get error:", error);
+                this.connected = false;
+                this.misses++;
+                throw error;
+            }
+        }, { "cache.key": key });
+    }
+    async set(key, entry) {
+        return withSpan("cache.redis.set", async () => {
+            try {
+                await this.ensureConnected();
+                const ttlMs = entry.expiresAt - Date.now();
+                const ttlSeconds = Math.max(1, Math.floor(ttlMs / 1000));
+                await this.client.setEx(this.key(key), ttlSeconds, JSON.stringify(entry));
+            }
+            catch (error) {
+                console.error("[RedisCache] Set error:", error);
+                this.connected = false;
+                throw error;
+            }
+        }, { "cache.key": key });
+    }
+    async delete(key) {
+        return withSpan("cache.redis.delete", async () => {
+            try {
+                await this.ensureConnected();
+                await this.client.del(this.key(key));
+            }
+            catch (error) {
+                console.error("[RedisCache] Delete error:", error);
+                this.connected = false;
+                throw error;
+            }
+        }, { "cache.key": key });
+    }
+    async clear() {
+        return withSpan("cache.redis.clear", async () => {
+            try {
+                await this.ensureConnected();
+                const pattern = `${this.prefix}*`;
+                let cursor = "0";
+                let totalDeleted = 0;
+                do {
+                    const result = await this.client.scan(cursor, {
+                        MATCH: pattern,
+                        COUNT: DEFAULT_SCAN_COUNT,
+                    });
+                    cursor = String(result.cursor);
+                    if (result.keys.length > 0) {
+                        totalDeleted += await this.client.del(result.keys);
+                    }
+                } while (cursor !== "0");
+                if (totalDeleted > 0) {
+                    console.log(`[RedisCache] Cleared ${totalDeleted} keys`);
+                }
+                this.hits = 0;
+                this.misses = 0;
+            }
+            catch (error) {
+                console.error("[RedisCache] Clear error:", error);
+                this.connected = false;
+                throw error;
+            }
+        });
+    }
+    async has(key) {
+        return withSpan("cache.redis.has", async () => {
+            try {
+                await this.ensureConnected();
+                const exists = await this.client.exists(this.key(key));
+                return exists === 1;
+            }
+            catch (error) {
+                console.error("[RedisCache] Has error:", error);
+                this.connected = false;
+                throw error;
+            }
+        }, { "cache.key": key });
+    }
+    async stats() {
+        return withSpan("cache.redis.stats", async () => {
+            let size = 0;
+            try {
+                await this.ensureConnected();
+                size = await this.client.dbSize();
+            }
+            catch (error) {
+                this.connected = false;
+                console.warn("[RedisCache] Stats error:", error);
+            }
+            return { hits: this.hits, misses: this.misses, size, type: "redis" };
+        });
+    }
+    async close() {
+        return withSpan("cache.redis.close", async () => {
+            if (this.client) {
+                try {
+                    await this.client.quit();
+                }
+                catch {
+                    // Ignore close errors
+                }
+                this.client = null;
+            }
+            this.connected = false;
+        });
+    }
+    async ensureConnected() {
+        return withSpan("cache.redis.connect", async () => {
+            if (this.connected && this.client) {
+                return;
+            }
+            // Create client with connection options
+            this.client = createClient({
+                url: this.url,
+                socket: {
+                    connectTimeout: this.connectTimeout,
+                    reconnectStrategy: (retries) => {
+                        // Exponential backoff with max 3 retries
+                        if (retries > 3) {
+                            return new Error("Max reconnection attempts reached");
+                        }
+                        return Math.min(retries * 100, 3000);
+                    },
+                },
+            });
+            // Handle connection errors
+            this.client.on("error", (err) => {
+                console.error("[RedisCache] Client error:", err);
+                this.connected = false;
+            });
+            await this.client.connect();
+            this.connected = true;
+            console.log("[RedisCache] Connected");
+        });
+    }
+}

package/esm/proxy/cache/resilient-cache.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Resilient Token Cache
+ *
+ * Wraps a primary cache (Redis) with a fallback cache (Memory).
+ * Automatically falls back to memory cache when Redis operations fail.
+ * Provides graceful degradation instead of hard failures.
+ */
+import type { CacheStats, TokenCache, TokenCacheEntry } from "./types.js";
+export declare class ResilientCache implements TokenCache {
+    private primary;
+    private fallback;
+    private usingFallback;
+    private failureCount;
+    private circuitOpenedAt;
+    constructor(primary: TokenCache, fallback: TokenCache);
+    /**
+     * Check if we should try primary again after circuit was opened.
+     */
+    private shouldTryPrimary;
+    /**
+     * Record a successful primary operation - reset failure state.
+     */
+    private recordSuccess;
+    /**
+     * Record a primary failure - may trigger fallback.
+     */
+    private recordFailure;
+    get(key: string): Promise<TokenCacheEntry | null>;
+    set(key: string, entry: TokenCacheEntry): Promise<void>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+    has(key: string): Promise<boolean>;
+    stats(): Promise<CacheStats>;
+    close(): Promise<void>;
+    /**
+     * Get current resilience status for debugging/health checks.
+     */
+    getStatus(): {
+        usingFallback: boolean;
+        failureCount: number;
+        circuitOpenedAt: number | null;
+    };
+}
+//# sourceMappingURL=resilient-cache.d.ts.map

package/esm/proxy/cache/resilient-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resilient-cache.d.ts","sourceRoot":"","sources":["../../../src/proxy/cache/resilient-cache.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAS1E,qBAAa,cAAe,YAAW,UAAU;IAC/C,OAAO,CAAC,OAAO,CAAa;IAC5B,OAAO,CAAC,QAAQ,CAAa;IAC7B,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,eAAe,CAAuB;gBAElC,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,UAAU;IAKrD;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAexB;;OAEG;IACH,OAAO,CAAC,aAAa;IASrB;;OAEG;IACH,OAAO,CAAC,aAAa;IAcf,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC;IAmBjD,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAkBvD,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAgBlC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAetB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAgBlC,KAAK,IAAI,OAAO,CAAC,UAAU,CAAC;IAwB5B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAM5B;;OAEG;IACH,SAAS,IAAI;QACX,aAAa,EAAE,OAAO,CAAC;QACvB,YAAY,EAAE,MAAM,CAAC;QACrB,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;KAChC;CAOF"}