@happyvertical/smrt-svelte 0.30.0

package/dist/browser-ai/adapters/stt/browser-speech.js

@@ -0,0 +1,217 @@
+/// <reference path="../../../../web-speech.d.ts" />
+/**
+ * Browser Speech Recognition API adapter
+ *
+ * Uses the Web Speech API (SpeechRecognition) available in most modern browsers.
+ * No download required, works immediately.
+ */
+import { CapabilityNotAvailableError, PermissionDeniedError, } from '../../core/errors.js';
+/**
+ * Get the SpeechRecognition constructor (handles vendor prefix)
+ */
+function getSpeechRecognition() {
+    if (typeof window === 'undefined')
+        return null;
+    return (window.SpeechRecognition ||
+        window.webkitSpeechRecognition ||
+        null);
+}
+/**
+ * Browser Speech Recognition adapter
+ */
+export class BrowserSpeechSTTAdapter {
+    type = 'browser-speech';
+    _initState = 'uninitialized';
+    recognition = null;
+    options;
+    _isListening = false;
+    // Event listeners
+    resultListeners = new Set();
+    errorListeners = new Set();
+    startListeners = new Set();
+    endListeners = new Set();
+    constructor(options = {}) {
+        this.options = {
+            defaultLanguage: 'en-US',
+            maxAlternatives: 3,
+            ...options,
+        };
+    }
+    get initState() {
+        return this._initState;
+    }
+    async ensureInitialized(_onProgress) {
+        if (this._initState === 'ready')
+            return;
+        if (this._initState === 'initializing') {
+            // Wait for existing initialization
+            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, 50);
+                };
+                check();
+            });
+        }
+        this._initState = 'initializing';
+        try {
+            const SpeechRecognitionCtor = getSpeechRecognition();
+            if (!SpeechRecognitionCtor) {
+                throw new CapabilityNotAvailableError('Web Speech API (SpeechRecognition)', 'browser-speech');
+            }
+            this.recognition = new SpeechRecognitionCtor();
+            this.setupRecognitionHandlers();
+            this._initState = 'ready';
+        }
+        catch (error) {
+            this._initState = 'error';
+            throw error;
+        }
+    }
+    setupRecognitionHandlers() {
+        if (!this.recognition)
+            return;
+        this.recognition.onresult = (event) => {
+            for (let i = event.resultIndex; i < event.results.length; i++) {
+                const result = event.results[i];
+                const sttResult = {
+                    text: result[0].transcript,
+                    confidence: result[0].confidence,
+                    isFinal: result.isFinal,
+                    timestamp: Date.now(),
+                    alternatives: Array.from({ length: result.length }, (_, index) => result[index])
+                        .slice(1)
+                        .map((alt) => ({
+                        text: alt.transcript,
+                        confidence: alt.confidence,
+                    })),
+                };
+                for (const cb of this.resultListeners) {
+                    cb(sttResult);
+                }
+            }
+        };
+        this.recognition.onerror = (event) => {
+            let error;
+            switch (event.error) {
+                case 'not-allowed':
+                case 'service-not-allowed':
+                    error = new PermissionDeniedError('microphone', 'browser-speech');
+                    break;
+                case 'no-speech':
+                    error = new Error('No speech detected');
+                    break;
+                case 'audio-capture':
+                    error = new Error('Audio capture failed - check microphone');
+                    break;
+                case 'network':
+                    error = new Error('Network error during speech recognition');
+                    break;
+                case 'aborted':
+                    // User aborted, not really an error
+                    return;
+                default:
+                    error = new Error(`Speech recognition error: ${event.error}`);
+            }
+            for (const cb of this.errorListeners) {
+                cb(error);
+            }
+        };
+        this.recognition.onstart = () => {
+            this._isListening = true;
+            for (const cb of this.startListeners) {
+                cb();
+            }
+        };
+        this.recognition.onend = () => {
+            this._isListening = false;
+            for (const cb of this.endListeners) {
+                cb();
+            }
+        };
+    }
+    getCapabilities() {
+        return {
+            continuous: true,
+            interimResults: true,
+            languages: [
+                'en-US',
+                'en-GB',
+                'en-AU',
+                'es-ES',
+                'es-MX',
+                'fr-FR',
+                'fr-CA',
+                'de-DE',
+                'it-IT',
+                'pt-BR',
+                'pt-PT',
+                'zh-CN',
+                'zh-TW',
+                'ja-JP',
+                'ko-KR',
+                // Many more supported, this is a subset
+            ],
+            accuracy: 'medium',
+            requiresDownload: false,
+        };
+    }
+    async start(options = {}) {
+        await this.ensureInitialized();
+        if (!this.recognition) {
+            throw new Error('Recognition not initialized');
+        }
+        if (this._isListening) {
+            return; // Already listening
+        }
+        // Configure recognition
+        this.recognition.lang =
+            options.language || this.options.defaultLanguage || 'en-US';
+        this.recognition.continuous = options.continuous ?? false;
+        this.recognition.interimResults = options.interimResults ?? true;
+        this.recognition.maxAlternatives = this.options.maxAlternatives || 3;
+        this.recognition.start();
+    }
+    async stop() {
+        if (this.recognition && this._isListening) {
+            this.recognition.stop();
+        }
+    }
+    abort() {
+        if (this.recognition && this._isListening) {
+            this.recognition.abort();
+        }
+    }
+    isListening() {
+        return this._isListening;
+    }
+    onResult(callback) {
+        this.resultListeners.add(callback);
+        return () => this.resultListeners.delete(callback);
+    }
+    onError(callback) {
+        this.errorListeners.add(callback);
+        return () => this.errorListeners.delete(callback);
+    }
+    onStart(callback) {
+        this.startListeners.add(callback);
+        return () => this.startListeners.delete(callback);
+    }
+    onEnd(callback) {
+        this.endListeners.add(callback);
+        return () => this.endListeners.delete(callback);
+    }
+    async dispose() {
+        this.abort();
+        this.recognition = null;
+        this.resultListeners.clear();
+        this.errorListeners.clear();
+        this.startListeners.clear();
+        this.endListeners.clear();
+        this._initState = 'uninitialized';
+    }
+}

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

