@deepseek-harness-tui/dsh-tui 0.13.0 → 0.14.1

package/lib/types/backends/claude/translate/lanes.js

@@ -0,0 +1,177 @@
+import { arr, rec, str } from '../narrow.js';
+import { parseSendMessageInput, sendMessageCallView, sendMessageResultState, sendMessageResultView } from '../send-message.js';
+import { claudeToolRole, presentClaudeToolCall, presentClaudeToolResult } from '../tools.js';
+import { toolResultText } from './content.js';
+/** A backgrounded command's acknowledgement: where its output goes (the
+ *  rest of the line — a path may contain spaces). */
+const BACKGROUND_OUTPUT = /Output is being written to: ([^\r\n]+)/u;
+/**
+ * The output path a backgrounded command's acknowledgement names: the rest
+ * of its line, cut after `<taskId>.output` (the sentence that follows on the
+ * same line is not part of it), else after the first `.output` that ends a
+ * word. Undefined when the text names none.
+ */
+export function backgroundOutputPath(text, taskId) {
+    const line = BACKGROUND_OUTPUT.exec(text)?.[1]?.trim();
+    if (line === undefined || line === '')
+        return undefined;
+    const marker = `${taskId}.output`;
+    const at = line.indexOf(marker);
+    if (at !== -1)
+        return line.slice(0, at + marker.length);
+    return /^(.+?\.output)(?=[.,;:]?(?:\s|$))/u.exec(line)?.[1];
+}
+/** The longest lane tool-result text kept (a subagent card shows a one-line
+ *  preview; the full output stays in the subagent's own transcript). */
+const LANE_RESULT_CHARS = 2000;
+/** A lane payload cut to {@link LANE_RESULT_CHARS} (never a lone surrogate). */
+function clipLane(text) {
+    if (text.length <= LANE_RESULT_CHARS)
+        return text;
+    const code = text.charCodeAt(LANE_RESULT_CHARS - 1);
+    return `${text.slice(0, code >= 0xd800 && code <= 0xdbff ? LANE_RESULT_CHARS - 1 : LANE_RESULT_CHARS)}…`;
+}
+export function createLaneTranslator(context) {
+    const { options, openCalls, outputFiles, now, nextSeq, debug } = context;
+    /**
+     * The subagent an `Agent` / `Task` call delegates to, pre-created from the
+     * call itself (the call arrives before `task_started`): keyed
+     * by the call id until `task_started` names the subagent.
+     */
+    const delegation = (callId, input) => {
+        const args = rec(input);
+        return {
+            type: 'subagent.start',
+            agentId: callId,
+            parentCallId: callId,
+            description: str(args?.description) ?? '',
+            ...(str(args?.subagent_type) === undefined ? {} : { kind: str(args?.subagent_type) }),
+            ...(str(args?.model) === undefined ? {} : { model: str(args?.model) }),
+            background: args?.run_in_background === true,
+            time: now(),
+        };
+    };
+    /**
+     * A subagent's own traffic (`parent_tool_use_id` = the delegating call,
+     * with `forwardSubagentText`): its text and thinking, tool calls and
+     * results as child-lane events for its card and panels. The main lane's
+     * turn / step / attempt state is never touched; a nested delegation is
+     * pre-created like a main-lane one.
+     */
+    const translateLane = (lane, type, message) => {
+        const body = rec(message.message);
+        const out = [];
+        if (type === 'assistant') {
+            const id = str(body?.id) ?? `lane-${context.seq + 1}`;
+            const blocks = [];
+            for (const raw of arr(body?.content)) {
+                const block = rec(raw);
+                switch (str(block?.type)) {
+                    case 'thinking': {
+                        const text = str(block?.thinking) ?? '';
+                        if (text !== '')
+                            blocks.push({ type: 'reasoning', text });
+                        break;
+                    }
+                    case 'text': {
+                        const text = str(block?.text) ?? '';
+                        if (text !== '')
+                            blocks.push({ type: 'text', text });
+                        break;
+                    }
+                    default:
+                        break;
+                }
+            }
+            if (blocks.length > 0) {
+                out.push({ type: 'assistant.message', seq: nextSeq(), anchor: id, turn: context.turn, step: context.step, attemptId: id, time: now(), blocks, canonical: false, parentCallId: lane });
+            }
+            for (const raw of arr(body?.content)) {
+                const block = rec(raw);
+                if (block?.type !== 'tool_use')
+                    continue;
+                const callId = str(block.id);
+                const name = str(block.name);
+                if (callId === undefined || name === undefined)
+                    continue;
+                openCalls.set(callId, { name, input: block.input, turn: context.turn, lane });
+                const presentation = presentClaudeToolCall(name, block.input, options.cwd);
+                out.push({
+                    type: 'tool.call',
+                    seq: nextSeq(),
+                    anchor: callId,
+                    turn: context.turn,
+                    step: context.step,
+                    callId,
+                    name,
+                    argsJson: JSON.stringify(block.input ?? {}),
+                    parentCallId: lane,
+                    time: now(),
+                    ...(presentation === undefined ? {} : { presentation }),
+                });
+                if (claudeToolRole(name) === 'subagent')
+                    out.push(delegation(callId, block.input));
+                // A SendMessage the subagent issued is a relay from that lane (the
+                // delegating call id names the sender).
+                if (name === 'SendMessage') {
+                    const parsed = parseSendMessageInput(block.input);
+                    if (parsed !== undefined)
+                        out.push({ type: 'agent.message', message: sendMessageCallView({ callId, lane, input: parsed, observedAt: now() }) });
+                }
+            }
+            return out;
+        }
+        if (type === 'user') {
+            const results = arr(body?.content).flatMap(raw => rec(raw)?.type === 'tool_result' ? [rec(raw)] : []);
+            // Message-level, as on the main lane: it describes a single result.
+            const structured = results.length === 1 ? rec(message.tool_use_result) : undefined;
+            for (const block of results) {
+                const callId = str(block.tool_use_id);
+                if (callId === undefined)
+                    continue;
+                const call = openCalls.get(callId);
+                openCalls.delete(callId);
+                const isError = block.is_error === true;
+                const fullText = toolResultText(block.content);
+                // A lane result only feeds its subagent card (a one-line preview):
+                // its payload is cut, so replayed history that lives as long as the
+                // session never keeps whole tool outputs.
+                const text = clipLane(fullText);
+                const presentation = call === undefined ? undefined : presentClaudeToolResult(call.name, call.input, { isError, text, structured: undefined }, options.cwd);
+                out.push({
+                    type: 'tool.result',
+                    seq: nextSeq(),
+                    turn: context.turn,
+                    step: context.step,
+                    callId,
+                    isError,
+                    time: now(),
+                    content: [{ type: 'text', text }],
+                    text: isError ? '' : text,
+                    ...(isError ? { errorText: text } : {}),
+                    ...(presentation === undefined ? {} : { presentation }),
+                    parentCallId: lane,
+                });
+                // Settle the lane's SendMessage from its result: an error is a
+                // refusal, anything unrecognized stays 'unknown'.
+                if (call?.name === 'SendMessage') {
+                    out.push({ type: 'agent.message', message: sendMessageResultView({ callId, observedAt: now(), state: sendMessageResultState({ isError, structured: undefined }) }) });
+                }
+                // A background command a subagent started names its output file in
+                // its acknowledgement too.
+                const backgroundTask = str(structured?.backgroundTaskId);
+                const outputFile = backgroundTask === undefined || isError ? undefined : backgroundOutputPath(fullText, backgroundTask);
+                if (backgroundTask !== undefined && outputFile !== undefined) {
+                    outputFiles.set(backgroundTask, outputFile);
+                    out.push({ type: 'task.update', taskId: backgroundTask, patch: { outputFile } });
+                }
+            }
+            // The subagent's prompt (its first user text) is not shown.
+            return out;
+        }
+        // Streamed partials of a subagent: its settled messages carry the content.
+        debug(`claude: subagent stream frame ignored (${lane})`);
+        return out;
+    };
+    return { delegation, translateLane };
+}

