@deepseek-harness-tui/dsh-tui 0.5.0

package/lib/types/ink/terminal-querier.d.ts

@@ -0,0 +1,161 @@
+/**
+ * Query the terminal and await responses without timeouts.
+ *
+ * Terminal queries (DECRQM, DA1, OSC 11, etc.) share the stdin stream
+ * with keyboard input. Response sequences are syntactically
+ * distinguishable from key events, so the input parser recognizes them
+ * and dispatches them here.
+ *
+ * To avoid timeouts, each query batch is terminated by a DA1 sentinel
+ * (CSI c) — every terminal since VT100 responds to DA1, and terminals
+ * answer queries in order. So: if your query's response arrives before
+ * DA1's, the terminal supports it; if DA1 arrives first, it doesn't.
+ *
+ * Usage:
+ *   const [sync, grapheme] = await Promise.all([
+ *     querier.send(decrqm(2026)),
+ *     querier.send(decrqm(2027)),
+ *     querier.flush(),
+ *   ])
+ *   // sync and grapheme are DECRPM responses or undefined if unsupported
+ */
+import type { TerminalResponse } from './parse-keypress.js';
+/** A terminal query: an outbound request sequence paired with a matcher
+ *  that recognizes the expected inbound response. Built by `decrqm()`,
+ *  `oscColor()`, `kittyKeyboard()`, etc. */
+export type TerminalQuery<T extends TerminalResponse = TerminalResponse> = {
+    /** Escape sequence to write to stdout */
+    request: string;
+    /** Recognizes the expected response in the inbound stream */
+    match: (r: TerminalResponse) => r is T;
+};
+type DecrpmResponse = Extract<TerminalResponse, {
+    type: 'decrpm';
+}>;
+type Da1Response = Extract<TerminalResponse, {
+    type: 'da1';
+}>;
+type Da2Response = Extract<TerminalResponse, {
+    type: 'da2';
+}>;
+type KittyResponse = Extract<TerminalResponse, {
+    type: 'kittyKeyboard';
+}>;
+type CursorPosResponse = Extract<TerminalResponse, {
+    type: 'cursorPosition';
+}>;
+type OscResponse = Extract<TerminalResponse, {
+    type: 'osc';
+}>;
+type XtversionResponse = Extract<TerminalResponse, {
+    type: 'xtversion';
+}>;
+/**
+ * DECRQM: request DEC private mode status (CSI ? mode $ p).
+ * Terminal replies with DECRPM (CSI ? mode ; status $ y) or ignores.
+ * @param mode - the DEC private mode number to query.
+ * @returns a query whose response is the DECRPM reply for mode.
+ */
+export declare function decrqm(mode: number): TerminalQuery<DecrpmResponse>;
+/**
+ * Primary Device Attributes query (CSI c). Every terminal answers this —
+ * used internally by flush() as a universal sentinel. Call directly if
+ * you want the DA1 params.
+ * @returns a query whose response is the DA1 reply.
+ */
+export declare function da1(): TerminalQuery<Da1Response>;
+/**
+ * Secondary Device Attributes query (CSI > c). Returns terminal version.
+ * @returns a query whose response is the DA2 reply.
+ */
+export declare function da2(): TerminalQuery<Da2Response>;
+/**
+ * Query current Kitty keyboard protocol flags (CSI ? u).
+ * Terminal replies with CSI ? flags u or ignores.
+ * @returns a query whose response is the Kitty keyboard reply.
+ */
+export declare function kittyKeyboard(): TerminalQuery<KittyResponse>;
+/**
+ * DECXCPR: request cursor position with DEC-private marker (CSI ? 6 n).
+ * Terminal replies with CSI ? row ; col R. The `?` marker is critical —
+ * the plain DSR form (CSI 6 n → CSI row;col R) is ambiguous with
+ * modified F3 keys (Shift+F3 = CSI 1;2 R, etc.).
+ * @returns a query whose response is the cursor-position reply.
+ */
+export declare function cursorPosition(): TerminalQuery<CursorPosResponse>;
+/**
+ * OSC dynamic color query (e.g. OSC 11 for bg color, OSC 10 for fg).
+ * The `?` data slot asks the terminal to reply with the current value.
+ * @param code - the OSC color code to query (10 = fg, 11 = bg, etc.).
+ * @returns a query whose response is the OSC color reply.
+ */
+export declare function oscColor(code: number): TerminalQuery<OscResponse>;
+/**
+ * XTVERSION: request terminal name/version (CSI > 0 q).
+ * Terminal replies with DCS > | name ST (e.g. "xterm.js(5.5.0)") or ignores.
+ * This survives SSH — the query goes through the pty, not the environment,
+ * so it identifies the *client* terminal even when TERM_PROGRAM isn't
+ * forwarded. Used to detect xterm.js for wheel-scroll compensation.
+ * @returns a query whose response is the XTVERSION reply.
+ */
+export declare function xtversion(): TerminalQuery<XtversionResponse>;
+/**
+ * Sends terminal queries to stdout and resolves their responses, using a
+ * flush() sentinel barrier so queries never time out.
+ */
+export declare class TerminalQuerier {
+    private stdout;
+    /**
+     * Interleaved queue of queries and sentinels in send order. Terminals
+     * respond in order, so each flush() barrier only drains queries queued
+     * before it — concurrent batches from independent callers stay isolated.
+     */
+    private queue;
+    constructor(stdout: NodeJS.WriteStream);
+    /**
+     * Send a query and wait for its response.
+     *
+     * Resolves with the response when `query.match` matches an incoming
+     * TerminalResponse, or with `undefined` when a flush() sentinel arrives
+     * before any matching response (meaning the terminal ignored the query).
+     *
+     * Never rejects; never times out on its own. If you never call flush()
+     * and the terminal doesn't respond, the promise remains pending.
+     * @param query - the query to send and await a response for.
+     * @returns the matched response, or undefined when the terminal did not
+     *   answer before the next flush() sentinel.
+     */
+    send<T extends TerminalResponse>(query: TerminalQuery<T>): Promise<T | undefined>;
+    /**
+     * Send the DA1 sentinel. Resolves when DA1's response arrives.
+     *
+     * As a side effect, all queries still pending when DA1 arrives are
+     * resolved with `undefined` (terminal didn't respond → doesn't support
+     * the query). This is the barrier that makes send() timeout-free.
+     *
+     * Safe to call with no pending queries — still waits for a round-trip.
+     */
+    flush(): Promise<void>;
+    /**
+     * Dispatch a response parsed from stdin. Called by App.tsx's
+     * processKeysInBatch for every `kind: 'response'` item.
+     *
+     * Matching strategy:
+     * - First, try to match a pending query (FIFO, first match wins).
+     *   This lets callers send(da1()) explicitly if they want the DA1
+     *   params — a separate DA1 write means the terminal sends TWO DA1
+     *   responses. The first matches the explicit query; the second
+     *   (unmatched) fires the sentinel.
+     * - Otherwise, if this is a DA1, fire the FIRST pending sentinel:
+     *   resolve any queries queued before that sentinel with undefined
+     *   (the terminal answered DA1 without answering them → unsupported)
+     *   and signal its flush() completion. Only draining up to the first
+     *   sentinel keeps later batches intact when multiple callers have
+     *   concurrent queries in flight.
+     * - Unsolicited responses (no match, no sentinel) are silently dropped.
+     * @param r - the response parsed from stdin.
+     */
+    onResponse(r: TerminalResponse): void;
+}
+export {};
+//# sourceMappingURL=terminal-querier.d.ts.map