@@ -0,0 +1,49 @@
+/**
+ * STT adapter factory with type guards
+ *
+ * Uses discriminated unions and lazy loading following SDK patterns.
+ */
+import type { GetSTTOptions, STTAdapter } from './types.js';
+/**
+ * Create an STT adapter
+ *
+ * Uses lazy loading to only import the requested adapter.
+ *
+ * @example
+ * ```ts
+ * // Browser Speech API (default)
+ * const stt = await getSTT();
+ *
+ * // Explicit Browser Speech
+ * const stt = await getSTT({ type: 'browser-speech' });
+ *
+ * // Whisper.cpp (recommended for accuracy)
+ * const stt = await getSTT({ type: 'whisper-cpp', model: 'tiny.en' });
+ *
+ * // Whisper WASM (transformers.js - has known issues)
+ * const stt = await getSTT({ type: 'whisper-wasm', modelSize: 'tiny' });
+ * ```
+ */
+export declare function getSTT(options?: GetSTTOptions): Promise<STTAdapter>;
+/**
+ * Auto-detect and create the best available STT adapter
+ *
+ * Selection priority:
+ * 1. Whisper WASM if WebGPU is available (best accuracy)
+ * 2. Browser Speech API if available (no download)
+ * 3. Whisper WASM as fallback
+ *
+ * @throws {CapabilityNotAvailableError} If no STT adapter is available
+ *
+ * @example
+ * ```ts
+ * const stt = await getSTTAuto();
+ * console.log(`Using ${stt.type} adapter`);
+ * ```
+ */
+export declare function getSTTAuto(options?: Partial<Omit<GetSTTOptions, 'type'>>): Promise<STTAdapter>;
+/**
+ * Check if a specific STT backend is available
+ */
+export declare function isSTTAvailable(type: 'browser-speech' | 'whisper-wasm'): boolean;
+//# sourceMappingURL=factory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../../src/browser-ai/adapters/stt/factory.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAOH,OAAO,KAAK,EAEV,aAAa,EACb,UAAU,EAGX,MAAM,YAAY,CAAC;AA6BpB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,MAAM,CAAC,OAAO,GAAE,aAAkB,GAAG,OAAO,CAAC,UAAU,CAAC,CAqB7E;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,UAAU,CAC9B,OAAO,GAAE,OAAO,CAAC,IAAI,CAAC,aAAa,EAAE,MAAM,CAAC,CAAM,GACjD,OAAO,CAAC,UAAU,CAAC,CAmBrB;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,gBAAgB,GAAG,cAAc,GACtC,OAAO,CAYT"}

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

