@eddyskywalker/dsh-chatgpt-subscription 0.9.9 → 0.10.1

package/lib/types/host/minimax-code/client.d.ts

@@ -0,0 +1,184 @@
+/**
+ * HTTP surface of the MiniMax Code subscription.
+ *
+ * ONE header rule governs this whole file, and it is the one the brief calls out as
+ * a hard constraint: credentials are sent as `authorization: Bearer <accessToken>`.
+ * The endpoint also speaks the Anthropic wire format, whose client normally
+ * authenticates with `x-api-key`, and that difference was measured directly — an
+ * `x-api-key` request answers 401 `{"code":401,"message":"token is required"}`
+ * while the bearer form answers 200. There is deliberately no fallback that tries
+ * `x-api-key` after a 401: the measured verdict is that it cannot succeed, and a
+ * retry would only add a request to the subscription's bill.
+ *
+ * The second rule is an absence: this file has no `/v1/models` call and must never
+ * grow one. That route is not configured for subscription traffic and answers 503
+ * `{"errorCode":50115,"errorReason":"direct_route_not_configured"}`; the model
+ * directory is hardcoded in ./model-catalog.ts instead.
+ */
+import { DEFAULT_DEVICE_INTERVAL_SECONDS, MESSAGES_PATH, agentBaseUrl, MINIMAX_CODE_BUILD_ENV, redactToken } from './types.ts';
+import { MinimaxCodeCredentialStore, type MinimaxCodeCredentials } from './token-store.ts';
+import { MinimaxCodeUnauthorizedError } from './oauth.ts';
+import type { MinimaxCodeAccount, MinimaxCodeQuota, MinimaxCodeRegion } from '../../shared/minimax-code-contracts.ts';
+/**
+ * Headers for one Messages request.
+ *
+ * `authorization: Bearer` is REQUIRED and is the only credential field sent —
+ * see this file's header comment for the measured reason an `x-api-key` variant
+ * must not exist.
+ *
+ * The token itself never appears in a log line or an error: callers that need to
+ * name a credential do so through `redactToken`.
+ */
+export declare function modelRequestHeaders(accessToken: string): Record<string, string>;
+/** Headers for a non-streaming call (the probe). */
+export declare function probeRequestHeaders(accessToken: string): Record<string, string>;
+/** One parsed Anthropic `usage` object. */
+export interface MinimaxUsage {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
+}
+/** Read the four token counters the Messages response reports. */
+export declare function parseAnthropicUsage(payload: unknown): MinimaxUsage | null;
+/** Short, single-line excerpt of one error body, safe to show a user. */
+export declare function summarizeFailureBody(raw: string): string;
+export interface MinimaxProbeResult {
+    ok: boolean;
+    /** Model the probe used, when it reached the service. */
+    model?: string;
+    /** Failure sentence, already safe to render. */
+    error?: string;
+    latencyMs: number;
+    account?: MinimaxCodeAccount | null;
+    usage?: MinimaxUsage;
+}
+/**
+ * Model the connection probe uses.
+ *
+ * M3 is the model the measured request used, so a probe against it exercises the
+ * exact shape the reconnaissance attested rather than a preview id that may not be
+ * entitled on every account.
+ */
+export declare const PROBE_MODEL = "MiniMax-M3";
+/**
+ * Prove the stored credential still authenticates.
+ *
+ * The probe is the real Messages endpoint, because that is the only surface the
+ * subscription exposes to a third-party client: there is no account-profile route
+ * and `/v1/models` is unavailable, so a 200 from `/messages` is what "signed in"
+ * means here. The request is deliberately tiny — one word, 16 output tokens — so a
+ * probe the user triggered by pressing a button costs almost nothing.
+ */
+export declare function testConnection(store: MinimaxCodeCredentialStore, options?: {
+    fetchFn?: typeof fetch;
+    signal?: AbortSignal;
+}): Promise<MinimaxProbeResult>;
+/**
+ * Non-streaming Messages call, used by callers that want the body rather than a stream.
+ *
+ * It exists so the streaming path is not the only implementation of the request
+ * shape: the probe and any future test use the same headers and URL builder, which
+ * is what keeps the Bearer rule from drifting in a second place.
+ */
+export declare function createMessage(store: MinimaxCodeCredentialStore, request: {
+    model: string;
+    maxTokens: number;
+    prompt: string;
+}, options?: {
+    fetchFn?: typeof fetch;
+    signal?: AbortSignal;
+}): Promise<{
+    ok: boolean;
+    status: number;
+    payload?: unknown;
+    error?: string;
+    latencyMs: number;
+}>;
+/**
+ * Headers for the Token Plan usage read.
+ *
+ * NOT {@link modelRequestHeaders}: that set asks for `text/event-stream` because
+ * the Messages route streams, and this route answers one JSON document. The
+ * credential is still the same bearer token.
+ */
+export declare function quotaRequestHeaders(accessToken: string, pathWithSearch: string, requestTime?: number): Record<string, string>;
+/**
+ * The host that last answered.
+ *
+ * Only a live call can settle which candidate serves this subscription, so the
+ * winner is remembered and probed first from then on.
+ */
+/**
+ * Why a usage snapshot is absent, when the reason is worth stating on the card.
+ *
+ * - `credential-not-accepted` — the endpoint answered, and refused THIS line's
+ *   credential because it needs a platform API key. Measured: every candidate
+ *   host answers HTTP 200 with `base_resp.status_code: 1004` for an
+ *   `mcode-public` (MiniMax Code) token, under every auth shape tried.
+ * - `unreachable` — no candidate host produced a usable answer at all.
+ */
+export type MinimaxCodeQuotaUnavailable = 'credential-not-accepted' | 'unreachable';
+/** Forget the cached usage snapshot (a sign-out, a sign-in, a test). */
+export declare function clearCachedQuota(): void;
+/** The last usage snapshot without touching the network. */
+export declare function getCachedQuota(): MinimaxCodeQuota | null;
+/** Why the last read produced no snapshot, or null when it produced one. */
+export declare function getQuotaUnavailable(): MinimaxCodeQuotaUnavailable | null;
+/**
+ * Resolve the ambiguous `*_usage_count` fields.
+ *
+ * TRANSCRIBED from the official CLI (`src/utils/quota.ts`), because the ambiguity
+ * is real and reading the field naively inverts the bar: older responses report
+ * it as a REMAINING count while newer ones report it as a CONSUMED count. When the
+ * server also returns an explicit remaining percentage, that percentage selects
+ * whichever reading agrees with it; when the counts agree with neither, this
+ * returns undefined and the window falls back to the percentage alone rather than
+ * inventing a number.
+ */
+export declare function resolveQuotaCounts(reportedCount: number, total: number, remainingPercent: number | undefined): {
+    used: number;
+    remaining: number;
+    total: number;
+} | undefined;
+/**
+ * Map one `/v1/token_plan/remains` document onto the card's quota shape.
+ *
+ * Returns null when nothing usable is present, which the contract defines as the
+ * card's graceful degradation.
+ */
+export declare function parseTokenPlanQuota(payload: unknown, now?: number): MinimaxCodeQuota | null;
+/**
+ * Read the Token Plan usage snapshot.
+ *
+ * The endpoint is undocumented (it was found in the official CLI, not in MiniMax's
+ * API docs), and which host serves THIS subscription has never been measured, so
+ * the candidates are tried in order and the winner is remembered. Any failure
+ * yields null: the contract makes `quota` optional precisely so a usage read can
+ * never break the connection half of the card.
+ */
+export declare function fetchTokenPlanQuota(credentials: MinimaxCodeCredentials, options?: {
+    fetchFn?: typeof fetch;
+    signal?: AbortSignal;
+    force?: boolean;
+}): Promise<MinimaxCodeQuota | null>;
+/**
+ * Every model id the hardcoded directory offers.
+ *
+ * Exposed as a function rather than re-exported directly so the status route
+ * cannot accidentally treat the catalog as live data: it is shipped, not fetched.
+ */
+export declare function listModelIds(): string[];
+/** The catalog entry count, for a status line that reports what is shipped. */
+export declare function catalogSize(): number;
+/**
+ * Whether a credential is worth reporting as signed in.
+ *
+ * A stored-but-expired credential still counts: the card's job is to show who is
+ * signed in and let the refresh path repair the token, not to hide an account whose
+ * access token happens to have aged out between two calls.
+ */
+export declare function describeCredentials(credentials: MinimaxCodeCredentials | null): MinimaxCodeAccount | null;
+export { MinimaxCodeUnauthorizedError, agentBaseUrl, MESSAGES_PATH, DEFAULT_DEVICE_INTERVAL_SECONDS, MINIMAX_CODE_BUILD_ENV, redactToken };
+export type { MinimaxCodeRegion };
+//# sourceMappingURL=client.d.ts.map