package/lib/types/ink/terminal-querier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terminal-querier.d.ts","sourceRoot":"","sources":["../../../src/ink/terminal-querier.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAA;AAI3D;;4CAE4C;AAC5C,MAAM,MAAM,aAAa,CAAC,CAAC,SAAS,gBAAgB,GAAG,gBAAgB,IAAI;IACzE,yCAAyC;IACzC,OAAO,EAAE,MAAM,CAAA;IACf,6DAA6D;IAC7D,KAAK,EAAE,CAAC,CAAC,EAAE,gBAAgB,KAAK,CAAC,IAAI,CAAC,CAAA;CACvC,CAAA;AAED,KAAK,cAAc,GAAG,OAAO,CAAC,gBAAgB,EAAE;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC,CAAA;AACnE,KAAK,WAAW,GAAG,OAAO,CAAC,gBAAgB,EAAE;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,CAAC,CAAA;AAC7D,KAAK,WAAW,GAAG,OAAO,CAAC,gBAAgB,EAAE;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,CAAC,CAAA;AAC7D,KAAK,aAAa,GAAG,OAAO,CAAC,gBAAgB,EAAE;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,CAAC,CAAA;AACzE,KAAK,iBAAiB,GAAG,OAAO,CAAC,gBAAgB,EAAE;IAAE,IAAI,EAAE,gBAAgB,CAAA;CAAE,CAAC,CAAA;AAC9E,KAAK,WAAW,GAAG,OAAO,CAAC,gBAAgB,EAAE;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,CAAC,CAAA;AAC7D,KAAK,iBAAiB,GAAG,OAAO,CAAC,gBAAgB,EAAE;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,CAAC,CAAA;AAIzE;;;;;GAKG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,CAAC,cAAc,CAAC,CAKlE;AAED;;;;;GAKG;AACH,wBAAgB,GAAG,IAAI,aAAa,CAAC,WAAW,CAAC,CAKhD;AAED;;;GAGG;AACH,wBAAgB,GAAG,IAAI,aAAa,CAAC,WAAW,CAAC,CAKhD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,IAAI,aAAa,CAAC,aAAa,CAAC,CAK5D;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,IAAI,aAAa,CAAC,iBAAiB,CAAC,CAKjE;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,CAAC,WAAW,CAAC,CAKjE;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,IAAI,aAAa,CAAC,iBAAiB,CAAC,CAK5D;AAeD;;;GAGG;AACH,qBAAa,eAAe;IAQd,OAAO,CAAC,MAAM;IAP1B;;;;OAIG;IACH,OAAO,CAAC,KAAK,CAAgB;gBAET,MAAM,EAAE,MAAM,CAAC,WAAW;IAE9C;;;;;;;;;;;;OAYG;IACH,IAAI,CAAC,CAAC,SAAS,gBAAgB,EAC7B,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,GACtB,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;IAWzB;;;;;;;;OAQG;IACH,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAOtB;;;;;;;;;;;;;;;;;;OAkBG;IACH,UAAU,CAAC,CAAC,EAAE,gBAAgB,GAAG,IAAI;CAiBtC"}

