@rhinestone/sdk 2.0.0-beta.8 → 2.0.0

package/dist/src/clients/orchestrator/errors.js

@@ -0,0 +1,525 @@
+class OrchestratorError extends Error {
+    code;
+    traceId;
+    statusCode;
+    constructor(params) {
+        super(params.message);
+        this.code = params.code ?? 'UNKNOWN';
+        this.traceId = params.traceId ?? '';
+        this.statusCode = params.statusCode;
+    }
+}
+class ValidationError extends OrchestratorError {
+    issues;
+    constructor(params) {
+        super({ ...params, code: 'VALIDATION_ERROR' });
+        this.issues = params.issues ?? [];
+    }
+}
+class InsufficientLiquidityError extends OrchestratorError {
+    availableIntents;
+    unfillable;
+    constructor(params) {
+        super({ ...params, code: 'INSUFFICIENT_LIQUIDITY' });
+        this.availableIntents = params.availableIntents;
+        this.unfillable = params.unfillable;
+    }
+}
+class NotFoundError extends OrchestratorError {
+    constructor(params) {
+        super({ ...params, code: 'NOT_FOUND' });
+    }
+}
+class UnauthorizedError extends OrchestratorError {
+    constructor(params) {
+        super({ ...params, code: 'UNAUTHORIZED' });
+    }
+}
+class ForbiddenError extends OrchestratorError {
+    constructor(params) {
+        super({ ...params, code: params.code ?? 'FORBIDDEN' });
+    }
+}
+/**
+ * Thrown when an API key's scope denies the request.
+ *
+ * Subclass of `ForbiddenError` carrying the failed `scope` and the
+ * `required` / `actual` levels — distinct from a generic 403 so integrators
+ * can prompt the user to widen the key's scope rather than rotate it.
+ */
+class KeyScopeDeniedError extends ForbiddenError {
+    scope;
+    required;
+    actual;
+    constructor(params) {
+        super({ ...params, code: 'KEY_SCOPE_DENIED' });
+        this.scope = params.scope;
+        this.required = params.required;
+        this.actual = params.actual;
+    }
+}
+class ConflictError extends OrchestratorError {
+    constructor(params) {
+        super({ ...params, code: 'CONFLICT' });
+    }
+}
+class UnprocessableContentError extends OrchestratorError {
+    details;
+    constructor(params) {
+        super({ ...params, code: 'UNPROCESSABLE_CONTENT' });
+        this.details = params.details ?? [];
+    }
+}
+/** Per-client sponsorship cap a quote can breach. Mirrors the orchestrator's
+ * `SponsorLimits` keys: per-intent gas, per-intent bridge fee, or the
+ * per-intent aggregate. */
+const SPONSOR_LIMIT_KEYS = [
+    'gasPerIntentUSD',
+    'bridgeFeePerIntentUSD',
+    'perIntentUSD',
+];
+/**
+ * A configured per-client sponsorship cap was exceeded by a quote.
+ *
+ * A `422 UNPROCESSABLE_CONTENT` specialization: the integrator's sponsor
+ * policy sets a per-intent USD ceiling (gas, bridge-fee, or aggregate) and
+ * this quote's sponsored coverage would exceed it. Distinct from
+ * {@link InsufficientSponsorBalanceError} (a funds shortfall) — a cap breach
+ * is deterministic and does NOT clear by topping up the sponsorship balance;
+ * the cap itself must be raised or the intent made cheaper.
+ *
+ * Extends {@link UnprocessableContentError} and keeps `code` as
+ * `'UNPROCESSABLE_CONTENT'` (the wire does not yet carry a dedicated code), so
+ * existing handling of that error still catches it. `sponsorAddress` is
+ * populated only for the pre-fold check; the post-fold multi-candidate
+ * rejection omits it, so treat every field as best-effort.
+ */
+class SponsorLimitExceededError extends UnprocessableContentError {
+    limitKey;
+    capUsd;
+    coverageUsd;
+    sponsorAddress;
+    constructor(params) {
+        super(params);
+        this.limitKey = params.limitKey;
+        this.capUsd = params.capUsd;
+        this.coverageUsd = params.coverageUsd;
+        this.sponsorAddress = params.sponsorAddress;
+    }
+}
+/**
+ * The sponsor's prefunded balance cannot cover the sponsored categories for a
+ * quote.
+ *
+ * A `422 UNPROCESSABLE_CONTENT` specialization. Coverage is all-or-nothing:
+ * `failedCategories` lists the enabled categories (`gas`, `bridgeFee`,
+ * `swapFee`) that could not be covered. Unlike
+ * {@link SponsorLimitExceededError} (a configured policy cap), this clears once
+ * the sponsorship balance is topped up.
+ *
+ * Extends {@link UnprocessableContentError} and keeps `code` as
+ * `'UNPROCESSABLE_CONTENT'`, so existing handling of that error still catches
+ * it.
+ */
+class InsufficientSponsorBalanceError extends UnprocessableContentError {
+    failedCategories;
+    sponsorAddress;
+    remainingBalanceUsd;
+    totalSponsoredUsd;
+    constructor(params) {
+        super(params);
+        this.failedCategories = params.failedCategories ?? [];
+        this.sponsorAddress = params.sponsorAddress;
+        this.remainingBalanceUsd = params.remainingBalanceUsd;
+        this.totalSponsoredUsd = params.totalSponsoredUsd;
+    }
+}
+class RateLimitedError extends OrchestratorError {
+    retryAfter;
+    constructor(params) {
+        super({ ...params, code: 'TOO_MANY_REQUESTS' });
+        this.retryAfter = params.retryAfter;
+    }
+}
+class SettlementQuoteError extends OrchestratorError {
+    constructor(params) {
+        super({ ...params, code: 'SETTLEMENT_QUOTE_ERROR' });
+    }
+}
+class SettlementExecutionError extends OrchestratorError {
+    constructor(params) {
+        super({ ...params, code: 'SETTLEMENT_EXECUTION_ERROR' });
+    }
+}
+class SimulationFailedError extends OrchestratorError {
+    nonce;
+    category;
+    errorSelector;
+    errorName;
+    errorArgs;
+    retryable;
+    retryHint;
+    simulations;
+    constructor(params) {
+        super({ ...params, code: 'SIMULATION_FAILED' });
+        this.nonce = params.nonce;
+        this.category = params.category;
+        this.errorSelector = params.errorSelector;
+        this.errorName = params.errorName;
+        this.errorArgs = params.errorArgs;
+        this.retryable = params.retryable ?? false;
+        this.retryHint = params.retryHint;
+        this.simulations = params.simulations ?? [];
+    }
+}
+class ExternalServiceTimeoutError extends OrchestratorError {
+    constructor(params) {
+        super({ ...params, code: 'EXTERNAL_SERVICE_TIMEOUT' });
+    }
+}
+class RelayerMarketUnavailableError extends OrchestratorError {
+    constructor(params) {
+        super({ ...params, code: 'RELAYER_MARKET_UNAVAILABLE' });
+    }
+}
+class InternalServerError extends OrchestratorError {
+    constructor(params) {
+        super({ ...params, code: 'INTERNAL_ERROR' });
+    }
+}
+function parseTokenAmounts(record) {
+    return Object.fromEntries(Object.entries(record).map(([addr, amount]) => [addr, BigInt(amount)]));
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function stringValue(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+function booleanValue(value) {
+    return typeof value === 'boolean' ? value : undefined;
+}
+function numberValue(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function recordValue(value) {
+    return isRecord(value) ? value : undefined;
+}
+function parseErrorDetails(details) {
+    if (!Array.isArray(details)) {
+        return [];
+    }
+    return details.flatMap((detail) => {
+        if (!isRecord(detail) || typeof detail.message !== 'string') {
+            return [];
+        }
+        const context = recordValue(detail.context);
+        return [
+            {
+                message: detail.message,
+                ...(context ? { context } : {}),
+            },
+        ];
+    });
+}
+const SIMULATION_ACTIONS = ['claim', 'fill'];
+const SIMULATION_RETRY_HINTS = ['RE_PREPARE', 'RETRY_LATER'];
+const SIMULATION_ERROR_CATEGORIES = [
+    'QUOTE_EXPIRED',
+    'ORDER_EXPIRED',
+    'PERMIT_EXPIRED',
+    'PERMIT2_NONCE_CONSUMED',
+    'EXECUTOR_NONCE_CONSUMED',
+    'INVALID_SIGNATURE',
+    'INVALID_PERMIT2_SIGNATURE',
+    'INVALID_CONTRACT_SIGNATURE',
+    'INVALID_SIGNER',
+    'INSUFFICIENT_BALANCE',
+    'INSUFFICIENT_ALLOWANCE',
+    'ACCOUNT_CREATION_FAILED',
+    'ACCOUNT_UNAUTHORIZED',
+    'ADAPTER_CALL_FAILED',
+    'EXECUTION_FAILED',
+    'CLAIM_FAILED',
+    'ROUTER_PAUSED',
+    'ADAPTER_NOT_FOUND',
+    'PANIC',
+    'REQUIRE_FAILED',
+    'UNCLASSIFIED_REVERT',
+    'EMPTY_REVERT',
+];
+function oneOf(value, allowed) {
+    return typeof value === 'string' && allowed.includes(value)
+        ? value
+        : undefined;
+}
+function stringArrayValue(value) {
+    return Array.isArray(value)
+        ? value.filter((item) => typeof item === 'string')
+        : undefined;
+}
+function parseSimulationCall(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    return {
+        chainId: stringValue(value.chainId),
+        to: stringValue(value.to),
+        data: stringValue(value.data),
+        value: stringValue(value.value),
+    };
+}
+function parseSimulationDetails(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    return {
+        stateOverride: value.stateOverride,
+        blockNumber: stringValue(value.blockNumber),
+        relayer: stringValue(value.relayer),
+        simulationUrls: stringArrayValue(value.simulationUrls),
+    };
+}
+function isSimulationFailureSimulation(value) {
+    return isRecord(value) && value.success === false;
+}
+function parseSimulationFailureSimulation(value) {
+    if (!isSimulationFailureSimulation(value)) {
+        return undefined;
+    }
+    return {
+        success: false,
+        action: oneOf(value.action, SIMULATION_ACTIONS),
+        chainId: stringValue(value.chainId),
+        call: parseSimulationCall(value.call),
+        errorSelector: stringValue(value.errorSelector),
+        errorName: stringValue(value.errorName),
+        errorArgs: recordValue(value.errorArgs),
+        errorCategory: oneOf(value.errorCategory, SIMULATION_ERROR_CATEGORIES),
+        details: parseSimulationDetails(value.details),
+    };
+}
+function parseSimulationFailureDetails(details) {
+    if (!isRecord(details)) {
+        return {};
+    }
+    return {
+        nonce: stringValue(details.nonce),
+        category: oneOf(details.category, SIMULATION_ERROR_CATEGORIES),
+        errorSelector: stringValue(details.errorSelector),
+        errorName: stringValue(details.errorName),
+        errorArgs: recordValue(details.errorArgs),
+        retryable: booleanValue(details.retryable),
+        retryHint: oneOf(details.retryHint, SIMULATION_RETRY_HINTS),
+        simulations: Array.isArray(details.simulations)
+            ? details.simulations
+                .map(parseSimulationFailureSimulation)
+                .filter((simulation) => simulation !== undefined)
+            : undefined,
+    };
+}
+/**
+ * Detect a sponsor-specific failure inside a generic `UNPROCESSABLE_CONTENT`
+ * envelope. The orchestrator collapses both sponsor errors onto that wire code
+ * and carries the distinguishing code plus structured fields in the first
+ * detail's `context`. This reads that (untyped) context defensively and mints
+ * the typed error; anything unrecognized returns `undefined` so the caller
+ * falls back to a plain {@link UnprocessableContentError}.
+ *
+ * Interim: keyed on `details[0].context.code`, which is not part of the formal
+ * wire schema. If the orchestrator stops emitting it, detection degrades to the
+ * generic error (non-breaking). Superseded once a dedicated wire code ships.
+ */
+function parseSponsorError(base, details) {
+    const context = details[0]?.context;
+    if (!context) {
+        return undefined;
+    }
+    switch (stringValue(context.code)) {
+        case 'SPONSOR_LIMIT_EXCEEDED':
+            return new SponsorLimitExceededError({
+                ...base,
+                details,
+                limitKey: oneOf(context.limitKey, SPONSOR_LIMIT_KEYS),
+                capUsd: numberValue(context.capUSD),
+                coverageUsd: numberValue(context.coverageUSD),
+                sponsorAddress: stringValue(context.sponsorAddress),
+            });
+        case 'INSUFFICIENT_SPONSOR_BALANCE':
+            return new InsufficientSponsorBalanceError({
+                ...base,
+                details,
+                failedCategories: stringArrayValue(context.failedCategories),
+                sponsorAddress: stringValue(context.sponsorAddress),
+                remainingBalanceUsd: numberValue(context.remainingBalanceUSD),
+                totalSponsoredUsd: numberValue(context.totalSponsoredUSD),
+            });
+        default:
+            return undefined;
+    }
+}
+function parseErrorEnvelope(envelope, statusCode, retryAfter) {
+    const base = {
+        message: envelope.message,
+        traceId: envelope.traceId,
+        statusCode,
+    };
+    switch (envelope.code) {
+        case 'VALIDATION_ERROR': {
+            const issues = Array.isArray(envelope.details)
+                ? envelope.details
+                : [];
+            return new ValidationError({ ...base, issues });
+        }
+        case 'INSUFFICIENT_LIQUIDITY': {
+            const details = (envelope.details ?? {});
+            return new InsufficientLiquidityError({
+                ...base,
+                availableIntents: (details.availableIntents ?? []).map(parseTokenAmounts),
+                unfillable: parseTokenAmounts(details.unfillable ?? {}),
+            });
+        }
+        case 'NOT_FOUND':
+            return new NotFoundError(base);
+        case 'UNAUTHORIZED':
+            return new UnauthorizedError(base);
+        case 'FORBIDDEN':
+            return new ForbiddenError(base);
+        case 'KEY_SCOPE_DENIED': {
+            const detail = Array.isArray(envelope.details)
+                ? envelope.details[0]
+                : undefined;
+            const context = (detail?.context ?? {});
+            return new KeyScopeDeniedError({
+                ...base,
+                scope: context.scope ?? '',
+                required: context.required ?? '',
+                actual: context.actual ?? '',
+            });
+        }
+        case 'CONFLICT':
+            return new ConflictError(base);
+        case 'UNPROCESSABLE_CONTENT': {
+            const details = parseErrorDetails(envelope.details);
+            return (parseSponsorError(base, details) ??
+                new UnprocessableContentError({ ...base, details }));
+        }
+        case 'TOO_MANY_REQUESTS':
+            return new RateLimitedError({ ...base, retryAfter });
+        case 'SETTLEMENT_QUOTE_ERROR':
+            return new SettlementQuoteError(base);
+        case 'SETTLEMENT_EXECUTION_ERROR':
+            return new SettlementExecutionError(base);
+        case 'SIMULATION_FAILED':
+            return new SimulationFailedError({
+                ...base,
+                ...parseSimulationFailureDetails(envelope.details),
+            });
+        case 'EXTERNAL_SERVICE_TIMEOUT':
+            return new ExternalServiceTimeoutError(base);
+        case 'RELAYER_MARKET_UNAVAILABLE':
+            return new RelayerMarketUnavailableError(base);
+        case 'INTERNAL_ERROR':
+            return new InternalServerError(base);
+        default:
+            return new OrchestratorError({ ...base, code: 'UNKNOWN' });
+    }
+}
+function isOrchestratorError(error) {
+    return error instanceof OrchestratorError;
+}
+function isRateLimited(error) {
+    return error instanceof RateLimitedError;
+}
+function isValidationError(error) {
+    return error instanceof ValidationError;
+}
+function isAuthError(error) {
+    return error instanceof UnauthorizedError || error instanceof ForbiddenError;
+}
+function isSimulationFailed(error) {
+    return error instanceof SimulationFailedError;
+}
+function isSponsorLimitExceeded(error) {
+    return error instanceof SponsorLimitExceededError;
+}
+function isInsufficientSponsorBalance(error) {
+    return error instanceof InsufficientSponsorBalanceError;
+}
+/** Either sponsor failure: a configured cap breach or a balance shortfall. */
+function isSponsorError(error) {
+    return isSponsorLimitExceeded(error) || isInsufficientSponsorBalance(error);
+}
+function isRetryable(error) {
+    return (error instanceof InternalServerError ||
+        error instanceof ExternalServiceTimeoutError ||
+        error instanceof RelayerMarketUnavailableError ||
+        (error instanceof SimulationFailedError && error.retryable));
+}
+// Transport-level error codes that escape `fetch` as raw errors rather than
+// typed HTTP envelopes. Spans Node/undici and common system codes.
+const CONNECTION_ERROR_CODES = new Set([
+    'ECONNRESET',
+    'ECONNREFUSED',
+    'ECONNABORTED',
+    'ETIMEDOUT',
+    'EPIPE',
+    'ENOTFOUND',
+    'EAI_AGAIN',
+    'EHOSTUNREACH',
+    'ENETUNREACH',
+    'UND_ERR_SOCKET',
+    'UND_ERR_CONNECT_TIMEOUT',
+    'UND_ERR_HEADERS_TIMEOUT',
+    'UND_ERR_BODY_TIMEOUT',
+]);
+const CONNECTION_ERROR_MESSAGES = [
+    'socket connection was closed', // Bun
+    'fetch failed', // undici/Node (the coded cause is matched separately)
+    'failed to fetch', // Chrome/Edge
+    'networkerror when attempting to fetch', // Firefox
+    'network request failed',
+    'connection closed',
+    'connection reset',
+];
+/**
+ * Detects transport-level failures (connection reset, socket closed, DNS, TLS)
+ * that `fetch` rejects with instead of returning an HTTP response. Unlike HTTP
+ * errors — which the client converts into typed {@link OrchestratorError}s —
+ * these carry no status and bubble up untyped, so {@link isRetryable} misses
+ * them. They are safe to retry for idempotent reads (e.g. intent-status
+ * polling). We match by `code` and message across the cause chain — never by
+ * error type: `fetch` rejects network failures as `TypeError`, but `TypeError`
+ * is also thrown for logic bugs, bad URLs, and response-decoding errors that
+ * must NOT be retried (`waitForExecution` has no SDK-side deadline). Runtimes
+ * differ (Bun throws a plain `Error` with a socket message; undici/Node a
+ * `TypeError` with a coded `cause`), hence both signals. Caller-initiated
+ * aborts are excluded so deadlines/cancellation still propagate.
+ */
+function isConnectionError(error) {
+    // HTTP-status errors are already typed and classified elsewhere.
+    if (isOrchestratorError(error)) {
+        return false;
+    }
+    // Caller cancellation / deadline must propagate, not retry.
+    if (error instanceof Error && error.name === 'AbortError') {
+        return false;
+    }
+    // Walk the `cause` chain; `seen` guards against cyclic causes looping forever.
+    const seen = new Set();
+    let current = error;
+    while (current != null && !seen.has(current)) {
+        seen.add(current);
+        const code = current.code;
+        if (typeof code === 'string' && CONNECTION_ERROR_CODES.has(code)) {
+            return true;
+        }
+        const message = current instanceof Error ? current.message.toLowerCase() : '';
+        if (CONNECTION_ERROR_MESSAGES.some((m) => message.includes(m))) {
+            return true;
+        }
+        current = current.cause;
+    }
+    return false;
+}
+export { parseErrorEnvelope, isOrchestratorError, isRetryable, isConnectionError, isAuthError, isValidationError, isRateLimited, isSimulationFailed, isSponsorLimitExceeded, isInsufficientSponsorBalance, isSponsorError, OrchestratorError, ValidationError, InsufficientLiquidityError, SponsorLimitExceededError, InsufficientSponsorBalanceError, NotFoundError, UnauthorizedError, ForbiddenError, KeyScopeDeniedError, ConflictError, UnprocessableContentError, RateLimitedError, SettlementQuoteError, SettlementExecutionError, SimulationFailedError, ExternalServiceTimeoutError, RelayerMarketUnavailableError, InternalServerError, };

package/dist/src/clients/orchestrator/fetch.d.ts

@@ -0,0 +1,7 @@
+export type FetchPort = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+export declare function fetchOrchestratorJson(input: {
+    readonly fetch: FetchPort;
+    readonly url: string;
+    readonly init?: RequestInit;
+}): Promise<unknown>;
+//# sourceMappingURL=fetch.d.ts.map

package/dist/src/clients/orchestrator/fetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch.d.ts","sourceRoot":"","sources":["../../../../clients/orchestrator/fetch.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,SAAS,GAAG,CACtB,KAAK,EAAE,MAAM,GAAG,GAAG,GAAG,OAAO,EAC7B,IAAI,CAAC,EAAE,WAAW,KACf,OAAO,CAAC,QAAQ,CAAC,CAAA;AAEtB,wBAAsB,qBAAqB,CAAC,KAAK,EAAE;IACjD,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAA;IACzB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,IAAI,CAAC,EAAE,WAAW,CAAA;CAC5B,GAAG,OAAO,CAAC,OAAO,CAAC,CA4CnB"}

package/dist/src/clients/orchestrator/fetch.js

@@ -0,0 +1,37 @@
+import { parseErrorEnvelope } from './errors.js';
+export async function fetchOrchestratorJson(input) {
+    // Transport-level failures reject here and bubble up raw so `isConnectionError`
+    // can classify them for retry; only HTTP responses become typed errors.
+    const response = await input.fetch(input.url, input.init);
+    const traceId = response.headers.get('x-trace-id') ?? undefined;
+    if (!response.ok) {
+        let body;
+        try {
+            body = (await response.json());
+        }
+        catch {
+            body = {
+                code: 'INTERNAL_ERROR',
+                message: `Orchestrator request failed with status ${response.status}`,
+                traceId: '',
+            };
+        }
+        const envelope = {
+            code: body.code ?? 'INTERNAL_ERROR',
+            message: body.message ??
+                `Orchestrator request failed with status ${response.status}`,
+            traceId: traceId ?? body.traceId ?? '',
+            details: body.details,
+        };
+        const retryAfter = response.headers.get('retry-after') ?? undefined;
+        throw parseErrorEnvelope(envelope, response.status, retryAfter ?? undefined);
+    }
+    const body = await response.json();
+    if (body && typeof body === 'object' && !Array.isArray(body)) {
+        return {
+            ...body,
+            ...(traceId ? { traceId } : {}),
+        };
+    }
+    return body;
+}

package/dist/src/clients/orchestrator/mappers.d.ts

@@ -0,0 +1,9 @@
+import type { OrchestratorIntentRequest, OrchestratorIntentStatus, OrchestratorPortfolio, OrchestratorQuoteResponse, OrchestratorSignedIntent, OrchestratorSplitRequest, OrchestratorSplitResult } from './types.js';
+export declare function mapIntentRequestToWire(input: OrchestratorIntentRequest): unknown;
+export declare function mapQuoteResponseFromWire(value: unknown): OrchestratorQuoteResponse;
+export declare function mapSignedIntentToWire(input: OrchestratorSignedIntent): unknown;
+export declare function mapIntentStatusFromWire(intentId: string, value: unknown): OrchestratorIntentStatus;
+export declare function mapPortfolioFromWire(value: unknown): OrchestratorPortfolio;
+export declare function mapSplitRequestToWire(input: OrchestratorSplitRequest): unknown;
+export declare function mapSplitResultFromWire(value: unknown): OrchestratorSplitResult;
+//# sourceMappingURL=mappers.d.ts.map

package/dist/src/clients/orchestrator/mappers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mappers.d.ts","sourceRoot":"","sources":["../../../../clients/orchestrator/mappers.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EACV,yBAAyB,EACzB,wBAAwB,EACxB,qBAAqB,EAErB,yBAAyB,EACzB,wBAAwB,EACxB,wBAAwB,EACxB,uBAAuB,EACxB,MAAM,SAAS,CAAA;AAShB,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,yBAAyB,GAC/B,OAAO,CAuBT;AAED,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,OAAO,GACb,yBAAyB,CAM3B;AAED,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,wBAAwB,GAC9B,OAAO,CA0BT;AAED,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,OAAO,GACb,wBAAwB,CAwB1B;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,qBAAqB,CAuB1E;AAED,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,wBAAwB,GAC9B,OAAO,CAMT;AAED,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,OAAO,GACb,uBAAuB,CAgBzB"}