@happyvertical/smrt-svelte 0.30.0

package/dist/browser-ai/adapters/llm/factory.js

@@ -0,0 +1,91 @@
+/**
+ * LLM adapter factory with type guards
+ */
+import { detectCapabilities, getBestLLMBackend, } from '../../capabilities/detector.js';
+import { UnsupportedAdapterError } from '../../core/errors.js';
+/**
+ * Type guard for WebLLM options
+ */
+function isWebLLMOptions(options) {
+    return !options.type || options.type === 'webllm';
+}
+/**
+ * Type guard for Transformers.js LLM options
+ */
+function isTransformersLLMOptions(options) {
+    return options.type === 'transformers-llm';
+}
+/**
+ * Create an LLM adapter
+ *
+ * Uses lazy loading to only import the requested adapter.
+ *
+ * @example
+ * ```ts
+ * // WebLLM (default)
+ * const llm = await getLLM();
+ *
+ * // With specific model
+ * const llm = await getLLM({ defaultModel: 'Llama-3.2-1B-Instruct-q4f16_1-MLC' });
+ * ```
+ */
+export async function getLLM(options = {}) {
+    if (isWebLLMOptions(options)) {
+        const { WebLLMAdapter } = await import('./webllm.js');
+        return new WebLLMAdapter(options);
+    }
+    if (isTransformersLLMOptions(options)) {
+        // Transformers.js adapter not yet implemented
+        throw new UnsupportedAdapterError('transformers-llm', ['webllm']);
+    }
+    throw new UnsupportedAdapterError(options.type, [
+        'webllm',
+        'transformers-llm',
+    ]);
+}
+/**
+ * Auto-detect and create the best available LLM adapter
+ *
+ * Selection priority:
+ * 1. WebLLM with WebGPU (best performance)
+ * 2. Transformers.js as fallback
+ *
+ * @throws If no LLM adapter is available
+ */
+export async function getLLMAuto(options = {}) {
+    const caps = detectCapabilities();
+    const backend = getBestLLMBackend(caps);
+    if (!backend) {
+        throw new Error('No LLM capability available in this browser');
+    }
+    if (backend === 'webllm') {
+        return getLLM({
+            type: 'webllm',
+            ...options,
+        });
+    }
+    // transformers-llm fallback (not yet implemented)
+    return getLLM({
+        type: 'webllm', // Fall back to webllm even without WebGPU
+        ...options,
+    });
+}
+/**
+ * Check if a specific LLM backend is available
+ */
+export function isLLMAvailable(type) {
+    const caps = detectCapabilities();
+    if (type === 'webllm') {
+        return caps.llm.webllm;
+    }
+    if (type === 'transformers-llm') {
+        return caps.llm.transformersLLM;
+    }
+    return false;
+}
+/**
+ * Check if WebGPU is available for accelerated inference
+ */
+export function hasWebGPU() {
+    return detectCapabilities().llm.webgpu;
+}

package/dist/browser-ai/adapters/llm/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * LLM adapters
+ */
+export * from './factory.js';
+export * from './types.js';
+export { WebLLMAdapter } from './webllm.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/browser-ai/adapters/llm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/browser-ai/adapters/llm/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC"}

package/dist/browser-ai/adapters/llm/index.js

@@ -0,0 +1,6 @@
+/**
+ * LLM adapters
+ */
+export * from './factory.js';
+export * from './types.js';
+export { WebLLMAdapter } from './webllm.js';

package/dist/browser-ai/adapters/llm/types.d.ts

