@tanstack-ai-browser/prompt-api 0.0.0-stage → 0.2.0

package/dist/sessions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessions.d.ts","sourceRoot":"","sources":["../src/sessions.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAClD,OAAO,KAAK,EACV,0BAA0B,EAC1B,oBAAoB,EACrB,MAAM,YAAY,CAAA;AAwBnB,wCAAwC;AACxC,MAAM,MAAM,KAAK,GAAG;IAClB,OAAO,EAAE,oBAAoB,CAAA;IAC7B,iEAAiE;IACjE,YAAY,EAAE,MAAM,CAAA;IACpB,yEAAyE;IACzE,QAAQ,EAAE,MAAM,CAAA;IAChB,qEAAqE;IACrE,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,mEAAmE;IACnE,MAAM,EAAE,OAAO,CAAA;IACf,gFAAgF;IAChF,UAAU,EAAE,MAAM,OAAO,CAAA;IACzB,+EAA+E;IAC/E,OAAO,EAAE,CAAC,OAAO,EAAE,KAAK,CAAC,aAAa,CAAC,KAAK,IAAI,CAAA;IAChD,iFAAiF;IACjF,OAAO,EAAE,MAAM,IAAI,CAAA;CACpB,CAAA;AAED;;;;GAIG;AACH,KAAK,cAAc,GAAG;IACpB,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAA;IAC5B,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,KAAK,CAAC,aAAa,CAAC,CAAA;IAC3B,OAAO,EAAE,0BAA0B,CAAA;IACnC,MAAM,EAAE,WAAW,GAAG,SAAS,CAAA;IAC/B,KAAK,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC,CAAA;IAClC,mFAAmF;IACnF,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,6EAA6E;IAC7E,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,+EAA+E;IAC/E,kBAAkB,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAA;CAChD,CAAA;AA6BD,wBAAsB,YAAY,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,KAAK,CAAC,CA8D1E;AA4KD;;;;GAIG;AACH,wBAAgB,wBAAwB,SAQvC"}

package/dist/sessions.js