package/lib/types/backends/claude/translate/messages.d.ts

@@ -0,0 +1,36 @@
+/** Translate main-lane assistant blocks, user echoes and tool results. */
+import type { AgentEvent, UsageDelta } from '../../../agent/events.js';
+import { type Rec } from '../narrow.js';
+import type { createTaskTools } from './tasks.js';
+import type { ClaudeTranslatorOptions, ClaudeUserRows, OpenAttempt, RegisteredInput } from './types.js';
+export declare function createMessageTranslator(context: {
+    readonly options: ClaudeTranslatorOptions;
+    readonly userRows: ClaudeUserRows;
+    readonly seq: number;
+    readonly turn: number;
+    readonly step: number;
+    currentMode: string | undefined;
+    toolResults: number;
+    summaryExpected: boolean;
+    readonly inputs: Map<string, RegisteredInput>;
+    readonly openCalls: Map<string, {
+        readonly name: string;
+        readonly input: unknown;
+        readonly turn: number;
+        readonly lane?: string;
+    }>;
+    readonly deniedReasons: Map<string, string>;
+    readonly outputFiles: Map<string, string>;
+    readonly tasks: ReturnType<typeof createTaskTools>;
+    now(): number;
+    nextSeq(): number;
+    debug(message: string): void;
+    ensureAttempt(out: AgentEvent[], id: string, model: string | undefined, usage: UsageDelta | undefined): OpenAttempt | undefined;
+    settleAttempt(out: AgentEvent[]): void;
+    confirmInput(out: AgentEvent[], uuid: string): void;
+    delegation(callId: string, input: unknown): AgentEvent;
+}): {
+    translateAssistant: (message: Rec) => AgentEvent[];
+    translateUser: (message: Rec) => AgentEvent[];
+};
+//# sourceMappingURL=messages.d.ts.map