package/lib/types/host/minimax-code/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../src/host/minimax-code/client.ts"],"names":[],"mappings":"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"}

package/lib/types/host/minimax-code/mapper.d.ts

@@ -0,0 +1,143 @@
+/**
+ * Provider-wire mapping for the MiniMax Code subscription.
+ *
+ * The subscription speaks Anthropic Messages, so this file builds a
+ * \`/messages\` body and normalizes the SSE stream back into DSH's block/delta
+ * vocabulary.
+ *
+ * WHAT IS REUSED, AND WHAT IS NOT
+ *
+ * The generic halves of this problem already exist beside it in
+ * \`../kimi-code/mapper.ts\` and are imported rather than reimplemented: durable
+ * image resolution, the image budget that drops the oldest attachments first,
+ * JSON-Schema cleanup for tool parameters, and the serialized-body guard. None of
+ * those is provider-specific, and having one implementation is what keeps the two
+ * lines from drifting.
+ *
+ * The provider-specific halves are written here:
+ *
+ * - the thinking control. The subscription's own model table names its thinking
+ *   vocabulary (M2.7 always on with no level, M3 a two-state switch, M3.1 forced
+ *   on with a level), which is not Kimi's low/high/max ladder; and
+ * - every diagnostic string, because an error a user reads must name the service
+ *   they are actually talking to.
+ *
+ * WHAT IS MEASURED AND WHAT IS INFERRED
+ *
+ * Measured (brief sections 2.1 and 2.3): the endpoint, the URL shape
+ * \`<base>/mavis/api/v1/llm/v1/messages\`, the bearer header, the Anthropic
+ * protocol revision, the request body \`{model, max_tokens, messages}\` answering
+ * 200, and the four usage counters in the response.
+ *
+ * Inferred, and isolated in \`thinkingFieldFor\` so it is the only thing to change if
+ * it is ever contradicted: the \`thinking\` object's exact shape. The model table
+ * describes thinking as a state ("none-thinking / thinking") and, for M3.1, as an
+ * \`effort\` level, so the field is emitted in that vocabulary and nowhere else. No
+ * other undocumented field is ever sent.
+ *
+ * UNRESOLVED, AND DELIBERATELY NOT ACTED ON: prompt caching.
+ *
+ * No `cache_control` marker is ever sent, yet this file reads the two cache
+ * counters out of `usage` (see the message_start branch) - so the route is
+ * prepared to report cache hits it never asks for. MiniMax documents two
+ * different mechanisms, and they are not interchangeable:
+ *
+ * - an AUTOMATIC cache on its native API, which needs no marker at all; and
+ * - an EXPLICIT cache on its Anthropic-compatible API, where the
+ *   `cache_control` breakpoints are what create the cache at all
+ *   (`tools` -> `system` -> `messages`, per the "Explicit Prompt Caching
+ *   (Anthropic API)" page of the MiniMax docs).
+ *
+ * This line speaks the Anthropic dialect, so the explicit mechanism may well be
+ * the one that applies - but the subscription endpoint is NOT the public API
+ * (`<base>/mavis/api/v1/llm/v1/messages` vs `api.minimax.io/anthropic`), and its
+ * caching behaviour has never been measured here. Adding a marker is not free
+ * either: `system` is a plain string on this line, so a system-level breakpoint
+ * means changing that field into an array of blocks, and a marker on a block the
+ * wire does not accept can fail the whole request - the same class of total
+ * failure the missing `stream: true` caused.
+ *
+ * So the marker stays out until one live request settles it: send a body with
+ * and without a breakpoint and compare `cache_read_input_tokens`. The shape to
+ * copy once that is measured is the Claude line's, which marks only a block the
+ * wire accepts and states the intent at the call site because caching there is
+ * request-driven (`claude/mapper.ts`, `claude/adapter.ts`).
+ */
+import { type ContentBlock, type OutboundContentBlock, type GenerateOptions, type StreamChunk } from '../common/llm-compat.ts';
+import { MAX_MESSAGE_BODY_BYTES, estimatedInputTokens, offloadOldestRequestImages, resolveRequestImages, type AttachmentImageReader, type ResolvedRequestImages } from '../kimi-code/mapper.ts';
+import { ANTHROPIC_VERSION } from './types.ts';
+export { MAX_MESSAGE_BODY_BYTES, estimatedInputTokens, offloadOldestRequestImages, resolveRequestImages };
+export type { AttachmentImageReader, ResolvedRequestImages };
+/**
+ * The thinking control for one request.
+ *
+ * This is the single inferred field in the builder, and it is kept to the
+ * vocabulary the subscription's own model table uses:
+ *
+ * - \`always-on\` (M2.7, M2.7-highspeed): nothing is sent. The model always thinks
+ *   and has no level, so any field would be decoration at best and a rejected one
+ *   at worst;
+ * - \`toggle\` (M3): the table names the two states "none-thinking / thinking", so
+ *   the off state is the explicit disable and the on state is what a request that
+ *   says nothing already gets;
+ * - \`forced-effort\` (M3.1-Flash-Preview): thinking is forced on and the table
+ *   gives the level in an \`effort\` field, so the level travels there.
+ *
+ * A caller asking for a level the model does not list is mapped to the model's
+ * documented default by \`effortForModel\` before it reaches here.
+ */
+export declare function thinkingFieldFor(modelId: string, requestedEffort: string | undefined | null): Record<string, unknown> | undefined;
+/** Output cap one request asks for, tracked against the model's declared ceiling. */
+export declare function maxOutputTokensFor(modelId: string, contextWindow?: number): number;
+/** Reduce a requested cap so prompt plus output still fit the window. */
+export declare function clampOutputToContext(requested: number, contextWindow: number, estimatedInputTokens?: number): number;
+/** Build one Anthropic Messages body for this subscription. */
+export declare function buildMinimaxRequest(options: GenerateOptions, images?: ResolvedRequestImages): Record<string, unknown>;
+/**
+ * Reject a request the service would refuse, before sending it.
+ *
+ * @returns the serialized body, so the caller about to send it does not serialize
+ * a multi-megabyte string a second time.
+ */
+export declare function assertRequestBodyFits(body: Record<string, unknown>): string;
+/** One tool call accumulating across content-block deltas. */
+interface PendingToolCall {
+    blockIndex: number;
+    id: string;
+    name: string;
+    arguments: string;
+}
+/** Stream accumulator for one Messages response. */
+export interface MinimaxStreamState {
+    blocks: OutboundContentBlock[];
+    current: {
+        index: number;
+        type: 'text' | 'reasoning';
+        text: string;
+    } | null;
+    /** wire content-block index -> accumulating call. */
+    toolCalls: Map<number, PendingToolCall>;
+    /** wire content-block index -> our block index. */
+    contentIndexes: Map<number, number>;
+    hasContent: boolean;
+    hasToolCall: boolean;
+    finishReason: string | null;
+    done: boolean;
+    finished: boolean;
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
+    sawUsage: boolean;
+}
+export declare function createStreamState(): MinimaxStreamState;
+/** Flush every open block, then emit usage and the terminal finish. */
+export declare function closeMinimaxStream(state: MinimaxStreamState): StreamChunk[];
+/** Raise when a stream ended without the terminal event the protocol promises. */
+export declare function assertStreamComplete(state: MinimaxStreamState): void;
+/** Feed one SSE line from the Messages endpoint. */
+export declare function processMinimaxStreamLine(line: string, state: MinimaxStreamState): StreamChunk[];
+/** Whether one chunk stream carried any assistant content at all. */
+export declare function streamHasContent(state: MinimaxStreamState): boolean;
+export { ANTHROPIC_VERSION, type ContentBlock };
+//# sourceMappingURL=mapper.d.ts.map