@@ -0,0 +1,275 @@
+/**
+ * Sessions by conversation. A Prompt API session holds the conversation
+ * it has read (the model's cache), so each thread keeps its own: when the
+ * next request extends what the session has read (a follow-up, or the step
+ * after a tool call), only the new messages are read. Anything else (an
+ * edited or regenerated message, another system prompt) starts a new
+ * session from the whole conversation.
+ */
+import { createLanguageModel } from "./model.js";
+import { keyOf, toLanguageModelMessages } from "./messages.js";
+/** Sessions kept at once, most recently used first; older ones are freed. */
+const MAX_SESSIONS = 4;
+const entries = new Map();
+const preparing = new Map();
+/** Counts unloads: a session created across one isn't cached. */
+let generation = 0;
+const startsWith = (list, start) => start.length <= list.length && start.every((key, i) => list[i] === key);
+/** Serialize base preparation only; independent clones generate concurrently. */
+async function lockPreparation(key, signal) {
+    const previous = preparing.get(key) ?? Promise.resolve();
+    let unlock = () => undefined;
+    const done = new Promise(resolve => { unlock = resolve; });
+    const queued = previous.then(() => done);
+    preparing.set(key, queued);
+    void queued.then(() => { if (preparing.get(key) === queued)
+        preparing.delete(key); });
+    try {
+        await new Promise((resolve, reject) => {
+            const cancel = () => reject(signal?.reason);
+            signal?.addEventListener("abort", cancel, { once: true });
+            void previous.then(() => {
+                signal?.removeEventListener("abort", cancel);
+                if (signal?.aborted)
+                    reject(signal.reason);
+                else
+                    resolve();
+            });
+        });
+        return unlock;
+    }
+    catch (error) {
+        // An aborted waiter releases its place without letting later callers pass
+        // the earlier preparation that is still in flight.
+        unlock();
+        throw error;
+    }
+}
+export async function leaseSession(options) {
+    options.signal?.throwIfAborted();
+    const { threadId, isolated, system, prior } = options;
+    const setup = JSON.stringify({ system, options: options.options });
+    // Separate namespaces prevent structured finalization from replacing a chat/tool
+    // session. Stateless calls can share an identical base without inventing a thread.
+    const cacheKey = options.retain === false ? undefined : isolated
+        ? JSON.stringify(["structured", threadId ?? null, threadId ? null : setup])
+        : threadId ? JSON.stringify(["chat", threadId]) : undefined;
+    const unlock = isolated && cacheKey !== undefined ? await lockPreparation(cacheKey, options.signal) : undefined;
+    try {
+        let recreated = false;
+        for (;;) {
+            const base = await leasePooledSession({ ...options, cacheKey });
+            // A non-retained session is already isolated: generate directly on it and
+            // destroy it when the call ends, without preparing an extra clone.
+            if (!isolated || options.retain === false)
+                return base;
+            const started = performance.now();
+            let copy;
+            try {
+                copy = await base.session.clone({ signal: options.signal });
+                options.signal?.throwIfAborted();
+                let overflowed = false;
+                const onOverflow = () => { overflowed = true; };
+                copy.addEventListener("contextoverflow", onOverflow);
+                const baseOverflowed = base.overflowed();
+                // Only preparation touches the base. Release it before generation so concurrent
+                // callers can clone it too; generated JSON and draft notes never enter it.
+                base.release(prior);
+                const session = copy;
+                let destroyed = false;
+                const destroy = () => {
+                    if (destroyed)
+                        return;
+                    destroyed = true;
+                    session.removeEventListener("contextoverflow", onOverflow);
+                    session.destroy();
+                };
+                return {
+                    ...base,
+                    session,
+                    createMs: base.createMs + performance.now() - started,
+                    overflowed: () => baseOverflowed || overflowed,
+                    release: destroy,
+                    discard: destroy
+                };
+            }
+            catch (error) {
+                copy?.destroy();
+                // Aborting a clone must not destroy its healthy cached parent.
+                if (options.signal?.aborted)
+                    base.release(prior);
+                else
+                    base.discard();
+                // A stale browser session can fail at clone() before any generation starts.
+                // Recreate that prefix once, just as the streaming path does.
+                if (!options.signal?.aborted && base.reused && !recreated && error instanceof DOMException && error.name === "InvalidStateError") {
+                    recreated = true;
+                    continue;
+                }
+                throw error;
+            }
+        }
+    }
+    finally {
+        unlock?.();
+    }
+}
+async function leasePooledSession({ cacheKey, system, prior, options, signal, media, onDownloadProgress }) {
+    const setup = JSON.stringify({ system, options });
+    const keys = prior.map(keyOf);
+    const entry = cacheKey ? entries.get(cacheKey) : undefined;
+    let miss;
+    if (entry) {
+        miss = entry.busy
+            ? "another call of this thread holds its session"
+            : entry.setup !== setup
+                ? "the system prompt, tools or options changed"
+                : startsWith(keys, entry.history)
+                    ? undefined
+                    : "the conversation changed (an edited, regenerated or rewritten message)";
+    }
+    if (entry && !miss) {
+        entry.busy = true;
+        // Most recently used last.
+        entries.delete(cacheKey);
+        entries.set(cacheKey, entry);
+        const cachedTokens = entry.session.contextUsage;
+        const started = performance.now();
+        const gap = prior.slice(entry.history.length);
+        entry.overflowed = false;
+        try {
+            if (gap.length > 0) {
+                await entry.session.append(await toLanguageModelMessages(gap, media), {
+                    signal
+                });
+            }
+            entry.history = keys;
+            return {
+                ...lease(cacheKey, entry, cachedTokens, performance.now() - started),
+                reused: true
+            };
+        }
+        catch (error) {
+            drop(cacheKey, entry);
+            if (signal?.aborted)
+                throw error;
+            // The session couldn't take them (it was destroyed, say): start over.
+            miss = `the kept session failed (${error instanceof Error ? error.message : String(error)})`;
+        }
+    }
+    // Another run of this thread holds its session (it shouldn't happen):
+    // this one gets a session of its own, freed when it ends.
+    const shared = !entry?.busy;
+    if (entry && shared && cacheKey)
+        drop(cacheKey, entry);
+    const startedIn = generation;
+    const started = performance.now();
+    const created = {
+        session: await createSession(system, prior, options, signal, media, onDownloadProgress),
+        setup,
+        history: keys,
+        busy: true,
+        overflowed: false
+    };
+    created.session.addEventListener("contextoverflow", () => {
+        created.overflowed = true;
+    });
+    // Unloaded while it was created: the call uses it, then it's freed.
+    const kept = cacheKey !== undefined && shared && startedIn === generation;
+    if (kept) {
+        entries.set(cacheKey, created);
+        trimIdleSessions();
+    }
+    return {
+        ...lease(kept ? cacheKey : undefined, created, 0, performance.now() - started),
+        reused: false,
+        ...(miss && { miss })
+    };
+}
+function lease(threadId, entry, cachedTokens, createMs) {
+    return {
+        session: entry.session,
+        cachedTokens,
+        createMs,
+        overflowed: () => entry.overflowed,
+        release: (history) => {
+            if (!threadId || entries.get(threadId) !== entry)
+                return entry.session.destroy();
+            entry.history = history.map(keyOf);
+            entry.busy = false;
+            trimIdleSessions();
+        },
+        discard: () => {
+            if (threadId)
+                drop(threadId, entry);
+            else
+                entry.session.destroy();
+        }
+    };
+}
+/** Busy entries can exceed the bound temporarily; evict oldest idle entries on return. */
+function trimIdleSessions() {
+    for (const [id, entry] of entries) {
+        if (entries.size <= MAX_SESSIONS)
+            break;
+        if (!entry.busy)
+            drop(id, entry);
+    }
+}
+function drop(threadId, entry) {
+    if (entries.get(threadId) === entry)
+        entries.delete(threadId);
+    entry.session.destroy();
+}
+/** The conversation without its oldest turn: up to the next user message. */
+function withoutOldestTurn(messages) {
+    const next = messages.findIndex((m, i) => i > 0 && m.role === "user");
+    return next > 0 ? messages.slice(next) : [];
+}
+/**
+ * A new session that has read the system prompt and the conversation. Only
+ * the system prompt is an initial prompt, which the browser never drops;
+ * the conversation is appended, so when it later outgrows the context the
+ * browser drops its oldest turns. If it doesn't fit now, its oldest turns
+ * are left out (measured first, not tried) until it does.
+ */
+async function createSession(system, prior, options, signal, media, onDownloadProgress) {
+    const session = await createLanguageModel({
+        ...options,
+        ...(system && { initialPrompts: [{ role: "system", content: system }] })
+    }, signal, onDownloadProgress);
+    try {
+        let rest = prior;
+        while (rest.length > 0) {
+            const input = await toLanguageModelMessages(rest, media);
+            const room = session.contextWindow - session.contextUsage;
+            const needed = await session.measureContextUsage(input, { signal });
+            if (needed <= room) {
+                await session.append(input, { signal });
+                break;
+            }
+            rest = withoutOldestTurn(rest);
+        }
+        return session;
+    }
+    catch (error) {
+        session.destroy();
+        throw error;
+    }
+}
+/**
+ * Frees every session kept, as when the page no longer needs the model.
+ * Sessions a call holds, or is still creating, finish that call and are
+ * freed when it ends instead of going back in the cache.
+ */
+export function destroyPromptApiSessions() {
+    generation++;
+    for (const [id, entry] of [...entries]) {
+        // A busy entry is only detached: its lease sees it's no longer the
+        // thread's and destroys the session on release.
+        if (entry.busy)
+            entries.delete(id);
+        else
+            drop(id, entry);
+    }
+}

