@revealui/ai 0.1.0

package/dist/llm/providers/openai.js

@@ -0,0 +1,245 @@
+/**
+ * OpenAI Provider
+ *
+ * Implementation of LLMProvider for OpenAI API
+ */
+const authorizationHeader = 'Authorization';
+const openAiOrganizationHeader = 'OpenAI-Organization';
+const maxTokensKey = 'max_tokens';
+const toolChoiceKey = 'tool_choice';
+const toolCallsKey = 'tool_calls';
+const toolCallIdKey = 'tool_call_id';
+const finishReasonKey = 'finish_reason';
+const promptTokensKey = 'prompt_tokens';
+const completionTokensKey = 'completion_tokens';
+const totalTokensKey = 'total_tokens';
+const asRecord = (value) => {
+    if (!value || typeof value !== 'object') {
+        return undefined;
+    }
+    return value;
+};
+const isFunctionToolCall = (call) => {
+    const record = asRecord(call);
+    if (!record || record.type !== 'function' || typeof record.id !== 'string') {
+        return false;
+    }
+    const fn = asRecord(record.function);
+    return !!fn && typeof fn.name === 'string' && typeof fn.arguments === 'string';
+};
+export class OpenAIProvider {
+    config;
+    baseURL;
+    constructor(config) {
+        this.config = config;
+        this.baseURL = config.baseURL || 'https://api.openai.com/v1';
+    }
+    async chat(messages, options) {
+        const response = await fetch(`${this.baseURL}/chat/completions`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                [authorizationHeader]: `Bearer ${this.config.apiKey}`,
+                ...(this.config.organization && {
+                    [openAiOrganizationHeader]: this.config.organization,
+                }),
+            },
+            body: JSON.stringify({
+                model: this.config.model || 'gpt-4o-mini',
+                messages: this.formatMessages(messages),
+                temperature: options?.temperature ?? this.config.temperature ?? 0.7,
+                [maxTokensKey]: options?.maxTokens ?? this.config.maxTokens,
+                tools: options?.tools,
+                [toolChoiceKey]: options?.toolChoice,
+            }),
+        });
+        if (!response.ok) {
+            const errorPayload = (await response.json().catch(() => undefined));
+            const errorRecord = asRecord(errorPayload);
+            const errorDetail = asRecord(errorRecord?.error);
+            const errorMessage = errorDetail && typeof errorDetail.message === 'string'
+                ? errorDetail.message
+                : response.statusText;
+            throw new Error(`OpenAI API error: ${errorMessage}`);
+        }
+        const data = (await response.json());
+        const choice = data.choices?.[0];
+        const choiceRecord = asRecord(choice);
+        const messageRecord = asRecord(choiceRecord?.message);
+        const rawToolCalls = messageRecord?.[toolCallsKey];
+        const toolCalls = Array.isArray(rawToolCalls)
+            ? rawToolCalls.filter(isFunctionToolCall).map((tc) => ({
+                id: tc.id,
+                type: 'function',
+                function: {
+                    name: tc.function.name,
+                    arguments: tc.function.arguments,
+                },
+            }))
+            : undefined;
+        const finishReasonValue = choiceRecord?.[finishReasonKey];
+        const finishReason = typeof finishReasonValue === 'string' ? finishReasonValue : undefined;
+        const usageRecord = asRecord(data.usage);
+        const promptTokens = usageRecord && typeof usageRecord[promptTokensKey] === 'number'
+            ? usageRecord[promptTokensKey]
+            : undefined;
+        const completionTokens = usageRecord && typeof usageRecord[completionTokensKey] === 'number'
+            ? usageRecord[completionTokensKey]
+            : undefined;
+        const totalTokens = usageRecord && typeof usageRecord[totalTokensKey] === 'number'
+            ? usageRecord[totalTokensKey]
+            : undefined;
+        return {
+            content: typeof messageRecord?.content === 'string' ? messageRecord.content : '',
+            role: 'assistant',
+            toolCalls,
+            finishReason,
+            usage: promptTokens !== undefined && completionTokens !== undefined && totalTokens !== undefined
+                ? {
+                    promptTokens,
+                    completionTokens,
+                    totalTokens,
+                }
+                : undefined,
+        };
+    }
+    async embed(text, options) {
+        const texts = Array.isArray(text) ? text : [text];
+        const model = options?.model || 'text-embedding-3-small';
+        const response = await fetch(`${this.baseURL}/embeddings`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                [authorizationHeader]: `Bearer ${this.config.apiKey}`,
+                ...(this.config.organization && {
+                    [openAiOrganizationHeader]: this.config.organization,
+                }),
+            },
+            body: JSON.stringify({
+                model,
+                input: texts,
+            }),
+        });
+        if (!response.ok) {
+            const errorPayload = (await response.json().catch(() => undefined));
+            const errorRecord = asRecord(errorPayload);
+            const errorDetail = asRecord(errorRecord?.error);
+            const errorMessage = errorDetail && typeof errorDetail.message === 'string'
+                ? errorDetail.message
+                : response.statusText;
+            throw new Error(`OpenAI API error: ${errorMessage}`);
+        }
+        const data = (await response.json());
+        const embeddings = (data.data || []).map((item) => {
+            const vector = item.embedding || [];
+            return {
+                vector,
+                dimension: vector.length,
+                model: item.model || model,
+            };
+        });
+        return Array.isArray(text) ? embeddings : embeddings[0];
+    }
+    async *stream(messages, options) {
+        const response = await fetch(`${this.baseURL}/chat/completions`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                [authorizationHeader]: `Bearer ${this.config.apiKey}`,
+                ...(this.config.organization && {
+                    [openAiOrganizationHeader]: this.config.organization,
+                }),
+            },
+            body: JSON.stringify({
+                model: this.config.model || 'gpt-4o-mini',
+                messages: this.formatMessages(messages),
+                temperature: options?.temperature ?? this.config.temperature ?? 0.7,
+                [maxTokensKey]: options?.maxTokens ?? this.config.maxTokens,
+                tools: options?.tools,
+                stream: true,
+            }),
+        });
+        if (!response.ok) {
+            const errorPayload = (await response.json().catch(() => undefined));
+            const errorRecord = asRecord(errorPayload);
+            const errorDetail = asRecord(errorRecord?.error);
+            const errorMessage = errorDetail && typeof errorDetail.message === 'string'
+                ? errorDetail.message
+                : response.statusText;
+            throw new Error(`OpenAI API error: ${errorMessage}`);
+        }
+        const reader = response.body?.getReader();
+        const decoder = new TextDecoder();
+        if (!reader) {
+            throw new Error('Response body is not readable');
+        }
+        let buffer = '';
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                yield { content: '', done: true };
+                break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || '';
+            for (const line of lines) {
+                if (line.startsWith('data: ')) {
+                    const data = line.slice(6);
+                    if (data === '[DONE]') {
+                        yield { content: '', done: true };
+                        return;
+                    }
+                    try {
+                        const parsed = JSON.parse(data);
+                        const choice = parsed.choices?.[0];
+                        const choiceRecord = asRecord(choice);
+                        const deltaRecord = asRecord(choiceRecord?.delta);
+                        if (deltaRecord) {
+                            const deltaToolCalls = Array.isArray(deltaRecord[toolCallsKey])
+                                ? deltaRecord[toolCallsKey].filter(isFunctionToolCall).map((tc) => ({
+                                    id: tc.id,
+                                    type: 'function',
+                                    function: {
+                                        name: tc.function.name,
+                                        arguments: tc.function.arguments,
+                                    },
+                                }))
+                                : undefined;
+                            yield {
+                                content: typeof deltaRecord.content === 'string' ? deltaRecord.content : '',
+                                done: false,
+                                toolCalls: deltaToolCalls,
+                            };
+                        }
+                    }
+                    catch {
+                        // Ignore parse errors for incomplete chunks
+                    }
+                }
+            }
+        }
+    }
+    formatMessages(messages) {
+        return messages.map((msg) => {
+            const formatted = {
+                role: msg.role,
+                content: msg.content,
+            };
+            if (msg.name) {
+                formatted.name = msg.name;
+            }
+            if (msg.toolCalls) {
+                formatted[toolCallsKey] = msg.toolCalls.map((tc) => ({
+                    id: tc.id,
+                    type: tc.type,
+                    function: tc.function,
+                }));
+            }
+            if (msg.toolCallId) {
+                formatted[toolCallIdKey] = msg.toolCallId;
+            }
+            return formatted;
+        });
+    }
+}