@@ -0,0 +1,182 @@
+/**
+ * LLM adapter types
+ */
+import type { BaseBrowserAIOptions, InitState, OnProgress } from '../../core/types.js';
+/**
+ * LLM message structure (matching standard chat format)
+ */
+export interface LLMMessage {
+    role: 'system' | 'user' | 'assistant';
+    content: string;
+}
+/**
+ * LLM response structure
+ */
+export interface LLMResponse {
+    /** Generated text content */
+    content: string;
+    /** Token usage statistics */
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+    /** Why generation stopped */
+    finishReason?: 'stop' | 'length' | 'error';
+    /** Model used for generation */
+    model?: string;
+}
+/**
+ * LLM model information
+ */
+export interface LLMModel {
+    /** Model identifier */
+    id: string;
+    /** Human-readable name */
+    name: string;
+    /** Maximum context length in tokens */
+    contextLength: number;
+    /** Download size in bytes */
+    downloadSize: number;
+    /** Quantization method (e.g., 'q4f16_1', 'q4f32_1') */
+    quantization?: string;
+    /** VRAM required in bytes */
+    vramRequired?: number;
+}
+/**
+ * LLM adapter capabilities
+ */
+export interface LLMCapabilities {
+    /** Available models */
+    models: LLMModel[];
+    /** Whether streaming is supported */
+    streaming: boolean;
+    /** Maximum context length (of best model) */
+    maxContextLength: number;
+    /** Whether download is required */
+    requiresDownload: boolean;
+    /** Whether WebGPU acceleration is available */
+    webgpu: boolean;
+}
+/**
+ * Options for LLM chat completion
+ */
+export interface LLMChatOptions {
+    /** Model ID to use */
+    model?: string;
+    /** Maximum tokens to generate */
+    maxTokens?: number;
+    /** Sampling temperature (0-2, higher = more creative) */
+    temperature?: number;
+    /** Top-p (nucleus) sampling */
+    topP?: number;
+    /** Stop sequences */
+    stop?: string[];
+    /** Streaming callback for partial results */
+    onToken?: (token: string) => void;
+}
+/**
+ * LLM adapter interface - all LLM implementations must implement this
+ */
+export interface LLMAdapter {
+    /** Adapter type identifier */
+    readonly type: 'webllm' | 'transformers-llm';
+    /** Current initialization state */
+    readonly initState: InitState;
+    /** Currently loaded model ID */
+    readonly currentModel: string | null;
+    /**
+     * Initialize the adapter with a specific model
+     * Downloads model files if not cached
+     */
+    ensureInitialized(modelId?: string, onProgress?: OnProgress): Promise<void>;
+    /**
+     * Get adapter capabilities and available models
+     */
+    getCapabilities(): Promise<LLMCapabilities>;
+    /**
+     * Generate chat completion
+     */
+    chat(messages: LLMMessage[], options?: LLMChatOptions): Promise<LLMResponse>;
+    /**
+     * Generate streaming chat completion
+     */
+    stream(messages: LLMMessage[], options?: LLMChatOptions): AsyncIterable<string>;
+    /**
+     * Simple message interface - single turn conversation
+     */
+    message(text: string, options?: LLMChatOptions & {
+        systemPrompt?: string;
+    }): Promise<string>;
+    /**
+     * Count tokens in text (approximate)
+     */
+    countTokens?(text: string): Promise<number>;
+    /**
+     * Unload current model to free VRAM/memory
+     */
+    unloadModel(): Promise<void>;
+    /**
+     * Dispose of all resources
+     */
+    dispose(): Promise<void>;
+}
+/**
+ * WebLLM adapter options
+ */
+export interface WebLLMOptions extends BaseBrowserAIOptions {
+    type?: 'webllm';
+    /** Default model to load */
+    defaultModel?: string;
+    /** App configuration for WebLLM */
+    appConfig?: any;
+}
+/**
+ * Transformers.js LLM adapter options
+ */
+export interface TransformersLLMOptions extends BaseBrowserAIOptions {
+    type: 'transformers-llm';
+    /** Default model to load */
+    defaultModel?: string;
+}
+/**
+ * Union type for LLM factory options
+ */
+export type GetLLMOptions = WebLLMOptions | TransformersLLMOptions;
+/**
+ * Common small models suitable for browser use
+ */
+export declare const RECOMMENDED_MODELS: {
+    readonly 'smollm2-360m': {
+        readonly id: "SmolLM2-360M-Instruct-q4f16_1-MLC";
+        readonly name: "SmolLM2 360M";
+        readonly contextLength: 2048;
+        readonly downloadSize: number;
+    };
+    readonly 'smollm2-1.7b': {
+        readonly id: "SmolLM2-1.7B-Instruct-q4f16_1-MLC";
+        readonly name: "SmolLM2 1.7B";
+        readonly contextLength: 2048;
+        readonly downloadSize: number;
+    };
+    readonly 'qwen2.5-1.5b': {
+        readonly id: "Qwen2.5-1.5B-Instruct-q4f16_1-MLC";
+        readonly name: "Qwen2.5 1.5B";
+        readonly contextLength: 32768;
+        readonly downloadSize: number;
+    };
+    readonly 'phi-3-mini': {
+        readonly id: "Phi-3-mini-4k-instruct-q4f16_1-MLC";
+        readonly name: "Phi-3 Mini 4K";
+        readonly contextLength: 4096;
+        readonly downloadSize: number;
+    };
+    readonly 'llama-3.2-1b': {
+        readonly id: "Llama-3.2-1B-Instruct-q4f16_1-MLC";
+        readonly name: "Llama 3.2 1B";
+        readonly contextLength: 8192;
+        readonly downloadSize: number;
+    };
+};
+export type RecommendedModelKey = keyof typeof RECOMMENDED_MODELS;
+//# sourceMappingURL=types.d.ts.map