@@ -0,0 +1,110 @@
+/**
+ * STT adapter factory with type guards
+ *
+ * Uses discriminated unions and lazy loading following SDK patterns.
+ */
+import { detectCapabilities, getBestSTTBackend, } from '../../capabilities/detector.js';
+import { UnsupportedAdapterError } from '../../core/errors.js';
+/**
+ * Type guard for Browser Speech API options
+ */
+function isBrowserSpeechOptions(options) {
+    return !options.type || options.type === 'browser-speech';
+}
+/**
+ * Type guard for Whisper WASM options (transformers.js)
+ */
+function isWhisperWasmOptions(options) {
+    return options.type === 'whisper-wasm';
+}
+/**
+ * Type guard for Whisper.cpp options (@remotion/whisper-web)
+ */
+function isWhisperCppOptions(options) {
+    return options.type === 'whisper-cpp';
+}
+/**
+ * Create an STT adapter
+ *
+ * Uses lazy loading to only import the requested adapter.
+ *
+ * @example
+ * ```ts
+ * // Browser Speech API (default)
+ * const stt = await getSTT();
+ *
+ * // Explicit Browser Speech
+ * const stt = await getSTT({ type: 'browser-speech' });
+ *
+ * // Whisper.cpp (recommended for accuracy)
+ * const stt = await getSTT({ type: 'whisper-cpp', model: 'tiny.en' });
+ *
+ * // Whisper WASM (transformers.js - has known issues)
+ * const stt = await getSTT({ type: 'whisper-wasm', modelSize: 'tiny' });
+ * ```
+ */
+export async function getSTT(options = {}) {
+    if (isBrowserSpeechOptions(options)) {
+        const { BrowserSpeechSTTAdapter } = await import('./browser-speech.js');
+        return new BrowserSpeechSTTAdapter(options);
+    }
+    if (isWhisperCppOptions(options)) {
+        const { WhisperCppSTTAdapter } = await import('./whisper-cpp.js');
+        return new WhisperCppSTTAdapter(options);
+    }
+    if (isWhisperWasmOptions(options)) {
+        const { WhisperWasmSTTAdapter } = await import('./whisper-wasm.js');
+        return new WhisperWasmSTTAdapter(options);
+    }
+    throw new UnsupportedAdapterError(options.type, [
+        'browser-speech',
+        'whisper-cpp',
+        'whisper-wasm',
+    ]);
+}
+/**
+ * Auto-detect and create the best available STT adapter
+ *
+ * Selection priority:
+ * 1. Whisper WASM if WebGPU is available (best accuracy)
+ * 2. Browser Speech API if available (no download)
+ * 3. Whisper WASM as fallback
+ *
+ * @throws {CapabilityNotAvailableError} If no STT adapter is available
+ *
+ * @example
+ * ```ts
+ * const stt = await getSTTAuto();
+ * console.log(`Using ${stt.type} adapter`);
+ * ```
+ */
+export async function getSTTAuto(options = {}) {
+    const caps = detectCapabilities();
+    const backend = getBestSTTBackend(caps);
+    if (!backend) {
+        throw new Error('No STT capability available in this browser');
+    }
+    if (backend === 'whisper-wasm') {
+        return getSTT({
+            type: 'whisper-wasm',
+            ...options,
+        });
+    }
+    return getSTT({
+        type: 'browser-speech',
+        ...options,
+    });
+}
+/**
+ * Check if a specific STT backend is available
+ */
+export function isSTTAvailable(type) {
+    const caps = detectCapabilities();
+    if (type === 'browser-speech') {
+        return caps.stt.browserSpeechAPI;
+    }
+    if (type === 'whisper-wasm') {
+        return caps.stt.whisperWasm;
+    }
+    return false;
+}

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

@@ -0,0 +1,9 @@
+/**
+ * Speech-to-Text adapters
+ */
+export { BrowserSpeechSTTAdapter } from './browser-speech.js';
+export * from './factory.js';
+export * from './types.js';
+export { WhisperCppSTTAdapter } from './whisper-cpp.js';
+export { WhisperWasmSTTAdapter } from './whisper-wasm.js';
+//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -0,0 +1,8 @@
+/**
+ * Speech-to-Text adapters
+ */
+export { BrowserSpeechSTTAdapter } from './browser-speech.js';
+export * from './factory.js';
+export * from './types.js';
+export { WhisperCppSTTAdapter } from './whisper-cpp.js';
+export { WhisperWasmSTTAdapter } from './whisper-wasm.js';

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

