vern-llm 2.9.0 → 3.0.0

package/dist/adapters/index.d.cts

@@ -0,0 +1,582 @@
+import { bt as ProviderRateLimitHint, n as LLMClient, v as WireStreamChunk } from "../client-HWxkwVvj.cjs";
+//#region src/adapters/internal/nativeStructuredOutput.d.ts
+/**
+ * A list of model ids, or a predicate, naming models with a capability.
+ * Native structured output has no built in list: which models support it
+ * is the provider's call and changes over time, and a wrong guess would
+ * trade a clear local error for a confusing provider one.
+ */
+type ModelCapabilityOverride = string[] | ((model: string) => boolean);
+//#endregion
+//#region src/adapters/internal/reasoningBudget.utils.d.ts
+/**
+ * Converts between `reasoningEffort` tiers and `budgetTokens`, for a
+ * provider that only understands the other one. The numbers are a guess,
+ * not a provider guarantee, and each adapter's `reasoningEffortTokens`
+ * overrides them.
+ */
+type EffortTokenTable = Record<'minimal' | 'low' | 'medium' | 'high', number>;
+//#endregion
+//#region src/adapters/internal/imageFormat.d.ts
+/**
+ * `ImageBlock.mimeType` values every adapter accepts: the types all
+ * supported providers share, so content valid for one is valid for all.
+ */
+declare const SUPPORTED_IMAGE_MIME_TYPES: readonly ["image/png", "image/jpeg", "image/gif", "image/webp"];
+type SupportedImageMimeType = (typeof SUPPORTED_IMAGE_MIME_TYPES)[number];
+//#endregion
+//#region src/adapters/claude/types.d.ts
+/** Anthropic's native per-block content shape for a message. */
+type AnthropicContentBlock = {
+  type: 'text';
+  text: string;
+} | {
+  type: 'image';
+  source: {
+    type: 'base64';
+    media_type: SupportedImageMimeType;
+    data: string;
+  };
+} | {
+  type: 'tool_use';
+  id: string;
+  name: string;
+  input: unknown;
+} | {
+  type: 'tool_result';
+  tool_use_id: string;
+  content: string;
+  is_error?: boolean;
+} | {
+  type: 'thinking';
+  thinking: string;
+  signature: string;
+} | {
+  type: 'redacted_thinking';
+  data: string;
+};
+/** The input side of Anthropic's `usage`, which carries the cache counts. */
+interface AnthropicUsage {
+  input_tokens?: number | null;
+  cache_creation_input_tokens?: number | null;
+  cache_read_input_tokens?: number | null;
+  cache_creation?: {
+    ephemeral_5m_input_tokens?: number;
+    ephemeral_1h_input_tokens?: number;
+  } | null;
+}
+/** Minimal structural type for the Anthropic SDK's `messages.create` */
+interface AnthropicClient {
+  messages: {
+    create(params: {
+      model: string;
+      max_tokens: number;
+      temperature?: number;
+      system?: string;
+      messages: Array<{
+        role: 'user' | 'assistant';
+        content: string | AnthropicContentBlock[];
+      }>;
+      tools?: Array<{
+        name: string;
+        description?: string;
+        input_schema: {
+          type: 'object';
+          [key: string]: unknown;
+        };
+        strict?: boolean;
+      }>;
+      tool_choice?: {
+        type: 'auto';
+      } | {
+        type: 'any';
+      } | {
+        type: 'none';
+      } | {
+        type: 'tool';
+        name: string;
+      };
+      /**
+       * `format` is native structured output, which takes only `type` and
+       * `schema`. `effort` drives adaptive thinking.
+       */
+      output_config?: {
+        format?: {
+          type: 'json_schema';
+          schema: Record<string, unknown>;
+        };
+        effort?: 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+      };
+      /** Manual budget thinking, or adaptive thinking paired with `output_config.effort`. */
+      thinking?: {
+        type: 'enabled';
+        budget_tokens: number;
+      } | {
+        type: 'adaptive';
+      };
+    }, options: {
+      signal: AbortSignal;
+    }): Promise<{
+      content: Array<{
+        type: string;
+        text?: string;
+        id?: string;
+        name?: string;
+        input?: unknown;
+        thinking?: string;
+        signature?: string;
+        data?: string;
+      }>;
+      stop_reason?: string | null;
+      usage?: AnthropicUsage & {
+        output_tokens?: number;
+        output_tokens_details?: {
+          thinking_tokens?: number;
+        } | null;
+      };
+    }>;
+  };
+}
+//#endregion
+//#region src/adapters/claude/anthropic.d.ts
+/** Optional configuration for `fromAnthropic`. */
+interface AnthropicAdapterOptions {
+  /**
+   * Models that support native structured output (`output_config.format`),
+   * which can be combined with real `tools`. No default: other models
+   * emulate `jsonSchema` as a forced tool call.
+   */
+  nativeStructuredOutputModels?: ModelCapabilityOverride;
+  /** Overrides the token count each `reasoningEffort` tier maps onto. Omitted tiers keep the default. */
+  reasoningEffortTokens?: Partial<EffortTokenTable>;
+  /**
+   * Adds models that only accept adaptive thinking, on top of the built in
+   * rule (Claude Opus 4.7 and later, every Claude 5 tier model).
+   */
+  adaptiveOnlyModels?: ModelCapabilityOverride;
+  /**
+   * Replaces the built in list of models that reject a forced `tool_choice`
+   * (Claude Fable 5.1 and later, Opus 5.5 and later, every Claude major 6
+   * and later). On these, `toolChoice: 'required'` or `{ name }` throws
+   * `unsupported_capability` before dispatch, and `jsonSchema` always uses
+   * native structured output.
+   */
+  forcedToolChoiceUnsupportedModels?: ModelCapabilityOverride;
+  /**
+   * Whether `messages.create` supports `.withResponse()`, which AIMD's
+   * proactive path needs. Default `false`, since a fake or thin wrapper
+   * won't implement it.
+   */
+  supportsWithResponse?: boolean;
+}
+/**
+ * Wraps an Anthropic SDK client as an `LLMClient`. `jsonSchema` uses native
+ * structured output on covered models and a forced tool call elsewhere,
+ * which can't be combined with `tools`. `json_object` throws, since
+ * Anthropic can't guarantee it.
+ */
+export declare function fromAnthropic(anthropicClient: AnthropicClient, options?: AnthropicAdapterOptions): LLMClient;
+//#endregion
+//#region src/adapters/gemini/types.d.ts
+/** Gemini's per-part content shape; object-typed args match the real SDK. */
+type GeminiPart = {
+  text: string;
+} | {
+  inlineData: {
+    mimeType: string;
+    data: string;
+  };
+} | {
+  functionCall: {
+    id?: string;
+    name: string;
+    args: Record<string, unknown>;
+  };
+} | {
+  functionResponse: {
+    id?: string;
+    name: string;
+    response: Record<string, unknown>;
+  };
+};
+/**
+ * Structural type matching the model methods of the real `@google/genai`
+ * SDK (`ai.models`).
+ *
+ * Every field is shaped to be structurally assignable from the real SDK's
+ * generated types without importing them, so provider SDKs stay optional:
+ * `model` is required (the real SDK requires it), `functionCall.args` /
+ * `functionResponse.response` are `Record<string, unknown>` (matching the
+ * real SDK, not `unknown`), `toolConfig...mode` is `any` (TypeScript never
+ * treats a string-literal union as assignable to the real SDK's string
+ * enum), and response-side `functionCall.name` is optional (matching the
+ * real SDK).
+ */
+interface GeminiModels {
+  generateContent(params: {
+    model: string;
+    contents: Array<{
+      role: 'user' | 'model';
+      parts: GeminiPart[];
+    }>;
+    config?: {
+      systemInstruction?: {
+        parts: Array<{
+          text: string;
+        }>;
+      };
+      temperature?: number;
+      maxOutputTokens?: number;
+      responseMimeType?: string;
+      responseSchema?: Record<string, unknown>;
+      tools?: Array<{
+        functionDeclarations: Array<{
+          name: string;
+          description?: string;
+          parameters: Record<string, unknown>;
+        }>;
+      }>;
+      toolConfig?: {
+        functionCallingConfig: {
+          mode: any;
+          allowedFunctionNames?: string[];
+        };
+      };
+      /** `thinkingBudget` up to Gemini 2.5, `thinkingLevel` from Gemini 3 on. */
+      thinkingConfig?: {
+        thinkingBudget?: number;
+        thinkingLevel?: any;
+      };
+      abortSignal?: AbortSignal;
+    };
+  }): Promise<{
+    candidates?: Array<{
+      content?: {
+        parts?: Array<{
+          text?: string;
+          functionCall?: {
+            id?: string;
+            name?: string;
+            args?: unknown;
+          };
+        }>;
+      };
+      finishReason?: string;
+    }>;
+    usageMetadata?: {
+      promptTokenCount?: number;
+      candidatesTokenCount?: number;
+      totalTokenCount?: number;
+      thoughtsTokenCount?: number;
+      cachedContentTokenCount?: number;
+    };
+  }>;
+  /** Required only for `stream: true`. Resolves to an iterable of partial responses. */
+  generateContentStream?(params: Parameters<GeminiModels['generateContent']>[0]): Promise<AsyncIterable<{
+    candidates?: Array<{
+      content?: {
+        parts?: Array<{
+          text?: string;
+          functionCall?: {
+            id?: string;
+            name?: string;
+            args?: unknown;
+          };
+        }>;
+      };
+    }>;
+    usageMetadata?: {
+      promptTokenCount?: number;
+      candidatesTokenCount?: number;
+      totalTokenCount?: number;
+      thoughtsTokenCount?: number;
+      cachedContentTokenCount?: number;
+    };
+  }>>;
+}
+/**
+ * The top level `@google/genai` client, `new GoogleGenAI(...)`:
+ *
+ * ```ts
+ * import { GoogleGenAI } from '@google/genai';
+ * const ai = new GoogleGenAI({ apiKey: '...' });
+ * const llm = new VernLLM({ client: fromGemini(ai), model: 'gemini-2.5-flash' });
+ * ```
+ */
+interface GeminiClient {
+  models: GeminiModels;
+  /** Set by the SDK; names the provider as Vertex AI or the Gemini API. */
+  vertexai?: boolean;
+}
+//#endregion
+//#region src/adapters/gemini/gemini.d.ts
+/** Optional configuration for `fromGemini`. */
+interface GeminiAdapterOptions {
+  /** Overrides the token count each `reasoningEffort` tier maps onto. Omitted tiers keep the default. */
+  reasoningEffortTokens?: Partial<EffortTokenTable>;
+  /**
+   * Adds models that use `thinkingLevel` instead of `thinkingBudget`, on top
+   * of the built in rule (Gemini 3 and later).
+   */
+  thinkingLevelModels?: ModelCapabilityOverride;
+}
+/**
+ * Wraps the top level `@google/genai` client as an `LLMClient`. `ai.models`
+ * throws at construction, since only the top level client says whether it
+ * talks to Vertex AI or the Gemini API. `responseSchema` and `tools` combine
+ * natively.
+ */
+export declare function fromGemini(client: GeminiClient, options?: GeminiAdapterOptions): LLMClient;
+//#endregion
+//#region src/adapters/fetch/types.d.ts
+/** The chat-completion-shaped request VernLLM builds internally */
+type ChatRequest = Parameters<LLMClient['chat']['completions']['create']>[0];
+/**
+ * The minimal response shape `fromFetch` reads. Native `fetch`'s `Response`
+ * satisfies it, as do thin wrappers around `axios`, `node-fetch` or `undici`.
+ */
+interface ResponseLike {
+  ok: boolean;
+  status: number;
+  headers: {
+    get(name: string): string | null;
+  };
+  text(): Promise<string>;
+  json(): Promise<unknown>;
+}
+/** A fetch-compatible request function; defaults to native `fetch` */
+type RequestLike = (url: string, init: {
+  method: string;
+  headers: Record<string, string>;
+  body?: string;
+  signal?: AbortSignal;
+}) => Promise<ResponseLike>;
+/**
+ * A streaming request function: resolves to the response body as an
+ * `AsyncIterable` of `Uint8Array` or `string` chunks. Defaults to native
+ * `fetch`.
+ */
+type StreamRequestLike = (url: string, init: {
+  method: string;
+  headers: Record<string, string>;
+  body?: string;
+  signal?: AbortSignal;
+}) => Promise<AsyncIterable<Uint8Array | string>>;
+interface FetchAdapterConfig {
+  /** Endpoint URL, or a function of the request in case it depends on model/params */
+  url: string | ((params: ChatRequest) => string);
+  /** Static headers, or a function (sync or async) for things like refreshed auth tokens */
+  headers?: Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>);
+  /** HTTP method. Default 'POST' */
+  method?: string;
+  /**
+   * The provider behind `url`, in the OpenTelemetry `gen_ai.provider.name`
+   * vocabulary, reported on `AttemptContext.adapter`. Left unset when omitted.
+   */
+  provider?: string;
+  /** The HTTP transport. Defaults to native `fetch`. */
+  request?: RequestLike;
+  /** Maps VernLLMs internal chat-completion request into the providers raw request body */
+  mapRequest: (params: ChatRequest) => unknown;
+  /**
+   * Maps the provider's JSON response. `content` may be empty when the model
+   * only called tools. Each tool call's `arguments` is the JSON-encoded
+   * string, as on OpenAI's wire; VernLLM parses and validates it.
+   */
+  mapResponse: (json: unknown) => {
+    content?: string;
+    usage?: {
+      /** Every input token, cache reads and writes included. */
+      promptTokens?: number;
+      completionTokens?: number;
+      totalTokens?: number;
+      /** Cache reads, a subset of `promptTokens`. */
+      cacheReadTokens?: number;
+      /** Cache writes, a subset of `promptTokens`. */
+      cacheWriteTokens?: number;
+      /** `cacheWriteTokens` by TTL label, e.g. `{ '5m': 1200 }`. */
+      cacheWriteTokensByTtl?: Record<string, number>;
+    };
+    toolCalls?: Array<{
+      id: string;
+      name: string;
+      arguments: string;
+    }>;
+  };
+  /**
+   * The streaming transport. Defaults to native `fetch`, and is required for
+   * `stream: true` when `request` is set, since it never falls back to it.
+   */
+  requestStream?: StreamRequestLike;
+  /**
+   * Splits the raw stream bytes into events. Defaults to Server-Sent Events
+   * framing (`parseSseStream`).
+   */
+  parseStreamFrames?: (chunks: AsyncIterable<Uint8Array | string>) => AsyncIterable<unknown>;
+  /**
+   * Maps one parsed stream event into zero or more chunks; `undefined` skips
+   * it. Required for `stream: true`.
+   */
+  mapStreamEvent?: (event: unknown) => WireStreamChunk | WireStreamChunk[] | undefined;
+  /**
+   * Reads AIMD's proactive rate limit hint off a successful response.
+   * Defaults to OpenAI's header set.
+   */
+  parseRateLimitHint?: (headers: ResponseLike['headers']) => ProviderRateLimitHint;
+}
+//#endregion
+//#region src/adapters/fetch/fetch.d.ts
+/**
+ * A raw HTTP adapter for providers with no SDK: supply the URL, headers,
+ * and the request and response mapping. A non-2xx response throws an error
+ * carrying `status` and `headers`, so retries, `nonRetryableStatus` and
+ * Retry-After all apply.
+ */
+export declare function fromFetch(config: FetchAdapterConfig): LLMClient;
+//#endregion
+//#region src/adapters/internal/sse.d.ts
+/**
+ * Parses a Server-Sent-Events stream of bytes or text into each frame's
+ * JSON `data:` payload, in order, over any transport. Multi-line data is
+ * joined with `\n`, comment-only frames yield `SSE_PING`, other fields are
+ * ignored, and a `[DONE]` frame ends iteration. `\r\n` and bare `\r` count
+ * as line endings, including a `\r\n` split across two chunks. Malformed
+ * JSON throws `LLMError('parse')`.
+ */
+export declare function parseSseStream(source: AsyncIterable<Uint8Array | string>): AsyncGenerator<unknown>;
+/**
+ * Yielded for a comment-only frame, the SSE keep-alive ping, so a consumer
+ * can tell "still alive" apart from an empty frame.
+ */
+export declare const SSE_PING: unique symbol;
+//#endregion
+//#region src/adapters/openai/openaiCompatible.d.ts
+/** Optional configuration for `fromOpenAICompatible`. */
+interface OpenAICompatibleAdapterOptions {
+  /**
+   * Whether the provider accepts `stream_options.include_usage`. Default
+   * `true`. With `false`, `stream_options` is omitted and streams report no
+   * usage.
+   */
+  supportsStreamUsage?: boolean;
+  /**
+   * Overrides the token counts `budgetTokens` buckets into when
+   * `reasoningEffort` isn't set. Omitted tiers keep the default.
+   */
+  reasoningEffortTokens?: Partial<EffortTokenTable>;
+  /**
+   * Whether the client supports `.withResponse()`, which AIMD's proactive
+   * path needs. Default `false`, since the client can't be verified.
+   */
+  supportsWithResponse?: boolean;
+  /**
+   * The provider, in the OpenTelemetry `gen_ai.provider.name` vocabulary,
+   * reported on `AttemptContext.adapter`. When omitted it is read off a well
+   * known `baseURL` host, and left unset otherwise.
+   */
+  provider?: string;
+  /**
+   * Models that only take `tools` on Chat Completions with
+   * `reasoning_effort: "none"`, replacing the built in rule (bare `gpt-` ids
+   * of major 6 and later, except `-chat` ids). With tools, `"none"` is sent,
+   * or the call throws `unsupported_capability` when reasoning was asked for.
+   */
+  noReasoningToolModels?: ModelCapabilityOverride;
+}
+/**
+ * Adapter for any client whose `chat.completions.create` speaks the OpenAI
+ * wire format. Requests pass through, except for message translation and
+ * the model specific rewrites above. The client is `unknown` because SDK
+ * types drift from `LLMClient`; the wire format is the contract.
+ */
+export declare function fromOpenAICompatible(client: unknown, options?: OpenAICompatibleAdapterOptions): LLMClient;
+//#endregion
+//#region src/adapters/openai/aliases.d.ts
+/**
+ * The OpenAI SDK. Wrap it rather than passing it directly, since newer SDK
+ * content-part types no longer typecheck against `LLMClient`.
+ */
+export declare const fromOpenAI: typeof fromOpenAICompatible;
+/** Groqs SDK matches the OpenAI wire format */
+export declare const fromGroq: typeof fromOpenAICompatible;
+/** Mistral's OpenAI-compatible endpoint, which accepts `stream_options.include_usage`. */
+export declare const fromMistral: typeof fromOpenAICompatible;
+/** DeepSeeks API is OpenAI-compatible */
+export declare const fromDeepSeek: typeof fromOpenAICompatible;
+/** Cerebras inference API is OpenAI-compatible */
+export declare const fromCerebras: typeof fromOpenAICompatible;
+/** Together AIs API is OpenAI-compatible */
+export declare const fromTogether: typeof fromOpenAICompatible;
+/** Fireworks AIs API is OpenAI-compatible */
+export declare const fromFireworks: typeof fromOpenAICompatible;
+/** Ollama's OpenAI-compatible `/v1/chat/completions` endpoint, not its native `/api/chat`. */
+export declare const fromOllama: typeof fromOpenAICompatible;
+/** OpenRouter's API is OpenAI-compatible */
+export declare const fromOpenRouter: typeof fromOpenAICompatible;
+/** Perplexity's API is OpenAI-compatible */
+export declare const fromPerplexity: typeof fromOpenAICompatible;
+/** DeepInfra's API is OpenAI-compatible */
+export declare const fromDeepInfra: typeof fromOpenAICompatible;
+/** Novita's API is OpenAI-compatible */
+export declare const fromNovita: typeof fromOpenAICompatible;
+/** Hyperbolic's API is OpenAI-compatible */
+export declare const fromHyperbolic: typeof fromOpenAICompatible;
+/** Moonshot's (Kimi) API is OpenAI-compatible */
+export declare const fromMoonshot: typeof fromOpenAICompatible;
+/** Zhipu's (GLM) API is OpenAI-compatible */
+export declare const fromZhipu: typeof fromOpenAICompatible;
+/**
+ * LM Studio exposes an OpenAI-compatible endpoint at `/v1/chat/completions`.
+ * Point an OpenAI SDK instance's `baseURL` at your local LM Studio server.
+ */
+export declare const fromLMStudio: typeof fromOpenAICompatible;
+/**
+ * vLLM's OpenAI-compatible server mode exposes `/v1/chat/completions`.
+ * Point an OpenAI SDK instance's `baseURL` at your vLLM server.
+ */
+export declare const fromVLLM: typeof fromOpenAICompatible;
+/** xAI's Grok API is OpenAI-compatible */
+export declare const fromXAI: typeof fromOpenAICompatible;
+/** NVIDIA NIM's hosted and self-hosted endpoints are OpenAI-compatible */
+export declare const fromNvidiaNIM: typeof fromOpenAICompatible;
+/** Vercel AI Gateway is OpenAI-compatible */
+export declare const fromVercelAIGateway: typeof fromOpenAICompatible;
+/** Cloudflare Workers AI exposes an OpenAI-compatible endpoint */
+export declare const fromCloudflareWorkersAI: typeof fromOpenAICompatible;
+/** Nebius AI Studio is OpenAI-compatible */
+export declare const fromNebius: typeof fromOpenAICompatible;
+/** SambaNova Cloud's API is OpenAI-compatible */
+export declare const fromSambaNova: typeof fromOpenAICompatible;
+/** Baseten's model hosting exposes an OpenAI-compatible endpoint */
+export declare const fromBaseten: typeof fromOpenAICompatible;
+/** Featherless AI's API is OpenAI-compatible */
+export declare const fromFeatherless: typeof fromOpenAICompatible;
+/** Friendli AI's serving endpoint is OpenAI-compatible */
+export declare const fromFriendli: typeof fromOpenAICompatible;
+/** SiliconFlow's API is OpenAI-compatible */
+export declare const fromSiliconFlow: typeof fromOpenAICompatible;
+/** Parasail's inference API is OpenAI-compatible */
+export declare const fromParasail: typeof fromOpenAICompatible;
+/** StepFun's API is OpenAI-compatible */
+export declare const fromStepFun: typeof fromOpenAICompatible;
+/** MiniMax's API is OpenAI-compatible */
+export declare const fromMiniMax: typeof fromOpenAICompatible;
+/** Lambda Labs' Inference API is OpenAI-compatible */
+export declare const fromLambdaLabs: typeof fromOpenAICompatible;
+/** Snowflake Cortex's LLM endpoint is OpenAI-compatible */
+export declare const fromSnowflakeCortex: typeof fromOpenAICompatible;
+/** Anyscale Endpoints' API is OpenAI-compatible */
+export declare const fromAnyscale: typeof fromOpenAICompatible;
+/** Lepton AI's inference API is OpenAI-compatible */
+export declare const fromLepton: typeof fromOpenAICompatible;
+/** Inference.net's API is OpenAI-compatible */
+export declare const fromInferenceNet: typeof fromOpenAICompatible;
+/** Infermatic's API is OpenAI-compatible */
+export declare const fromInfermatic: typeof fromOpenAICompatible;
+/** AtlasCloud's inference API is OpenAI-compatible */
+export declare const fromAtlasCloud: typeof fromOpenAICompatible;
+/** 01.AI's (Yi models) API is OpenAI-compatible */
+export declare const from01AI: typeof fromOpenAICompatible;
+//#endregion
+export type { AnthropicAdapterOptions, AnthropicClient, FetchAdapterConfig, GeminiAdapterOptions, GeminiClient, OpenAICompatibleAdapterOptions, RequestLike, ResponseLike, StreamRequestLike };
+//# sourceMappingURL=index.d.cts.map