package/dist/browser-ai/adapters/llm/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/browser-ai/adapters/llm/types.ts"],"names":[],"mappings":"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"}

package/dist/browser-ai/adapters/llm/types.js

@@ -0,0 +1,43 @@
+/**
+ * LLM adapter types
+ */
+/**
+ * Common small models suitable for browser use
+ */
+export const RECOMMENDED_MODELS = {
+    // Smallest, fastest
+    'smollm2-360m': {
+        id: 'SmolLM2-360M-Instruct-q4f16_1-MLC',
+        name: 'SmolLM2 360M',
+        contextLength: 2048,
+        downloadSize: 250 * 1024 * 1024, // ~250MB
+    },
+    // Good balance
+    'smollm2-1.7b': {
+        id: 'SmolLM2-1.7B-Instruct-q4f16_1-MLC',
+        name: 'SmolLM2 1.7B',
+        contextLength: 2048,
+        downloadSize: 1.1 * 1024 * 1024 * 1024, // ~1.1GB
+    },
+    // Larger, more capable
+    'qwen2.5-1.5b': {
+        id: 'Qwen2.5-1.5B-Instruct-q4f16_1-MLC',
+        name: 'Qwen2.5 1.5B',
+        contextLength: 32768,
+        downloadSize: 1 * 1024 * 1024 * 1024, // ~1GB
+    },
+    // Phi-3 mini
+    'phi-3-mini': {
+        id: 'Phi-3-mini-4k-instruct-q4f16_1-MLC',
+        name: 'Phi-3 Mini 4K',
+        contextLength: 4096,
+        downloadSize: 2.3 * 1024 * 1024 * 1024, // ~2.3GB
+    },
+    // Llama 3.2
+    'llama-3.2-1b': {
+        id: 'Llama-3.2-1B-Instruct-q4f16_1-MLC',
+        name: 'Llama 3.2 1B',
+        contextLength: 8192,
+        downloadSize: 800 * 1024 * 1024, // ~800MB
+    },
+};

package/dist/browser-ai/adapters/llm/webllm.d.ts

@@ -0,0 +1,33 @@
+/**
+ * WebLLM adapter
+ *
+ * Uses @mlc-ai/web-llm for running LLMs in the browser with WebGPU.
+ * Requires downloading model files (100MB - 4GB+ depending on model).
+ */
+import type { InitState, OnProgress } from '../../core/types.js';
+import type { LLMAdapter, LLMCapabilities, LLMChatOptions, LLMMessage, LLMResponse, WebLLMOptions } from './types.js';
+/**
+ * WebLLM adapter for in-browser LLM inference
+ */
+export declare class WebLLMAdapter implements LLMAdapter {
+    readonly type: "webllm";
+    private _initState;
+    private _currentModel;
+    private options;
+    private engine;
+    constructor(options?: WebLLMOptions);
+    get initState(): InitState;
+    get currentModel(): string | null;
+    ensureInitialized(modelId?: string, onProgress?: OnProgress): Promise<void>;
+    private importWebLLM;
+    getCapabilities(): Promise<LLMCapabilities>;
+    chat(messages: LLMMessage[], options?: LLMChatOptions): Promise<LLMResponse>;
+    stream(messages: LLMMessage[], options?: LLMChatOptions): AsyncIterable<string>;
+    message(text: string, options?: LLMChatOptions & {
+        systemPrompt?: string;
+    }): Promise<string>;
+    countTokens(text: string): Promise<number>;
+    unloadModel(): Promise<void>;
+    dispose(): Promise<void>;
+}
+//# sourceMappingURL=webllm.d.ts.map

