vern-llm 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,608 @@
+//#region src/logger.d.ts
+interface Logger {
+  debug(message: string): void;
+  warn(message: string): void;
+  error(message: string, meta?: Record<string, unknown>): void;
+}
+/**
+ * Default logger. `debug` is gated by the `debug` option on VernLLM
+ * warn/error always fire since they indicate real problems (retries, cache failures)
+ */
+declare class ConsoleLogger implements Logger {
+  private debugEnabled;
+  constructor(debugEnabled: boolean);
+  debug(message: string): void;
+  warn(message: string): void;
+  error(message: string, meta?: Record<string, unknown>): void;
+} //#endregion
+//#region src/circuitBreaker.d.ts
+interface CircuitBreakerOptions {
+  /** Consecutive failures before the circuit opens, default 5 */
+  threshold?: number;
+  /** How long the circuit stays open before allowing a trial request, in ms. Default 30000 */
+  cooldownMs?: number;
+}
+type CircuitState = 'closed' | 'open' | 'half-open';
+/**
+ * Per retry VernLLM-instance circuit breaker. Tracks consecutive failures across
+ * calls. Once the threshold is hit, short-circuits new calls with an
+ * LLMError('circuit_open') instead of hitting the provider, until the
+ * cooldown elapses and a single trial call is allowed through
+ */
+declare class CircuitBreaker {
+  private state;
+  private consecutiveFailures;
+  private openedAt;
+  private threshold;
+  private cooldownMs;
+  constructor(options?: CircuitBreakerOptions);
+  /** Throws if the circuit is open and the cooldown hasnt elapsed */
+  assertClosed(): void;
+  recordSuccess(): void;
+  recordFailure(): void;
+  getState(): CircuitState;
+}
+
+//#endregion
+//#region src/types.d.ts
+type LLMErrorType = 'timeout' | 'api' | 'parse' | 'validation' | 'circuit_open' | 'unknown' | 'aborted';
+declare class LLMError extends Error {
+  type: LLMErrorType;
+  status?: number | undefined;
+  issues?: unknown | undefined;
+  constructor(message: string, type: LLMErrorType, status?: number | undefined, issues?: unknown | undefined);
+}
+declare function isLLMError(err: unknown): err is LLMError;
+interface CacheAdapter<T = unknown> {
+  get(key: string): Promise<T | null>;
+  set(key: string, value: T, ttl: number): Promise<void>;
+}
+/**
+ * Trivial default so the package works out of the box with no external deps
+ * Not shared across processes, swap in Redis/Upstash/etc for production
+ */
+declare class InMemoryCacheAdapter<T = unknown> implements CacheAdapter<T> {
+  private store;
+  get(key: string): Promise<T | null>;
+  set(key: string, value: T, ttl: number): Promise<void>;
+}
+/**
+ * Minimal shape compatible with the OpenAI SDKs chat.completions.create,
+ * so consumers can pass an OpenAI client directly
+ * `response_format.json_schema` and `reasoning_effort` are optional on the wire
+ * providers that don't support them will just ignore fields they don't recognize,
+ * but not every SDKs TS types accept them, hence this being a structural type
+ * rather than importing the SDKs own params type
+ */
+interface LLMClient {
+  chat: {
+    completions: {
+      create(params: {
+        model: string;
+        temperature: number;
+        max_tokens: number;
+        response_format?: {
+          type: 'json_object';
+        } | {
+          type: 'json_schema';
+          json_schema: {
+            name: string;
+            schema: Record<string, unknown>;
+            strict?: boolean;
+            description?: string;
+          };
+        };
+        /** OpenAI reasoning-model param (o-series, gpt-5), ignored by providers that don't support it */
+        reasoning_effort?: 'minimal' | 'low' | 'medium' | 'high';
+        messages: Array<{
+          role: 'system' | 'user';
+          content: string;
+        }>;
+      }, options: {
+        signal: AbortSignal;
+      }): Promise<{
+        choices?: Array<{
+          message?: {
+            content?: string | null;
+          };
+        }>;
+        usage?: {
+          prompt_tokens?: number;
+          completion_tokens?: number;
+          total_tokens?: number;
+        };
+      }>;
+    };
+  };
+}
+type ReserveUsage = () => Promise<void>;
+type RefundUsage = () => Promise<void>;
+interface TokenUsage {
+  promptTokens: number;
+  completionTokens: number;
+  totalTokens: number;
+  requestId: string;
+  model: string;
+}
+type OnUsage = (usage: TokenUsage) => void;
+/**
+ * Minimal structural type for a Zod-like schema, so this package doesnt need
+ * a hard dependency on a specific Zod major version. Any object exposing
+ * `safeParse` (Zod v3/v4, and most Zod-compatible validators) should satisfy this
+ */
+interface SchemaLike<T> {
+  safeParse(data: unknown): {
+    success: true;
+    data: T;
+  } | {
+    success: false;
+    error: unknown;
+  };
+}
+interface VernLLMOptions {
+  client: LLMClient;
+  model: string;
+  /** Max retries after the first attempt. Default 1 (2 attempts total) */
+  maxRetries?: number;
+  /** Per-attempt timeout in ms. Default 25000 */
+  timeoutMs?: number;
+  /** Base delay for exponential backoff in ms. Default 500 */
+  baseDelayMs?: number;
+  /** Default max_tokens for calls that don't override it. Default 1000 */
+  defaultMaxTokens?: number;
+  /** Enables debug logging of raw model output. Default: NODE_ENV !== 'production' */
+  debug?: boolean;
+  /** Cache adapter for cachedCall. Defaults to an in-memory adapter */
+  cache?: CacheAdapter;
+  /** HTTP status codes that should fail fast without retrying. Default [400, 401, 403] */
+  nonRetryableStatus?: number[];
+  /** Custom JSON parser. Must return undefined/null on failure. Default: JSON.parse wrapped in try/catch */
+  parseJson?: (content: string) => unknown;
+  /** Called after every successful call with token usage, if the provider reports it */
+  onUsage?: OnUsage;
+  /** Injectable logger. Defaults to a console-based logger gated by `debug` */
+  logger?: Logger;
+  /**
+   * Enables a circuit breaker that short-circuits calls after repeated
+   * consecutive failures, instead of continuing to hammer a down provider
+   * Pass `true` for defaults, or an options object to tune threshold/cooldown
+   */
+  circuitBreaker?: boolean | CircuitBreakerOptions;
+}
+/**
+ * A provider-native JSON Schema for structured outputs (OpenAI/Groq
+ * `response_format: { type: 'json_schema' }`) This is the wire-format
+ * schema the model is constrained to generate against, distinct from
+ * `schema`, which is a client-side Zod validator run on the parsed result
+ * You can use one, both, or neither; using both gets you provider-level
+ * constraint plus client-side type inference/validation as a safety net
+ */
+interface JsonSchemaSpec {
+  name: string;
+  schema: Record<string, unknown>;
+  /** Enforces the schema strictly (OpenAI-specific), default true when supported */
+  strict?: boolean;
+  description?: string;
+}
+interface CallParams<T = unknown> {
+  systemPrompt: string;
+  userContent: string;
+  temperature?: number;
+  jsonMode?: boolean;
+  maxTokens?: number;
+  requestId?: string;
+  signal?: AbortSignal;
+  /** Overrides the model set on the VernLLM instance for this call only */
+  model?: string;
+  /**
+   * OpenAI-style reasoning effort for reasoning models (o-series, gpt-5, etc).
+   * Passed through as-is, providers/models that don't support it ignore it
+   */
+  reasoningEffort?: 'minimal' | 'low' | 'medium' | 'high';
+  /**
+   * Provider-native JSON Schema structured-output mode. When set, this is sent
+   * as `response_format: { type: 'json_schema', json_schema: ... }` instead of
+   * the looser `json_object` mode, constraining the models output shape at
+   * generation time (not just validating it after the fact). Implies jsonMode: true.
+   */
+  jsonSchema?: JsonSchemaSpec;
+  /**
+   * Optional Zod (or Zod-compatible) schema. When provided, the parsed JSON
+   * is validated against it; on failure an LLMError('validation') is thrown
+   * with `.issues` set to the schema's error object. Implies jsonMode: true.
+   * Can be combined with `jsonSchema` for provider-level constraint + client-side typing.
+   */
+  schema?: SchemaLike<T>;
+}
+interface CachedCallParams<T> {
+  cacheKey: string;
+  ttl: number;
+  fn: () => Promise<T>;
+  reserveUsage?: ReserveUsage;
+  refundUsage?: RefundUsage;
+} //#endregion
+//#region src/vernLLM.d.ts
+/**
+ * A resilient wrapper around an LLM chat completions client, this is VernLLM!
+ *
+ * Adds retry with exponential backoff and jitter, per-attempt timeouts,
+ * an optional circuit breaker, JSON parsing with optional schema
+ * validation, usage tracking, and an optional response cache, all
+ * configurable, all opt-in beyond sensible defaults
+ */
+declare class VernLLM {
+  private readonly client;
+  private readonly model;
+  private readonly maxRetries;
+  private readonly timeoutMs;
+  private readonly baseDelayMs;
+  private readonly defaultMaxTokens;
+  private readonly cache;
+  private readonly nonRetryableStatus;
+  private readonly parseJson;
+  private readonly onUsage?;
+  private readonly logger;
+  private readonly breaker?;
+  /**
+   * @param options: Client, model, and all tunables (retries, timeout,
+   * backoff, cache, circuit breaker, logger, etc). See VernLLMOptions in `types.ts`
+   * for individual defaults
+   */
+  constructor(options: VernLLMOptions);
+  /**
+   * Resolves retry/timeout/token defaults from the given options,
+   * falling back to the librarys built-in defaults for anything unset
+   */
+  private resolveRetryConfig;
+  /**
+   * Returns the caller supplied logger, or a console-based logger whose
+   * debug output is gated by the `debug` option (defaulting to on
+   * outside production)
+   */
+  private resolveLogger;
+  /**
+   * Builds a circuit breaker if `circuitBreaker` is truthy on the
+   * options. Passing `true` uses default thresholds, passing an options
+   * object tunes them. Returns undefined when the breaker is disabled
+   */
+  private resolveCircuitBreaker;
+  /**
+   * Makes a single logical LLM call, transparently retrying on failure
+   * according to the configured retry policy
+   *
+   * Fails fast if the circuit breaker is open or the signal is already
+   * aborted, before any request is dispatched. On exhausting all
+   * retries, records a circuit breaker failure and rejects with a
+   * normalized LLMError
+   *
+   * @param params : System/user content plus per call overrides
+   * (model, temperature, jsonMode, schema, signal, etc)
+   * @returns The parsed and optionally schema-validated response, or
+   * the raw string content when jsonMode is disabled
+   */
+  call<T = unknown>(params: CallParams<T>): Promise<T>;
+  /**
+   * Runs `fn`, retrying with backoff according to `shouldRetry` policy
+   * Purely mechanical: knows nothing about LLM specifics beyond the retry
+   * predicate, so its testable independent of request/response shaping
+   */
+  private retryWithBackoff;
+  /**
+   * Converts any thrown value into a well-typed LLMError for the public
+   * API surface. Preserves an existing LLMError as is, reports aborted
+   * signals as such, classifies errors carrying an http status as
+   * type api, and otherwise falls back to a generic unknown error.
+   */
+  private normalizeError;
+  /**
+   * Performs a single attempt: builds the request, dispatches it with a
+   * timeout, and shapes the response. Throws on an empty response so
+   * the retry loop treats it like any other transient failure. Records
+   * usage and a circuit breaker success before returning
+   */
+  private executeCall;
+  /**
+   * Applies per call defaults and shapes the params into the request
+   * object expected by the underlying client, including the resolved
+   * response format. Also returns whether JSON parsing should be
+   * applied to the response and which model was ultimately used
+   */
+  private buildRequestPayload;
+  /**
+   * Chooses the response format to send to the provider. A provider
+   * native json schema takes priority when supplied, constraining
+   * generation directly, otherwise falls back to the looser json
+   * object mode when JSON output is requested, or no format at all
+   * for plain text responses
+   */
+  private buildResponseFormat;
+  /**
+   * Reports token usage to the caller supplied onUsage callback, when
+   * both a callback was configured and the provider actually returned
+   * usage data on this response. A no op otherwise.
+   */
+  private recordUsage;
+  /**
+   * Parses the raw response content as JSON and, when a schema is
+   * supplied, validates the parsed value against it. Throws a parse
+   * type LLMError on malformed JSON and a validation type LLMError,
+   * carrying the schemas issues, on a failed validation
+   */
+  private parseAndValidate;
+  /**
+   * Waits out the backoff delay for a given retry attempt, logging the
+   * attempt for observability before the wait begins. Rejects early if
+   * the signal aborts during the wait
+   */
+  private recoverDelay;
+  /**
+   * Decides whether a failed attempt is worth retrying. Never retries
+   * once the signal has aborted, never retries a parse or validation
+   * failure since those stem from the response content rather than a
+   * transient fault, and never retries a status code the caller has
+   * marked as non retryable. Retries everything else
+   */
+  private shouldRetry;
+  /**
+   * Thin cache wrapper around caller supplied logic. `params.fn` is expected
+   * to be a call that itself invokes `this.call(...)` (see `cachedLLMCall`
+   * below for a convenience wrapper that wires this up automatically),
+   * `cachedCall` does not itself apply retry/timeout policy.
+   */
+  cachedCall<T>(params: CachedCallParams<T>): Promise<T>;
+  /**
+   * Convenience wrapper composing `call` + `cachedCall`, so cached LLM calls
+   * automatically get retry/timeout/circuit-breaker behavior without callers
+   * having to remember to wire `fn: () => this.call(...)` themselves
+   */
+  cachedLLMCall<T>(params: Omit<CachedCallParams<T>, 'fn'> & {
+    call: CallParams<T>;
+  }): Promise<T>;
+  /**
+   * Returns the current circuit breaker state, or undefined when no
+   * circuit breaker was configured on this instance
+   */
+  getCircuitState(): ("closed" | "open" | "half-open") | undefined;
+}
+
+//#endregion
+//#region src/adapters/anthropic.d.ts
+/** Minimal structural type for the Anthropic SDKs `messages.create` */
+interface AnthropicClient {
+  messages: {
+    create(params: {
+      model: string;
+      max_tokens: number;
+      temperature?: number;
+      system?: string;
+      messages: Array<{
+        role: 'user' | 'assistant';
+        content: string;
+      }>;
+    }, options: {
+      signal: AbortSignal;
+    }): Promise<{
+      content: Array<{
+        type: string;
+        text?: string;
+      }>;
+      usage?: {
+        input_tokens?: number;
+        output_tokens?: number;
+      };
+    }>;
+  };
+}
+/**
+ * Wraps an Anthropic SDK client so it satisfies the same `LLMClient`
+ * interface VernLLM uses for OpenAI/Groq. Anthropics Messages API has no
+ * `response_format: json_object` equivalent, so when the caller requests
+ * JSON mode, this adapter appends an instruction to the system prompt
+ * asking the model to respond with JSON only
+ */
+declare function fromAnthropic(anthropicClient: AnthropicClient): LLMClient;
+
+//#endregion
+//#region src/adapters/gemini.d.ts
+/**
+ * Minimal structural type for Geminis `generateContent`, matching both the
+ * legacy `@google/generative-ai` SDKs `model.generateContent(...)` and the
+ * newer `@google/genai` SDKs `ai.models.generateContent({ model, ... })`
+ * closely enough to adapt either — pass whichever `.generateContent` you have.
+ */
+interface GeminiClient {
+  generateContent(params: {
+    model?: string;
+    contents: Array<{
+      role: "user";
+      parts: Array<{
+        text: string;
+      }>;
+    }>;
+    systemInstruction?: {
+      parts: Array<{
+        text: string;
+      }>;
+    };
+    generationConfig?: {
+      temperature?: number;
+      maxOutputTokens?: number;
+      responseMimeType?: string;
+      responseSchema?: Record<string, unknown>;
+    };
+  }, options: {
+    signal: AbortSignal;
+  }): Promise<{
+    candidates?: Array<{
+      content?: {
+        parts?: Array<{
+          text?: string;
+        }>;
+      };
+    }>;
+    usageMetadata?: {
+      promptTokenCount?: number;
+      candidatesTokenCount?: number;
+      totalTokenCount?: number;
+    };
+  }>;
+}
+/**
+ * Wraps a Gemini client so it satisfies the `LLMClient` interface VernLLM
+ * uses for OpenAI/Groq. Geminis shape differs on nearly every axis: a
+ * `contents` array instead of `messages`, a separate `systemInstruction`
+ * field instead of a `system` role message, `generationConfig` instead of
+ * top-level `temperature`/`max_tokens`, and native JSON Schema support via
+ * `responseMimeType: 'application/json'` + `responseSchema` (so `jsonSchema`
+ * is provider-enforced here, unlike the Anthropic adapters prompt-embedding
+ * fallback). `reasoning_effort` has no equivalent. Geminis thinking models
+ * use a token budget, not an effort tier, so its dropped, same as Anthropic.
+ */
+declare function fromGemini(geminiClient: GeminiClient): LLMClient;
+
+//#endregion
+//#region src/adapters/bedrock.d.ts
+/**
+ * Minimal structural type matching AWS Bedrocks Converse API. This is
+ * intentionally NOT `BedrockRuntimeClient` itself, the AWS SDK v3 client
+ * exposes `.send(command)`, not a direct `.converse()` method, and pulling
+ * in `@aws-sdk/client-bedrock-runtime` as a dependency just for its types
+ * isn't worth it for a structural adapter. Wrap your client, e.g:
+ *
+ * ```ts
+ * import { BedrockRuntimeClient, ConverseCommand } from '@aws-sdk/client-bedrock-runtime';
+ * const client = new BedrockRuntimeClient({ region: 'us-east-1' });
+ * const converseClient = {
+ *   converse: (params, options) =>
+ *     client.send(new ConverseCommand(params), { abortSignal: options.signal }),
+ * };
+ * ```
+ */
+interface BedrockConverseClient {
+  converse(params: {
+    modelId: string;
+    messages: Array<{
+      role: 'user';
+      content: Array<{
+        text: string;
+      }>;
+    }>;
+    system?: Array<{
+      text: string;
+    }>;
+    inferenceConfig?: {
+      temperature?: number;
+      maxTokens?: number;
+    };
+  }, options: {
+    signal: AbortSignal;
+  }): Promise<{
+    output?: {
+      message?: {
+        content?: Array<{
+          text?: string;
+        }>;
+      };
+    };
+    usage?: {
+      inputTokens?: number;
+      outputTokens?: number;
+      totalTokens?: number;
+    };
+  }>;
+}
+/**
+ * Wraps a Bedrock Converse-API client so it satisfies the `LLMClient`
+ * interface VernLLM uses for OpenAI/Groq. The Converse API is unified
+ * across Bedrocks model families (Anthropic, Titan, Llama, Mistral, etc.),
+ * so unlike raw per-model Bedrock invocation, this one adapter works
+ * regardless of which underlying model `modelId` points at, as long as
+ * that model supports Converse (most current-generation ones do)
+ *
+ * Theres no uniform native JSON Schema enforcement across families here
+ * (some support it via forced tool-use, which varies per model), so
+ * `jsonSchema`/`jsonMode` are emulated via a system-prompt instruction, same
+ * approach as the Anthropic adapter. `reasoning_effort` has no Converse
+ * equivalent and is dropped
+ */
+declare function fromBedrock(bedrockClient: BedrockConverseClient): LLMClient;
+
+//#endregion
+//#region src/adapters/fetch.d.ts
+/** The chat-completion-shaped request VernLLM builds internally */
+type ChatRequest = Parameters<LLMClient['chat']['completions']['create']>[0];
+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;
+  /** Maps VernLLMs internal chat-completion request into the providers raw request body */
+  mapRequest: (params: ChatRequest) => unknown;
+  /**
+   * Maps the providers raw JSON response into `{ content, usage? }`
+   * `content` is the assistants text (JSON string when JSON mode was requested)
+   */
+  mapResponse: (json: unknown) => {
+    content: string;
+    usage?: {
+      promptTokens?: number;
+      completionTokens?: number;
+      totalTokens?: number;
+    };
+  };
+}
+/**
+ * A fetch-based escape hatch for providers with no SDK, or where pulling one
+ * in isnt worth it. You supply the URL, headers, and two small mapping
+ * functions; this handles the HTTP call and slots the result into the same
+ * `LLMClient` shape every other adapter produces, so retries, timeouts,
+ * the circuit breaker, and JSON/schema handling all still work unmodified
+ *
+ * Non-2xx responses throw an error with `.status` set to the HTTP status
+ * code, so VernLLMs `nonRetryableStatus` handling (e.g. failing fast on
+ * 401/403) applies here too
+ */
+declare function fromFetch(config: FetchAdapterConfig): LLMClient;
+
+//#endregion
+//#region src/adapters/openaiCompatible.d.ts
+/**
+ * Passthrough adapter for any SDK/client whose `chat.completions.create`
+ * already matches the OpenAI wire format 1:1 : this covers most hosted
+ * inference providers, since "OpenAI-compatible" is a de facto standard for
+ * chat completion APIs. No transformation happens here, this exists purely
+ * so call sites read clearly (`fromMistral(client)` vs handing a Mistral
+ * client to something typed for OpenAI) and so a real transformation could
+ * be added later, per-provider, without a breaking change.
+ *
+ * Not every SDKs own TypeScript types line up exactly with `LLMClient`
+ * (extra fields, stricter unions, etc.), so this takes `unknown` and casts:
+ * the actual compatibility contract is the JSON each provider sends and
+ * receives over the wire, not the SDKs TS types.
+ */
+declare function fromOpenAICompatible(client: unknown): LLMClient;
+/** Groqs SDK matches the OpenAI wire format */
+declare const fromGroq: typeof fromOpenAICompatible;
+/** Mistrals `chat.completions`-shaped client (or their OpenAI-compat endpoint) */
+declare const fromMistral: typeof fromOpenAICompatible;
+/** DeepSeeks API is OpenAI-compatible */
+declare const fromDeepSeek: typeof fromOpenAICompatible;
+/** Cerebras inference API is OpenAI-compatible */
+declare const fromCerebras: typeof fromOpenAICompatible;
+/** Together AIs API is OpenAI-compatible */
+declare const fromTogether: typeof fromOpenAICompatible;
+/** Fireworks AIs API is OpenAI-compatible */
+declare const fromFireworks: typeof fromOpenAICompatible;
+/**
+ * Ollama exposes an OpenAI-compatible endpoint at `/v1/chat/completions`
+ * (as opposed to its native `/api/chat` format, which differs). Point an
+ * OpenAI SDK instances `baseURL` at your Ollama server and pass it here:
+ * this does not talk to Ollamas native API directly.
+ */
+declare const fromOllama: typeof fromOpenAICompatible;
+
+//#endregion
+export { CacheAdapter, CachedCallParams, CallParams, CircuitBreaker, CircuitBreakerOptions, ConsoleLogger, FetchAdapterConfig, InMemoryCacheAdapter, JsonSchemaSpec, LLMClient, LLMError, LLMErrorType, Logger, OnUsage, RefundUsage, ReserveUsage, SchemaLike, TokenUsage, VernLLM, VernLLMOptions, fromAnthropic, fromBedrock, fromCerebras, fromDeepSeek, fromFetch, fromFireworks, fromGemini, fromGroq, fromMistral, fromOllama, fromOpenAICompatible, fromTogether, isLLMError };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/logger.d.ts","../src/circuitBreaker.d.ts","../src/types.d.ts","../src/vernLLM.d.ts","../src/adapters/anthropic.d.ts","../src/adapters/gemini.d.ts","../src/adapters/bedrock.d.ts","../src/adapters/fetch.d.ts","../src/adapters/openaiCompatible.d.ts"],"sourcesContent":null,"mappings":";AAAA,IAAW,SAAS,CAAC,IAAG,MAAA,MAAA;;;;;AAKxB,IAAE,gBAAA;CAAA;CAAA,MAAA;CAAA,MAAA;AAAA;;;;ACLF,IAAW,wBAAwB,CAAC,EAAG;AACvC,IAAI,eAAe,CAAC,EAAG;;;;;;;AAOvB,IAAW,iBAAiB;CAAC;CAAI,MAAM;CAAuB,MAAM;AAAY;;;;ACNhF,IAAW,eAAW,CAAA,EAAA;AACtB,IAAW,WAAW;CAAC;CAAI,MAAI;CAAA,MAAA;CAAA,MAAA;AAAA;AAC/B,IAAW,aAAa,CAAC,IAAI,MAAG,QAAA;AAChC,IAAW,eAAe;CAAC;CAAI,MAAM;CAAG,MAAM;CAAS,MAAM;CAAG,MAAM;AAAQ;;;;;AAK9E,IAAW,uBAAuB;CAAC;CAAI,MAAM;CAAG,MAAM;CAAG,MAAC;CAAA,MAAA;CAAA,MAAA;CAAA,MAAA;AAAA;;;;;;;;;AAS1D,IAAW,YAAY;CAAC;CAAI,MAAM;CAAQ,MAAM;CAAO,MAAG;CAAA,MAAA;CAAA,MAAA;AAAA;AAC1D,IAAA,eAAA,CAAA,IAAA,MAAA,OAAA;AACA,IAAE,cAAA,CAAA,IAAA,MAAA,OAAA;AACF,IAAW,aAAa,CAAC,EAAG;AAC5B,IAAW,UAAU,CAAC,IAAI,MAAM,UAAW;;;;;;AAM3C,IAAW,aAAa,CAAC,IAAE,MAAA,CAAA;AAC3B,IAAU,iBAAA;CAAA;CAAA,MAAA;CAAA,MAAA;CAAA,MAAA;CAAA;CAAA;AAAA;;;;;;;;;AASV,IAAW,iBAAiB,CAAC,IAAI,MAAM,MAAA;AACvC,IAAW,aAAa;CAAC;CAAI,MAAI;CAAA,MAAA;CAAA,MAAA;CAAA,MAAA;AAAA;AACjC,IAAW,mBAAmB;CAAC;CAAI,MAAC;CAAA,MAAA;CAAA,MAAA;CAAA,MAAA;AAAA;;;;;;;;;;;;AChCpC,IAAW,UAAU;CAAC;CAAI,MAAG;CAAA,MAAA;CAAA,MAAA;CAAA,MAAA;CAAA,MAAA;CAAA,MAAA;CAAA,MAAA;CAAA,MAAA;CAAA,MAAA;CAAA,MAAA;CAAA,MAAA;CAAA,MAAA;CAAA,MAAA;CAAA,MAAA;CAAA,MAAA;CAAA,MAAA;AAAA;;;;;ACP7B,IAAI,kBAAkB;CAAC;CAAG,MAAA;CAAA,MAAA;CAAA,MAAA;CAAA,MAAA;AAAA;;;;;;;;AAQ1B,IAAW,gBAAgB;CAAC;CAAI,MAAM;CAAI,MAAA;AAAA;;;;;;;;;;ACH1C,IAAI,eAAe;CAAC;CAAG,MAAA;CAAA,MAAA;CAAA,MAAA;CAAA,MAAA;CAAA,MAAA;CAAA,MAAA;CAAA,MAAA;CAAA,MAAA;AAAA;;;;;;;;;;;;AAYvB,IAAW,aAAG;CAAA;CAAA,MAAA;CAAA,MAAA;AAAA;;;;;;;;;;;;;;;;;;;;ACFd,IAAI,wBAAwB;CAAC;CAAG,MAAA;CAAA,MAAA;CAAA,MAAA;CAAA,MAAA;CAAA,MAAA;CAAA,MAAA;AAAA;;;;;;;;;;;;;;;AAehC,IAAS,cAAA;CAAA;CAAA,MAAA;CAAA,MAAA;AAAA;;;;;AC9BT,IAAI,cAAc;CAAC;CAAG,MAAM;CAAW,MAAM;AAAW;AACxD,IAAW,qBAAqB;CAAC;CAAG,MAAA;CAAA,MAAA;CAAA,MAAA;CAAA,MAAA;CAAA,MAAA;CAAA,MAAA;AAAA;;;;;;;;;;;;AAYpC,IAAM,YAAA;CAAA;CAAA,MAAA;CAAA,MAAA;AAAA;;;;;;;;;;;;;;;;;;ACAN,IAAW,uBAAuB,CAAC,GAAG,MAAM,SAAU;;AAEtD,IAAW,WAAW,CAAC,GAAG,MAAM,oBAAqB;;AAErD,IAAW,cAAc,CAAC,GAAG,MAAM,oBAAqB;;AAExD,IAAW,eAAe,CAAC,IAAI,MAAM,oBAAqB;;AAE1D,IAAW,eAAe,CAAC,IAAI,MAAM,oBAAqB;;AAE1D,IAAW,eAAe,CAAC,IAAI,MAAM,oBAAqB;;AAE1D,IAAW,gBAAgB,CAAC,IAAI,MAAM,oBAAqB;;;;;;;AAO3D,IAAW,aAAa,CAAC,IAAI,MAAM,oBAAqB"}