package/lib/types/backends/claude/translate/messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../../../../src/backends/claude/translate/messages.ts"],"names":[],"mappings":"AAAA,0EAA0E;AAC1E,OAAO,KAAK,EAAE,UAAU,EAAkC,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAEtG,OAAO,EAAiB,KAAK,GAAG,EAAE,MAAM,cAAc,CAAA;AAKtD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AACjD,OAAO,KAAK,EAAE,uBAAuB,EAAE,cAAc,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAEvG,wBAAgB,uBAAuB,CAAC,OAAO,EAAE;IAC/C,QAAQ,CAAC,OAAO,EAAE,uBAAuB,CAAA;IACzC,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAA;IACjC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,WAAW,EAAE,MAAM,GAAG,SAAS,CAAA;IAC/B,WAAW,EAAE,MAAM,CAAA;IACnB,eAAe,EAAE,OAAO,CAAA;IACxB,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,CAAA;IAC7C,QAAQ,CAAC,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;IAClI,QAAQ,CAAC,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC3C,QAAQ,CAAC,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACzC,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC,OAAO,eAAe,CAAC,CAAA;IAClD,GAAG,IAAI,MAAM,CAAA;IACb,OAAO,IAAI,MAAM,CAAA;IACjB,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B,aAAa,CAAC,GAAG,EAAE,UAAU,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,KAAK,EAAE,UAAU,GAAG,SAAS,GAAG,WAAW,GAAG,SAAS,CAAA;IAC/H,aAAa,CAAC,GAAG,EAAE,UAAU,EAAE,GAAG,IAAI,CAAA;IACtC,YAAY,CAAC,GAAG,EAAE,UAAU,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACnD,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,UAAU,CAAA;CACvD;kCAEsC,GAAG,KAAG,UAAU,EAAE;6BAgFvB,GAAG,KAAG,UAAU,EAAE;EAqGnD"}

package/lib/types/backends/claude/translate/messages.js

