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

package/dist/adapter.js

@@ -0,0 +1,414 @@
+/**
+ * A TanStack AI text adapter for the browser's built-in language model,
+ * through the Prompt API (`LanguageModel`): Gemini Nano in Chrome,
+ * Phi-4-mini in Edge. The browser downloads and runs the model itself;
+ * nothing leaves the device. Hand it to `chat()` like any hosted model's
+ * adapter: `chat()` runs tools and the agent loop, and each `chatStream`
+ * call here is one step of the model, streamed back as AG-UI events.
+ *
+ * Each thread (`threadId`) keeps a session: a step prompts it with only the
+ * messages it hasn't seen, and a conversation that changed (an edit, a new
+ * system prompt) starts a new one. Tools go by prompt (`tools.ts`);
+ * structured output prompts the thread's session under the Prompt API's own
+ * `responseConstraint`.
+ */
+import { buildBaseUsage, EventType, normalizeSystemPrompts } from "@tanstack/ai";
+import { BaseTextAdapter } from "@tanstack/ai/adapters";
+import { contentText, mediaIn, toLanguageModelMessages } from "./messages.js";
+import { baseOptions, createSession, DEFAULT_LANGUAGES, MEDIA_INPUTS, promptApiAvailability } from "./model.js";
+import { toolCallReader, toolSystemPrompt } from "./tools.js";
+/**
+ * Threads that keep a session open; the least recently used closes first. A
+ * session holds its conversation in the model's memory (about 100 MB for
+ * 6,000 tokens in Chrome 156), freed only by `destroy()`.
+ */
+const KEPT_SESSIONS = 4;
+/** Closes a session once it's made; one that failed to start has nothing to close. */
+const close = (session) => void session.then((s) => s.destroy(), () => undefined);
+/**
+ * A message as compared with what a session holds. The model's own replies
+ * go by their text alone: the session has them as the model wrote them.
+ */
+const messageKey = (m) => m.role === "assistant"
+    ? JSON.stringify(["assistant", contentText(m.content).trim()])
+    : JSON.stringify([m.role, m.content, m.toolCallId ?? null, m.error ?? null]);
+/** The tools a step offers: none for `toolChoice: "none"`, only the chosen one for a named choice. */
+function offeredTools(options) {
+    const { toolChoice, tools = [] } = options;
+    if (toolChoice === "none")
+        return [];
+    if (typeof toolChoice === "object")
+        return tools.filter((tool) => tool.name === toolChoice.name);
+    return tools;
+}
+/** A step's system prompt (the caller's, then the tools), and the settings its session is made with. */
+function sessionSettings(options, tools) {
+    const system = toolSystemPrompt(normalizeSystemPrompts(options.systemPrompts)
+        .map((p) => p.content)
+        .join("\n\n"), tools);
+    const { samplingMode, temperature, topK } = options.modelOptions ?? {};
+    return { system, settings: JSON.stringify([system, samplingMode, temperature, topK, mediaIn(options.messages)]) };
+}
+/** Whether a conversation (its messages' keys) goes on from what a kept session holds, with its settings. */
+const goesOnFrom = (held, settings, keys) => !held.busy && held.settings === settings && held.seen.length < keys.length && held.seen.every((key, i) => key === keys[i]);
+let ids = 0;
+const nextId = (prefix) => `${prefix}_${Date.now().toString(36)}_${(ids++).toString(36)}`;
+/** The caller's signal: the legacy `abortController` first, then `request`. */
+const signalOf = (options) => options.abortController?.signal ?? options.request?.signal ?? undefined;
+export class PromptApiTextAdapter extends BaseTextAdapter {
+    kind = "text";
+    name = "prompt-api";
+    provider = "prompt-api";
+    api = "prompt-api";
+    inputModalities = ["text", "image", "audio"];
+    languages;
+    inputs;
+    onDownloadProgress;
+    onContextOverflow;
+    /** Each thread's session, least recently used first. */
+    kept = new Map();
+    constructor(config, model) {
+        super({}, model);
+        this.languages = config.languages ?? DEFAULT_LANGUAGES;
+        this.inputs = config.inputs ?? [];
+        this.onDownloadProgress = config.onDownloadProgress;
+        this.onContextOverflow = config.onContextOverflow;
+    }
+    /**
+     * The browser's own `LanguageModel.availability()` for this adapter's
+     * `languages` and `inputs`: "available" (on the device), "downloadable"
+     * or "downloading" (it downloads when a session starts, or at `create`),
+     * or "unavailable" (no Prompt API, or the device can't run it).
+     */
+    availability() {
+        return promptApiAvailability(baseOptions(this.languages, this.inputs));
+    }
+    /**
+     * The kinds of input the browser's model takes here, of the
+     * `inputModalities` the Prompt API has: each kind the browser's
+     * `LanguageModel.availability()` doesn't call "unavailable" for this
+     * adapter's `languages` (images need more of the device, audio a GPU).
+     * Empty where there's no model. Sessions expect what each conversation has.
+     */
+    async availableInputModalities() {
+        if ((await promptApiAvailability(baseOptions(this.languages))) === "unavailable")
+            return [];
+        const media = await Promise.all(MEDIA_INPUTS.map(async (kind) => (await promptApiAvailability(baseOptions(this.languages, [kind]))) === "unavailable" ? [] : [kind]));
+        return ["text", ...media.flat()];
+    }
+    /**
+     * Downloads the browser's model if it isn't on the device and starts it,
+     * with the download's progress, 0 to 1, then 1 once it's ready. Resolves
+     * to this adapter; rejects if it can't start (fine to leave unawaited).
+     * `chat()` doesn't need it, but the browser asks for a click on the page
+     * before a download: call it from the click that turns the model on.
+     * Aborting `signal` aborts the browser's `create()`.
+     */
+    create(options = {}) {
+        const listeners = [this.onDownloadProgress, options.onDownloadProgress].filter((l) => !!l);
+        const ready = createSession(baseOptions(this.languages), options.signal, (progress) => {
+            for (const listener of listeners)
+                listener(progress);
+        }).then((session) => {
+            session.destroy();
+            return this;
+        });
+        // Callers may leave it: an unawaited failure isn't an unhandled rejection.
+        ready.catch(() => undefined);
+        return ready;
+    }
+    /**
+     * Tokens a thread's session holds (the session's `contextUsage`): the
+     * system prompt, the tools and the conversation so far. The thread is
+     * `chat()`'s `threadId` (or its `promptCache.key`); left out, the thread
+     * used last. Undefined where the thread keeps no session.
+     */
+    async contextUsage(threadId) {
+        return (await this.keptSession(threadId))?.contextUsage;
+    }
+    /**
+     * Tokens a thread's session can hold (the session's `contextWindow`), for
+     * the thread as `contextUsage` takes it. Undefined where the thread keeps
+     * no session.
+     */
+    async contextWindow(threadId) {
+        return (await this.keptSession(threadId))?.contextWindow;
+    }
+    /** A thread's kept session, or the last used thread's; undefined if there's none, or it failed to start. */
+    keptSession(threadId) {
+        const kept = threadId === undefined ? [...this.kept.values()].at(-1) : this.kept.get(threadId);
+        return kept ? kept.session.catch(() => undefined) : Promise.resolve(undefined);
+    }
+    /** Closes every thread's session. The browser keeps the model. */
+    async destroy() {
+        for (const kept of this.kept.values())
+            close(kept.session);
+        this.kept.clear();
+    }
+    /** Keeps a thread's session, closing the least recently used past the limit. */
+    keep(threadId, kept) {
+        this.kept.delete(threadId);
+        this.kept.set(threadId, kept);
+        for (const [id, old] of this.kept) {
+            if (this.kept.size <= KEPT_SESSIONS)
+                break;
+            if (old.busy)
+                continue;
+            close(old.session);
+            this.kept.delete(id);
+        }
+    }
+    /** Closes a thread's session, unless a step is using it. */
+    drop(threadId) {
+        const kept = this.kept.get(threadId);
+        if (!kept || kept.busy)
+            return;
+        close(kept.session);
+        this.kept.delete(threadId);
+    }
+    /** A session for this call, holding the system prompt, that reports an overflow. */
+    async session(options, system, signal) {
+        const { samplingMode, temperature, topK } = options.modelOptions ?? {};
+        const session = await createSession({
+            ...baseOptions(this.languages, mediaIn(options.messages)),
+            ...(system && { initialPrompts: [{ role: "system", content: system }] }),
+            ...(samplingMode !== undefined && { samplingMode }),
+            ...(temperature !== undefined && { temperature }),
+            ...(topK !== undefined && { topK })
+        }, signal, this.onDownloadProgress);
+        if (this.onContextOverflow)
+            session.addEventListener("contextoverflow", this.onContextOverflow);
+        return session;
+    }
+    /**
+     * The step's session and the messages to prompt it with: the thread's
+     * kept session if the conversation goes on from what it holds (only the
+     * new messages), else a new one with the whole conversation. The session
+     * is reserved before anything is awaited, so a second step on a busy
+     * thread gets a session of its own (`kept` undefined), closed after it.
+     * Threads go by `promptCache.key`; retention "none" keeps no session.
+     */
+    async begin(options, signal) {
+        const key = options.promptCache?.key ?? options.threadId;
+        const retain = options.promptCache?.retention !== "none";
+        const tools = offeredTools(options);
+        const { system, settings } = sessionSettings(options, tools);
+        const keys = options.messages.map(messageKey);
+        const held = retain ? this.kept.get(key) : undefined;
+        const goesOn = !!held && goesOnFrom(held, settings, keys);
+        let kept;
+        if (goesOn)
+            kept = held;
+        else if (retain && !held?.busy) {
+            this.drop(key);
+            kept = { session: this.session(options, system, signal), settings, seen: [], busy: false };
+        }
+        if (kept) {
+            kept.busy = true;
+            this.keep(key, kept);
+        }
+        const pending = kept?.session ?? this.session(options, system, signal);
+        try {
+            const session = await pending;
+            const input = await toLanguageModelMessages(options.messages, goesOn ? held.seen.length : 0);
+            return { key, session, kept, keys, input, tools, goesOn };
+        }
+        catch (error) {
+            // A session that goes on still holds the thread; a new one is dropped.
+            this.end(key, pending, kept, !goesOn);
+            throw error;
+        }
+    }
+    /** Frees a step's session: a kept one stays for the thread unless the step failed. */
+    end(key, session, kept, failed) {
+        if (!kept)
+            return close(session);
+        kept.busy = false;
+        if (failed && this.kept.get(key) === kept)
+            this.drop(key);
+    }
+    /**
+     * A step's token counts, which the Prompt API doesn't report, from the
+     * session's own: the tokens it held before the prompt, the prompt as the
+     * session measures it, and the reply measured the same way, less an empty
+     * message's tokens (the turn markers the session counts around any
+     * message). What a kept session held is cached: it isn't read again. A
+     * new session read what it holds (the system prompt) in this step.
+     * Nothing where the browser can't measure.
+     */
+    async usage(session, held, goesOn, input, reply) {
+        try {
+            const [read, written, markers] = await Promise.all([
+                session.measureContextUsage(input),
+                session.measureContextUsage(reply),
+                session.measureContextUsage("")
+            ]);
+            const counts = [held, read, written, markers];
+            if (!counts.every((count) => Number.isFinite(count)))
+                return undefined;
+            const promptTokens = held + read;
+            const completionTokens = Math.max(0, written - markers);
+            return {
+                ...buildBaseUsage({ promptTokens, completionTokens, totalTokens: promptTokens + completionTokens }),
+                // A new session read all of it in this step: none was cached.
+                promptTokensDetails: { cachedTokens: goesOn ? held : 0 }
+            };
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async *chatStream(options) {
+        const runId = options.runId ?? nextId("run");
+        const { threadId } = options;
+        const messageId = nextId("msg");
+        const model = this.model;
+        const signal = signalOf(options);
+        const timestamp = () => Date.now();
+        yield {
+            type: EventType.RUN_STARTED,
+            runId,
+            threadId,
+            model,
+            timestamp: timestamp(),
+            ...(options.parentRunId && { parentRunId: options.parentRunId })
+        };
+        let step;
+        let failed = false;
+        // Stops the generation once a tool call is read.
+        const stop = new AbortController();
+        try {
+            step = await this.begin(options, signal);
+            const { session, kept, keys, input, tools, goesOn } = step;
+            // Without tools to offer, the reply is all text.
+            const reader = tools.length > 0 ? toolCallReader(tools.map((tool) => tool.name)) : undefined;
+            let text = "";
+            const textEvents = function* (delta) {
+                if (!delta)
+                    return;
+                if (!text)
+                    yield { type: EventType.TEXT_MESSAGE_START, messageId, role: "assistant", model, timestamp: timestamp() };
+                text += delta;
+                yield { type: EventType.TEXT_MESSAGE_CONTENT, messageId, delta, content: text, model, timestamp: timestamp() };
+            };
+            const generation = signal ? AbortSignal.any([signal, stop.signal]) : stop.signal;
+            // What the session holds before this prompt, and all the model writes (a tool call's text too).
+            const held = session.contextUsage;
+            let written = "";
+            try {
+                for await (const piece of session.promptStreaming(input, { signal: generation })) {
+                    written += piece;
+                    yield* textEvents(reader ? reader.push(piece) : piece);
+                    if (reader?.call) {
+                        stop.abort();
+                        break;
+                    }
+                }
+            }
+            catch (error) {
+                if (!stop.signal.aborted || signal?.aborted)
+                    throw error;
+            }
+            const call = reader?.call;
+            if (reader) {
+                yield* textEvents(reader.end());
+                // Text after the call, in the piece that closed it, is shown too.
+                yield* textEvents(reader.trailing);
+            }
+            if (text)
+                yield { type: EventType.TEXT_MESSAGE_END, messageId, model, timestamp: timestamp() };
+            // A finished reply is in the session now. One stopped at a tool call
+            // isn't: Chrome drops a stopped turn whole, so the next step sends it.
+            if (kept && !stop.signal.aborted)
+                kept.seen = [...keys, messageKey({ role: "assistant", content: text })];
+            if (call) {
+                const toolCallId = nextId("call");
+                const args = JSON.stringify(call.arguments);
+                yield {
+                    type: EventType.TOOL_CALL_START,
+                    toolCallId,
+                    toolCallName: call.name,
+                    parentMessageId: messageId,
+                    index: 0,
+                    model,
+                    timestamp: timestamp()
+                };
+                yield { type: EventType.TOOL_CALL_ARGS, toolCallId, delta: args, args, model, timestamp: timestamp() };
+                yield {
+                    type: EventType.TOOL_CALL_END,
+                    toolCallId,
+                    toolCallName: call.name,
+                    args,
+                    input: call.arguments,
+                    model,
+                    timestamp: timestamp()
+                };
+            }
+            const usage = await this.usage(session, held, goesOn, input, written);
+            yield {
+                type: EventType.RUN_FINISHED,
+                runId,
+                threadId,
+                model,
+                timestamp: timestamp(),
+                finishReason: call ? "tool_calls" : "stop",
+                ...(usage && { usage })
+            };
+        }
+        catch (error) {
+            // An abort keeps the thread's session: Chrome drops the stopped turn.
+            const aborted = !!signal?.aborted;
+            failed = !aborted;
+            options.logger.errors("prompt-api chatStream failed", { error, source: "prompt-api.chatStream" });
+            const message = error instanceof Error ? error.message : String(error);
+            yield {
+                type: EventType.RUN_ERROR,
+                runId,
+                model,
+                timestamp: timestamp(),
+                message,
+                error: { message, ...(aborted && { code: "aborted" }) }
+            };
+        }
+        finally {
+            if (step)
+                this.end(step.key, Promise.resolve(step.session), step.kept, failed);
+        }
+    }
+    /**
+     * A JSON answer for `chat({ outputSchema })`: the thread's session
+     * answers the conversation under the Prompt API's `responseConstraint`,
+     * which holds the model to the schema as given. `chat()` validates the
+     * result.
+     */
+    async structuredOutput(options) {
+        const { chatOptions, outputSchema } = options;
+        const signal = signalOf(chatOptions);
+        let step;
+        let failed = false;
+        try {
+            step = await this.begin(chatOptions, signal);
+            const { session, kept, keys, input, goesOn } = step;
+            const held = session.contextUsage;
+            const rawText = await session.prompt(input, { responseConstraint: outputSchema, signal });
+            if (kept)
+                kept.seen = [...keys, messageKey({ role: "assistant", content: rawText })];
+            const data = JSON.parse(rawText);
+            const usage = await this.usage(session, held, goesOn, input, rawText);
+            return { data, rawText, model: this.model, ...(usage && { usage }) };
+        }
+        catch (error) {
+            failed = true;
+            throw error;
+        }
+        finally {
+            if (step)
+                this.end(step.key, Promise.resolve(step.session), step.kept, failed);
+        }
+    }
+}
+export function promptApiText(modelOrConfig, config = {}) {
+    return typeof modelOrConfig === "string"
+        ? new PromptApiTextAdapter(config, modelOrConfig)
+        : new PromptApiTextAdapter(modelOrConfig ?? {}, "text");
+}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * TanStack AI adapter for the browser's built-in language model, through
+ * the Prompt API: Gemini Nano in Chrome, Phi-4-mini in Edge. The model
+ * catalog (model-meta.ts) is exported here too.
+ */
+export { PromptApiTextAdapter, promptApiText } from "./adapter.js";
+export type { PromptApiConfig, PromptApiTextModelOptions } from "./adapter.js";
+export type { Availability, DownloadProgressCallback } from "./types.js";
+export { PROMPT_API_CHAT_MODELS, PROMPT_API_MODEL_META } from "./model-meta.js";
+export type { PromptApiChatModel, PromptApiModelMeta } from "./model-meta.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,oBAAoB,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAClE,YAAY,EACV,eAAe,EACf,yBAAyB,EAC1B,MAAM,cAAc,CAAA;AACrB,YAAY,EAAE,YAAY,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAA;AACxE,OAAO,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAA;AAC/E,YAAY,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAA"}

package/dist/index.js

@@ -0,0 +1,7 @@
+/**
+ * TanStack AI adapter for the browser's built-in language model, through
+ * the Prompt API: Gemini Nano in Chrome, Phi-4-mini in Edge. The model
+ * catalog (model-meta.ts) is exported here too.
+ */
+export { PromptApiTextAdapter, promptApiText } from "./adapter.js";
+export { PROMPT_API_CHAT_MODELS, PROMPT_API_MODEL_META } from "./model-meta.js";

package/dist/limit.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Output token limits, emulated. The Prompt API has no output cap (a prompt
+ * takes only `signal`, `responseConstraint` and
+ * `omitResponseConstraintInput`), so the adapter holds the reply to a limit
+ * itself, for `maxCompletionTokens`.
+ *
+ * Chrome runs one operation at a time per model, so the model can't count
+ * text while it writes it. The limit is estimated during the generation
+ * (from a ratio calibrated on the request before it starts), the generation
+ * is stopped by an internal abort a little past the limit, and the text is
+ * measured and trimmed exactly once the model is idle again.
+ */
+import type { LanguageModelSession } from "./types.js";
+/** `maxCompletionTokens`, validated like the other adapters validate it. */
+export declare function outputTokenLimit(options: {
+    maxCompletionTokens?: number;
+} | undefined): number | undefined;
+/** The cap's report in `usage.providerUsageDetails`, when a cap was set. */
+export type PromptApiOutputLimitUsage = {
+    outputTokenLimit: number;
+    outputTokenMeasurement: "estimate-then-context-usage";
+    outputTokenLimitEnforcement: "best-effort";
+    outputTokenLimitReached: boolean;
+};
+export declare const outputLimitUsage: (limit: number | undefined, reached: boolean) => PromptApiOutputLimitUsage | undefined;
+/** A message's text, without its images or audio. */
+type TextBearing = {
+    content: string | ReadonlyArray<{
+        type: string;
+        value?: unknown;
+    }>;
+};
+/** The text of a prompt input (or of messages), without images or audio. */
+export declare function textOfInput(input: string | ReadonlyArray<TextBearing>): string;
+/**
+ * Live emission stops once the estimate passes this share of the limit, or
+ * once the text passes the limit in UTF-8 bytes. Text sent live can't be
+ * taken back, so it must stay within the limit whatever the estimate says:
+ * no token is shorter than a byte, so text of at most `limit` bytes holds at
+ * most `limit` tokens, however much denser the reply is than the calibration
+ * text. The share keeps longer limits from streaming up to the last token
+ * live, where a low estimate would leave nothing to trim.
+ */
+export declare const LIVE_FRACTION = 0.75;
+/**
+ * Generation is stopped once the estimate passes STOP_FACTOR × limit +
+ * STOP_SLACK tokens: past the limit, so the exact trim afterwards finds the
+ * limit's worth of text unless the reply holds a fifth fewer tokens per byte
+ * than the calibration text (the estimate is then high by more than 1.25×).
+ * The slack covers short limits, where a chunk or two of noise is a large
+ * share; 8 tokens is about 0.15 s of Gemini Nano's decoding.
+ */
+export declare const STOP_FACTOR = 1.25;
+export declare const STOP_SLACK = 8;
+/**
+ * The text a limit's tokens-per-byte ratio is calibrated on: the request's
+ * own text first, then earlier messages (most recent first) while it's
+ * under 64 bytes, then a fixed reference sentence if it still is.
+ */
+export declare function calibrationSample(texts: ReadonlyArray<string>): string;
+/** What a limiter kept, once the generation has stopped. */
+export type LimitResult = {
+    /** The text within the limit: everything sent live, and `held`. */
+    text: string;
+    /** The part of `text` held back during generation, to send now. */
+    held: string;
+    /** `text`'s tokens, measured. */
+    tokens: number;
+    /**
+     * The limit ended the text: the exact count reached it, or the limiter
+     * stopped the generation (even if the estimate ran high and the count
+     * fell short: the reply was still cut for the limit).
+     */
+    reached: boolean;
+};
+/** Holds streamed text to a token limit without calling the model mid-stream. */
+export type TokenLimiter = {
+    /** All the text received so far. */
+    readonly text: string;
+    /** The estimate passed the stop line: stop the generation. */
+    readonly stopped: boolean;
+    /**
+     * Takes the next piece of text and returns what can be sent live now
+     * (all of it, or nothing once text is held back). Never calls the model.
+     */
+    push(delta: string): string;
+    /**
+     * Once the generation has stopped (the model is idle, so measuring is
+     * instant): the exact count, trimmed to the longest prefix within the
+     * limit, never shorter than what was already sent live.
+     */
+    finish(): Promise<LimitResult>;
+};
+/**
+ * A limiter for one generation. Chrome runs one operation at a time per
+ * model: `measureContextUsage` (on any session or clone) and `clone()` wait
+ * until a generation in progress finishes, so nothing can be measured while
+ * the model writes. Instead, before generating, `sample` (the request's
+ * text) is measured to calibrate a bytes-per-token ratio; while generating,
+ * tokens are estimated from UTF-8 bytes with it; once the generation has
+ * stopped, `finish()` measures exactly and trims.
+ *
+ * Bytes per token, not characters: it varies much less across scripts (a
+ * CJK character is 3 bytes and about a token; English runs about 4 bytes a
+ * token), and no token is shorter than a byte, so the ratio's floor of 1 is
+ * the hard bound tokens ≤ bytes.
+ */
+export declare function tokenLimiter(session: LanguageModelSession, limit: number, sample: string, signal: AbortSignal | undefined): Promise<TokenLimiter>;
+/**
+ * An abort signal for one generation that follows the caller's (with its
+ * reason) and that `stop()` aborts on its own, never touching the caller's.
+ */
+export declare function internalAbort(signal: AbortSignal | undefined, reason: string): {
+    signal: AbortSignal;
+    stop: () => void;
+    dispose: () => void | undefined;
+};
+export {};
+//# sourceMappingURL=limit.d.ts.map

package/dist/limit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"limit.d.ts","sourceRoot":"","sources":["../src/limit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAA;AAEtD,4EAA4E;AAC5E,wBAAgB,gBAAgB,CAAC,OAAO,EAAE;IAAE,mBAAmB,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,sBAMrF;AAED,4EAA4E;AAC5E,MAAM,MAAM,yBAAyB,GAAG;IACtC,gBAAgB,EAAE,MAAM,CAAA;IACxB,sBAAsB,EAAE,6BAA6B,CAAA;IACrD,2BAA2B,EAAE,aAAa,CAAA;IAC1C,uBAAuB,EAAE,OAAO,CAAA;CACjC,CAAA;AAED,eAAO,MAAM,gBAAgB,GAC3B,OAAO,MAAM,GAAG,SAAS,EACzB,SAAS,OAAO,KACf,yBAAyB,GAAG,SAQxB,CAAA;AAiBP,qDAAqD;AACrD,KAAK,WAAW,GAAG;IAAE,OAAO,EAAE,MAAM,GAAG,aAAa,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC,CAAA;CAAE,CAAA;AAEzF,4EAA4E;AAC5E,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,aAAa,CAAC,WAAW,CAAC,GAAG,MAAM,CAY9E;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,OAAO,CAAA;AACjC;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,OAAO,CAAA;AAC/B,eAAO,MAAM,UAAU,IAAI,CAAA;AAY3B;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,MAAM,CAatE;AAED,4DAA4D;AAC5D,MAAM,MAAM,WAAW,GAAG;IACxB,mEAAmE;IACnE,IAAI,EAAE,MAAM,CAAA;IACZ,mEAAmE;IACnE,IAAI,EAAE,MAAM,CAAA;IACZ,iCAAiC;IACjC,MAAM,EAAE,MAAM,CAAA;IACd;;;;OAIG;IACH,OAAO,EAAE,OAAO,CAAA;CACjB,CAAA;AAED,iFAAiF;AACjF,MAAM,MAAM,YAAY,GAAG;IACzB,oCAAoC;IACpC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,8DAA8D;IAC9D,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB;;;OAGG;IACH,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;IAC3B;;;;OAIG;IACH,MAAM,IAAI,OAAO,CAAC,WAAW,CAAC,CAAA;CAC/B,CAAA;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,YAAY,CAChC,OAAO,EAAE,oBAAoB,EAC7B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,WAAW,GAAG,SAAS,GAC9B,OAAO,CAAC,YAAY,CAAC,CAqEvB;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,WAAW,GAAG,SAAS,EAAE,MAAM,EAAE,MAAM;;;;EAU5E"}