@happyvertical/smrt-svelte 0.55.5 → 0.55.7

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

@@ -0,0 +1,111 @@
+import type { DownloadProgressInfo } from '../../core/types.js';
+/** Where the speech model comes from by default (kept for `whisper-local`). */
+export declare const WHISPER_LOCAL_DEFAULT_MODEL = "onnx-community/whisper-tiny.en";
+/**
+ * Bytes a first download of the default model takes: the 8-bit encoder
+ * (~10 MB), merged decoder (~31 MB) and tokenizer/config files (~4 MB).
+ */
+export declare const WHISPER_LOCAL_DEFAULT_SIZE_BYTES = 45100000;
+/** A model this package knows by a short name. */
+export interface LocalSpeechModelPreset {
+    /** Hugging Face model id. */
+    id: string;
+    /** Approximate first-download size in bytes (8-bit weights + tokenizer). */
+    bytes: number;
+    /** Transcribes English only (its decoder takes no `language`). */
+    englishOnly: boolean;
+    label: string;
+}
+/**
+ * Short names for `model`. Moonshine is the fastest for live dictation;
+ * Whisper `.en` is the longer-established English model.
+ */
+export declare const LOCAL_SPEECH_MODELS: Readonly<Record<string, LocalSpeechModelPreset>>;
+/** Resolve a short name (`moonshine-tiny`) or a Hugging Face id. */
+export declare function resolveLocalSpeechModelId(model?: string): string;
+/** Whether a model id only transcribes English. */
+export declare function isEnglishOnlyLocalSpeechModel(modelId: string): boolean;
+export type LocalSpeechDevice = 'webgpu' | 'wasm';
+/** @deprecated Use {@link LocalSpeechDevice}. */
+export type WhisperLocalDevice = LocalSpeechDevice;
+export interface LocalSpeechModelOptions {
+    /**
+     * A short name (`'moonshine-tiny'`, `'moonshine-base'`, `'whisper-tiny.en'`,
+     * ...) or a Hugging Face model id. Default `onnx-community/whisper-tiny.en`.
+     */
+    model?: string;
+    /** Alias of `model`, kept from `createWhisperLocalModel`. */
+    modelId?: string;
+    /**
+     * `'auto'` (default): WebGPU when available, else single-thread WASM.
+     * With a worker, the worker entry decides (see `local-speech.worker.ts`).
+     */
+    device?: 'auto' | LocalSpeechDevice;
+    /** Weight quantisation. Default `'q8'`. Page-thread only, as `device`. */
+    dtype?: string;
+    /** Make the Web Worker (see `local-speech.worker.ts`). */
+    createWorker?: () => Worker;
+    /**
+     * Load `@happyvertical/speech/local`, e.g.
+     * `() => import('@happyvertical/speech/local')`. A bundled browser app
+     * needs it; plain `import()` of the bare name only works where Node (or
+     * an import map) resolves it.
+     */
+    loadSpeech?: () => Promise<unknown>;
+    /**
+     * Load `@huggingface/transformers` when running on the page's thread,
+     * e.g. `() => import('@huggingface/transformers')`.
+     */
+    loadModule?: () => Promise<unknown>;
+    allowLocalModels?: boolean;
+}
+/** @deprecated Use {@link LocalSpeechModelOptions}. */
+export type WhisperLocalModelOptions = LocalSpeechModelOptions;
+export interface LocalSpeechLoadOptions {
+    onProgress?: (progress: DownloadProgressInfo) => void;
+    /**
+     * Cancel the download. With a worker the download stops (the worker is
+     * ended); on the page's own thread the promise rejects and the files
+     * already fetched stay cached.
+     */
+    signal?: AbortSignal;
+}
+/** @deprecated Use {@link LocalSpeechLoadOptions}. */
+export type WhisperLocalLoadOptions = LocalSpeechLoadOptions;
+export type LocalSpeechModelState = 'idle' | 'loading' | 'ready' | 'error';
+/** @deprecated Use {@link LocalSpeechModelState}. */
+export type WhisperLocalModelState = LocalSpeechModelState;
+export declare class LocalSpeechModel {
+    private readonly options;
+    readonly modelId: string;
+    private backend;
+    private loadPromise;
+    private listeners;
+    private _state;
+    constructor(options?: LocalSpeechModelOptions);
+    get state(): LocalSpeechModelState;
+    get ready(): boolean;
+    /** Transcribes English only (no `language` is sent to the engine). */
+    get englishOnly(): boolean;
+    /** Bytes a first download takes (an estimate; cached models take none). */
+    estimateSize(): number;
+    private emit;
+    private onEngineProgress;
+    private getBackend;
+    /** Whether the model files are already stored on this device. */
+    isCached(): Promise<boolean>;
+    /**
+     * Download (if needed) and prepare the model. Safe to call again: a ready
+     * model returns at once and a load in flight is shared.
+     */
+    load(options?: LocalSpeechLoadOptions): Promise<void>;
+    /** Transcribe 16 kHz mono PCM. The model must be loaded. */
+    transcribe(audio: Float32Array, language?: string): Promise<string>;
+    dispose(): void;
+}
+/** @deprecated Use {@link LocalSpeechModel}. */
+export { LocalSpeechModel as WhisperLocalModel };
+export declare function createLocalSpeechModel(options?: LocalSpeechModelOptions): LocalSpeechModel;
+/** @deprecated Use {@link createLocalSpeechModel}. */
+export declare const createWhisperLocalModel: typeof createLocalSpeechModel;
+//# sourceMappingURL=local-speech-model.d.ts.map

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

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

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

