@happyvertical/smrt-svelte 0.30.0

package/dist/Provider.svelte

@@ -0,0 +1,204 @@
+<script lang="ts">
+import {
+  createI18nContext,
+  type I18nSnapshot,
+  setI18nContext,
+} from '@happyvertical/smrt-ui/i18n';
+import type { Snippet } from 'svelte';
+import { onDestroy, untrack } from 'svelte';
+import AILoadingOverlay from './browser-ai/svelte/components/AILoadingOverlay.svelte';
+import type {
+  AIConfig,
+  AILoadingState,
+  AppMode,
+  SocketConfig,
+  User,
+} from './state/app-state.js';
+import { createAppState } from './state/app-state.svelte.js';
+import { setAppStateContext } from './state/context.js';
+
+interface Props {
+  /**
+   * Initial mode: 'default' | 'smrt'
+   * If not provided, mode is auto-detected based on capabilities
+   */
+  mode?: AppMode;
+  /**
+   * Whether to auto-enable smrt mode when capabilities are available
+   * @default true
+   */
+  autoEnableSmrt?: boolean;
+  /**
+   * User object from smrt-users (from your load function)
+   * Pass null when not authenticated
+   */
+  user?: User | null;
+  /**
+   * Resolved permissions (from PermissionResolver in your load function)
+   */
+  permissions?: string[];
+  /**
+   * WebSocket configuration
+   * If provided, connects on mount and disconnects on unmount
+   */
+  socket?: SocketConfig;
+  /**
+   * AI configuration for preloading and warm clients
+   *
+   * @example
+   * ```svelte
+   * <Provider
+   *   ai={{
+   *     preload: 'idle',
+   *     stt: { type: 'whisper-cpp' },
+   *     showLoadingOverlay: true
+   *   }}
+   * >
+   *   ...
+   * </Provider>
+   * ```
+   */
+  ai?: AIConfig;
+  /**
+   * Callback when capabilities are detected
+   */
+  onReady?: () => void;
+  /**
+   * Callback when mode changes
+   */
+  onModeChange?: (mode: AppMode) => void;
+  /**
+   * Callback when AI loading state changes
+   */
+  onAILoadingChange?: (state: AILoadingState) => void;
+  /**
+   * i18n snapshot from your load function (`buildI18nSnapshot` on
+   * `@happyvertical/smrt-svelte/i18n/server`). Provides the active locale +
+   * resolved message templates to `useI18n()` / `<Trans>`. Omit for
+   * English-default-only rendering.
+   */
+  i18n?: I18nSnapshot;
+  /**
+   * Children to render
+   */
+  children: Snippet;
+}
+
+const {
+  mode,
+  autoEnableSmrt = true,
+  user = null,
+  permissions = [],
+  socket,
+  ai,
+  onReady,
+  onModeChange,
+  onAILoadingChange,
+  i18n,
+  children,
+}: Props = $props();
+
+// Determine if we should show the loading overlay
+const showLoadingOverlay = $derived(ai?.showLoadingOverlay ?? true);
+
+// Create app state
+const appState = createAppState({
+  onCapabilitiesDetected: () => {
+    onReady?.();
+  },
+  onModeChange: (newMode) => {
+    onModeChange?.(newMode);
+  },
+  onAILoadingChange: (state) => {
+    onAILoadingChange?.(state);
+  },
+});
+
+$effect(() => {
+  const currentPreferences = untrack(() => appState.state.session.preferences);
+  if (currentPreferences.autoEnableSmrt === autoEnableSmrt) {
+    return;
+  }
+
+  appState.updateSession({
+    preferences: {
+      ...currentPreferences,
+      autoEnableSmrt,
+    },
+  });
+});
+
+$effect(() => {
+  if (mode) {
+    appState.setMode(mode, 'explicit');
+  }
+});
+
+// Provide context
+setAppStateContext(appState);
+
+// i18n: seed the store from the initial snapshot synchronously (untrack — this
+// MUST run during SSR, where $effect does not, so translated strings render on
+// the server), then keep it in sync when the `i18n` prop changes (locale
+// switch). Reads stay synchronous on the client; all async resolution happened
+// server-side in buildI18nSnapshot.
+const i18nStore = untrack(() => createI18nContext(i18n));
+setI18nContext(i18nStore);
+$effect(() => {
+  if (i18n) {
+    i18nStore.snapshot = i18n;
+  }
+});
+
+// Initialize on mount (untrack to prevent infinite loop)
+// Skip during SSR - browser-ai APIs require browser environment
+$effect(() => {
+  if (typeof window === 'undefined') return;
+  untrack(() => {
+    appState.initialize();
+  });
+});
+
+// Sync user and permissions when they change
+$effect(() => {
+  appState.setUser(user, permissions);
+});
+
+// Manage socket lifecycle (browser-only)
+$effect(() => {
+  if (typeof window === 'undefined') return;
+  if (socket) {
+    // connectSocket already handles disconnecting any existing socket
+    appState.connectSocket(socket);
+
+    // Cleanup when socket prop changes or component unmounts
+    return () => {
+      appState.disconnectSocket();
+    };
+  }
+});
+
+// Update AI config when it changes (for dynamic config updates, browser-only)
+$effect(() => {
+  if (typeof window === 'undefined') return;
+  if (ai) {
+    untrack(() => {
+      appState.setAIConfig(ai);
+    });
+  }
+});
+
+// Cleanup on destroy
+onDestroy(() => {
+  appState.disconnectSocket();
+});
+</script>
+
+{#if ai && showLoadingOverlay}
+  <AILoadingOverlay
+    message={ai.loadingMessage}
+    dismissible={true}
+  />
+{/if}
+
+{@render children()}

package/dist/Provider.svelte.d.ts

@@ -0,0 +1,73 @@
+import { type I18nSnapshot } from '@happyvertical/smrt-ui/i18n';
+import type { Snippet } from 'svelte';
+import type { AIConfig, AILoadingState, AppMode, SocketConfig, User } from './state/app-state.js';
+interface Props {
+    /**
+     * Initial mode: 'default' | 'smrt'
+     * If not provided, mode is auto-detected based on capabilities
+     */
+    mode?: AppMode;
+    /**
+     * Whether to auto-enable smrt mode when capabilities are available
+     * @default true
+     */
+    autoEnableSmrt?: boolean;
+    /**
+     * User object from smrt-users (from your load function)
+     * Pass null when not authenticated
+     */
+    user?: User | null;
+    /**
+     * Resolved permissions (from PermissionResolver in your load function)
+     */
+    permissions?: string[];
+    /**
+     * WebSocket configuration
+     * If provided, connects on mount and disconnects on unmount
+     */
+    socket?: SocketConfig;
+    /**
+     * AI configuration for preloading and warm clients
+     *
+     * @example
+     * ```svelte
+     * <Provider
+     *   ai={{
+     *     preload: 'idle',
+     *     stt: { type: 'whisper-cpp' },
+     *     showLoadingOverlay: true
+     *   }}
+     * >
+     *   ...
+     * </Provider>
+     * ```
+     */
+    ai?: AIConfig;
+    /**
+     * Callback when capabilities are detected
+     */
+    onReady?: () => void;
+    /**
+     * Callback when mode changes
+     */
+    onModeChange?: (mode: AppMode) => void;
+    /**
+     * Callback when AI loading state changes
+     */
+    onAILoadingChange?: (state: AILoadingState) => void;
+    /**
+     * i18n snapshot from your load function (`buildI18nSnapshot` on
+     * `@happyvertical/smrt-svelte/i18n/server`). Provides the active locale +
+     * resolved message templates to `useI18n()` / `<Trans>`. Omit for
+     * English-default-only rendering.
+     */
+    i18n?: I18nSnapshot;
+    /**
+     * Children to render
+     */
+    children: Snippet;
+}
+declare const Provider: import("svelte").Component<Props, {}, "">;
+type Provider = ReturnType<typeof Provider>;
+export default Provider;
+//# sourceMappingURL=Provider.svelte.d.ts.map

package/dist/Provider.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Provider.svelte.d.ts","sourceRoot":"","sources":["../src/Provider.svelte.ts"],"names":[],"mappings":"AAGA,OAAO,EAEL,KAAK,YAAY,EAElB,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAC;AAGtC,OAAO,KAAK,EACV,QAAQ,EACR,cAAc,EACd,OAAO,EACP,YAAY,EACZ,IAAI,EACL,MAAM,sBAAsB,CAAC;AAK9B,UAAU,KAAK;IACb;;;OAGG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IACf;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;OAGG;IACH,IAAI,CAAC,EAAE,IAAI,GAAG,IAAI,CAAC;IACnB;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB;;;OAGG;IACH,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB;;;;;;;;;;;;;;;OAeG;IACH,EAAE,CAAC,EAAE,QAAQ,CAAC;IACd;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB;;OAEG;IACH,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;IACvC;;OAEG;IACH,iBAAiB,CAAC,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,CAAC;IACpD;;;;;OAKG;IACH,IAAI,CAAC,EAAE,YAAY,CAAC;IACpB;;OAEG;IACH,QAAQ,EAAE,OAAO,CAAC;CACnB;AAiID,QAAA,MAAM,QAAQ,2CAAwC,CAAC;AACvD,KAAK,QAAQ,GAAG,UAAU,CAAC,OAAO,QAAQ,CAAC,CAAC;AAC5C,eAAe,QAAQ,CAAC"}

package/dist/__tests__/app-state.test.js

@@ -0,0 +1,156 @@
+/**
+ * Tests for app state types and initial state
+ */
+import { describe, expect, it } from 'vitest';
+import { createInitialState, } from '../state/app-state.js';
+describe('createInitialState', () => {
+    it('creates initial state with correct defaults', () => {
+        const state = createInitialState();
+        expect(state.mode).toBe('default');
+        expect(state.modeSource).toBe('auto');
+        expect(state.initialized).toBe(false);
+        expect(state.error).toBeNull();
+    });
+    it('creates initial session with null user', () => {
+        const state = createInitialState();
+        expect(state.session.user).toBeNull();
+        expect(state.session.isAuthenticated).toBe(false);
+        expect(state.session.permissions).toEqual([]);
+        expect(state.session.preferences).toEqual({});
+    });
+    it('creates initial socket state as disconnected', () => {
+        const state = createInitialState();
+        expect(state.socket.status).toBe('disconnected');
+        expect(state.socket.reconnectAttempts).toBe(0);
+        expect(state.socket.lastError).toBeNull();
+    });
+    it('creates initial AI state as uninitialized', () => {
+        const state = createInitialState();
+        expect(state.ai.stt.initState).toBe('uninitialized');
+        expect(state.ai.tts.initState).toBe('uninitialized');
+        expect(state.ai.llm.initState).toBe('uninitialized');
+    });
+});
+describe('UserSession type', () => {
+    it('allows null user', () => {
+        const session = {
+            user: null,
+            isAuthenticated: false,
+            permissions: [],
+            preferences: {},
+        };
+        expect(session.user).toBeNull();
+        expect(session.isAuthenticated).toBe(false);
+    });
+    it('allows user with permissions', () => {
+        const session = {
+            user: {
+                id: 'user-123',
+                profileId: 'profile-456',
+                email: 'test@example.com',
+                status: 'active',
+                lastLoginAt: null,
+            },
+            isAuthenticated: true,
+            permissions: ['articles.create', 'articles.read'],
+            preferences: {
+                preferredSTT: 'whisper-cpp',
+                autoEnableSmrt: true,
+            },
+        };
+        expect(session.user?.email).toBe('test@example.com');
+        expect(session.isAuthenticated).toBe(true);
+        expect(session.permissions).toContain('articles.create');
+    });
+});
+describe('SocketState type', () => {
+    it('allows all socket statuses', () => {
+        const statuses = [
+            'disconnected',
+            'connecting',
+            'connected',
+            'reconnecting',
+        ];
+        statuses.forEach((status) => {
+            const state = {
+                status,
+                reconnectAttempts: 0,
+                lastError: null,
+            };
+            expect(state.status).toBe(status);
+        });
+    });
+});
+describe('SocketConfig type', () => {
+    it('allows minimal config with just url', () => {
+        const config = {
+            url: 'wss://example.com/ws',
+        };
+        expect(config.url).toBe('wss://example.com/ws');
+        expect(config.reconnect).toBeUndefined();
+        expect(config.onMessage).toBeUndefined();
+    });
+    it('allows full config with all options', () => {
+        const config = {
+            url: 'wss://example.com/ws',
+            reconnect: {
+                enabled: true,
+                maxAttempts: 10,
+                baseDelay: 2000,
+            },
+            onOpen: () => { },
+            onMessage: (data) => console.log(data),
+            onClose: (event) => console.log(event),
+            onError: (event) => console.log(event),
+        };
+        expect(config.url).toBe('wss://example.com/ws');
+        expect(config.reconnect?.enabled).toBe(true);
+        expect(config.reconnect?.maxAttempts).toBe(10);
+    });
+});
+describe('AIConfig type', () => {
+    it('creates initial AI loading state', () => {
+        const state = createInitialState();
+        expect(state.aiLoading.phase).toBe('idle');
+        expect(state.aiLoading.currentAdapter).toBeNull();
+        expect(state.aiLoading.overallProgress).toBe(0);
+        expect(state.aiLoading.message).toBe('');
+        expect(state.aiLoading.loaded).toEqual([]);
+        expect(state.aiLoading.failed).toEqual([]);
+        expect(state.aiLoading.error).toBeNull();
+    });
+});
+describe('AIConfig types', () => {
+    it('allows preload strategies', () => {
+        const strategies = ['none', 'eager', 'idle', 'on-visible'];
+        strategies.forEach((strategy) => {
+            expect(strategy).toBeDefined();
+        });
+    });
+    it('allows STT config', () => {
+        const sttConfig = {
+            type: 'whisper-cpp',
+            model: 'tiny.en',
+            enabled: true,
+        };
+        expect(sttConfig.type).toBe('whisper-cpp');
+        expect(sttConfig.model).toBe('tiny.en');
+    });
+    it('allows TTS config', () => {
+        const ttsConfig = {
+            type: 'browser-synthesis',
+            voice: 'Google UK English Female',
+            enabled: true,
+        };
+        expect(ttsConfig.type).toBe('browser-synthesis');
+    });
+    it('allows LLM config', () => {
+        const llmConfig = {
+            type: 'webllm',
+            model: 'Llama-3.1-8B-Instruct',
+            enabled: true,
+        };
+        expect(llmConfig.type).toBe('webllm');
+        expect(llmConfig.model).toBe('Llama-3.1-8B-Instruct');
+    });
+});

package/dist/__tests__/warm-clients.test.js

@@ -0,0 +1,186 @@
+/**
+ * Tests for warm client cache
+ */
+import { afterEach, describe, expect, it } from 'vitest';
+import { clearAllCaches, getCachedLLM, getCachedSTT, getCachedTTS, getCacheStats, removeCachedLLM, removeCachedSTT, removeCachedTTS, setCachedLLM, setCachedSTT, setCachedTTS, updateLLMCacheState, updateSTTCacheState, updateTTSCacheState, } from '../state/warm-clients.js';
+// Mock adapters for testing
+const createMockSTTAdapter = () => ({
+    type: 'whisper-cpp',
+    dispose: () => Promise.resolve(),
+    ensureInitialized: () => Promise.resolve(),
+    start: () => Promise.resolve(),
+    stop: () => Promise.resolve(),
+    onResult: () => { },
+    onStart: () => { },
+    onEnd: () => { },
+    onError: () => { },
+});
+const createMockTTSAdapter = () => ({
+    type: 'browser-synthesis',
+    dispose: () => Promise.resolve(),
+    ensureInitialized: () => Promise.resolve(),
+    speak: () => Promise.resolve(),
+    stop: () => { },
+    pause: () => { },
+    resume: () => { },
+    getVoices: () => [],
+    onStart: () => { },
+    onEnd: () => { },
+    onError: () => { },
+});
+const createMockLLMAdapter = () => ({
+    type: 'webllm',
+    currentModel: 'test-model',
+    dispose: () => Promise.resolve(),
+    ensureInitialized: () => Promise.resolve(),
+    message: () => Promise.resolve('response'),
+    unloadModel: () => Promise.resolve(),
+});
+describe('warm-clients', () => {
+    afterEach(async () => {
+        await clearAllCaches();
+    });
+    describe('STT cache', () => {
+        it('caches STT adapter', () => {
+            const adapter = createMockSTTAdapter();
+            setCachedSTT('whisper-cpp', adapter);
+            const cached = getCachedSTT('whisper-cpp');
+            expect(cached).toBeDefined();
+            expect(cached?.adapter).toBe(adapter);
+            expect(cached?.initState).toBe('ready');
+            expect(cached?.type).toBe('whisper-cpp');
+        });
+        it('returns undefined for uncached adapter', () => {
+            const cached = getCachedSTT('browser-speech');
+            expect(cached).toBeUndefined();
+        });
+        it('updates cache state', () => {
+            const adapter = createMockSTTAdapter();
+            setCachedSTT('whisper-cpp', adapter);
+            updateSTTCacheState('whisper-cpp', {
+                initState: 'initializing',
+                downloadProgress: {
+                    state: 'downloading',
+                    percent: 50,
+                    bytesLoaded: 50,
+                    bytesTotal: 100,
+                },
+            });
+            const cached = getCachedSTT('whisper-cpp');
+            expect(cached?.initState).toBe('initializing');
+            expect(cached?.downloadProgress?.percent).toBe(50);
+        });
+        it('removes cached adapter', () => {
+            const adapter = createMockSTTAdapter();
+            setCachedSTT('whisper-cpp', adapter);
+            removeCachedSTT('whisper-cpp');
+            const cached = getCachedSTT('whisper-cpp');
+            expect(cached).toBeUndefined();
+        });
+    });
+    describe('TTS cache', () => {
+        it('caches TTS adapter', () => {
+            const adapter = createMockTTSAdapter();
+            setCachedTTS('browser-synthesis', adapter);
+            const cached = getCachedTTS('browser-synthesis');
+            expect(cached).toBeDefined();
+            expect(cached?.adapter).toBe(adapter);
+            expect(cached?.initState).toBe('ready');
+        });
+        it('updates cache state', () => {
+            const adapter = createMockTTSAdapter();
+            setCachedTTS('browser-synthesis', adapter);
+            updateTTSCacheState('browser-synthesis', {
+                initState: 'error',
+                error: new Error('test error'),
+            });
+            const cached = getCachedTTS('browser-synthesis');
+            expect(cached?.initState).toBe('error');
+            expect(cached?.error?.message).toBe('test error');
+        });
+    });
+    describe('LLM cache', () => {
+        it('caches LLM adapter with model ID', () => {
+            const adapter = createMockLLMAdapter();
+            setCachedLLM('webllm', adapter, 'test-model');
+            const cached = getCachedLLM('webllm', 'test-model');
+            expect(cached).toBeDefined();
+            expect(cached?.adapter).toBe(adapter);
+            expect(cached?.initState).toBe('ready');
+        });
+        it('caches LLM adapter without model ID', () => {
+            const adapter = createMockLLMAdapter();
+            setCachedLLM('webllm', adapter);
+            const cached = getCachedLLM('webllm');
+            expect(cached).toBeDefined();
+            expect(cached?.adapter).toBe(adapter);
+        });
+        it('distinguishes between models', () => {
+            const adapter1 = createMockLLMAdapter();
+            const adapter2 = {
+                ...createMockLLMAdapter(),
+                currentModel: 'other-model',
+            };
+            setCachedLLM('webllm', adapter1, 'model-1');
+            setCachedLLM('webllm', adapter2, 'model-2');
+            expect(getCachedLLM('webllm', 'model-1')?.adapter).toBe(adapter1);
+            expect(getCachedLLM('webllm', 'model-2')?.adapter).toBe(adapter2);
+        });
+        it('updates cache state', () => {
+            const adapter = createMockLLMAdapter();
+            setCachedLLM('webllm', adapter, 'test-model');
+            updateLLMCacheState('webllm', 'test-model', {
+                initState: 'initializing',
+                downloadProgress: {
+                    state: 'downloading',
+                    percent: 75,
+                    bytesLoaded: 75,
+                    bytesTotal: 100,
+                },
+            });
+            const cached = getCachedLLM('webllm', 'test-model');
+            expect(cached?.initState).toBe('initializing');
+            expect(cached?.downloadProgress?.percent).toBe(75);
+        });
+        it('removes cached adapter', () => {
+            const adapter = createMockLLMAdapter();
+            setCachedLLM('webllm', adapter, 'test-model');
+            removeCachedLLM('webllm', 'test-model');
+            const cached = getCachedLLM('webllm', 'test-model');
+            expect(cached).toBeUndefined();
+        });
+    });
+    describe('getCacheStats', () => {
+        it('returns empty stats initially', async () => {
+            const stats = getCacheStats();
+            expect(stats.stt.count).toBe(0);
+            expect(stats.tts.count).toBe(0);
+            expect(stats.llm.count).toBe(0);
+        });
+        it('returns correct counts after caching', () => {
+            setCachedSTT('whisper-cpp', createMockSTTAdapter());
+            setCachedSTT('browser-speech', createMockSTTAdapter());
+            setCachedTTS('browser-synthesis', createMockTTSAdapter());
+            setCachedLLM('webllm', createMockLLMAdapter(), 'model-1');
+            const stats = getCacheStats();
+            expect(stats.stt.count).toBe(2);
+            expect(stats.stt.types).toContain('whisper-cpp');
+            expect(stats.stt.types).toContain('browser-speech');
+            expect(stats.tts.count).toBe(1);
+            expect(stats.llm.count).toBe(1);
+            expect(stats.llm.keys).toContain('webllm:model-1');
+        });
+    });
+    describe('clearAllCaches', () => {
+        it('clears all cached adapters', async () => {
+            setCachedSTT('whisper-cpp', createMockSTTAdapter());
+            setCachedTTS('browser-synthesis', createMockTTSAdapter());
+            setCachedLLM('webllm', createMockLLMAdapter());
+            await clearAllCaches();
+            const stats = getCacheStats();
+            expect(stats.stt.count).toBe(0);
+            expect(stats.tts.count).toBe(0);
+            expect(stats.llm.count).toBe(0);
+        });
+    });
+});

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

@@ -0,0 +1,38 @@
+/**
+ * LLM adapter factory with type guards
+ */
+import type { GetLLMOptions, LLMAdapter } from './types.js';
+/**
+ * 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 declare function getLLM(options?: GetLLMOptions): Promise<LLMAdapter>;
+/**
+ * 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 declare function getLLMAuto(options?: Partial<Omit<GetLLMOptions, 'type'>>): Promise<LLMAdapter>;
+/**
+ * Check if a specific LLM backend is available
+ */
+export declare function isLLMAvailable(type: 'webllm' | 'transformers-llm'): boolean;
+/**
+ * Check if WebGPU is available for accelerated inference
+ */
+export declare function hasWebGPU(): boolean;
+//# sourceMappingURL=factory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../../src/browser-ai/adapters/llm/factory.ts"],"names":[],"mappings":"AAAA;;GAEG;AAOH,OAAO,KAAK,EACV,aAAa,EACb,UAAU,EAGX,MAAM,YAAY,CAAC;AAkBpB;;;;;;;;;;;;;GAaG;AACH,wBAAsB,MAAM,CAAC,OAAO,GAAE,aAAkB,GAAG,OAAO,CAAC,UAAU,CAAC,CAe7E;AAED;;;;;;;;GAQG;AACH,wBAAsB,UAAU,CAC9B,OAAO,GAAE,OAAO,CAAC,IAAI,CAAC,aAAa,EAAE,MAAM,CAAC,CAAM,GACjD,OAAO,CAAC,UAAU,CAAC,CAoBrB;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,QAAQ,GAAG,kBAAkB,GAAG,OAAO,CAY3E;AAED;;GAEG;AACH,wBAAgB,SAAS,IAAI,OAAO,CAEnC"}