@happyvertical/smrt-svelte 0.51.11 → 0.51.13

package/dist/browser-ai/adapters/llm/bitgpu-inference-backend.test.js

@@ -0,0 +1,464 @@
+/**
+ * The `bitgpu` inference backend.
+ *
+ * Beyond the sibling WebLLM suite's invariants, these three are what make this
+ * backend worth having:
+ *
+ * 1. **`signal` is forwarded.** bitgpu is the only backend in this package that
+ *    can abort a live generation, so losing the option would make the one
+ *    cancellation-capable path behave like the ones that cannot cancel.
+ * 2. **A turn before `load()` fails with a named reason.** These weights run from
+ *    hundreds of MB to multiple GB; an implicit download behind the first turn is
+ *    the failure this refuses to have.
+ * 3. **Progress maps onto the mirrored shape**, so `DownloadProgress` renders it
+ *    without acquiring a second vocabulary.
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { createBitGpuInferenceBackend, } from './bitgpu-inference-backend.js';
+const originalNavigator = Object.getOwnPropertyDescriptor(globalThis, 'navigator');
+/** jsdom has no `navigator.gpu`; detectCapabilities keys off `'gpu' in navigator`. */
+function withWebGpu() {
+    Object.defineProperty(globalThis, 'navigator', {
+        value: { ...globalThis.navigator, gpu: {} },
+        configurable: true,
+    });
+}
+function makeModules() {
+    let onProgress;
+    let engineFailure = null;
+    let markEngineReady = () => { };
+    const whenEngineReady = new Promise((resolve) => {
+        markEngineReady = resolve;
+    });
+    const d = {
+        engineCalls: 0,
+        chatCalls: 0,
+        sends: [],
+        streams: [],
+        disposed: 0,
+        emitProgress: (report) => onProgress?.(report),
+        failEngine: (error) => {
+            engineFailure = error;
+        },
+        streamDeltas: ['Hel', 'lo'],
+        finishReason: 'stop',
+        whenEngineReady,
+    };
+    const engine = {
+        dispose() {
+            d.disposed += 1;
+        },
+    };
+    // Typed as the interfaces the backend declares, so the compiler checks the
+    // double rather than a cast asserting it.
+    const bitgpu = {
+        async createEngine(options) {
+            d.engineCalls += 1;
+            if (engineFailure)
+                throw engineFailure;
+            onProgress = typeof options === 'string' ? undefined : options.onProgress;
+            markEngineReady();
+            return engine;
+        },
+        WebGPUUnavailableError: class extends Error {
+        },
+    };
+    const chatModule = {
+        async createChat() {
+            d.chatCalls += 1;
+            return {
+                async send(messages, options) {
+                    d.sends.push({ messages, options });
+                    return { text: 'reply', finishReason: d.finishReason };
+                },
+                async *stream(messages, options) {
+                    d.streams.push({ messages, options });
+                    for (const delta of d.streamDeltas)
+                        yield delta;
+                    return {
+                        text: d.streamDeltas.join(''),
+                        finishReason: d.finishReason,
+                    };
+                },
+            };
+        },
+    };
+    return {
+        options: {
+            loadBitGpu: async () => bitgpu,
+            loadChat: async () => chatModule,
+        },
+        d,
+    };
+}
+async function expectPathError(run, code) {
+    const error = await run().then(() => undefined, (thrown) => thrown);
+    expect(error).toMatchObject({ name: 'InferencePathError', code });
+}
+const USER = [{ role: 'user', content: 'hi' }];
+describe('createBitGpuInferenceBackend', () => {
+    beforeEach(() => {
+        Object.defineProperty(globalThis, 'navigator', {
+            value: { ...globalThis.navigator },
+            configurable: true,
+        });
+    });
+    afterEach(() => {
+        if (originalNavigator) {
+            Object.defineProperty(globalThis, 'navigator', originalNavigator);
+        }
+    });
+    it('reports unavailable without WebGPU', () => {
+        const { options } = makeModules();
+        const backend = createBitGpuInferenceBackend(options);
+        expect(backend.status).toBe('unavailable');
+        expect(backend.kind).toBe('local');
+    });
+    it('refuses to load without WebGPU rather than starting a doomed download', async () => {
+        const { options, d } = makeModules();
+        const backend = createBitGpuInferenceBackend(options);
+        await expectPathError(() => backend.load(), 'no_usable_backend');
+        expect(d.engineCalls).toBe(0);
+    });
+    it('reports idle before load and ready after', async () => {
+        withWebGpu();
+        const { options } = makeModules();
+        const backend = createBitGpuInferenceBackend(options);
+        expect(backend.status).toBe('idle');
+        await backend.load();
+        expect(backend.status).toBe('ready');
+    });
+    it('reports loading before the first await resolves', () => {
+        withWebGpu();
+        const { options } = makeModules();
+        const backend = createBitGpuInferenceBackend(options);
+        // `idle` is the state auto-selection is told to skip, so the window between
+        // clicking Load and the engine resolving must not report it.
+        void backend.load();
+        expect(backend.status).toBe('loading');
+    });
+    it('maps a bytes report onto the mirrored progress shape', async () => {
+        withWebGpu();
+        const { options, d } = makeModules();
+        const backend = createBitGpuInferenceBackend(options);
+        const seen = [];
+        const load = backend.load((p) => seen.push(p));
+        await d.whenEngineReady;
+        d.emitProgress({ phase: 'weights', loaded: 50, total: 200 });
+        expect(backend.progress).toMatchObject({
+            state: 'downloading',
+            bytesLoaded: 50,
+            bytesTotal: 200,
+            percent: 25,
+            currentFile: 'weights',
+        });
+        await load;
+        expect(seen[0]).toMatchObject({ percent: 25 });
+        // Cleared once the model is usable.
+        expect(backend.progress).toBeUndefined();
+    });
+    it('reports the pipeline phase as unpacking, without inventing a percent', async () => {
+        withWebGpu();
+        const { options, d } = makeModules();
+        const backend = createBitGpuInferenceBackend(options);
+        const load = backend.load();
+        await d.whenEngineReady;
+        d.emitProgress({ phase: 'pipelines' });
+        expect(backend.progress).toMatchObject({ state: 'extracting', percent: 0 });
+        await load;
+    });
+    it('reports error status and the failure when a load rejects', async () => {
+        withWebGpu();
+        const { options, d } = makeModules();
+        d.failEngine(new Error('out of GPU memory'));
+        const backend = createBitGpuInferenceBackend(options);
+        await expect(backend.load()).rejects.toThrow('out of GPU memory');
+        expect(backend.status).toBe('error');
+        expect(backend.progress).toMatchObject({
+            state: 'error',
+            error: 'out of GPU memory',
+        });
+    });
+    it('re-enters on a retry after a failed load', async () => {
+        withWebGpu();
+        const { options, d } = makeModules();
+        d.failEngine(new Error('transient'));
+        const backend = createBitGpuInferenceBackend(options);
+        await expect(backend.load()).rejects.toThrow('transient');
+        d.failEngine(null);
+        await backend.load();
+        // The second attempt must start a new engine, not replay the rejection.
+        expect(d.engineCalls).toBe(2);
+        expect(backend.status).toBe('ready');
+    });
+    it('shares one load between concurrent callers', async () => {
+        withWebGpu();
+        const { options, d } = makeModules();
+        const backend = createBitGpuInferenceBackend(options);
+        await Promise.all([backend.load(), backend.load(), backend.load()]);
+        expect(d.engineCalls).toBe(1);
+    });
+    it('is a no-op when the engine is already ready', async () => {
+        withWebGpu();
+        const { options, d } = makeModules();
+        const backend = createBitGpuInferenceBackend(options);
+        await backend.load();
+        expect(d.engineCalls).toBe(1);
+        // `load` is documented as a no-op when already ready. A second call that
+        // re-entered would fetch the weights again and orphan the live engine,
+        // since nothing disposes the reference it replaces.
+        await backend.load();
+        expect(d.engineCalls).toBe(1);
+        expect(d.chatCalls).toBe(1);
+        expect(d.disposed).toBe(0);
+        expect(backend.status).toBe('ready');
+    });
+    it('retries after a loader that throws synchronously', async () => {
+        withWebGpu();
+        const { options } = makeModules();
+        let failing = true;
+        const backend = createBitGpuInferenceBackend({
+            ...options,
+            loadBitGpu: () => {
+                // Synchronous, not a rejected promise: legal for the declared
+                // `() => Promise<BitGpuModule>` and what an absent module shim does.
+                if (failing)
+                    throw new Error('bitgpu is not installed');
+                return options.loadBitGpu();
+            },
+        });
+        await expect(backend.load()).rejects.toThrow('bitgpu is not installed');
+        expect(backend.status).toBe('error');
+        failing = false;
+        await backend.load();
+        // A synchronous throw settles the load body before it is stored, so a
+        // cached rejection here would replay on every later attempt.
+        expect(backend.status).toBe('ready');
+    });
+    it('discards a load that overlaps an unload', async () => {
+        withWebGpu();
+        const { options, d } = makeModules();
+        const backend = createBitGpuInferenceBackend(options);
+        const pending = backend.load();
+        await backend.unload();
+        await pending;
+        // Publishing the engine here would report `ready` with a live GPU device
+        // nothing disposes, and a later `load()` would no-op on it.
+        expect(backend.status).toBe('idle');
+        expect(d.disposed).toBe(1);
+    });
+    it('stays idle when a load rejects after an unload', async () => {
+        withWebGpu();
+        const { options, d } = makeModules();
+        d.failEngine(new Error('out of GPU memory'));
+        const backend = createBitGpuInferenceBackend(options);
+        const pending = backend.load();
+        await backend.unload();
+        await expect(pending).rejects.toThrow('out of GPU memory');
+        // The caller cancelled the work, so the backend must not report an error
+        // for it — and `unload()` already cleared any prior failure.
+        expect(backend.status).toBe('idle');
+        expect(backend.progress).toBeUndefined();
+    });
+    it('starts real work when load() follows an unload', async () => {
+        withWebGpu();
+        const { options, d } = makeModules();
+        const backend = createBitGpuInferenceBackend(options);
+        const discarded = backend.load();
+        await backend.unload();
+        // Issued while the discarded attempt is still pending: handing back that
+        // attempt's promise would resolve this call without loading anything.
+        const second = backend.load();
+        await Promise.all([discarded, second]);
+        expect(d.engineCalls).toBe(2);
+        expect(backend.status).toBe('ready');
+    });
+    it('disposes the engine it created when createChat fails', async () => {
+        withWebGpu();
+        const { options, d } = makeModules();
+        const backend = createBitGpuInferenceBackend({
+            ...options,
+            // The tokenizer comes from a different host than the manifest, so a
+            // failing `createChat` is the documented real failure after the engine
+            // already exists.
+            loadChat: async () => ({
+                async createChat() {
+                    throw new Error('tokenizer 404');
+                },
+            }),
+        });
+        await expect(backend.load()).rejects.toThrow('tokenizer 404');
+        // Nothing else holds the engine, so the abandoned attempt must release it —
+        // otherwise every retry allocates another GPU device over the leaked one.
+        expect(d.disposed).toBe(1);
+        expect(backend.status).toBe('error');
+    });
+    it('keeps the load failure when the teardown throws', async () => {
+        withWebGpu();
+        const { options } = makeModules();
+        const backend = createBitGpuInferenceBackend({
+            ...options,
+            loadBitGpu: async () => ({
+                async createEngine() {
+                    return {
+                        dispose() {
+                            throw new Error('device lost');
+                        },
+                    };
+                },
+                WebGPUUnavailableError: class extends Error {
+                },
+            }),
+            loadChat: async () => ({
+                async createChat() {
+                    throw new Error('tokenizer 404');
+                },
+            }),
+        });
+        // The teardown runs while abandoning the attempt; its own error must not
+        // replace the failure the caller is owed, nor skip recording it.
+        await expect(backend.load()).rejects.toThrow('tokenizer 404');
+        expect(backend.status).toBe('error');
+    });
+    it('refuses a turn before load, naming what is missing', async () => {
+        withWebGpu();
+        const { options, d } = makeModules();
+        const backend = createBitGpuInferenceBackend(options);
+        await expectPathError(() => backend.chat([...USER]), 'no_usable_backend');
+        expect(d.sends).toEqual([]);
+    });
+    it('forwards messages and options, and maps the result', async () => {
+        withWebGpu();
+        const { options, d } = makeModules();
+        const backend = createBitGpuInferenceBackend(options);
+        await backend.load();
+        const response = await backend.chat([...USER], {
+            maxTokens: 64,
+            temperature: 0.4,
+            topP: 0.9,
+            stop: 'END',
+        });
+        expect(d.sends[0].messages).toEqual([{ role: 'user', content: 'hi' }]);
+        expect(d.sends[0].options).toMatchObject({
+            maxTokens: 64,
+            temperature: 0.4,
+            topP: 0.9,
+            // bitgpu takes an array of stop sequences; a scalar is normalized.
+            stopSequences: ['END'],
+        });
+        expect(response).toEqual({ content: 'reply', finishReason: 'stop' });
+    });
+    it('omits an abort finish reason the mirrored response has no member for', async () => {
+        withWebGpu();
+        const { options, d } = makeModules();
+        const backend = createBitGpuInferenceBackend(options);
+        await backend.load();
+        d.finishReason = 'abort';
+        // `AIResponse.finishReason` has no `'abort'` member — a completed response
+        // simply carries none rather than inventing one.
+        await expect(backend.chat([...USER])).resolves.toEqual({
+            content: 'reply',
+        });
+    });
+    it('forwards the caller signal — the one thing WebLLM cannot do', async () => {
+        withWebGpu();
+        const { options, d } = makeModules();
+        const backend = createBitGpuInferenceBackend(options);
+        await backend.load();
+        const controller = new AbortController();
+        for await (const _chunk of backend.stream([...USER], {
+            signal: controller.signal,
+        })) {
+            /* drain */
+        }
+        expect(d.streams[0].options).toMatchObject({ signal: controller.signal });
+    });
+    it('turns a timeout into a signal the engine can abort on', async () => {
+        withWebGpu();
+        const { options, d } = makeModules();
+        const backend = createBitGpuInferenceBackend(options);
+        await backend.load();
+        // bitgpu is the only local backend that can cancel, so a deadline must
+        // reach the engine rather than being silently dropped.
+        await backend.chat([...USER], { timeout: 5_000 });
+        const sent = d.sends.at(-1)?.options;
+        expect(sent?.signal).toBeInstanceOf(AbortSignal);
+    });
+    it('streams deltas in order and reports each to onProgress', async () => {
+        withWebGpu();
+        const { options } = makeModules();
+        const backend = createBitGpuInferenceBackend(options);
+        await backend.load();
+        const onProgress = vi.fn();
+        const chunks = [];
+        for await (const chunk of backend.stream([...USER], { onProgress })) {
+            chunks.push(chunk);
+        }
+        expect(chunks).toEqual(['Hel', 'lo']);
+        expect(onProgress.mock.calls).toEqual([['Hel'], ['lo']]);
+    });
+    it('refuses tool definitions and tool turns, like every other backend', async () => {
+        withWebGpu();
+        const { options, d } = makeModules();
+        const backend = createBitGpuInferenceBackend(options);
+        await backend.load();
+        // bitgpu supports tools, but exposing them here would mean a per-call switch
+        // changes what a turn means: the other backends refuse these.
+        await expectPathError(() => backend.chat([...USER], {
+            tools: [{ type: 'function', function: { name: 'product_list' } }],
+        }), 'unsupported_message');
+        await expectPathError(() => backend.chat([
+            {
+                role: 'assistant',
+                content: '',
+                tool_calls: [
+                    {
+                        id: 'c1',
+                        type: 'function',
+                        function: { name: 'x', arguments: '{}' },
+                    },
+                ],
+            },
+        ]), 'unsupported_message');
+        expect(d.sends).toEqual([]);
+    });
+    it('disposes the engine and returns to idle on unload', async () => {
+        withWebGpu();
+        const { options, d } = makeModules();
+        const backend = createBitGpuInferenceBackend(options);
+        await backend.load();
+        await backend.unload();
+        expect(d.disposed).toBe(1);
+        expect(backend.status).toBe('idle');
+        expect(backend.progress).toBeUndefined();
+    });
+    it('refuses a turn after unload', async () => {
+        withWebGpu();
+        const { options } = makeModules();
+        const backend = createBitGpuInferenceBackend(options);
+        await backend.load();
+        await backend.unload();
+        await expectPathError(() => backend.chat([...USER]), 'no_usable_backend');
+    });
+    it('notifies subscribers on each status change', async () => {
+        withWebGpu();
+        const { options } = makeModules();
+        const backend = createBitGpuInferenceBackend(options);
+        const listener = vi.fn();
+        const unsubscribe = backend.subscribe(listener);
+        await backend.load();
+        await backend.unload();
+        // Three status changes: idle→loading, loading→ready, ready→idle.
+        expect(listener).toHaveBeenCalledTimes(3);
+        unsubscribe();
+    });
+    it('stops notifying after unsubscribe', async () => {
+        withWebGpu();
+        const { options } = makeModules();
+        const backend = createBitGpuInferenceBackend(options);
+        const listener = vi.fn();
+        backend.subscribe(listener)();
+        await backend.load();
+        expect(listener).not.toHaveBeenCalled();
+    });
+});

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

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

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