@@ -0,0 +1,377 @@
+/**
+ * The downloadable on-device speech model behind `whisper-local` and
+ * `moonshine`, as a handle a consent UI can drive before anything is spoken:
+ *
+ * ```ts
+ * const model = createLocalSpeechModel({ model: 'moonshine-tiny', createWorker });
+ * const bytes = model.estimateSize();            // "Download 32 MB?"
+ * if (await model.isCached()) { ... }            // already on this device
+ * await model.load({ onProgress, signal });      // downloads, then ready
+ * createSttDictationSource({ type: 'moonshine', modelHandle: model });
+ * ```
+ *
+ * The engine is `@happyvertical/speech/local` (`LocalTranscriber`, or its
+ * worker host `serveLocalTranscriber` when `createWorker` is given). The
+ * files live in Cache Storage, so a later `load()` (even in a new tab) is
+ * quick. Passing the handle to an adapter shares the one loaded pipeline
+ * rather than loading a second copy.
+ *
+ * `@happyvertical/speech` and `@huggingface/transformers` are OPTIONAL
+ * peers. This module never imports them statically: a host supplies
+ * `loadSpeech` (and, without a worker, `loadModule`), or builds the worker
+ * from `@happyvertical/smrt-svelte/browser-ai/whisper-worker?worker`.
+ */
+import { importOptional } from '@happyvertical/smrt-ui/utils/import-optional.js';
+import { InitializationError } from '../../core/errors.js';
+import { configureTransformersEnv } from './transformers-env.js';
+/** Where the speech model comes from by default (kept for `whisper-local`). */
+export const WHISPER_LOCAL_DEFAULT_MODEL = 'onnx-community/whisper-tiny.en';
+/**
+ * Bytes a first download of the default model takes: the 8-bit encoder
+ * (~10 MB), merged decoder (~31 MB) and tokenizer/config files (~4 MB).
+ */
+export const WHISPER_LOCAL_DEFAULT_SIZE_BYTES = 45_100_000;
+/**
+ * Short names for `model`. Moonshine is the fastest for live dictation;
+ * Whisper `.en` is the longer-established English model.
+ */
+export const LOCAL_SPEECH_MODELS = {
+    'moonshine-tiny': {
+        id: 'onnx-community/moonshine-tiny-ONNX',
+        bytes: 32_200_000,
+        englishOnly: true,
+        label: 'Moonshine tiny',
+    },
+    'moonshine-base': {
+        id: 'onnx-community/moonshine-base-ONNX',
+        bytes: 67_000_000,
+        englishOnly: true,
+        label: 'Moonshine base',
+    },
+    'whisper-tiny.en': {
+        id: WHISPER_LOCAL_DEFAULT_MODEL,
+        bytes: WHISPER_LOCAL_DEFAULT_SIZE_BYTES,
+        englishOnly: true,
+        label: 'Whisper tiny (English)',
+    },
+    'whisper-base.en': {
+        id: 'onnx-community/whisper-base.en',
+        bytes: 85_000_000,
+        englishOnly: true,
+        label: 'Whisper base (English)',
+    },
+    'whisper-small.en': {
+        id: 'onnx-community/whisper-small.en',
+        bytes: 260_000_000,
+        englishOnly: true,
+        label: 'Whisper small (English)',
+    },
+};
+/** Resolve a short name (`moonshine-tiny`) or a Hugging Face id. */
+export function resolveLocalSpeechModelId(model) {
+    if (!model)
+        return WHISPER_LOCAL_DEFAULT_MODEL;
+    return LOCAL_SPEECH_MODELS[model]?.id ?? model;
+}
+/** Whether a model id only transcribes English. */
+export function isEnglishOnlyLocalSpeechModel(modelId) {
+    return (Object.values(LOCAL_SPEECH_MODELS).some((preset) => preset.id === modelId && preset.englishOnly) || /\.en$|moonshine/i.test(modelId));
+}
+const PCM_MIME = 'audio/pcm;rate=16000;channels=1;encoding=f32le';
+function abortError() {
+    const error = new Error('Download cancelled');
+    error.name = 'AbortError';
+    return error;
+}
+/** `en-CA` -> `en`; Whisper wants the two-letter code. */
+function languageCode(language) {
+    return language?.split(/[-_]/)[0]?.toLowerCase() || undefined;
+}
+function pcmRequest(pcm) {
+    // The worker takes ownership of what it is sent: hand over a copy.
+    const bytes = new Uint8Array(pcm.slice().buffer);
+    return { data: bytes, mimeType: PCM_MIME };
+}
+async function loadSpeechModule(loadSpeech) {
+    try {
+        return (await (loadSpeech
+            ? loadSpeech()
+            : importOptional('@happyvertical/speech/local')));
+    }
+    catch (error) {
+        throw new InitializationError('local-speech', '@happyvertical/speech could not be loaded. Install it (and ' +
+            '@huggingface/transformers) and pass ' +
+            '`loadSpeech: () => import("@happyvertical/speech/local")`.');
+    }
+}
+class WorkerBackend {
+    createWorker;
+    loadSpeech;
+    progress;
+    worker = null;
+    client = null;
+    constructor(createWorker, loadSpeech, progress) {
+        this.createWorker = createWorker;
+        this.loadSpeech = loadSpeech;
+        this.progress = progress;
+    }
+    ensure() {
+        this.client ??= loadSpeechModule(this.loadSpeech).then((speech) => {
+            const worker = this.createWorker();
+            this.worker = worker;
+            return new speech.LocalTranscriberWorkerClient(worker, {
+                onProgress: this.progress,
+            });
+        });
+        return this.client;
+    }
+    async isCached(model) {
+        const client = await this.ensure();
+        return client.isCached(model);
+    }
+    async preload(model, signal) {
+        if (signal?.aborted)
+            throw abortError();
+        const client = await this.ensure();
+        if (!signal)
+            return client.preload(model);
+        // The only way to stop a download in a worker is to end the worker.
+        const onAbort = () => this.dispose();
+        signal.addEventListener('abort', onAbort, { once: true });
+        try {
+            await Promise.race([
+                client.preload(model),
+                new Promise((_, reject) => signal.addEventListener('abort', () => reject(abortError()), {
+                    once: true,
+                })),
+            ]);
+        }
+        finally {
+            signal.removeEventListener('abort', onAbort);
+        }
+    }
+    async transcribe(pcm, model, language) {
+        const client = await this.ensure();
+        const result = await client.transcribe({
+            audio: pcmRequest(pcm),
+            model,
+            language: languageCode(language),
+        });
+        return result.text.trim();
+    }
+    dispose() {
+        this.client?.then((client) => client.close()).catch(() => undefined);
+        this.worker?.terminate();
+        this.worker = null;
+        this.client = null;
+    }
+}
+class InPageBackend {
+    options;
+    model;
+    progress;
+    transcriber = null;
+    constructor(options, model, progress) {
+        this.options = options;
+        this.model = model;
+        this.progress = progress;
+    }
+    ensure() {
+        this.transcriber ??= loadSpeechModule(this.options.loadSpeech).then((speech) => new speech.LocalTranscriber({
+            model: this.model,
+            device: this.options.device ?? 'auto',
+            dtype: this.options.dtype ?? 'q8',
+            ...(this.options.loadModule
+                ? { transformers: this.options.loadModule }
+                : {}),
+            onProgress: this.progress,
+            configureEnv: configureTransformersEnv(this.options.allowLocalModels ?? false),
+        }));
+        return this.transcriber;
+    }
+    async isCached(model) {
+        const transcriber = await this.ensure();
+        return transcriber.isCached(model);
+    }
+    async preload(model, signal) {
+        if (signal?.aborted)
+            throw abortError();
+        const transcriber = await this.ensure();
+        // `preload` stops waiting on abort; the files fetched stay cached.
+        await transcriber.preload(model, signal).catch((error) => {
+            if (signal?.aborted)
+                throw abortError();
+            throw error;
+        });
+    }
+    async transcribe(pcm, model, language) {
+        const transcriber = await this.ensure();
+        const result = await transcriber.transcribe({
+            audio: pcmRequest(pcm),
+            model,
+            language: languageCode(language),
+        });
+        return result.text.trim();
+    }
+    dispose() {
+        this.transcriber?.then((t) => t.dispose()).catch(() => undefined);
+        this.transcriber = null;
+    }
+}
+export class LocalSpeechModel {
+    options;
+    modelId;
+    backend = null;
+    loadPromise = null;
+    listeners = new Set();
+    _state = 'idle';
+    constructor(options = {}) {
+        this.options = options;
+        this.modelId = resolveLocalSpeechModelId(options.model ?? options.modelId);
+    }
+    get state() {
+        return this._state;
+    }
+    get ready() {
+        return this._state === 'ready';
+    }
+    /** Transcribes English only (no `language` is sent to the engine). */
+    get englishOnly() {
+        return isEnglishOnlyLocalSpeechModel(this.modelId);
+    }
+    /** Bytes a first download takes (an estimate; cached models take none). */
+    estimateSize() {
+        return (Object.values(LOCAL_SPEECH_MODELS).find((p) => p.id === this.modelId)
+            ?.bytes ?? WHISPER_LOCAL_DEFAULT_SIZE_BYTES);
+    }
+    emit(progress) {
+        for (const listener of this.listeners)
+            listener(progress);
+    }
+    onEngineProgress = (event) => {
+        if (event.status !== 'progress_total' ||
+            typeof event.loaded !== 'number' ||
+            typeof event.total !== 'number') {
+            return;
+        }
+        const total = this.estimateSize();
+        const bytesTotal = event.total || total;
+        // All bytes are in: what remains is compiling the model ("Getting ready").
+        const finished = event.total > 0 && event.loaded >= event.total;
+        this.emit({
+            state: finished ? 'extracting' : 'downloading',
+            bytesLoaded: event.loaded,
+            bytesTotal,
+            percent: event.total ? Math.round((event.loaded / event.total) * 100) : 0,
+            currentFile: event.file,
+        });
+    };
+    getBackend() {
+        if (this.backend)
+            return this.backend;
+        const { createWorker, loadSpeech } = this.options;
+        this.backend = createWorker
+            ? new WorkerBackend(createWorker, loadSpeech, this.onEngineProgress)
+            : new InPageBackend(this.options, this.modelId, this.onEngineProgress);
+        return this.backend;
+    }
+    /** Whether the model files are already stored on this device. */
+    async isCached() {
+        if (this._state === 'ready')
+            return true;
+        try {
+            return await this.getBackend().isCached(this.modelId);
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Download (if needed) and prepare the model. Safe to call again: a ready
+     * model returns at once and a load in flight is shared.
+     */
+    load(options = {}) {
+        const { onProgress, signal } = options;
+        if (this._state === 'ready')
+            return Promise.resolve();
+        if (onProgress)
+            this.listeners.add(onProgress);
+        if (!this.loadPromise) {
+            this._state = 'loading';
+            const total = this.estimateSize();
+            this.emit({
+                state: 'downloading',
+                bytesLoaded: 0,
+                bytesTotal: total,
+                percent: 0,
+            });
+            this.loadPromise = this.getBackend()
+                .preload(this.modelId, signal)
+                .then(() => {
+                this._state = 'ready';
+                this.emit({
+                    state: 'complete',
+                    bytesLoaded: total,
+                    bytesTotal: total,
+                    percent: 100,
+                });
+            })
+                .catch((error) => {
+                this._state = 'idle';
+                // A cancelled worker is gone; start fresh next time.
+                this.backend?.dispose();
+                this.backend = null;
+                const err = error instanceof Error ? error : new Error(String(error));
+                if (err.name !== 'AbortError') {
+                    this._state = 'error';
+                    this.emit({
+                        state: 'error',
+                        bytesLoaded: 0,
+                        bytesTotal: total,
+                        percent: 0,
+                        error: err.message,
+                    });
+                }
+                throw err;
+            })
+                .finally(() => {
+                this.loadPromise = null;
+                this.listeners.clear();
+            });
+        }
+        const shared = this.loadPromise;
+        if (!signal)
+            return shared;
+        // Each caller's own signal rejects its own promise; the load stops only
+        // when the backend can (worker) and the call that owns it aborts.
+        return new Promise((resolve, reject) => {
+            if (signal.aborted)
+                return reject(abortError());
+            signal.addEventListener('abort', () => reject(abortError()), {
+                once: true,
+            });
+            shared.then(resolve, reject);
+        });
+    }
+    /** Transcribe 16 kHz mono PCM. The model must be loaded. */
+    transcribe(audio, language) {
+        if (this._state !== 'ready') {
+            return Promise.reject(new Error('The speech model is not loaded'));
+        }
+        return this.getBackend().transcribe(audio, this.modelId, language);
+    }
+    dispose() {
+        this.backend?.dispose();
+        this.backend = null;
+        this.loadPromise = null;
+        this.listeners.clear();
+        this._state = 'idle';
+    }
+}
+/** @deprecated Use {@link LocalSpeechModel}. */
+export { LocalSpeechModel as WhisperLocalModel };
+export function createLocalSpeechModel(options = {}) {
+    return new LocalSpeechModel(options);
+}
+/** @deprecated Use {@link createLocalSpeechModel}. */
+export const createWhisperLocalModel = createLocalSpeechModel;

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

@@ -0,0 +1,82 @@
+/**
+ * On-device speech-to-text (`whisper-local`, alias `whisper-wasm`, and
+ * `moonshine`).
+ *
+ * For browsers whose own speech recognition is missing or unreliable
+ * (Firefox, Brave). It is push-to-talk: `start()` records from the
+ * microphone, `stop()` ends the recording and transcribes it with a Whisper
+ * or Moonshine model running in the browser (WebGPU when available,
+ * single-thread WASM otherwise, in a Web Worker when the host supplies one),
+ * then emits one final result. `transcribePcm()` transcribes one finished
+ * utterance directly, which smrt-ui's hands-free dictation uses. The engine
+ * is `@happyvertical/speech/local`; the model is a one-time download kept in
+ * Cache Storage; see `LocalSpeechModel` for the consent/progress API.
+ */
+import { type DictationAudioCaptureFactory } from '@happyvertical/smrt-ui/forms';
+import type { InitState, OnProgress } from '../../core/types.js';
+import { type LocalSpeechLoadOptions, type LocalSpeechModel } from './local-speech-model.js';
+import type { LocalSpeechSTTOptions, STTAdapter, STTCapabilities, STTOptions, STTResult } from './types.js';
+export declare class LocalSpeechSTTAdapter implements STTAdapter {
+    readonly type: 'whisper-local' | 'whisper-wasm' | 'moonshine';
+    /**
+     * `Dictation` waits this long for the text after the person stops.
+     */
+    readonly stopTimeoutMs = 90000;
+    private readonly options;
+    private readonly _model;
+    private readonly makeCapture;
+    private capture;
+    private captureOff;
+    private _isListening;
+    private language;
+    private session;
+    private starting;
+    private stopping;
+    private resultListeners;
+    private errorListeners;
+    private startListeners;
+    private endListeners;
+    constructor(options?: Partial<LocalSpeechSTTOptions> & {
+        /** Test seam: the microphone recorder. */
+        capture?: DictationAudioCaptureFactory;
+    });
+    /** The downloadable model, for consent UIs. */
+    get model(): LocalSpeechModel;
+    get initState(): InitState;
+    estimateSize(): number;
+    isCached(): Promise<boolean>;
+    load(options?: LocalSpeechLoadOptions): Promise<void>;
+    ensureInitialized(onProgress?: OnProgress): Promise<void>;
+    /**
+     * Make the model ready for dictation without ever downloading it: a model
+     * already loaded is used, one stored on this device is loaded from there,
+     * and anything else rejects with `ModelNotDownloadedError`. The host asks
+     * for consent and calls `load()` itself.
+     */
+    prepare(): Promise<void>;
+    getCapabilities(): STTCapabilities;
+    /**
+     * Transcribe one finished utterance (16 kHz mono PCM). Loads the model
+     * first if it is not ready. This is what hands-free dictation calls for
+     * each utterance the voice activity detector cuts out.
+     */
+    transcribePcm(pcm: Float32Array, options?: {
+        language?: string;
+    }): Promise<string>;
+    start(options?: STTOptions): Promise<void>;
+    /** End the recording, transcribe it, emit the final result, then end. */
+    stop(): Promise<void>;
+    private finish;
+    private emitError;
+    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>;
+}
+/** @deprecated Use {@link LocalSpeechSTTAdapter}. */
+/** @deprecated Use {@link LocalSpeechSTTAdapter}. */
+export { LocalSpeechSTTAdapter as WhisperLocalSTTAdapter, LocalSpeechSTTAdapter as WhisperWasmSTTAdapter, };
+//# sourceMappingURL=local-speech.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"local-speech.d.ts","sourceRoot":"","sources":["../../../../src/browser-ai/adapters/stt/local-speech.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,EAGL,KAAK,4BAA4B,EAClC,MAAM,8BAA8B,CAAC;AAEtC,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjE,OAAO,EAEL,KAAK,sBAAsB,EAC3B,KAAK,gBAAgB,EACtB,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EACV,qBAAqB,EACrB,UAAU,EACV,eAAe,EACf,UAAU,EACV,SAAS,EACV,MAAM,YAAY,CAAC;AAgCpB,qBAAa,qBAAsB,YAAW,UAAU;IACtD,QAAQ,CAAC,IAAI,EAAE,eAAe,GAAG,cAAc,GAAG,WAAW,CAAC;IAC9D;;OAEG;IACH,QAAQ,CAAC,aAAa,SAAmB;IAEzC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAwB;IAChD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAmB;IAC1C,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA+B;IAC3D,OAAO,CAAC,OAAO,CAAsC;IACrD,OAAO,CAAC,UAAU,CAA6B;IAC/C,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,QAAQ,CAAQ;IACxB,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,QAAQ,CAA8B;IAE9C,OAAO,CAAC,eAAe,CAA0C;IACjE,OAAO,CAAC,cAAc,CAAqC;IAC3D,OAAO,CAAC,cAAc,CAAyB;IAC/C,OAAO,CAAC,YAAY,CAAyB;gBAG3C,OAAO,GAAE,OAAO,CAAC,qBAAqB,CAAC,GAAG;QACxC,0CAA0C;QAC1C,OAAO,CAAC,EAAE,4BAA4B,CAAC;KACnC;IA+BR,+CAA+C;IAC/C,IAAI,KAAK,IAAI,gBAAgB,CAE5B;IAED,IAAI,SAAS,IAAI,SAAS,CAWzB;IAED,YAAY,IAAI,MAAM;IAItB,QAAQ,IAAI,OAAO,CAAC,OAAO,CAAC;IAI5B,IAAI,CAAC,OAAO,CAAC,EAAE,sBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC;IAI/C,iBAAiB,CAAC,UAAU,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAM/D;;;;;OAKG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ9B,eAAe,IAAI,eAAe;IA0BlC;;;;OAIG;IACG,aAAa,CACjB,GAAG,EAAE,YAAY,EACjB,OAAO,GAAE;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAO,GAClC,OAAO,CAAC,MAAM,CAAC;IAQZ,KAAK,CAAC,OAAO,GAAE,UAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAwCpD,yEAAyE;IACzE,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;YAsBP,MAAM;IAwBpB,OAAO,CAAC,SAAS;IAIjB,KAAK,IAAI,IAAI;IAab,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;AAED,qDAAqD;AACrD,qDAAqD;AACrD,OAAO,EACL,qBAAqB,IAAI,sBAAsB,EAC/C,qBAAqB,IAAI,qBAAqB,GAC/C,CAAC"}