@@ -0,0 +1,154 @@
+/**
+ * Speech-to-Text adapter types
+ */
+import type { BaseBrowserAIOptions, InitState, OnProgress } from '../../core/types.js';
+/**
+ * STT recognition result
+ */
+export interface STTResult {
+    /** Transcribed text */
+    text: string;
+    /** Confidence score (0-1), if available */
+    confidence: number;
+    /** Whether this is a final result or interim */
+    isFinal: boolean;
+    /** Alternative transcriptions, if available */
+    alternatives?: Array<{
+        text: string;
+        confidence: number;
+    }>;
+    /** Timestamp of the result */
+    timestamp: number;
+}
+/**
+ * STT adapter capabilities
+ */
+export interface STTCapabilities {
+    /** Whether continuous listening is supported */
+    continuous: boolean;
+    /** Whether interim results are supported */
+    interimResults: boolean;
+    /** Supported languages (BCP-47 codes) */
+    languages: string[];
+    /** Estimated accuracy level */
+    accuracy: 'low' | 'medium' | 'high';
+    /** Whether download is required before use */
+    requiresDownload: boolean;
+    /** Estimated download size in bytes (if requiresDownload) */
+    downloadSize?: number;
+}
+/**
+ * Options for STT recognition session
+ */
+export interface STTOptions {
+    /** Language code (BCP-47, e.g., 'en-US') */
+    language?: string;
+    /** Enable continuous recognition (keep listening after results) */
+    continuous?: boolean;
+    /** Provide interim results as user speaks */
+    interimResults?: boolean;
+}
+/**
+ * STT event callbacks
+ */
+export interface STTEventHandlers {
+    onResult?: (result: STTResult) => void;
+    onError?: (error: Error) => void;
+    onStart?: () => void;
+    onEnd?: () => void;
+    onSoundStart?: () => void;
+    onSoundEnd?: () => void;
+}
+/**
+ * STT adapter interface - all STT implementations must implement this
+ */
+export interface STTAdapter {
+    /** Adapter type identifier */
+    readonly type: 'browser-speech' | 'whisper-wasm' | 'whisper-cpp';
+    /** Current initialization state */
+    readonly initState: InitState;
+    /**
+     * Initialize the adapter (phase 2 of two-phase init)
+     * Downloads models/WASM if required
+     */
+    ensureInitialized(onProgress?: OnProgress): Promise<void>;
+    /**
+     * Get adapter capabilities
+     */
+    getCapabilities(): STTCapabilities;
+    /**
+     * Start listening for speech
+     */
+    start(options?: STTOptions): Promise<void>;
+    /**
+     * Stop listening
+     */
+    stop(): Promise<void>;
+    /**
+     * Abort listening (stops immediately without final result)
+     */
+    abort(): void;
+    /**
+     * Check if currently listening
+     */
+    isListening(): boolean;
+    /**
+     * Subscribe to recognition results
+     * @returns Unsubscribe function
+     */
+    onResult(callback: (result: STTResult) => void): () => void;
+    /**
+     * Subscribe to errors
+     * @returns Unsubscribe function
+     */
+    onError(callback: (error: Error) => void): () => void;
+    /**
+     * Subscribe to start event
+     * @returns Unsubscribe function
+     */
+    onStart(callback: () => void): () => void;
+    /**
+     * Subscribe to end event
+     * @returns Unsubscribe function
+     */
+    onEnd(callback: () => void): () => void;
+    /**
+     * Dispose of resources
+     */
+    dispose(): Promise<void>;
+}
+/**
+ * Browser Speech API adapter options
+ */
+export interface BrowserSpeechSTTOptions extends BaseBrowserAIOptions {
+    type?: 'browser-speech';
+    /** Override default language */
+    defaultLanguage?: string;
+    /** Max alternatives to return */
+    maxAlternatives?: number;
+}
+/**
+ * Whisper WASM adapter options
+ */
+export interface WhisperWasmSTTOptions extends BaseBrowserAIOptions {
+    type: 'whisper-wasm';
+    /** Model size: 'tiny', 'base', 'small' */
+    modelSize?: 'tiny' | 'base' | 'small';
+    /** Custom model URL (overrides modelSize) */
+    modelUrl?: string;
+    /** Language code for transcription */
+    defaultLanguage?: string;
+}
+/**
+ * Whisper.cpp WASM adapter options (using @remotion/whisper-web)
+ */
+export interface WhisperCppSTTOptions extends BaseBrowserAIOptions {
+    type: 'whisper-cpp';
+    /** Model size: 'tiny.en', 'base.en', 'small.en', 'tiny', 'base', 'small' */
+    model?: 'tiny.en' | 'base.en' | 'small.en' | 'tiny' | 'base' | 'small';
+}
+/**
+ * Union type for STT factory options
+ */
+export type GetSTTOptions = BrowserSpeechSTTOptions | WhisperWasmSTTOptions | WhisperCppSTTOptions;
+//# sourceMappingURL=types.d.ts.map

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

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

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