package/lib/types/ink/terminal-querier.js

@@ -0,0 +1,204 @@
+/**
+ * Query the terminal and await responses without timeouts.
+ *
+ * Terminal queries (DECRQM, DA1, OSC 11, etc.) share the stdin stream
+ * with keyboard input. Response sequences are syntactically
+ * distinguishable from key events, so the input parser recognizes them
+ * and dispatches them here.
+ *
+ * To avoid timeouts, each query batch is terminated by a DA1 sentinel
+ * (CSI c) — every terminal since VT100 responds to DA1, and terminals
+ * answer queries in order. So: if your query's response arrives before
+ * DA1's, the terminal supports it; if DA1 arrives first, it doesn't.
+ *
+ * Usage:
+ *   const [sync, grapheme] = await Promise.all([
+ *     querier.send(decrqm(2026)),
+ *     querier.send(decrqm(2027)),
+ *     querier.flush(),
+ *   ])
+ *   // sync and grapheme are DECRPM responses or undefined if unsupported
+ */
+import { csi } from './termio/csi.js';
+import { osc } from './termio/osc.js';
+// -- Query builders --
+/**
+ * DECRQM: request DEC private mode status (CSI ? mode $ p).
+ * Terminal replies with DECRPM (CSI ? mode ; status $ y) or ignores.
+ * @param mode - the DEC private mode number to query.
+ * @returns a query whose response is the DECRPM reply for mode.
+ */
+export function decrqm(mode) {
+    return {
+        request: csi(`?${mode}$p`),
+        match: (r) => r.type === 'decrpm' && r.mode === mode,
+    };
+}
+/**
+ * Primary Device Attributes query (CSI c). Every terminal answers this —
+ * used internally by flush() as a universal sentinel. Call directly if
+ * you want the DA1 params.
+ * @returns a query whose response is the DA1 reply.
+ */
+export function da1() {
+    return {
+        request: csi('c'),
+        match: (r) => r.type === 'da1',
+    };
+}
+/**
+ * Secondary Device Attributes query (CSI > c). Returns terminal version.
+ * @returns a query whose response is the DA2 reply.
+ */
+export function da2() {
+    return {
+        request: csi('>c'),
+        match: (r) => r.type === 'da2',
+    };
+}
+/**
+ * Query current Kitty keyboard protocol flags (CSI ? u).
+ * Terminal replies with CSI ? flags u or ignores.
+ * @returns a query whose response is the Kitty keyboard reply.
+ */
+export function kittyKeyboard() {
+    return {
+        request: csi('?u'),
+        match: (r) => r.type === 'kittyKeyboard',
+    };
+}
+/**
+ * DECXCPR: request cursor position with DEC-private marker (CSI ? 6 n).
+ * Terminal replies with CSI ? row ; col R. The `?` marker is critical —
+ * the plain DSR form (CSI 6 n → CSI row;col R) is ambiguous with
+ * modified F3 keys (Shift+F3 = CSI 1;2 R, etc.).
+ * @returns a query whose response is the cursor-position reply.
+ */
+export function cursorPosition() {
+    return {
+        request: csi('?6n'),
+        match: (r) => r.type === 'cursorPosition',
+    };
+}
+/**
+ * OSC dynamic color query (e.g. OSC 11 for bg color, OSC 10 for fg).
+ * The `?` data slot asks the terminal to reply with the current value.
+ * @param code - the OSC color code to query (10 = fg, 11 = bg, etc.).
+ * @returns a query whose response is the OSC color reply.
+ */
+export function oscColor(code) {
+    return {
+        request: osc(code, '?'),
+        match: (r) => r.type === 'osc' && r.code === code,
+    };
+}
+/**
+ * XTVERSION: request terminal name/version (CSI > 0 q).
+ * Terminal replies with DCS > | name ST (e.g. "xterm.js(5.5.0)") or ignores.
+ * This survives SSH — the query goes through the pty, not the environment,
+ * so it identifies the *client* terminal even when TERM_PROGRAM isn't
+ * forwarded. Used to detect xterm.js for wheel-scroll compensation.
+ * @returns a query whose response is the XTVERSION reply.
+ */
+export function xtversion() {
+    return {
+        request: csi('>0q'),
+        match: (r) => r.type === 'xtversion',
+    };
+}
+// -- Querier --
+/** Sentinel request sequence (DA1). Kept internal; flush() writes it. */
+const SENTINEL = csi('c');
+/**
+ * Sends terminal queries to stdout and resolves their responses, using a
+ * flush() sentinel barrier so queries never time out.
+ */
+export class TerminalQuerier {
+    stdout;
+    /**
+     * Interleaved queue of queries and sentinels in send order. Terminals
+     * respond in order, so each flush() barrier only drains queries queued
+     * before it — concurrent batches from independent callers stay isolated.
+     */
+    queue = [];
+    constructor(stdout) {
+        this.stdout = stdout;
+    }
+    /**
+     * Send a query and wait for its response.
+     *
+     * Resolves with the response when `query.match` matches an incoming
+     * TerminalResponse, or with `undefined` when a flush() sentinel arrives
+     * before any matching response (meaning the terminal ignored the query).
+     *
+     * Never rejects; never times out on its own. If you never call flush()
+     * and the terminal doesn't respond, the promise remains pending.
+     * @param query - the query to send and await a response for.
+     * @returns the matched response, or undefined when the terminal did not
+     *   answer before the next flush() sentinel.
+     */
+    send(query) {
+        return new Promise(resolve => {
+            this.queue.push({
+                kind: 'query',
+                match: query.match,
+                resolve: r => resolve(r),
+            });
+            this.stdout.write(query.request);
+        });
+    }
+    /**
+     * Send the DA1 sentinel. Resolves when DA1's response arrives.
+     *
+     * As a side effect, all queries still pending when DA1 arrives are
+     * resolved with `undefined` (terminal didn't respond → doesn't support
+     * the query). This is the barrier that makes send() timeout-free.
+     *
+     * Safe to call with no pending queries — still waits for a round-trip.
+     */
+    flush() {
+        return new Promise(resolve => {
+            this.queue.push({ kind: 'sentinel', resolve });
+            this.stdout.write(SENTINEL);
+        });
+    }
+    /**
+     * Dispatch a response parsed from stdin. Called by App.tsx's
+     * processKeysInBatch for every `kind: 'response'` item.
+     *
+     * Matching strategy:
+     * - First, try to match a pending query (FIFO, first match wins).
+     *   This lets callers send(da1()) explicitly if they want the DA1
+     *   params — a separate DA1 write means the terminal sends TWO DA1
+     *   responses. The first matches the explicit query; the second
+     *   (unmatched) fires the sentinel.
+     * - Otherwise, if this is a DA1, fire the FIRST pending sentinel:
+     *   resolve any queries queued before that sentinel with undefined
+     *   (the terminal answered DA1 without answering them → unsupported)
+     *   and signal its flush() completion. Only draining up to the first
+     *   sentinel keeps later batches intact when multiple callers have
+     *   concurrent queries in flight.
+     * - Unsolicited responses (no match, no sentinel) are silently dropped.
+     * @param r - the response parsed from stdin.
+     */
+    onResponse(r) {
+        const idx = this.queue.findIndex(p => p.kind === 'query' && p.match(r));
+        if (idx !== -1) {
+            const [q] = this.queue.splice(idx, 1);
+            if (q?.kind === 'query')
+                q.resolve(r);
+            return;
+        }
+        if (r.type === 'da1') {
+            const s = this.queue.findIndex(p => p.kind === 'sentinel');
+            if (s === -1)
+                return;
+            for (const p of this.queue.splice(0, s + 1)) {
+                if (p.kind === 'query')
+                    p.resolve(undefined);
+                else
+                    p.resolve();
+            }
+        }
+    }
+}