@@ -0,0 +1,202 @@
+import { t } from '../../../i18n.js';
+import { arr, rec, str } from '../narrow.js';
+import { parseSendMessageInput, sendMessageCallView, sendMessageResultState, sendMessageResultView } from '../send-message.js';
+import { claudeToolRole, presentClaudeToolCall, presentClaudeToolResult } from '../tools.js';
+import { COMMAND_TAG, INTERRUPT_ECHO, LOCAL_COMMAND_TAG, questionRecordText, toolResultText, usageOf, userText } from './content.js';
+import { backgroundOutputPath } from './lanes.js';
+export function createMessageTranslator(context) {
+    const { options, inputs, openCalls, deniedReasons, outputFiles, tasks, now, nextSeq, debug, ensureAttempt, settleAttempt, confirmInput, delegation } = context;
+    const translateAssistant = (message) => {
+        const body = rec(message.message);
+        const id = str(body?.id);
+        if (body === undefined || id === undefined)
+            return [];
+        const out = [];
+        const open = ensureAttempt(out, id, str(body.model), usageOf(body.usage));
+        if (open === undefined) {
+            debug(`claude: late block of settled message ${id} ignored`);
+            return out;
+        }
+        open.usage ??= usageOf(body.usage);
+        if (message.aborted === true)
+            open.aborted = true;
+        const error = str(message.error);
+        if (error !== undefined)
+            out.push({ type: 'notice', level: 'error', text: t('claude-assistant-error', { error }) });
+        for (const raw of arr(body.content)) {
+            const block = rec(raw);
+            if (block === undefined)
+                continue;
+            open.blocks += 1;
+            switch (str(block.type)) {
+                case 'thinking':
+                    open.reasoning += str(block.thinking) ?? '';
+                    break;
+                case 'redacted_thinking':
+                    break;
+                case 'text':
+                    open.text += str(block.text) ?? '';
+                    break;
+                case 'tool_use': {
+                    const callId = str(block.id);
+                    const name = str(block.name);
+                    if (callId === undefined || name === undefined)
+                        break;
+                    const input = block.input;
+                    openCalls.set(callId, { name, input, turn: context.turn });
+                    // Plan-mode tools render as a mode change and the plan-review
+                    // panel, never as a card: no call, and their result below only
+                    // reports the outcome.
+                    if (claudeToolRole(name) === 'plan')
+                        break;
+                    const presentation = presentClaudeToolCall(name, input, options.cwd);
+                    out.push({
+                        type: 'tool.call',
+                        seq: nextSeq(),
+                        anchor: callId,
+                        turn: context.turn,
+                        step: open.step,
+                        callId,
+                        name,
+                        argsJson: JSON.stringify(input ?? {}),
+                        time: now(),
+                        ...(presentation === undefined ? {} : { presentation }),
+                    });
+                    if (claudeToolRole(name) === 'subagent')
+                        out.push(delegation(callId, input));
+                    // The session's own SendMessage is a relay from the parent (no
+                    // sender id).
+                    if (name === 'SendMessage') {
+                        const parsed = parseSendMessageInput(input);
+                        if (parsed !== undefined)
+                            out.push({ type: 'agent.message', message: sendMessageCallView({ callId, input: parsed, observedAt: now() }) });
+                    }
+                    tasks.applyTaskInput(out, name, input);
+                    break;
+                }
+                default:
+                    break;
+            }
+        }
+        // An aborted response gets no message_stop: it settles here with the
+        // prefix it streamed.
+        if (open.aborted)
+            settleAttempt(out);
+        return out;
+    };
+    /** What a settled plan-mode tool means for the transcript and the mode. */
+    const planOutcome = (name, isError) => {
+        if (name === 'EnterPlanMode') {
+            if (isError || context.currentMode === 'plan')
+                return [];
+            context.currentMode = 'plan';
+            return [{ type: 'mode.changed', modeId: 'plan' }];
+        }
+        return [{ type: 'notice', level: 'info', text: t(isError ? 'claude-plan-kept' : 'claude-plan-approved') }];
+    };
+    const translateUser = (message) => {
+        const body = rec(message.message);
+        const content = body?.content;
+        const out = [];
+        const uuid = str(message.uuid);
+        // Our own message echoed back (`--replay-user-messages` fallback).
+        if (message.isReplay === true && uuid !== undefined && inputs.has(uuid)) {
+            if (context.userRows === 'replay')
+                confirmInput(out, uuid);
+            return out;
+        }
+        const results = arr(content).flatMap(raw => {
+            const block = rec(raw);
+            return block?.type === 'tool_result' ? [block] : [];
+        });
+        if (results.length > 0) {
+            // The open attempt is not settled here: the CLI drains finished tool
+            // results while the same API message is still streaming (parallel
+            // calls), so a later block of that message — another tool_use, more
+            // text, the closing usage — still belongs to it. It settles on
+            // `message_stop`, a new message id, an abort, `result` or a forced
+            // close.
+            // `tool_use_result` is message-level: it describes the one result of a
+            // single-result message and nothing when several share the message.
+            const structured = results.length === 1 ? message.tool_use_result : undefined;
+            for (const block of results) {
+                const callId = str(block.tool_use_id);
+                if (callId === undefined)
+                    continue;
+                const call = openCalls.get(callId);
+                openCalls.delete(callId);
+                // A TaskUpdate the CLI refused may say so only in its structured
+                // result (`success:false`, no `is_error`): it failed all the same,
+                // so its failure still gets a card.
+                const isError = block.is_error === true || (call !== undefined && call.name === 'TaskUpdate' && rec(structured)?.success === false);
+                const rawText = toolResultText(block.content);
+                if (call !== undefined && claudeToolRole(call.name) === 'plan') {
+                    out.push(...planOutcome(call.name, isError));
+                    continue;
+                }
+                // An auto-denied call: its card names the deciding component's reason.
+                const denied = deniedReasons.get(callId);
+                deniedReasons.delete(callId);
+                const text = isError && denied !== undefined && !rawText.includes(denied)
+                    ? `${rawText}${rawText === '' ? '' : '\n'}${t('claude-denied-reason', { reason: denied })}`
+                    : call !== undefined && claudeToolRole(call.name) === 'question' && !isError
+                        ? questionRecordText(call.input, structured, rawText)
+                        : rawText;
+                const presentation = call === undefined ? undefined : presentClaudeToolResult(call.name, call.input, { isError, text, structured }, options.cwd);
+                out.push({
+                    type: 'tool.result',
+                    seq: nextSeq(),
+                    turn: context.turn,
+                    step: context.step,
+                    callId,
+                    isError,
+                    time: now(),
+                    content: typeof block.content === 'string' ? [{ type: 'text', text }] : arr(block.content),
+                    text: isError ? '' : text,
+                    ...(isError ? { errorText: text } : {}),
+                    ...(structured === undefined ? {} : { structured }),
+                    ...(presentation === undefined ? {} : { presentation }),
+                });
+                // Settle the parent's SendMessage from its result: only an explicit
+                // structured field or an error says more than 'unknown'.
+                if (call?.name === 'SendMessage') {
+                    out.push({ type: 'agent.message', message: sendMessageResultView({ callId, observedAt: now(), state: sendMessageResultState({ isError, structured }) }) });
+                }
+                // Every settled main-lane result is one tool done this turn (the
+                // working line's toolCount; plan-mode tools continue'd above).
+                context.toolResults += 1;
+                tasks.applyTaskResult(out, call, isError, structured, openCalls);
+                // A backgrounded command's acknowledgement names its output file
+                // (`task_started` does not): the job's output tail is read from it.
+                const backgroundTask = str(rec(structured)?.backgroundTaskId);
+                const outputFile = backgroundTask === undefined || isError ? undefined : backgroundOutputPath(rawText, backgroundTask);
+                if (backgroundTask !== undefined && outputFile !== undefined) {
+                    outputFiles.set(backgroundTask, outputFile);
+                    out.push({ type: 'task.update', taskId: backgroundTask, patch: { outputFile } });
+                }
+            }
+            return out;
+        }
+        const text = userText(content)?.trim();
+        if (text === undefined || text === '')
+            return out;
+        // Abort echoes and local-command transcript records are not bubbles.
+        if (text.startsWith(INTERRUPT_ECHO) || LOCAL_COMMAND_TAG.test(text) || COMMAND_TAG.test(text))
+            return out;
+        if (message.isSynthetic === true && context.summaryExpected) {
+            context.summaryExpected = false;
+            out.push({ type: 'user.message', id: uuid ?? `summary-${context.seq + 1}`, anchor: uuid ?? '', seq: nextSeq(), turn: context.turn, time: now(), source: 'compaction', text, blocks: [{ type: 'text', text }] });
+            return out;
+        }
+        const origin = str(rec(message.origin)?.kind);
+        if (origin !== undefined && origin !== 'human') {
+            // A system-originated prompt (task notification, peer, channel): not
+            // a human bubble; the turn start already says what happened.
+            debug(`claude: ${origin} prompt not projected as a bubble`);
+            return out;
+        }
+        debug(`claude: unconfirmed user text not projected (${text.slice(0, 40)})`);
+        return out;
+    };
+    return { translateAssistant, translateUser };
+}