package/dist/browser-ai/adapters/llm/webllm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webllm.d.ts","sourceRoot":"","sources":["../../../../src/browser-ai/adapters/llm/webllm.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAQH,OAAO,KAAK,EAEV,SAAS,EACT,UAAU,EACX,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EACV,UAAU,EACV,eAAe,EACf,cAAc,EACd,UAAU,EAEV,WAAW,EACX,aAAa,EACd,MAAM,YAAY,CAAC;AAMpB;;GAEG;AACH,qBAAa,aAAc,YAAW,UAAU;IAC9C,QAAQ,CAAC,IAAI,EAAG,QAAQ,CAAU;IAElC,OAAO,CAAC,UAAU,CAA8B;IAChD,OAAO,CAAC,aAAa,CAAuB;IAC5C,OAAO,CAAC,OAAO,CAAgB;IAG/B,OAAO,CAAC,MAAM,CAAa;gBAEf,OAAO,GAAE,aAAkB;IAOvC,IAAI,SAAS,IAAI,SAAS,CAEzB;IAED,IAAI,YAAY,IAAI,MAAM,GAAG,IAAI,CAEhC;IAEK,iBAAiB,CACrB,OAAO,CAAC,EAAE,MAAM,EAChB,UAAU,CAAC,EAAE,UAAU,GACtB,OAAO,CAAC,IAAI,CAAC;YAoFF,YAAY;IAWpB,eAAe,IAAI,OAAO,CAAC,eAAe,CAAC;IAsB3C,IAAI,CACR,QAAQ,EAAE,UAAU,EAAE,EACtB,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,WAAW,CAAC;IAoChB,MAAM,CACX,QAAQ,EAAE,UAAU,EAAE,EACtB,OAAO,GAAE,cAAmB,GAC3B,aAAa,CAAC,MAAM,CAAC;IA+BlB,OAAO,CACX,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,cAAc,GAAG;QAAE,YAAY,CAAC,EAAE,MAAM,CAAA;KAAO,GACvD,OAAO,CAAC,MAAM,CAAC;IAmBZ,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAM1C,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;IAa5B,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAG/B"}

package/dist/browser-ai/adapters/llm/webllm.js