package/dist/shared-load.d.ts

@@ -0,0 +1,48 @@
+/**
+ * The callers waiting on one shared model load: their progress callbacks
+ * and how many still wait. A caller whose signal aborts stops waiting at
+ * once and hears nothing more; when the last caller still waiting aborts,
+ * the load is cancelled. (Kept in step with the same file in the other
+ * runtime packages.)
+ */
+/** A download's progress, from 0 to 1. */
+type DownloadProgressCallback = (progress: number) => void;
+/** What an aborted `create()` rejects with. */
+export declare function abortError(): DOMException;
+/** Calls a progress callback; one that throws doesn't stop the load. */
+export declare function callProgress(listener: DownloadProgressCallback, progress: number): void;
+export type WaitOptions = {
+    onDownloadProgress?: DownloadProgressCallback;
+    signal?: AbortSignal;
+    /**
+     * Whether this caller aborting last cancels the load (true by default).
+     * A chat's own wait passes false: it stops waiting, and the download goes
+     * on for the next chat.
+     */
+    cancels?: boolean;
+    /** What this caller rejects with when it aborts: an AbortError by default. */
+    reason?: (signal: AbortSignal) => unknown;
+};
+export declare class LoadWaiters {
+    private readonly cancel;
+    /** Each callback, with how many waiting callers use it: called once per report. */
+    private readonly callbacks;
+    private waiting;
+    private settled;
+    /** `cancel` stops the load: called when the last caller still waiting aborts. */
+    constructor(cancel: () => void);
+    /** Reports progress to the callers still waiting. */
+    report(progress: number): void;
+    /** The load settled (ready, failed or replaced): nothing more to report or cancel. */
+    settle(): void;
+    /**
+     * `load`'s result for one more caller. Aborting `signal` rejects this
+     * caller at once and stops its reports; if it was the last caller waiting
+     * (and `cancels`), the load is cancelled. The promise is fine to leave
+     * unawaited. Check the signal before starting the load: an aborted one
+     * rejects here without waiting.
+     */
+    wait<T>(load: Promise<T>, options?: WaitOptions): Promise<T>;
+}
+export {};
+//# sourceMappingURL=shared-load.d.ts.map