@@ -0,0 +1,4 @@
+/**
+ * Speech-to-Text adapter types
+ */
+export {};

package/dist/browser-ai/adapters/stt/whisper-cpp.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Whisper.cpp adapter using @remotion/whisper-web
+ *
+ * Uses whisper.cpp compiled to WASM for high-accuracy speech recognition.
+ * More stable than transformers.js implementation.
+ */
+import type { InitState, OnProgress } from '../../core/types.js';
+import type { STTAdapter, STTCapabilities, STTOptions, STTResult, WhisperCppSTTOptions } from './types.js';
+/**
+ * Whisper.cpp adapter for high-accuracy speech recognition
+ */
+export declare class WhisperCppSTTAdapter implements STTAdapter {
+    readonly type: "whisper-cpp";
+    private _initState;
+    private options;
+    private _isListening;
+    private mediaRecorder;
+    private audioChunks;
+    private stream;
+    private resultListeners;
+    private errorListeners;
+    private startListeners;
+    private endListeners;
+    private whisperWeb;
+    private modelDownloaded;
+    private processingPromise;
+    private processingResolve;
+    constructor(options?: Partial<WhisperCppSTTOptions>);
+    get initState(): InitState;
+    private get model();
+    ensureInitialized(onProgress?: OnProgress): Promise<void>;
+    private importWhisperWeb;
+    getCapabilities(): STTCapabilities;
+    start(_options?: STTOptions): Promise<void>;
+    private getSupportedMimeType;
+    private processRecording;
+    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=whisper-cpp.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"whisper-cpp.d.ts","sourceRoot":"","sources":["../../../../src/browser-ai/adapters/stt/whisper-cpp.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAOH,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjE,OAAO,KAAK,EACV,UAAU,EACV,eAAe,EACf,UAAU,EACV,SAAS,EACT,oBAAoB,EACrB,MAAM,YAAY,CAAC;AAoBpB;;GAEG;AACH,qBAAa,oBAAqB,YAAW,UAAU;IACrD,QAAQ,CAAC,IAAI,EAAG,aAAa,CAAU;IAEvC,OAAO,CAAC,UAAU,CAA8B;IAChD,OAAO,CAAC,OAAO,CAAuB;IACtC,OAAO,CAAC,YAAY,CAAS;IAG7B,OAAO,CAAC,aAAa,CAA8B;IACnD,OAAO,CAAC,WAAW,CAAc;IACjC,OAAO,CAAC,MAAM,CAA4B;IAG1C,OAAO,CAAC,eAAe,CAA0C;IACjE,OAAO,CAAC,cAAc,CAAqC;IAC3D,OAAO,CAAC,cAAc,CAAyB;IAC/C,OAAO,CAAC,YAAY,CAAyB;IAG7C,OAAO,CAAC,UAAU,CAAa;IAE/B,OAAO,CAAC,eAAe,CAAS;IAGhC,OAAO,CAAC,iBAAiB,CAA8B;IACvD,OAAO,CAAC,iBAAiB,CAA6B;gBAE1C,OAAO,GAAE,OAAO,CAAC,oBAAoB,CAAM;IAQvD,IAAI,SAAS,IAAI,SAAS,CAEzB;IAED,OAAO,KAAK,KAAK,GAEhB;IAEK,iBAAiB,CAAC,UAAU,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;YA8FjD,gBAAgB;IAW9B,eAAe,IAAI,eAAe;IA+B5B,KAAK,CAAC,QAAQ,GAAE,UAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAmDrD,OAAO,CAAC,oBAAoB;YAiBd,gBAAgB;IAyExB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAyB3B,KAAK,IAAI,IAAI;IAmBb,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;CAU/B"}