@@ -0,0 +1,225 @@
+/**
+ * WebLLM adapter
+ *
+ * Uses @mlc-ai/web-llm for running LLMs in the browser with WebGPU.
+ * Requires downloading model files (100MB - 4GB+ depending on model).
+ */
+import { importOptional } from '@happyvertical/smrt-ui/utils/import-optional.js';
+import { CapabilityNotAvailableError, InitializationError, ModelLoadError, } from '../../core/errors.js';
+import { RECOMMENDED_MODELS } from './types.js';
+// Default model - small and fast
+const DEFAULT_MODEL = 'SmolLM2-360M-Instruct-q4f16_1-MLC';
+/**
+ * WebLLM adapter for in-browser LLM inference
+ */
+export class WebLLMAdapter {
+    type = 'webllm';
+    _initState = 'uninitialized';
+    _currentModel = null;
+    options;
+    // WebLLM engine instance
+    engine = null;
+    constructor(options = {}) {
+        this.options = {
+            defaultModel: DEFAULT_MODEL,
+            ...options,
+        };
+    }
+    get initState() {
+        return this._initState;
+    }
+    get currentModel() {
+        return this._currentModel;
+    }
+    async ensureInitialized(modelId, onProgress) {
+        const targetModel = modelId || this.options.defaultModel || DEFAULT_MODEL;
+        // Already loaded with the right model
+        if (this._initState === 'ready' && this._currentModel === targetModel) {
+            return;
+        }
+        // If we have a different model loaded, unload it first
+        if (this._currentModel && this._currentModel !== targetModel) {
+            await this.unloadModel();
+        }
+        if (this._initState === 'initializing') {
+            return new Promise((resolve, reject) => {
+                const check = () => {
+                    if (this._initState === 'ready')
+                        resolve();
+                    else if (this._initState === 'error')
+                        reject(new Error('Initialization failed'));
+                    else
+                        setTimeout(check, 100);
+                };
+                check();
+            });
+        }
+        this._initState = 'initializing';
+        try {
+            // Check WebGPU support
+            if (!('gpu' in navigator)) {
+                throw new CapabilityNotAvailableError('WebGPU', 'webllm');
+            }
+            // Dynamically import WebLLM
+            const webllm = await this.importWebLLM();
+            // Create progress callback wrapper
+            const progressCallback = (report) => {
+                if (!onProgress)
+                    return;
+                const progress = {
+                    state: 'downloading',
+                    bytesLoaded: 0,
+                    bytesTotal: 0,
+                    percent: Math.round(report.progress * 100),
+                    currentFile: report.text,
+                };
+                if (report.progress >= 1) {
+                    progress.state = 'complete';
+                }
+                onProgress(progress);
+            };
+            // Create MLCEngine
+            this.engine = await webllm.CreateMLCEngine(targetModel, {
+                initProgressCallback: progressCallback,
+                appConfig: this.options.appConfig,
+            });
+            this._currentModel = targetModel;
+            this._initState = 'ready';
+            onProgress?.({
+                state: 'complete',
+                bytesLoaded: 100,
+                bytesTotal: 100,
+                percent: 100,
+            });
+        }
+        catch (error) {
+            this._initState = 'error';
+            if (error instanceof Error) {
+                if (error.message.includes('WebGPU')) {
+                    throw new CapabilityNotAvailableError('WebGPU', 'webllm');
+                }
+                throw new ModelLoadError(targetModel, error.message, 'webllm');
+            }
+            throw new InitializationError('webllm', String(error));
+        }
+    }
+    async importWebLLM() {
+        try {
+            return await importOptional('@mlc-ai/web-llm');
+        }
+        catch {
+            throw new InitializationError('webllm', '@mlc-ai/web-llm not installed. Run: npm install @mlc-ai/web-llm');
+        }
+    }
+    async getCapabilities() {
+        const webgpu = typeof navigator !== 'undefined' && 'gpu' in navigator;
+        // Convert recommended models to LLMModel format
+        const models = Object.entries(RECOMMENDED_MODELS).map(([_key, model]) => ({
+            id: model.id,
+            name: model.name,
+            contextLength: model.contextLength,
+            downloadSize: model.downloadSize,
+        }));
+        return {
+            models,
+            streaming: true,
+            maxContextLength: 32768, // Qwen2.5 has highest
+            requiresDownload: true,
+            webgpu,
+        };
+    }
+    async chat(messages, options = {}) {
+        await this.ensureInitialized(options.model);
+        if (!this.engine) {
+            throw new Error('Engine not initialized');
+        }
+        const response = await this.engine.chat.completions.create({
+            messages: messages.map((m) => ({
+                role: m.role,
+                content: m.content,
+            })),
+            model: this._currentModel,
+            max_tokens: options.maxTokens,
+            temperature: options.temperature,
+            top_p: options.topP,
+            stop: options.stop,
+            stream: false,
+        });
+        const choice = response.choices[0];
+        return {
+            content: choice.message?.content || '',
+            usage: response.usage
+                ? {
+                    promptTokens: response.usage.prompt_tokens,
+                    completionTokens: response.usage.completion_tokens,
+                    totalTokens: response.usage.total_tokens,
+                }
+                : undefined,
+            finishReason: choice.finish_reason,
+            model: this._currentModel || undefined,
+        };
+    }
+    async *stream(messages, options = {}) {
+        await this.ensureInitialized(options.model);
+        if (!this.engine) {
+            throw new Error('Engine not initialized');
+        }
+        const stream = await this.engine.chat.completions.create({
+            messages: messages.map((m) => ({
+                role: m.role,
+                content: m.content,
+            })),
+            model: this._currentModel,
+            max_tokens: options.maxTokens,
+            temperature: options.temperature,
+            top_p: options.topP,
+            stop: options.stop,
+            stream: true,
+        });
+        for await (const chunk of stream) {
+            const content = chunk.choices[0]?.delta?.content;
+            if (content) {
+                if (options.onToken) {
+                    options.onToken(content);
+                }
+                yield content;
+            }
+        }
+    }
+    async message(text, options = {}) {
+        const messages = [];
+        if (options.systemPrompt) {
+            messages.push({
+                role: 'system',
+                content: options.systemPrompt,
+            });
+        }
+        messages.push({
+            role: 'user',
+            content: text,
+        });
+        const response = await this.chat(messages, options);
+        return response.content;
+    }
+    async countTokens(text) {
+        // WebLLM doesn't expose tokenizer directly
+        // Use rough estimation: ~4 chars per token for English
+        return Math.ceil(text.length / 4);
+    }
+    async unloadModel() {
+        if (this.engine) {
+            try {
+                await this.engine.unload();
+            }
+            catch {
+                // Ignore unload errors
+            }
+            this.engine = null;
+        }
+        this._currentModel = null;
+        this._initState = 'uninitialized';
+    }
+    async dispose() {
+        await this.unloadModel();
+    }
+}