package/lib/types/host/minimax-code/mapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapper.d.ts","sourceRoot":"","sources":["../../../../src/host/minimax-code/mapper.ts"],"names":[],"mappings":"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"}

package/lib/types/host/minimax-code/model-catalog.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Hardcoded catalog of the models the MiniMax Code subscription serves.
+ *
+ * This catalog is hardcoded on purpose. The endpoint documents a
+ * `GET /v1/models` route, but it is not configured for subscription traffic and
+ * answers 503 `{"errorCode":50115,"errorReason":"direct_route_not_configured"}`
+ * (and 401 when queried with `x-api-key`). Nothing in this package may probe it,
+ * at startup or otherwise.
+ *
+ * The four entries and every number in them are transcribed verbatim from the
+ * model table in `~/.minimax/config.yaml` (brief section 2.3). No value here is
+ * inferred from another provider's catalog.
+ */
+import type { MinimaxCodeModelOption, MinimaxCodeReasoningEffort } from '../../shared/minimax-code-contracts.ts';
+/**
+ * How one model's thinking behaves.
+ *
+ * - `always-on`    — thinking cannot be turned off and has no selectable level;
+ * - `toggle`       — thinking is on by default and can be disabled;
+ * - `forced-effort` — thinking is forced on and a level can be selected.
+ */
+export type MinimaxCodeThinkingMode = 'always-on' | 'toggle' | 'forced-effort';
+/** One model the MiniMax Code subscription serves. */
+export interface MinimaxCodeCatalogModel {
+    /** Exact model id to put on the wire. */
+    id: string;
+    /** Display name shown in the picker. */
+    name: string;
+    /** Context window the account is entitled to by default. */
+    contextWindow: number;
+    /** Larger window the model can reach, when one is offered as an option. */
+    optionalContextWindow: number | null;
+    /** Output cap the model accepts. */
+    maxTokens: number;
+    /**
+     * Input the model accepts.
+     *
+     * Declared as the wire accepts it. Note that a capability listed here is a claim
+     * DSH's capability pipeline acts on (prompt admission, the model picker, subagent
+     * delegation), so this line lists only what its mapper can actually put on the
+     * wire. Video is deliberately NOT listed even though the model table documents it
+     * on M3 and M3.1: DSH's attachment service is image-only and this line installs no
+     * video byte reader, so a clip that reached the mapper would be replaced by a
+     * placeholder — advertising it would promise an upload the route cannot perform.
+     * Add 'video' here only together with a real reader (see the Kimi Code line, which
+     * implements one in `video-store.ts` and widens the modality vocabulary for it).
+     */
+    inputModalities: readonly ('text' | 'image')[];
+    /** How thinking behaves on this model. */
+    thinking: MinimaxCodeThinkingMode;
+    /**
+     * Levels the model accepts, in escalating order.
+     *
+     * A single `default` entry means the model has no selectable level: the picker
+     * shows one always-on option rather than inventing a gradient the model does
+     * not document.
+     */
+    reasoningEfforts: readonly MinimaxCodeReasoningEffort[];
+    /** Level used when the conversation does not pick one. */
+    defaultReasoningEffort: MinimaxCodeReasoningEffort;
+    /** Attachments one request may carry, when the model states a bound. */
+    maxAttachments: number | null;
+    /** Largest single image the model accepts, in bytes. */
+    maxImageBytes: number | null;
+    /** Largest single video the model accepts, in bytes. */
+    maxVideoBytes: number | null;
+    /** Whether the model is served through the subscription's files API. */
+    supportsFilesApi: boolean;
+    /** One-line description, from the model table. */
+    description: string;
+}
+/**
+ * The four ids the subscription serves today.
+ *
+ * `MiniMax-M3` is the durable default: it is the flagship the measured request
+ * used, and it is the one model whose wire behaviour is directly attested.
+ */
+export declare const MINIMAX_CODE_MODELS: readonly MinimaxCodeCatalogModel[];
+/** Registry entry for one model id, or undefined when the id is unknown. */
+export declare function minimaxCodeModelDef(modelId: string): MinimaxCodeCatalogModel | undefined;
+/** Membership test for one known model id. */
+export declare function isMinimaxCodeModelId(value: unknown): boolean;
+/** Display name for one model id, falling back to the raw id so nothing is hidden. */
+export declare function minimaxCodeModelName(modelId: string): string;
+/** Every model id the picker offers, in catalog order. */
+export declare function minimaxCodeModelIds(): string[];
+/**
+ * Whether one effort id means "thinking off".
+ *
+ * The subscription table spells the disabled state "none-thinking" while the
+ * shared contract's effort vocabulary has no such member, so a caller that
+ * nevertheless asks for an off state (an older preference file, a hand-built
+ * request) is recognized here rather than silently treated as "on".
+ */
+export declare function isThinkingDisabledEffort(value: unknown): boolean;
+/**
+ * The effort level to put on the wire for one model.
+ *
+ * An unknown or off value falls back to the model's documented default, so a
+ * caller cannot talk this route into a level the model does not list.
+ */
+export declare function effortForModel(modelId: string, requested: string | undefined | null): MinimaxCodeReasoningEffort;
+/**
+ * Smallest context window an override may name.
+ *
+ * Exported because the settings route validates POSTed overrides against the
+ * same number this reader uses: if they drifted, the route would accept a value
+ * the reader then treats as absent, and the card would show a saved override
+ * that silently does nothing.
+ */
+export declare const MIN_CONTEXT_WINDOW = 1000;
+/**
+ * The effective context window for one model.
+ *
+ * One reader for both the status card and the request path, because the two
+ * disagreeing is the exact failure this override can cause: the card would show
+ * a window the request builder then ignored, and the user would see a request
+ * clamped to the catalog's number with nothing on screen explaining why.
+ *
+ * A non-positive or sub-minimum override is treated as absent rather than
+ * clamped: the route never stores one (it validates them), so seeing one means
+ * the document was hand-edited, and inventing a window from it would size every
+ * request on that model against a number the user never chose.
+ */
+export declare function contextWindowForModel(modelId: string, contextWindowOverrides: Record<string, number> | undefined): number;
+/**
+ * The catalog ids the user's stored selection actually resolves to.
+ *
+ * A stored list that still equals the shipped default has never been edited, so
+ * it cannot know about models a later release added; treating it as "everything
+ * the catalog currently offers" is what keeps a first run from hiding a new
+ * model behind an unedited default. Any explicit edit is honoured exactly, and
+ * an id the catalog no longer serves is dropped so the picker cannot offer a
+ * model this build has no entry for.
+ */
+export declare function resolveMinimaxCodeEnabledModelIds(stored: readonly string[], enabled?: boolean): string[];
+/**
+ * The settings-card rows for the whole shipped catalog.
+ *
+ * Every model is present, enabled or not: the card toggles rows, so a disabled
+ * model has to be rendered to be re-enabled. `contextWindow` is the effective
+ * window and `defaultContextWindow` the catalog's own number, which is what lets
+ * the card show a modified row as modified.
+ */
+export declare function buildMinimaxCodeModelOptions(storedEnabledModelIds: readonly string[], contextWindowOverrides: Record<string, number>, enabled?: boolean): MinimaxCodeModelOption[];
+//# sourceMappingURL=model-catalog.d.ts.map