package/dist/llm/providers/vultr.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Vultr Inference Provider
+ *
+ * Implements the LLMProvider interface for Vultr Serverless Inference API
+ */
+import type { Embedding, LLMChatOptions, LLMChunk, LLMEmbedOptions, LLMProvider, LLMProviderConfig, LLMResponse, LLMStreamOptions, Message } from './base.js';
+export interface VultrProviderConfig extends LLMProviderConfig {
+    subscriptionId?: string;
+}
+export declare class VultrProvider implements LLMProvider {
+    private config;
+    private baseURL;
+    constructor(config: VultrProviderConfig);
+    chat(messages: Message[], options?: LLMChatOptions): Promise<LLMResponse>;
+    embed(text: string | string[], options?: LLMEmbedOptions): Promise<Embedding | Embedding[]>;
+    stream(messages: Message[], options?: LLMStreamOptions): AsyncIterable<LLMChunk>;
+}
+//# sourceMappingURL=vultr.d.ts.map

package/dist/llm/providers/vultr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vultr.d.ts","sourceRoot":"","sources":["../../../src/llm/providers/vultr.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EACV,SAAS,EACT,cAAc,EACd,QAAQ,EACR,eAAe,EACf,WAAW,EACX,iBAAiB,EACjB,WAAW,EACX,gBAAgB,EAChB,OAAO,EAER,MAAM,WAAW,CAAA;AAElB,MAAM,WAAW,mBAAoB,SAAQ,iBAAiB;IAC5D,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB;AAgBD,qBAAa,aAAc,YAAW,WAAW;IAC/C,OAAO,CAAC,MAAM,CAAqB;IACnC,OAAO,CAAC,OAAO,CAAQ;gBAEX,MAAM,EAAE,mBAAmB;IAKjC,IAAI,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,WAAW,CAAC;IA2DzE,KAAK,CACT,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,EACvB,OAAO,CAAC,EAAE,eAAe,GACxB,OAAO,CAAC,SAAS,GAAG,SAAS,EAAE,CAAC;IAuC5B,MAAM,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,aAAa,CAAC,QAAQ,CAAC;CAkExF"}