package/dist/shared-load.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-load.d.ts","sourceRoot":"","sources":["../src/shared-load.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,0CAA0C;AAC1C,KAAK,wBAAwB,GAAG,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAA;AAE1D,+CAA+C;AAC/C,wBAAgB,UAAU,IAAI,YAAY,CAEzC;AAED,wEAAwE;AACxE,wBAAgB,YAAY,CAAC,QAAQ,EAAE,wBAAwB,EAAE,QAAQ,EAAE,MAAM,QAMhF;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,kBAAkB,CAAC,EAAE,wBAAwB,CAAA;IAC7C,MAAM,CAAC,EAAE,WAAW,CAAA;IACpB;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,8EAA8E;IAC9E,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,OAAO,CAAA;CAC1C,CAAA;AAED,qBAAa,WAAW;IAOV,OAAO,CAAC,QAAQ,CAAC,MAAM;IANnC,mFAAmF;IACnF,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA8C;IACxE,OAAO,CAAC,OAAO,CAAI;IACnB,OAAO,CAAC,OAAO,CAAQ;IAEvB,iFAAiF;gBACpD,MAAM,EAAE,MAAM,IAAI;IAE/C,qDAAqD;IACrD,MAAM,CAAC,QAAQ,EAAE,MAAM;IAIvB,sFAAsF;IACtF,MAAM;IAMN;;;;;;OAMG;IACH,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,GAAE,WAAgB,GAAG,OAAO,CAAC,CAAC,CAAC;CA8CjE"}

package/dist/shared-load.js