package/lib/types/backends/claude/translate/system.d.ts

@@ -0,0 +1,40 @@
+/** Translate session, compaction, background-task and rate-limit frames. */
+import type { AgentEvent, AgentEventOf, TurnEndReason } from '../../../agent/events.js';
+import { type Rec } from '../narrow.js';
+import type { ClaudeTranslatorOptions, OpenAttempt } from './types.js';
+/** A duration until a reset, coarse (`3d 1h`, `2h 5m`, `7m`). */
+export declare function formatDuration(ms: number): string;
+export declare function createSystemTranslator(context: {
+    currentModel: string;
+    currentMode: string | undefined;
+    summaryExpected: boolean;
+    notificationTurnExpected: boolean;
+    readonly options: ClaudeTranslatorOptions;
+    readonly turnOpen: boolean;
+    readonly compactRequested: boolean;
+    readonly attempt: OpenAttempt | undefined;
+    readonly taskKinds: Map<string, 'agent' | 'job' | 'foreground'>;
+    readonly taskInfo: Map<string, {
+        readonly description: string;
+        readonly callId?: string;
+    }>;
+    readonly laneTasks: Map<string, string>;
+    readonly outputFiles: Map<string, string>;
+    readonly hiddenTasks: Set<string>;
+    readonly openCalls: Map<string, {
+        readonly name: string;
+        readonly input: unknown;
+        readonly turn: number;
+        readonly lane?: string;
+    }>;
+    readonly deniedReasons: Map<string, string>;
+    now(): number;
+    debug(message: string): void;
+    openTurn(out: AgentEvent[], origin: AgentEventOf<'turn.start'>['origin'], userMessageId?: string): void;
+    delta(open: OpenAttempt, value: AgentEventOf<'assistant.delta'>['delta'], index: number): AgentEvent;
+    forceCloseTurn(reason: TurnEndReason): AgentEvent[];
+}): {
+    translateSystem: (message: Rec) => AgentEvent[];
+    rateLimitNotice: (info: Rec | undefined) => AgentEvent[];
+};
+//# sourceMappingURL=system.d.ts.map