package/lib/types/host/minimax-code/model-catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-catalog.d.ts","sourceRoot":"","sources":["../../../../src/host/minimax-code/model-catalog.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EACV,sBAAsB,EACtB,0BAA0B,EAE3B,MAAM,wCAAwC,CAAA;AAI/C;;;;;;GAMG;AACH,MAAM,MAAM,uBAAuB,GAAG,WAAW,GAAG,QAAQ,GAAG,eAAe,CAAA;AAE9E,sDAAsD;AACtD,MAAM,WAAW,uBAAuB;IACtC,yCAAyC;IACzC,EAAE,EAAE,MAAM,CAAA;IACV,wCAAwC;IACxC,IAAI,EAAE,MAAM,CAAA;IACZ,4DAA4D;IAC5D,aAAa,EAAE,MAAM,CAAA;IACrB,2EAA2E;IAC3E,qBAAqB,EAAE,MAAM,GAAG,IAAI,CAAA;IACpC,oCAAoC;IACpC,SAAS,EAAE,MAAM,CAAA;IACjB;;;;;;;;;;;;OAYG;IACH,eAAe,EAAE,SAAS,CAAC,MAAM,GAAG,OAAO,CAAC,EAAE,CAAA;IAC9C,0CAA0C;IAC1C,QAAQ,EAAE,uBAAuB,CAAA;IACjC;;;;;;OAMG;IACH,gBAAgB,EAAE,SAAS,0BAA0B,EAAE,CAAA;IACvD,0DAA0D;IAC1D,sBAAsB,EAAE,0BAA0B,CAAA;IAClD,wEAAwE;IACxE,cAAc,EAAE,MAAM,GAAG,IAAI,CAAA;IAC7B,wDAAwD;IACxD,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B,wDAAwD;IACxD,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B,wEAAwE;IACxE,gBAAgB,EAAE,OAAO,CAAA;IACzB,kDAAkD;IAClD,WAAW,EAAE,MAAM,CAAA;CACpB;AAED;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,EAAE,SAAS,uBAAuB,EAqEjE,CAAA;AAID,4EAA4E;AAC5E,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,uBAAuB,GAAG,SAAS,CAExF;AAED,8CAA8C;AAC9C,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAE5D;AAED,sFAAsF;AACtF,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE5D;AAED,0DAA0D;AAC1D,wBAAgB,mBAAmB,IAAI,MAAM,EAAE,CAE9C;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAIhE;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,GACnC,0BAA0B,CAO5B;AAMD;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,OAAQ,CAAA;AAEvC;;;;;;;;;;;;GAYG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,MAAM,EACf,sBAAsB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,GACzD,MAAM,CAOR;AAED;;;;;;;;;GASG;AACH,wBAAgB,iCAAiC,CAC/C,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,OAAO,UAAO,GACb,MAAM,EAAE,CAOV;AAED;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAC1C,qBAAqB,EAAE,SAAS,MAAM,EAAE,EACxC,sBAAsB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC9C,OAAO,UAAO,GACb,sBAAsB,EAAE,CAoB1B"}