@@ -0,0 +1,103 @@
+/**
+ * The callers waiting on one shared model load: their progress callbacks
+ * and how many still wait. A caller whose signal aborts stops waiting at
+ * once and hears nothing more; when the last caller still waiting aborts,
+ * the load is cancelled. (Kept in step with the same file in the other
+ * runtime packages.)
+ */
+/** What an aborted `create()` rejects with. */
+export function abortError() {
+    return new DOMException("The model load was aborted.", "AbortError");
+}
+/** Calls a progress callback; one that throws doesn't stop the load. */
+export function callProgress(listener, progress) {
+    try {
+        listener(progress);
+    }
+    catch (error) {
+        console.error(error);
+    }
+}
+export class LoadWaiters {
+    cancel;
+    /** Each callback, with how many waiting callers use it: called once per report. */
+    callbacks = new Map();
+    waiting = 0;
+    settled = false;
+    /** `cancel` stops the load: called when the last caller still waiting aborts. */
+    constructor(cancel) {
+        this.cancel = cancel;
+    }
+    /** Reports progress to the callers still waiting. */
+    report(progress) {
+        for (const listener of [...this.callbacks.keys()])
+            callProgress(listener, progress);
+    }
+    /** The load settled (ready, failed or replaced): nothing more to report or cancel. */
+    settle() {
+        this.settled = true;
+        this.callbacks.clear();
+        this.waiting = 0;
+    }
+    /**
+     * `load`'s result for one more caller. Aborting `signal` rejects this
+     * caller at once and stops its reports; if it was the last caller waiting
+     * (and `cancels`), the load is cancelled. The promise is fine to leave
+     * unawaited. Check the signal before starting the load: an aborted one
+     * rejects here without waiting.
+     */
+    wait(load, options = {}) {
+        const { onDownloadProgress, signal, cancels = true, reason = abortError } = options;
+        if (signal?.aborted)
+            return quiet(Promise.reject(reason(signal)));
+        if (this.settled)
+            return quiet(load);
+        this.waiting++;
+        if (onDownloadProgress) {
+            this.callbacks.set(onDownloadProgress, (this.callbacks.get(onDownloadProgress) ?? 0) + 1);
+        }
+        let left = false;
+        const leave = () => {
+            if (left)
+                return;
+            left = true;
+            if (this.settled)
+                return;
+            this.waiting--;
+            if (!onDownloadProgress)
+                return;
+            const count = (this.callbacks.get(onDownloadProgress) ?? 0) - 1;
+            if (count > 0)
+                this.callbacks.set(onDownloadProgress, count);
+            else
+                this.callbacks.delete(onDownloadProgress);
+        };
+        if (!signal) {
+            load.then(leave, leave);
+            return quiet(load);
+        }
+        return quiet(new Promise((resolve, reject) => {
+            const onAbort = () => {
+                leave();
+                reject(reason(signal));
+                if (cancels && !this.settled && this.waiting === 0)
+                    this.cancel();
+            };
+            signal.addEventListener("abort", onAbort, { once: true });
+            load.then((value) => {
+                signal.removeEventListener("abort", onAbort);
+                leave();
+                resolve(value);
+            }, (error) => {
+                signal.removeEventListener("abort", onAbort);
+                leave();
+                reject(error);
+            });
+        }));
+    }
+}
+/** `promise`, with a rejection that's fine to leave unhandled. */
+function quiet(promise) {
+    promise.catch(() => undefined);
+    return promise;
+}

package/dist/store.d.ts

@@ -0,0 +1,8 @@
+/** A value that can be read, set and watched. Framework-free. */
+export type Store<T> = {
+    get: () => T;
+    set: (value: T) => void;
+    subscribe: (listener: () => void) => () => void;
+};
+export declare function createStore<T>(initial: T): Store<T>;
+//# sourceMappingURL=store.d.ts.map

package/dist/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../src/store.ts"],"names":[],"mappings":"AAAA,iEAAiE;AACjE,MAAM,MAAM,KAAK,CAAC,CAAC,IAAI;IACrB,GAAG,EAAE,MAAM,CAAC,CAAA;IACZ,GAAG,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAA;IACvB,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,MAAM,IAAI,CAAA;CAChD,CAAA;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAgBnD"}