package/lib/types/backends/claude/translate/system.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../../../../src/backends/claude/translate/system.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAiB,aAAa,EAAE,MAAM,0BAA0B,CAAA;AAEtG,OAAO,EAAsB,KAAK,GAAG,EAAE,MAAM,cAAc,CAAA;AAC3D,OAAO,KAAK,EAAE,uBAAuB,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAatE,iEAAiE;AACjE,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAQjD;AAaD,wBAAgB,sBAAsB,CAAC,OAAO,EAAE;IAC9C,YAAY,EAAE,MAAM,CAAA;IACpB,WAAW,EAAE,MAAM,GAAG,SAAS,CAAA;IAC/B,eAAe,EAAE,OAAO,CAAA;IACxB,wBAAwB,EAAE,OAAO,CAAA;IACjC,QAAQ,CAAC,OAAO,EAAE,uBAAuB,CAAA;IACzC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;IAC1B,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAA;IAClC,QAAQ,CAAC,OAAO,EAAE,WAAW,GAAG,SAAS,CAAA;IACzC,QAAQ,CAAC,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,GAAG,KAAK,GAAG,YAAY,CAAC,CAAA;IAC/D,QAAQ,CAAC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;IAC1F,QAAQ,CAAC,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACvC,QAAQ,CAAC,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACzC,QAAQ,CAAC,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IACjC,QAAQ,CAAC,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;IAClI,QAAQ,CAAC,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC3C,GAAG,IAAI,MAAM,CAAA;IACb,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B,QAAQ,CAAC,GAAG,EAAE,UAAU,EAAE,EAAE,MAAM,EAAE,YAAY,CAAC,YAAY,CAAC,CAAC,QAAQ,CAAC,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACvG,KAAK,CAAC,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,YAAY,CAAC,iBAAiB,CAAC,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,MAAM,GAAG,UAAU,CAAA;IACpG,cAAc,CAAC,MAAM,EAAE,aAAa,GAAG,UAAU,EAAE,CAAA;CACpD;+BA+EmC,GAAG,KAAG,UAAU,EAAE;4BAlBrB,GAAG,GAAG,SAAS,KAAG,UAAU,EAAE;EA6Q9D"}