package/dist/browser-ai/adapters/stt/browser-speech.d.ts

@@ -0,0 +1,31 @@
+import type { InitState, OnProgress } from '../../core/types.js';
+import type { BrowserSpeechSTTOptions, STTAdapter, STTCapabilities, STTOptions, STTResult } from './types.js';
+/**
+ * Browser Speech Recognition adapter
+ */
+export declare class BrowserSpeechSTTAdapter implements STTAdapter {
+    readonly type: "browser-speech";
+    private _initState;
+    private recognition;
+    private options;
+    private _isListening;
+    private resultListeners;
+    private errorListeners;
+    private startListeners;
+    private endListeners;
+    constructor(options?: BrowserSpeechSTTOptions);
+    get initState(): InitState;
+    ensureInitialized(_onProgress?: OnProgress): Promise<void>;
+    private setupRecognitionHandlers;
+    getCapabilities(): STTCapabilities;
+    start(options?: STTOptions): Promise<void>;
+    stop(): Promise<void>;
+    abort(): void;
+    isListening(): boolean;
+    onResult(callback: (result: STTResult) => void): () => void;
+    onError(callback: (error: Error) => void): () => void;
+    onStart(callback: () => void): () => void;
+    onEnd(callback: () => void): () => void;
+    dispose(): Promise<void>;
+}
+//# sourceMappingURL=browser-speech.d.ts.map

package/dist/browser-ai/adapters/stt/browser-speech.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-speech.d.ts","sourceRoot":"","sources":["../../../../src/browser-ai/adapters/stt/browser-speech.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjE,OAAO,KAAK,EACV,uBAAuB,EACvB,UAAU,EACV,eAAe,EACf,UAAU,EACV,SAAS,EACV,MAAM,YAAY,CAAC;AAepB;;GAEG;AACH,qBAAa,uBAAwB,YAAW,UAAU;IACxD,QAAQ,CAAC,IAAI,EAAG,gBAAgB,CAAU;IAE1C,OAAO,CAAC,UAAU,CAA8B;IAChD,OAAO,CAAC,WAAW,CAAkC;IACrD,OAAO,CAAC,OAAO,CAA0B;IACzC,OAAO,CAAC,YAAY,CAAS;IAG7B,OAAO,CAAC,eAAe,CAA0C;IACjE,OAAO,CAAC,cAAc,CAAqC;IAC3D,OAAO,CAAC,cAAc,CAAyB;IAC/C,OAAO,CAAC,YAAY,CAAyB;gBAEjC,OAAO,GAAE,uBAA4B;IAQjD,IAAI,SAAS,IAAI,SAAS,CAEzB;IAEK,iBAAiB,CAAC,WAAW,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAqChE,OAAO,CAAC,wBAAwB;IAwEhC,eAAe,IAAI,eAAe;IA2B5B,KAAK,CAAC,OAAO,GAAE,UAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAqB9C,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAM3B,KAAK,IAAI,IAAI;IAMb,WAAW,IAAI,OAAO;IAItB,QAAQ,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,SAAS,KAAK,IAAI,GAAG,MAAM,IAAI;IAK3D,OAAO,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAAG,MAAM,IAAI;IAKrD,OAAO,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI;IAKzC,KAAK,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI;IAKjC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAS/B"}