package/dist/store.js

@@ -0,0 +1,17 @@
+export function createStore(initial) {
+    let value = initial;
+    const listeners = new Set();
+    return {
+        get: () => value,
+        set: (next) => {
+            value = next;
+            listeners.forEach((listener) => listener());
+        },
+        subscribe: (listener) => {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        }
+    };
+}

package/dist/tools.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Tool calls by prompt. Chrome's Prompt API has no
+ * working tool use on web pages (a session that expects tool calls fails to
+ * start, and `tools` alone are never called), so the system prompt lists the
+ * tools as JSON and asks for a call as JSON in a ```tool_call fence; results
+ * go back in a ```tool_result fence. The adapter reads calls out of the
+ * streamed text; `chat()` checks them against the tools.
+ */
+import type { ModelMessage, Tool } from "@tanstack/ai";
+/** A tool call read from the model's text. */
+export type ParsedToolCall = {
+    name: string;
+    arguments: unknown;
+};
+/**
+ * The system prompt with the tools and how to call them; unchanged without
+ * tools.
+ */
+export declare function toolSystemPrompt(system: string, tools: ReadonlyArray<Tool>): string;
+/** Earlier tool calls in the conversation, as the model would have written them. */
+export declare function toolCallFence(calls: NonNullable<ModelMessage["toolCalls"]>): string;
+/** A tool's result line for a ```tool_result fence. */
+export declare function toolResultLine(id: string, name: string, content: string, error?: string): string;
+/** Tool results as the model reads them. */
+export declare const toolResultFence: (lines: ReadonlyArray<string>) => string;
+/**
+ * The first tool call in a fence's body: a JSON object (or an array of them,
+ * or one per line) with `name` and `arguments` (or `parameters`), the
+ * arguments possibly a JSON string; else, as the whole body, a Python-style
+ * call, `[name(key="v")]`, or `call:name{key:value}`.
+ */
+export declare function parseToolCall(body: string): ParsedToolCall | undefined;
+/**
+ * Reads a streamed reply: `push` each piece and get back the text that can
+ * be shown now; text inside a ```tool_call fence (or another call's
+ * delimiters: `<tool_call>`, `<|tool_call>`, `<|tool_call_start|>`, or a
+ * Python-style `[name(…)]`) is held back. The first fence that closes with
+ * a call in it ends the reply (stop generating then): `call` is the call,
+ * and `trailing` the text after it. A fence without a call, a call to a tool
+ * not in `names` (when given), and other code fences, are text. `end` gives
+ * the rest, an unclosed fence as text.
+ */
+export declare function toolCallReader(names?: ReadonlyArray<string>): {
+    readonly call: ParsedToolCall | undefined;
+    /** Text that came after the call: shown after it. */
+    readonly trailing: string;
+    push(piece: string): string;
+    end(): string;
+};
+//# sourceMappingURL=tools.d.ts.map

package/dist/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,cAAc,CAAA;AAEtD,8CAA8C;AAC9C,MAAM,MAAM,cAAc,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;CAAE,CAAA;AAiBjE;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,CAAC,IAAI,CAAC,GAAG,MAAM,CAiCnF;AAED,oFAAoF;AACpF,wBAAgB,aAAa,CAAC,KAAK,EAAE,WAAW,CAAC,YAAY,CAAC,WAAW,CAAC,CAAC,GAAG,MAAM,CAWnF;AAED,uDAAuD;AACvD,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAUhG;AAED,4CAA4C;AAC5C,eAAO,MAAM,eAAe,UAAW,aAAa,CAAC,MAAM,CAAC,WAAqD,CAAA;AAEjH;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAgCtE;AAwGD;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,KAAK,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC;aA2CpD,IAAI;IAGR,qDAAqD;aACjD,QAAQ;IAGZ,IAAI,QAAQ,MAAM,GAAG,MAAM;IAI3B,GAAG,IAAI,MAAM;EAOhB"}