@@ -1 +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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/browser-ai/adapters/llm/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,+BAA+B,CAAC;AAC9C,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,cAAc,+BAA+B,CAAC"}

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

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

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

@@ -135,6 +135,24 @@ export interface WebLLMOptions extends BaseBrowserAIOptions {
      * dependency's type into this package's public surface.
      */
     appConfig?: Record<string, unknown>;
+    /**
+     * Supply the `@mlc-ai/web-llm` module namespace.
+     *
+     * The default loader resolves the package through a variable specifier so
+     * this module never hard-depends on an optional peer — but a variable
+     * specifier is exactly what a BROWSER cannot resolve, so the default only
+     * works under a bundler that rewrites it. A host that has the dependency
+     * should inject its own loader with a STATIC specifier:
+     *
+     * ```ts
+     * createWebLlmInferenceBackend({ loadModule: () => import('@mlc-ai/web-llm') })
+     * ```
+     *
+     * Typed as `unknown` (the module namespace) for the same reason `appConfig`
+     * is opaque: importing the peer's type would put it on this package's public
+     * surface. The adapter narrows it at the point of use.
+     */
+    loadModule?: () => Promise<unknown>;
 }
 /**
  * Transformers.js LLM adapter options

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

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

@@ -0,0 +1,67 @@
+/**
+ * An `InferenceBackend` over a browser LLM adapter.
+ *
+ * This is the local half of the inference path: it exposes whatever the
+ * adapter layer can actually do — text generation with load/progress — and
+ * refuses, loudly, the shapes it cannot faithfully represent rather than
+ * quietly degrading them.
+ *
+ * ## What the local backend cannot do, and says so
+ *
+ * `LLMAdapter` (`./types.js`) is a TEXT conversation contract:
+ * `LLMMessage.role` is `'system' | 'user' | 'assistant'`, `content` is a
+ * `string`, and `LLMChatOptions` carries no `tools`. So this backend runs
+ * {@link assertTextOnlyTurn} — the SAME check the route backend runs — and
+ * throws `InferencePathError` (`code: 'unsupported_message'`) for a
+ * `tool`/`function` message, a message carrying `tool_calls`, non-string
+ * content, or any tool definition/choice. Those turns belong on a backend that
+ * supports them: a silent rewrite would let a model answer as though it had
+ * seen context (or tools) it never received, and the two backends must agree
+ * on which turns they accept or a per-call switch changes the answer.
+ *
+ * `signal` and `timeout` are NOT honored: the adapter has no cancellation
+ * seam, so a local generation runs to completion once started. That wastes GPU
+ * time but cannot produce a wrong answer, so it degrades rather than throws.
+ *
+ * ## Adapter ownership
+ *
+ * Pass `adapter` to share the app-managed one (the warm-client cache and
+ * `SmrtAppStateManager.initializeLLM` own a single adapter per
+ * `type:model` — `src/state/warm-clients.ts`). Omitting it constructs an
+ * unshared adapter via `getLLM()`, which will NOT deduplicate against that
+ * cache; this module cannot reach the cache itself, because `state/` depends
+ * on `browser-ai/` and not the other way round.
+ *
+ * @module
+ */
+import { type InferenceBackend } from '@happyvertical/smrt-web/ai';
+import type { LLMAdapter } from './types.js';
+export interface WebLlmInferenceBackendOptions {
+    /**
+     * The adapter to drive. Supply the app-state-managed adapter so loading
+     * shares the warm-client cache; omit to construct an unshared one.
+     */
+    adapter?: LLMAdapter;
+    /** Backend id. Defaults to `'local'`. */
+    id?: string;
+    /** Model to ensure on `load()`. Adapter default when omitted. */
+    model?: string;
+    /** Passed through to `getLLM()` when no `adapter` is supplied. */
+    appConfig?: Record<string, unknown>;
+    /**
+     * Supplies the `@mlc-ai/web-llm` module namespace, passed through to the
+     * adapter. A browser can only resolve a STATIC specifier, so a host that has
+     * the dependency should pass `() => import('@mlc-ai/web-llm')`.
+     */
+    loadModule?: () => Promise<unknown>;
+}
+/**
+ * A local backend over a browser LLM adapter.
+ *
+ * `status` reports `'unavailable'` without WebGPU, so an `auto` path skips it
+ * instead of attempting a multi-gigabyte download on a device that cannot run
+ * the result. `load()` must be called (by a control, or by the caller) before
+ * the backend reports `'ready'`.
+ */
+export declare function createWebLlmInferenceBackend(options?: WebLlmInferenceBackendOptions): InferenceBackend;
+//# sourceMappingURL=webllm-inference-backend.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"webllm-inference-backend.d.ts","sourceRoot":"","sources":["../../../../src/browser-ai/adapters/llm/webllm-inference-backend.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,OAAO,EAEL,KAAK,gBAAgB,EAOtB,MAAM,4BAA4B,CAAC;AAGpC,OAAO,KAAK,EACV,UAAU,EAIX,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,6BAA6B;IAC5C;;;OAGG;IACH,OAAO,CAAC,EAAE,UAAU,CAAC;IACrB,yCAAyC;IACzC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,iEAAiE;IACjE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,kEAAkE;IAClE,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACpC;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;CACrC;AA2DD;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAC1C,OAAO,GAAE,6BAAkC,GAC1C,gBAAgB,CAsRlB"}