package/dist/llm/providers/vultr.js

@@ -0,0 +1,168 @@
+/**
+ * Vultr Inference Provider
+ *
+ * Implements the LLMProvider interface for Vultr Serverless Inference API
+ */
+const authorizationHeader = 'Authorization';
+const contentTypeHeader = 'Content-Type';
+const asRecord = (v) => typeof v === 'object' && v !== null ? v : undefined;
+const isFunctionToolCall = (call) => {
+    const r = asRecord(call);
+    if (!r)
+        return false;
+    return r.type === 'function' && typeof r.id === 'string';
+};
+export class VultrProvider {
+    config;
+    baseURL;
+    constructor(config) {
+        this.config = config;
+        this.baseURL = config.baseURL || 'https://api.vultrinference.com/v1';
+    }
+    async chat(messages, options) {
+        const body = {
+            model: this.config.model,
+            messages: messages.map((m) => ({ role: m.role, content: m.content, name: m.name })),
+            temperature: options?.temperature ?? this.config.temperature ?? 0.7,
+            max_tokens: options?.maxTokens ?? this.config.maxTokens,
+            tools: options?.tools,
+        };
+        const res = await fetch(`${this.baseURL}/chat/completions`, {
+            method: 'POST',
+            headers: {
+                [contentTypeHeader]: 'application/json',
+                [authorizationHeader]: `Bearer ${this.config.apiKey}`,
+            },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok) {
+            const json = await res.json().catch(() => undefined);
+            const rec = asRecord(json);
+            const err = rec && typeof rec.error === 'string' ? rec.error : res.statusText;
+            throw new Error(`Vultr API error: ${err}`);
+        }
+        const data = (await res.json());
+        const choice = Array.isArray(data.choices) ? data.choices[0] : undefined;
+        const choiceRec = asRecord(choice);
+        const message = asRecord(choiceRec?.message);
+        // Parse tool calls if present
+        let toolCalls;
+        if (message && Array.isArray(message.tool_calls || message.toolCalls)) {
+            const raw = (message.tool_calls || message.toolCalls);
+            toolCalls = raw.filter(isFunctionToolCall).map((tc) => {
+                const r = asRecord(tc) ?? {};
+                const fn = asRecord(r.function);
+                return {
+                    id: String(r.id),
+                    type: 'function',
+                    function: {
+                        name: typeof fn?.name === 'string' ? fn?.name : '',
+                        arguments: typeof fn?.arguments === 'string'
+                            ? fn?.arguments
+                            : JSON.stringify(fn?.arguments ?? {}),
+                    },
+                };
+            });
+        }
+        return {
+            content: typeof message?.content === 'string' ? message.content : '',
+            role: 'assistant',
+            toolCalls,
+            finishReason: undefined,
+        };
+    }
+    async embed(text, options) {
+        // Vultr may support embeddings on some models. Try /embeddings endpoint if available.
+        const inputs = Array.isArray(text) ? text : [text];
+        const model = options?.model || this.config.model;
+        const res = await fetch(`${this.baseURL}/embeddings`, {
+            method: 'POST',
+            headers: {
+                [contentTypeHeader]: 'application/json',
+                [authorizationHeader]: `Bearer ${this.config.apiKey}`,
+            },
+            body: JSON.stringify({ model, input: inputs }),
+        });
+        if (!res.ok) {
+            const json = await res.json().catch(() => undefined);
+            const rec = asRecord(json);
+            // If embeddings not supported, throw a clear error
+            if (res.status === 404 || (rec?.error && typeof rec.error === 'string')) {
+                throw new Error('Vultr embeddings not available for this configuration');
+            }
+            throw new Error(`Vultr embeddings API error: ${res.statusText}`);
+        }
+        const data = (await res.json());
+        const items = Array.isArray(data.data) ? data.data : [];
+        const embeddings = items.map((it) => {
+            const rec = asRecord(it);
+            const vector = Array.isArray(rec?.embedding) ? rec?.embedding : [];
+            return {
+                vector,
+                dimension: vector.length,
+                model: typeof rec?.model === 'string' ? rec?.model : String(model),
+            };
+        });
+        return Array.isArray(text) ? embeddings : embeddings[0];
+    }
+    async *stream(messages, options) {
+        const body = {
+            model: this.config.model,
+            messages: messages.map((m) => ({ role: m.role, content: m.content, name: m.name })),
+            temperature: options?.temperature ?? this.config.temperature ?? 0.7,
+            max_tokens: options?.maxTokens ?? this.config.maxTokens,
+            stream: true,
+        };
+        const res = await fetch(`${this.baseURL}/chat/completions`, {
+            method: 'POST',
+            headers: {
+                [contentTypeHeader]: 'application/json',
+                [authorizationHeader]: `Bearer ${this.config.apiKey}`,
+            },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok) {
+            const json = await res.json().catch(() => undefined);
+            const rec = asRecord(json);
+            const err = rec && typeof rec.error === 'string' ? rec.error : res.statusText;
+            throw new Error(`Vultr streaming error: ${err}`);
+        }
+        const reader = res.body?.getReader();
+        const decoder = new TextDecoder();
+        if (!reader) {
+            throw new Error('Response body is not readable');
+        }
+        let buffer = '';
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                yield { content: '', done: true };
+                break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || '';
+            for (const line of lines) {
+                if (line.startsWith('data: ')) {
+                    const data = line.slice(6);
+                    if (data === '[DONE]') {
+                        yield { content: '', done: true };
+                        return;
+                    }
+                    try {
+                        const parsed = JSON.parse(data);
+                        const choice = Array.isArray(parsed.choices) ? parsed.choices[0] : undefined;
+                        // Vultr uses OpenAI-compatible SSE format: delta not message
+                        const delta = asRecord(asRecord(choice)?.delta);
+                        if (delta && typeof delta.content === 'string') {
+                            yield { content: delta.content, done: false };
+                        }
+                    }
+                    catch {
+                        // ignore partial JSON
+                    }
+                }
+            }
+        }
+    }
+}

package/dist/llm/response-cache.d.ts

@@ -0,0 +1,166 @@
+/**
+ * Response Cache for LLM Providers
+ *
+ * Application-level caching for LLM responses. Works with any provider.
+ * Provides 100% cost savings on cache hits vs Anthropic's 90% token-level savings.
+ *
+ * Use cases:
+ * - Vultr (doesn't have prompt caching)
+ * - OpenAI (doesn't have prompt caching)
+ * - Any provider without built-in caching
+ * - Supplement to Anthropic prompt caching for exact duplicates
+ *
+ * Features:
+ * - LRU eviction policy
+ * - Configurable TTL (default: 5 minutes)
+ * - SHA-256 based cache keys
+ * - Hit/miss statistics
+ * - Memory-efficient storage
+ */
+import type { Message, ToolCall, ToolDefinition } from './providers/base.js';
+export interface CachedResponse {
+    content: string;
+    role: 'assistant';
+    finishReason?: 'stop' | 'length' | 'tool_calls' | 'content_filter';
+    toolCalls?: ToolCall[];
+    timestamp: number;
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+}
+export interface ResponseCacheOptions {
+    /** Maximum number of cached responses (default: 1000) */
+    max?: number;
+    /** Time to live in milliseconds (default: 5 minutes) */
+    ttl?: number;
+    /** Enable cache statistics tracking (default: true) */
+    enableStats?: boolean;
+}
+export interface CacheStats {
+    hits: number;
+    misses: number;
+    evictions: number;
+    hitRate: number;
+    size: number;
+}
+/**
+ * Response cache for LLM completions
+ *
+ * @example
+ * ```typescript
+ * const cache = new ResponseCache({ max: 1000, ttl: 5 * 60 * 1000 })
+ *
+ * const key = cache.getCacheKey(messages, options)
+ * const cached = cache.get(key)
+ *
+ * if (cached) {
+ *   return { ...cached, cached: true }
+ * }
+ *
+ * const response = await llm.chat(messages, options)
+ * cache.set(key, response)
+ * ```
+ */
+export declare class ResponseCache {
+    private cache;
+    private stats;
+    private enableStats;
+    constructor(options?: ResponseCacheOptions);
+    /**
+     * Generate cache key from messages and options
+     *
+     * Uses SHA-256 hash of JSON-serialized payload for:
+     * - Consistent key generation
+     * - Fixed-length keys (64 chars)
+     * - Security (prevents key enumeration)
+     */
+    getCacheKey(messages: Message[], options?: {
+        temperature?: number;
+        maxTokens?: number;
+        tools?: ToolDefinition[];
+        model?: string;
+    }): string;
+    /**
+     * Get cached response
+     *
+     * @returns Cached response or undefined if not found/expired
+     */
+    get(key: string): CachedResponse | undefined;
+    /**
+     * Store response in cache
+     */
+    set(key: string, response: CachedResponse): void;
+    /**
+     * Check if key exists in cache (without updating stats)
+     */
+    has(key: string): boolean;
+    /**
+     * Remove entry from cache
+     */
+    delete(key: string): boolean;
+    /**
+     * Clear all cached responses
+     */
+    clear(): void;
+    /**
+     * Get cache statistics
+     */
+    getStats(): CacheStats;
+    /**
+     * Reset statistics
+     */
+    resetStats(): void;
+    /**
+     * Get cache size (number of entries)
+     */
+    get size(): number;
+    /**
+     * Get maximum cache size
+     */
+    get maxSize(): number;
+}
+/**
+ * Get or create global response cache
+ *
+ * @example
+ * ```typescript
+ * const cache = getGlobalResponseCache()
+ * const stats = cache.getStats()
+ * // Hit rate: ${stats.hitRate}%
+ * ```
+ */
+export declare function getGlobalResponseCache(options?: ResponseCacheOptions): ResponseCache;
+/**
+ * Clear global response cache
+ */
+export declare function clearGlobalResponseCache(): void;
+/**
+ * Calculate cost savings from response caching
+ *
+ * @example
+ * ```typescript
+ * const stats = cache.getStats()
+ * const savings = calculateResponseCacheSavings(stats, {
+ *   avgInputTokens: 3000,
+ *   avgOutputTokens: 500,
+ *   inputCostPerM: 3.0,
+ *   outputCostPerM: 15.0,
+ * })
+ *
+ * // Saved: $${savings.totalSaved.toFixed(2)}
+ * // Avoided ${savings.tokensAvoided.toLocaleString()} tokens
+ * ```
+ */
+export declare function calculateResponseCacheSavings(stats: CacheStats, pricing: {
+    avgInputTokens: number;
+    avgOutputTokens: number;
+    inputCostPerM: number;
+    outputCostPerM: number;
+}): {
+    totalSaved: number;
+    tokensAvoided: number;
+    requestsAvoided: number;
+};
+//# sourceMappingURL=response-cache.d.ts.map

package/dist/llm/response-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response-cache.d.ts","sourceRoot":"","sources":["../../src/llm/response-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAIH,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AAE5E,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,WAAW,CAAA;IACjB,YAAY,CAAC,EAAE,MAAM,GAAG,QAAQ,GAAG,YAAY,GAAG,gBAAgB,CAAA;IAClE,SAAS,CAAC,EAAE,QAAQ,EAAE,CAAA;IACtB,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,CAAC,EAAE;QACN,YAAY,EAAE,MAAM,CAAA;QACpB,gBAAgB,EAAE,MAAM,CAAA;QACxB,WAAW,EAAE,MAAM,CAAA;KACpB,CAAA;CACF;AAED,MAAM,WAAW,oBAAoB;IACnC,yDAAyD;IACzD,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,wDAAwD;IACxD,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,uDAAuD;IACvD,WAAW,CAAC,EAAE,OAAO,CAAA;CACtB;AAED,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,MAAM,CAAA;IACd,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;CACb;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,KAAK,CAAkC;IAC/C,OAAO,CAAC,KAAK,CAAqD;IAClE,OAAO,CAAC,WAAW,CAAS;gBAEhB,OAAO,GAAE,oBAAyB;IAqB9C;;;;;;;OAOG;IACH,WAAW,CACT,QAAQ,EAAE,OAAO,EAAE,EACnB,OAAO,CAAC,EAAE;QACR,WAAW,CAAC,EAAE,MAAM,CAAA;QACpB,SAAS,CAAC,EAAE,MAAM,CAAA;QAClB,KAAK,CAAC,EAAE,cAAc,EAAE,CAAA;QACxB,KAAK,CAAC,EAAE,MAAM,CAAA;KACf,GACA,MAAM;IAqBT;;;;OAIG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS;IAiB5C;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,GAAG,IAAI;IAShD;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIzB;;OAEG;IACH,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAI5B;;OAEG;IACH,KAAK,IAAI,IAAI;IASb;;OAEG;IACH,QAAQ,IAAI,UAAU;IAatB;;OAEG;IACH,UAAU,IAAI,IAAI;IAQlB;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;OAEG;IACH,IAAI,OAAO,IAAI,MAAM,CAEpB;CACF;AAQD;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,CAAC,EAAE,oBAAoB,GAAG,aAAa,CAKpF;AAED;;GAEG;AACH,wBAAgB,wBAAwB,IAAI,IAAI,CAI/C;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE;IACP,cAAc,EAAE,MAAM,CAAA;IACtB,eAAe,EAAE,MAAM,CAAA;IACvB,aAAa,EAAE,MAAM,CAAA;IACrB,cAAc,EAAE,MAAM,CAAA;CACvB,GACA;IACD,UAAU,EAAE,MAAM,CAAA;IAClB,aAAa,EAAE,MAAM,CAAA;IACrB,eAAe,EAAE,MAAM,CAAA;CACxB,CAcA"}