@cartanova/qgrid-cli 2.10.9 → 2.11.0

package/bundle/dist/utils/providers/grok/grok-direct-client.js

@@ -0,0 +1,196 @@
+import "./grok-constants.js";
+import { classifyGrokHttpError, encodeGrokRequestBody, normalizeGrokSSE, readGrokResponseHeaders } from "./grok-backend-protocol.js";
+//#region src/utils/providers/grok/grok-direct-client.ts
+const GROK_DEFAULT_IDLE_TIMEOUT_MS = 3e5;
+const GROK_PROXY_GET_TIMEOUT_MS = 1e4;
+const MAX_ERROR_BODY_LENGTH = 2e3;
+/**
+* A non-2xx response or a transport failure before any response arrived (`status = 0`).
+* Media/voice ports should throw this class too, so the dispatcher can apply §5.4 handling.
+*/
+var GrokHttpError = class extends Error {
+	classification;
+	bodyText;
+	responseHeaders;
+	constructor(classification, bodyText, responseHeaders = {}, options) {
+		const detail = classification.message ? `: ${classification.message}` : "";
+		super(classification.status === 0 ? `Grok request failed before a response${detail}` : `Grok HTTP ${classification.status} (${classification.kind})${detail}`, options);
+		this.name = "GrokHttpError";
+		this.classification = classification;
+		this.bodyText = bodyText.slice(0, MAX_ERROR_BODY_LENGTH);
+		this.responseHeaders = responseHeaders;
+	}
+	get status() {
+		return this.classification.status;
+	}
+};
+/** The stream produced no bytes for `idleTimeoutMs`. Upstream may already be executing. */
+var GrokIdleTimeoutError = class extends Error {
+	idleTimeoutMs;
+	constructor(idleTimeoutMs) {
+		super(`Grok stream idle for ${idleTimeoutMs} ms`);
+		this.name = "GrokIdleTimeoutError";
+		this.idleTimeoutMs = idleTimeoutMs;
+	}
+};
+function abortReason(signal) {
+	const reason = signal.reason;
+	return reason instanceof Error ? reason : new DOMException("Aborted", "AbortError");
+}
+function connectError(cause) {
+	const message = cause instanceof Error ? cause.message : String(cause);
+	return new GrokHttpError({
+		...classifyGrokHttpError(0, "", {}),
+		message
+	}, "", {}, { cause });
+}
+async function readErrorBody(response) {
+	try {
+		return (await response.text()).slice(0, MAX_ERROR_BODY_LENGTH);
+	} catch {
+		return "";
+	}
+}
+async function grokHttpErrorFromResponse(response) {
+	const bodyText = await readErrorBody(response);
+	return new GrokHttpError(classifyGrokHttpError(response.status, bodyText, response.headers), bodyText, readGrokResponseHeaders(response.headers));
+}
+/**
+* Yields from `source` but fails with GrokIdleTimeoutError when no item arrives within
+* `idleTimeoutMs`, and with the abort reason when `signal` aborts. `onStop` runs exactly once
+* when iteration ends for any reason, so the caller can cancel the underlying request.
+*/
+async function* guardStream(source, idleTimeoutMs, signal, onStop) {
+	const iterator = source[Symbol.asyncIterator]();
+	let settledNormally = false;
+	let pendingNext = false;
+	let stopped = false;
+	const stop = (reason) => {
+		if (stopped) return;
+		stopped = true;
+		onStop(reason);
+	};
+	try {
+		while (true) {
+			if (signal?.aborted) throw abortReason(signal);
+			let timer;
+			let removeAbort;
+			const interrupt = new Promise((_, reject) => {
+				timer = setTimeout(() => reject(new GrokIdleTimeoutError(idleTimeoutMs)), idleTimeoutMs);
+				if (signal) {
+					const onAbort = () => reject(abortReason(signal));
+					signal.addEventListener("abort", onAbort, { once: true });
+					removeAbort = () => signal.removeEventListener("abort", onAbort);
+				}
+			});
+			pendingNext = true;
+			const next = iterator.next().finally(() => {
+				pendingNext = false;
+			});
+			let result;
+			try {
+				result = await Promise.race([next, interrupt]);
+			} finally {
+				clearTimeout(timer);
+				removeAbort?.();
+			}
+			if (result.done) {
+				settledNormally = true;
+				return;
+			}
+			yield result.value;
+		}
+	} catch (error) {
+		stop(error instanceof Error ? error : new Error(String(error)));
+		throw error;
+	} finally {
+		if (settledNormally) stop(void 0);
+		else stop(new DOMException("Grok stream consumer stopped", "AbortError"));
+		if (!pendingNext) await iterator.return?.(void 0).catch(() => void 0);
+	}
+}
+var GrokChatClient = class {
+	fetchImpl;
+	baseUrl;
+	constructor(options = {}) {
+		this.fetchImpl = options.fetch ?? fetch;
+		this.baseUrl = options.baseUrl ?? "https://cli-chat-proxy.grok.com/v1";
+	}
+	/**
+	* POST {proxy}/responses. Resolves once response headers arrive; rejects with GrokHttpError on
+	* a non-2xx status or a transport failure, or with the abort reason when `signal` aborts.
+	* The stream ends at the first terminal event; `[DONE]` is not required.
+	*/
+	async stream(request) {
+		request.signal?.throwIfAborted();
+		const encoded = request.encoding === "plain" ? {
+			bytes: new TextEncoder().encode(JSON.stringify(request.body)),
+			contentEncoding: void 0
+		} : await encodeGrokRequestBody(request.body);
+		const headers = { ...request.headers };
+		if (encoded.contentEncoding) headers["content-encoding"] = encoded.contentEncoding;
+		else delete headers["content-encoding"];
+		const controller = new AbortController();
+		const signal = request.signal ? AbortSignal.any([request.signal, controller.signal]) : controller.signal;
+		let response;
+		try {
+			response = await this.fetchImpl(`${this.baseUrl}/responses`, {
+				method: "POST",
+				headers,
+				body: new Uint8Array(encoded.bytes),
+				signal
+			});
+		} catch (error) {
+			if (request.signal?.aborted) throw abortReason(request.signal);
+			throw connectError(error);
+		}
+		if (!response.ok) throw await grokHttpErrorFromResponse(response);
+		if (!response.body) throw new GrokHttpError({
+			...classifyGrokHttpError(502, "", response.headers),
+			message: "empty body"
+		}, "", readGrokResponseHeaders(response.headers));
+		const events = guardStream(normalizeGrokSSE(response.body), request.idleTimeoutMs ?? 3e5, request.signal, (reason) => {
+			if (reason) controller.abort(reason);
+		});
+		return {
+			status: response.status,
+			headers: readGrokResponseHeaders(response.headers),
+			events
+		};
+	}
+};
+/** GET {proxy}{path} returning parsed JSON; rejects with GrokHttpError on failure. */
+async function grokProxyGet(path, options) {
+	const timeout = AbortSignal.timeout(options.timeoutMs ?? 1e4);
+	const signal = options.signal ? AbortSignal.any([options.signal, timeout]) : timeout;
+	let response;
+	try {
+		response = await (options.fetch ?? fetch)(`${options.baseUrl ?? "https://cli-chat-proxy.grok.com/v1"}${path}`, {
+			method: "GET",
+			headers: options.headers,
+			signal
+		});
+	} catch (error) {
+		if (options.signal?.aborted) throw abortReason(options.signal);
+		throw connectError(error);
+	}
+	if (!response.ok) throw await grokHttpErrorFromResponse(response);
+	let json;
+	try {
+		json = await response.json();
+	} catch (error) {
+		throw new GrokHttpError({
+			...classifyGrokHttpError(502, "", response.headers),
+			message: "invalid JSON body"
+		}, "", readGrokResponseHeaders(response.headers), { cause: error });
+	}
+	return {
+		status: response.status,
+		headers: readGrokResponseHeaders(response.headers),
+		json
+	};
+}
+//#endregion
+export { GROK_DEFAULT_IDLE_TIMEOUT_MS, GROK_PROXY_GET_TIMEOUT_MS, GrokChatClient, GrokHttpError, GrokIdleTimeoutError, grokHttpErrorFromResponse, grokProxyGet };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"grok-direct-client.js","names":[],"sources":["../../../../src/utils/providers/grok/grok-direct-client.ts"],"sourcesContent":["import {\n  classifyGrokHttpError,\n  encodeGrokRequestBody,\n  normalizeGrokSSE,\n  readGrokResponseHeaders,\n  type GrokHttpErrorClassification,\n  type GrokNormalizedEvent,\n  type GrokResponseHeaderInfo,\n  type GrokResponsesRequest,\n} from \"./grok-backend-protocol\";\nimport { GROK_CHAT_PROXY_URL } from \"./grok-constants\";\n\n// HTTPS/SSE transport for the chat proxy. Headers are built by the caller (grok-headers.ts) so the\n// fingerprint stays in one place; this module only moves bytes, classifies HTTP failures, and\n// enforces abort and idle limits.\n\nexport const GROK_DEFAULT_IDLE_TIMEOUT_MS = 300_000;\nexport const GROK_PROXY_GET_TIMEOUT_MS = 10_000;\nconst MAX_ERROR_BODY_LENGTH = 2_000;\n\n/**\n * A non-2xx response or a transport failure before any response arrived (`status = 0`).\n * Media/voice ports should throw this class too, so the dispatcher can apply §5.4 handling.\n */\nexport class GrokHttpError extends Error {\n  readonly classification: GrokHttpErrorClassification;\n  readonly bodyText: string;\n  readonly responseHeaders: GrokResponseHeaderInfo;\n\n  constructor(\n    classification: GrokHttpErrorClassification,\n    bodyText: string,\n    responseHeaders: GrokResponseHeaderInfo = {},\n    options?: ErrorOptions,\n  ) {\n    const detail = classification.message ? `: ${classification.message}` : \"\";\n    super(\n      classification.status === 0\n        ? `Grok request failed before a response${detail}`\n        : `Grok HTTP ${classification.status} (${classification.kind})${detail}`,\n      options,\n    );\n    this.name = \"GrokHttpError\";\n    this.classification = classification;\n    this.bodyText = bodyText.slice(0, MAX_ERROR_BODY_LENGTH);\n    this.responseHeaders = responseHeaders;\n  }\n\n  get status(): number {\n    return this.classification.status;\n  }\n}\n\n/** The stream produced no bytes for `idleTimeoutMs`. Upstream may already be executing. */\nexport class GrokIdleTimeoutError extends Error {\n  readonly idleTimeoutMs: number;\n\n  constructor(idleTimeoutMs: number) {\n    super(`Grok stream idle for ${idleTimeoutMs} ms`);\n    this.name = \"GrokIdleTimeoutError\";\n    this.idleTimeoutMs = idleTimeoutMs;\n  }\n}\n\nfunction abortReason(signal: AbortSignal): Error {\n  const reason: unknown = signal.reason;\n\n  return reason instanceof Error ? reason : new DOMException(\"Aborted\", \"AbortError\");\n}\n\nfunction connectError(cause: unknown): GrokHttpError {\n  const message = cause instanceof Error ? cause.message : String(cause);\n\n  return new GrokHttpError({ ...classifyGrokHttpError(0, \"\", {}), message }, \"\", {}, { cause });\n}\n\nasync function readErrorBody(response: Response): Promise<string> {\n  try {\n    return (await response.text()).slice(0, MAX_ERROR_BODY_LENGTH);\n  } catch {\n    return \"\";\n  }\n}\n\nexport async function grokHttpErrorFromResponse(response: Response): Promise<GrokHttpError> {\n  const bodyText = await readErrorBody(response);\n\n  return new GrokHttpError(\n    classifyGrokHttpError(response.status, bodyText, response.headers),\n    bodyText,\n    readGrokResponseHeaders(response.headers),\n  );\n}\n\n/**\n * Yields from `source` but fails with GrokIdleTimeoutError when no item arrives within\n * `idleTimeoutMs`, and with the abort reason when `signal` aborts. `onStop` runs exactly once\n * when iteration ends for any reason, so the caller can cancel the underlying request.\n */\nasync function* guardStream<T>(\n  source: AsyncIterable<T>,\n  idleTimeoutMs: number,\n  signal: AbortSignal | undefined,\n  onStop: (reason: Error | undefined) => void,\n): AsyncGenerator<T> {\n  const iterator = source[Symbol.asyncIterator]();\n  let settledNormally = false;\n  let pendingNext = false;\n  let stopped = false;\n\n  const stop = (reason: Error | undefined) => {\n    if (stopped) return;\n    stopped = true;\n    onStop(reason);\n  };\n\n  try {\n    while (true) {\n      if (signal?.aborted) throw abortReason(signal);\n      let timer: NodeJS.Timeout | undefined;\n      let removeAbort: (() => void) | undefined;\n\n      const interrupt = new Promise<never>((_, reject) => {\n        timer = setTimeout(() => reject(new GrokIdleTimeoutError(idleTimeoutMs)), idleTimeoutMs);\n\n        if (signal) {\n          const onAbort = () => reject(abortReason(signal));\n          signal.addEventListener(\"abort\", onAbort, { once: true });\n          removeAbort = () => signal.removeEventListener(\"abort\", onAbort);\n        }\n      });\n\n      pendingNext = true;\n\n      const next = iterator.next().finally(() => {\n        pendingNext = false;\n      });\n\n      let result: IteratorResult<T>;\n\n      try {\n        result = await Promise.race([next, interrupt]);\n      } finally {\n        clearTimeout(timer);\n        removeAbort?.();\n      }\n\n      if (result.done) {\n        settledNormally = true;\n\n        return;\n      }\n\n      yield result.value;\n    }\n  } catch (error) {\n    stop(error instanceof Error ? error : new Error(String(error)));\n    throw error;\n  } finally {\n    if (settledNormally) stop(undefined);\n    else stop(new DOMException(\"Grok stream consumer stopped\", \"AbortError\"));\n\n    // A pending next() would block return(); the cancelled request settles it instead.\n    if (!pendingNext) await iterator.return?.(undefined).catch(() => undefined);\n  }\n}\n\nexport interface GrokChatStreamRequest {\n  body: GrokResponsesRequest;\n  /** Complete header map from buildGrokChatHeaders (bearer included). */\n  headers: Record<string, string>;\n  signal?: AbortSignal;\n  idleTimeoutMs?: number;\n  /** Defaults to zstd, as the pinned grok-build sends. */\n  encoding?: \"zstd\" | \"plain\";\n}\n\nexport interface GrokChatStream {\n  status: number;\n  headers: GrokResponseHeaderInfo;\n  events: AsyncGenerator<GrokNormalizedEvent>;\n}\n\nexport interface GrokChatClientOptions {\n  fetch?: typeof fetch;\n  baseUrl?: string;\n}\n\nexport class GrokChatClient {\n  readonly fetchImpl: typeof fetch;\n  readonly baseUrl: string;\n\n  constructor(options: GrokChatClientOptions = {}) {\n    this.fetchImpl = options.fetch ?? fetch;\n    this.baseUrl = options.baseUrl ?? GROK_CHAT_PROXY_URL;\n  }\n\n  /**\n   * POST {proxy}/responses. Resolves once response headers arrive; rejects with GrokHttpError on\n   * a non-2xx status or a transport failure, or with the abort reason when `signal` aborts.\n   * The stream ends at the first terminal event; `[DONE]` is not required.\n   */\n  async stream(request: GrokChatStreamRequest): Promise<GrokChatStream> {\n    request.signal?.throwIfAborted();\n\n    const encoded =\n      request.encoding === \"plain\"\n        ? {\n            bytes: new TextEncoder().encode(JSON.stringify(request.body)),\n            contentEncoding: undefined,\n          }\n        : await encodeGrokRequestBody(request.body);\n\n    const headers = { ...request.headers };\n\n    if (encoded.contentEncoding) headers[\"content-encoding\"] = encoded.contentEncoding;\n    else delete headers[\"content-encoding\"];\n\n    const controller = new AbortController();\n\n    const signal = request.signal\n      ? AbortSignal.any([request.signal, controller.signal])\n      : controller.signal;\n\n    let response: Response;\n\n    try {\n      response = await this.fetchImpl(`${this.baseUrl}/responses`, {\n        method: \"POST\",\n        headers,\n        body: new Uint8Array(encoded.bytes),\n        signal,\n      });\n    } catch (error) {\n      if (request.signal?.aborted) throw abortReason(request.signal);\n      throw connectError(error);\n    }\n\n    if (!response.ok) throw await grokHttpErrorFromResponse(response);\n\n    if (!response.body) {\n      throw new GrokHttpError(\n        { ...classifyGrokHttpError(502, \"\", response.headers), message: \"empty body\" },\n        \"\",\n        readGrokResponseHeaders(response.headers),\n      );\n    }\n\n    const events = guardStream(\n      normalizeGrokSSE(response.body),\n      request.idleTimeoutMs ?? GROK_DEFAULT_IDLE_TIMEOUT_MS,\n      request.signal,\n      (reason) => {\n        if (reason) controller.abort(reason);\n      },\n    );\n\n    return {\n      status: response.status,\n      headers: readGrokResponseHeaders(response.headers),\n      events,\n    };\n  }\n}\n\nexport interface GrokProxyGetResult {\n  status: number;\n  headers: GrokResponseHeaderInfo;\n  json: unknown;\n}\n\n/** GET {proxy}{path} returning parsed JSON; rejects with GrokHttpError on failure. */\nexport async function grokProxyGet(\n  path: string,\n  options: {\n    headers: Record<string, string>;\n    fetch?: typeof fetch;\n    signal?: AbortSignal;\n    baseUrl?: string;\n    timeoutMs?: number;\n  },\n): Promise<GrokProxyGetResult> {\n  const timeout = AbortSignal.timeout(options.timeoutMs ?? GROK_PROXY_GET_TIMEOUT_MS);\n  const signal = options.signal ? AbortSignal.any([options.signal, timeout]) : timeout;\n  let response: Response;\n\n  try {\n    response = await (options.fetch ?? fetch)(`${options.baseUrl ?? GROK_CHAT_PROXY_URL}${path}`, {\n      method: \"GET\",\n      headers: options.headers,\n      signal,\n    });\n  } catch (error) {\n    if (options.signal?.aborted) throw abortReason(options.signal);\n    throw connectError(error);\n  }\n\n  if (!response.ok) throw await grokHttpErrorFromResponse(response);\n  let json: unknown;\n\n  try {\n    json = await response.json();\n  } catch (error) {\n    throw new GrokHttpError(\n      { ...classifyGrokHttpError(502, \"\", response.headers), message: \"invalid JSON body\" },\n      \"\",\n      readGrokResponseHeaders(response.headers),\n      { cause: error },\n    );\n  }\n\n  return { status: response.status, headers: readGrokResponseHeaders(response.headers), json };\n}\n"],"mappings":";;;AAgBA,MAAa,+BAA+B;AAC5C,MAAa,4BAA4B;AACzC,MAAM,wBAAwB;;;;;AAM9B,IAAa,gBAAb,cAAmC,MAAM;CACvC;CACA;CACA;CAEA,YACE,gBACA,UACA,kBAA0C,CAAC,GAC3C,SACA;EACA,MAAM,SAAS,eAAe,UAAU,KAAK,eAAe,YAAY;EACxE,MACE,eAAe,WAAW,IACtB,wCAAwC,WACxC,aAAa,eAAe,OAAO,IAAI,eAAe,KAAK,GAAG,UAClE,OACF;EACA,KAAK,OAAO;EACZ,KAAK,iBAAiB;EACtB,KAAK,WAAW,SAAS,MAAM,GAAG,qBAAqB;EACvD,KAAK,kBAAkB;CACzB;CAEA,IAAI,SAAiB;EACnB,OAAO,KAAK,eAAe;CAC7B;AACF;;AAGA,IAAa,uBAAb,cAA0C,MAAM;CAC9C;CAEA,YAAY,eAAuB;EACjC,MAAM,wBAAwB,cAAc,IAAI;EAChD,KAAK,OAAO;EACZ,KAAK,gBAAgB;CACvB;AACF;AAEA,SAAS,YAAY,QAA4B;CAC/C,MAAM,SAAkB,OAAO;CAE/B,OAAO,kBAAkB,QAAQ,SAAS,IAAI,aAAa,WAAW,YAAY;AACpF;AAEA,SAAS,aAAa,OAA+B;CACnD,MAAM,UAAU,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;CAErE,OAAO,IAAI,cAAc;EAAE,GAAG,sBAAsB,GAAG,IAAI,CAAC,CAAC;EAAG;CAAQ,GAAG,IAAI,CAAC,GAAG,EAAE,MAAM,CAAC;AAC9F;AAEA,eAAe,cAAc,UAAqC;CAChE,IAAI;EACF,QAAQ,MAAM,SAAS,KAAK,EAAA,CAAG,MAAM,GAAG,qBAAqB;CAC/D,QAAQ;EACN,OAAO;CACT;AACF;AAEA,eAAsB,0BAA0B,UAA4C;CAC1F,MAAM,WAAW,MAAM,cAAc,QAAQ;CAE7C,OAAO,IAAI,cACT,sBAAsB,SAAS,QAAQ,UAAU,SAAS,OAAO,GACjE,UACA,wBAAwB,SAAS,OAAO,CAC1C;AACF;;;;;;AAOA,gBAAgB,YACd,QACA,eACA,QACA,QACmB;CACnB,MAAM,WAAW,OAAO,OAAO,cAAc,CAAC;CAC9C,IAAI,kBAAkB;CACtB,IAAI,cAAc;CAClB,IAAI,UAAU;CAEd,MAAM,QAAQ,WAA8B;EAC1C,IAAI,SAAS;EACb,UAAU;EACV,OAAO,MAAM;CACf;CAEA,IAAI;EACF,OAAO,MAAM;GACX,IAAI,QAAQ,SAAS,MAAM,YAAY,MAAM;GAC7C,IAAI;GACJ,IAAI;GAEJ,MAAM,YAAY,IAAI,SAAgB,GAAG,WAAW;IAClD,QAAQ,iBAAiB,OAAO,IAAI,qBAAqB,aAAa,CAAC,GAAG,aAAa;IAEvF,IAAI,QAAQ;KACV,MAAM,gBAAgB,OAAO,YAAY,MAAM,CAAC;KAChD,OAAO,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK,CAAC;KACxD,oBAAoB,OAAO,oBAAoB,SAAS,OAAO;IACjE;GACF,CAAC;GAED,cAAc;GAEd,MAAM,OAAO,SAAS,KAAK,CAAC,CAAC,cAAc;IACzC,cAAc;GAChB,CAAC;GAED,IAAI;GAEJ,IAAI;IACF,SAAS,MAAM,QAAQ,KAAK,CAAC,MAAM,SAAS,CAAC;GAC/C,UAAU;IACR,aAAa,KAAK;IAClB,cAAc;GAChB;GAEA,IAAI,OAAO,MAAM;IACf,kBAAkB;IAElB;GACF;GAEA,MAAM,OAAO;EACf;CACF,SAAS,OAAO;EACd,KAAK,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,KAAK,CAAC,CAAC;EAC9D,MAAM;CACR,UAAU;EACR,IAAI,iBAAiB,KAAK,MAAS;OAC9B,KAAK,IAAI,aAAa,gCAAgC,YAAY,CAAC;EAGxE,IAAI,CAAC,aAAa,MAAM,SAAS,SAAS,MAAS,CAAC,CAAC,YAAY,MAAS;CAC5E;AACF;AAuBA,IAAa,iBAAb,MAA4B;CAC1B;CACA;CAEA,YAAY,UAAiC,CAAC,GAAG;EAC/C,KAAK,YAAY,QAAQ,SAAS;EAClC,KAAK,UAAU,QAAQ,WAAA;CACzB;;;;;;CAOA,MAAM,OAAO,SAAyD;EACpE,QAAQ,QAAQ,eAAe;EAE/B,MAAM,UACJ,QAAQ,aAAa,UACjB;GACE,OAAO,IAAI,YAAY,CAAC,CAAC,OAAO,KAAK,UAAU,QAAQ,IAAI,CAAC;GAC5D,iBAAiB;EACnB,IACA,MAAM,sBAAsB,QAAQ,IAAI;EAE9C,MAAM,UAAU,EAAE,GAAG,QAAQ,QAAQ;EAErC,IAAI,QAAQ,iBAAiB,QAAQ,sBAAsB,QAAQ;OAC9D,OAAO,QAAQ;EAEpB,MAAM,aAAa,IAAI,gBAAgB;EAEvC,MAAM,SAAS,QAAQ,SACnB,YAAY,IAAI,CAAC,QAAQ,QAAQ,WAAW,MAAM,CAAC,IACnD,WAAW;EAEf,IAAI;EAEJ,IAAI;GACF,WAAW,MAAM,KAAK,UAAU,GAAG,KAAK,QAAQ,aAAa;IAC3D,QAAQ;IACR;IACA,MAAM,IAAI,WAAW,QAAQ,KAAK;IAClC;GACF,CAAC;EACH,SAAS,OAAO;GACd,IAAI,QAAQ,QAAQ,SAAS,MAAM,YAAY,QAAQ,MAAM;GAC7D,MAAM,aAAa,KAAK;EAC1B;EAEA,IAAI,CAAC,SAAS,IAAI,MAAM,MAAM,0BAA0B,QAAQ;EAEhE,IAAI,CAAC,SAAS,MACZ,MAAM,IAAI,cACR;GAAE,GAAG,sBAAsB,KAAK,IAAI,SAAS,OAAO;GAAG,SAAS;EAAa,GAC7E,IACA,wBAAwB,SAAS,OAAO,CAC1C;EAGF,MAAM,SAAS,YACb,iBAAiB,SAAS,IAAI,GAC9B,QAAQ,iBAAA,KACR,QAAQ,SACP,WAAW;GACV,IAAI,QAAQ,WAAW,MAAM,MAAM;EACrC,CACF;EAEA,OAAO;GACL,QAAQ,SAAS;GACjB,SAAS,wBAAwB,SAAS,OAAO;GACjD;EACF;CACF;AACF;;AASA,eAAsB,aACpB,MACA,SAO6B;CAC7B,MAAM,UAAU,YAAY,QAAQ,QAAQ,aAAA,GAAsC;CAClF,MAAM,SAAS,QAAQ,SAAS,YAAY,IAAI,CAAC,QAAQ,QAAQ,OAAO,CAAC,IAAI;CAC7E,IAAI;CAEJ,IAAI;EACF,WAAW,OAAO,QAAQ,SAAS,MAAA,CAAO,GAAG,QAAQ,WAAA,uCAAiC,QAAQ;GAC5F,QAAQ;GACR,SAAS,QAAQ;GACjB;EACF,CAAC;CACH,SAAS,OAAO;EACd,IAAI,QAAQ,QAAQ,SAAS,MAAM,YAAY,QAAQ,MAAM;EAC7D,MAAM,aAAa,KAAK;CAC1B;CAEA,IAAI,CAAC,SAAS,IAAI,MAAM,MAAM,0BAA0B,QAAQ;CAChE,IAAI;CAEJ,IAAI;EACF,OAAO,MAAM,SAAS,KAAK;CAC7B,SAAS,OAAO;EACd,MAAM,IAAI,cACR;GAAE,GAAG,sBAAsB,KAAK,IAAI,SAAS,OAAO;GAAG,SAAS;EAAoB,GACpF,IACA,wBAAwB,SAAS,OAAO,GACxC,EAAE,OAAO,MAAM,CACjB;CACF;CAEA,OAAO;EAAE,QAAQ,SAAS;EAAQ,SAAS,wBAAwB,SAAS,OAAO;EAAG;CAAK;AAC7F"}