package/dist/adapters/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../src/adapters/internal/nativeStructuredOutput.ts","../../src/adapters/internal/reasoningBudget.utils.ts","../../src/adapters/internal/imageFormat.ts","../../src/adapters/claude/types.ts","../../src/adapters/claude/anthropic.ts","../../src/adapters/gemini/types.ts","../../src/adapters/gemini/gemini.ts","../../src/adapters/fetch/types.ts","../../src/adapters/fetch/fetch.ts","../../src/adapters/internal/sse.ts","../../src/adapters/openai/openaiCompatible.ts","../../src/adapters/openai/aliases.ts"],"mappings":";;;;;;;;KAMY,uCAAuC;;;;;;;;;KCIvC,mBAAmB;;;;;;;cCJlB;KAOD,iCAAiC;;;;KCVjC;EACN;EAAc;;EAEd;EACA;IAAU;IAAgB,YAAY;IAAwB;;;EAE9D;EAAkB;EAAY;EAAc;;EAC5C;EAAqB;EAAqB;EAAiB;;EAC3D;EAAkB;EAAkB;;EACpC;EAA2B;;;UAGhB;EACf;EACA;EACA;EACA;IACE;IACA;;;;UAKa;EACf;IACE,OACE;MACE;MACA;MACA;MACA;MACA,UAAU;QAAQ;QAA4B,kBAAkB;;MAChE,QAAQ;QACN;QACA;QAGA;UAAgB;WAAiB;;QACjC;;MAEF;QACM;;QACA;;QACA;;QACA;QAAc;;;;;;MAKpB;QACE;UACE;UACA,QAAQ;;QAEV;;;MAGF;QAAa;QAAiB;;QAA4B;;OAE5D;MAAW,QAAQ;QAClB;MACD,SAAS;QACP;QACA;QACA;QACA;QACA;QACA;QACA;QACA;;MAEF;MACA,QAAQ;QACN;QACA;UAA0B;;;;;;;;;UCrDjB;;;;;;EAMf,+BAA+B;;EAE/B,wBAAwB,QAAQ;;;;;EAKhC,qBAAqB;;;;;;;;EAQrB,oCAAoC;;;;;;EAMpC;;;;;;;;wBASc,cACd,iBAAiB,iBACjB,UAAU,0BACT;;;;KC9DS;EACN;;EACA;IAAc;IAAkB;;;EAChC;IAAgB;IAAa;IAAc,MAAM;;;EACjD;IAAoB;IAAa;IAAc,UAAU;;;;;;;;;;;;;;;;UAe9C;EACf,gBAAgB;IACd;IACA,UAAU;MAAQ;MAAwB,OAAO;;IACjD;MACE;QAAsB,OAAO;UAAQ;;;MACrC;MACA;MACA;MACA,iBAAiB;MACjB,QAAQ;QACN,sBAAsB;UACpB;UACA;UACA,YAAY;;;MAGhB;QACE;UAEE;UACA;;;;MAIJ;QACE;QAEA;;MAEF,cAAc;;MAEd;IACF,aAAa;MACX;QACE,QAAQ;UACN;UACA;YAAiB;YAAa;YAAe;;;;MAGjD;;IAEF;MACE;MACA;MACA;MACA;MACA;;;;EAKJ,uBAAuB,QAAQ,WAAW,sCAAsC,QAC9E;IACE,aAAa;MACX;QACE,QAAQ;UACN;UACA;YAAiB;YAAa;YAAe;;;;;IAInD;MACE;MACA;MACA;MACA;MACA;;;;;;;;;;;;;UAeS;EACf,QAAQ;;EAER;;;;;UC1Fe;;EAEf,wBAAwB,QAAQ;;;;;EAKhC,sBAAsB;;;;;;;;wBAgCR,WAAW,QAAQ,cAAc,UAAU,uBAAuB;;;;KClDtE,cAAc,WAAW;;;;;UAMpB;EACf;EACA;EACA;IACE,IAAI;;EAEN,QAAQ;EACR,QAAQ;;;KAIE,eACV,aACA;EACE;EACA,SAAS;EACT;EACA,SAAS;MAER,QAAQ;;;;;;KAOD,qBACV,aACA;EACE;EACA,SAAS;EACT;EACA,SAAS;MAER,QAAQ,cAAc;UAEV;;EAEf,gBAAgB,QAAQ;;EAExB,UACI,gCACO,yBAAyB,QAAQ;;EAE5C;;;;;EAKA;;EAEA,UAAU;;EAEV,aAAa,QAAQ;;;;;;EAMrB,cAAc;IACZ;IACA;;MAEE;MACA;MACA;;MAEA;;MAEA;;MAEA,wBAAwB;;IAE1B,YAAY;MAAQ;MAAY;MAAc;;;;;;;EAMhD,gBAAgB;;;;;EAKhB,qBAAqB,QAAQ,cAAc,yBAAyB;;;;;EAKpE,kBAAkB,mBAAmB,kBAAkB;;;;;EAKvD,sBAAsB,SAAS,4BAA4B;;;;;;;;;;wBCvF7C,UAAU,QAAQ,qBAAqB;;;;;;;;;;;wBCPhC,eACrB,QAAQ,cAAc,uBACrB;;;;;qBAyIU;;;;UCvHI;;;;;;EAMf;;;;;EAKA,wBAAwB,QAAQ;;;;;EAKhC;;;;;;EAMA;;;;;;;EAOA,wBAAwB;;;;;;;;wBASV,qBACd,iBACA,UAAS,iCACR;;;;;;;qBCjEU,mBAAU;;qBAGV,iBAAQ;;qBAGR,oBAAW;;qBAGX,qBAAY;;qBAGZ,qBAAY;;qBAGZ,qBAAY;;qBAGZ,sBAAa;;qBAGb,mBAAU;;qBAGV,uBAAc;;qBAGd,uBAAc;;qBAGd,sBAAa;;qBAGb,mBAAU;;qBAGV,uBAAc;;qBAGd,qBAAY;;qBAGZ,kBAAS;;;;;qBAMT,qBAAY;;;;;qBAMZ,iBAAQ;;qBAGR,gBAAO;;qBAGP,sBAAa;;qBAGb,4BAAmB;;qBAGnB,gCAAuB;;qBAGvB,mBAAU;;qBAGV,sBAAa;;qBAGb,oBAAW;;qBAGX,wBAAe;;qBAGf,qBAAY;;qBAGZ,wBAAe;;qBAGf,qBAAY;;qBAGZ,oBAAW;;qBAGX,oBAAW;;qBAGX,uBAAc;;qBAGd,4BAAmB;;qBAGnB,qBAAY;;qBAGZ,mBAAU;;qBAGV,yBAAgB;;qBAGhB,uBAAc;;qBAGd,uBAAc;;qBAGd,iBAAQ"}