package/lib/types/ink/terminal.d.ts

@@ -0,0 +1,80 @@
+import type { Writable } from 'stream';
+import type { Diff } from './frame.js';
+/**
+ * Progress-report state for OSC 9;4: a state plus an optional percentage.
+ */
+export type Progress = {
+    state: 'running' | 'completed' | 'error' | 'indeterminate';
+    percentage?: number;
+};
+/**
+ * Checks if the terminal supports OSC 9;4 progress reporting.
+ * Supported terminals:
+ * - ConEmu (Windows) - all versions
+ * - Ghostty 1.2.0+
+ * - iTerm2 3.6.6+
+ *
+ * Note: Windows Terminal interprets OSC 9;4 as notifications, not progress.
+ * @returns true when the terminal supports OSC 9;4 progress reporting.
+ */
+export declare function isProgressReportingAvailable(): boolean;
+/**
+ * Checks if the terminal supports DEC mode 2026 (synchronized output).
+ * When supported, BSU/ESU sequences prevent visible flicker during redraws.
+ * @returns true when the terminal supports DEC 2026.
+ */
+export declare function isSynchronizedOutputSupported(): boolean;
+/**
+ * Record the XTVERSION response. Called once from App.tsx when the reply
+ * arrives on stdin. No-op if already set (defend against re-probe).
+ * @param name - the terminal name reported by the XTVERSION reply.
+ */
+export declare function setXtversionName(name: string): void;
+/**
+ * True if running in an xterm.js-based terminal (VS Code, Cursor, Windsurf
+ * integrated terminals). Combines TERM_PROGRAM env check (fast, sync, but
+ * not forwarded over SSH) with the XTVERSION probe result (async, survives
+ * SSH — query/reply goes through the pty). Early calls may miss the probe
+ * reply — call lazily (e.g. in an event handler) if SSH detection matters.
+ * @returns true when the terminal is xterm.js-based.
+ */
+export declare function isXtermJs(): boolean;
+/**
+ * True if this terminal correctly handles extended key reporting
+ * (Kitty keyboard protocol + xterm modifyOtherKeys).
+ * @returns true when the terminal is on the extended-keys allowlist.
+ */
+export declare function supportsExtendedKeys(): boolean;
+/**
+ * True if the terminal scrolls the viewport when it receives cursor-up
+ * sequences that reach above the visible area. On Windows, conhost's
+ * SetConsoleCursorPosition follows the cursor into scrollback
+ * (microsoft/terminal#14774), yanking users to the top of their buffer
+ * mid-stream. WT_SESSION catches WSL-in-Windows-Terminal where platform
+ * is linux but output still routes through conhost.
+ * @returns true when the cursor-up viewport-yank bug applies.
+ */
+export declare function hasCursorUpViewportYankBug(): boolean;
+/**
+ * Whether synchronized output (DEC 2026) is available, computed once at
+ * module load — terminal capabilities don't change mid-session. Exported
+ * so callers can pass a sync-skip hint gated to specific modes.
+ */
+export declare const SYNC_OUTPUT_SUPPORTED: boolean;
+/**
+ * The output streams a terminal renders to.
+ */
+export type Terminal = {
+    stdout: Writable;
+    stderr: Writable;
+};
+/**
+ * Write a frame diff to the terminal as a single buffered write. Wraps
+ * the output in BSU/ESU synchronized-update markers unless skipSyncMarkers
+ * is set. No-op when the diff contains no patches.
+ * @param terminal - the terminal to write to.
+ * @param diff - the frame diff patches to render.
+ * @param skipSyncMarkers - when true, omit the BSU/ESU wrapping.
+ */
+export declare function writeDiffToTerminal(terminal: Terminal, diff: Diff, skipSyncMarkers?: boolean): void;
+//# sourceMappingURL=terminal.d.ts.map

package/lib/types/ink/terminal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terminal.d.ts","sourceRoot":"","sources":["../../../src/ink/terminal.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAA;AAKtC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AAKtC;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG;IACrB,KAAK,EAAE,SAAS,GAAG,WAAW,GAAG,OAAO,GAAG,eAAe,CAAA;IAC1D,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB,CAAA;AAED;;;;;;;;;GASG;AACH,wBAAgB,4BAA4B,IAAI,OAAO,CAuCtD;AAED;;;;GAIG;AACH,wBAAgB,6BAA6B,IAAI,OAAO,CAgDvD;AAcD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAEnD;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,IAAI,OAAO,CAGnC;AAmBD;;;;GAIG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CAE9C;AAED;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,IAAI,OAAO,CAEpD;AAED;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,SAAkC,CAAA;AAuBpE;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG;IACrB,MAAM,EAAE,QAAQ,CAAA;IAChB,MAAM,EAAE,QAAQ,CAAA;CACjB,CAAA;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,IAAI,EACV,eAAe,UAAQ,GACtB,IAAI,CAqEN"}