@nexrall/code-core 1.4.76 → 1.4.77

package/dist/search/globalSearch.js

@@ -0,0 +1,350 @@
+"use strict";
+// Lives in core (moved from the CLI's ui/globalSearch.ts, 2026-10-04) so
+// /find searches with the same engine in the VS Code panel; the CLI module is
+// a re-export shim.
+// §52 Global search — one query across files, conversation, tools, git, errors and agents.
+//
+// WHY: every scope already had its own command (/diff, /expand, /failures, /agents, /find), so
+// answering "where does JWT show up at all?" meant running five of them and remembering which
+// one held the answer. This module is the missing index over the sources the session already
+// holds — pure functions, so a count is exactly what the scope contains and nothing is invented.
+// It finds and ranks; the per-scope commands still do the jumping.
+//
+// Pure (no Ink, no console, no fs) so ranking, clipping and the counts block are unit-testable.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LABEL_CLIP = exports.DETAIL_CLIP = exports.MAX_PER_SCOPE = exports.SCOPE_LABEL = exports.SCOPES = void 0;
+exports.fitLine = fitLine;
+exports.scoreText = scoreText;
+exports.searchFiles = searchFiles;
+exports.searchConversation = searchConversation;
+exports.searchTools = searchTools;
+exports.searchGit = searchGit;
+exports.searchErrors = searchErrors;
+exports.searchAgents = searchAgents;
+exports.globalSearch = globalSearch;
+exports.filterScope = filterScope;
+exports.formatCounts = formatCounts;
+exports.formatHits = formatHits;
+exports.scopeHint = scopeHint;
+exports.parseSearchArgs = parseSearchArgs;
+exports.searchUsage = searchUsage;
+const cellWidth_1 = require("../util/cellWidth");
+/** Display order — §52 lists files first because that is where a code query usually lives. */
+exports.SCOPES = ['files', 'conversation', 'tools', 'git', 'errors', 'agents'];
+exports.SCOPE_LABEL = {
+    files: 'Files',
+    conversation: 'Conversation',
+    tools: 'Tools',
+    git: 'Git',
+    errors: 'Errors',
+    agents: 'Agents',
+};
+/** Flags accepted after the query, including the short forms a user is likely to try first. */
+const SCOPE_FLAG = {
+    '--files': 'files',
+    '--file': 'files',
+    '--chat': 'conversation',
+    '--conversation': 'conversation',
+    '--conv': 'conversation',
+    '--tools': 'tools',
+    '--tool': 'tools',
+    '--git': 'git',
+    '--errors': 'errors',
+    '--error': 'errors',
+    '--agents': 'agents',
+    '--agent': 'agents',
+};
+/** Hits printed per scope. The counts line stays complete — only the list is capped. */
+exports.MAX_PER_SCOPE = 5;
+/** A matched line kept for context, so a hit is recognisable without opening anything. */
+exports.DETAIL_CLIP = 96;
+exports.LABEL_CLIP = 72;
+function clip(s, max) {
+    const flat = s.replace(/\s+/g, ' ').trim();
+    return (0, cellWidth_1.truncateCells)(flat, max);
+}
+/**
+ * Shorten an ASSEMBLED line to `cols`, keeping its leading indent.
+ *
+ * `clip` flattens whitespace, which is right for a path or a matched line but destroys a row
+ * whose alignment is the point: `clip('  Files  12')` returns `Files  12`, and every column in
+ * the counts block collapses. Measured on the first run of the tests in this module.
+ */
+function fitLine(body, cols, indent = '') {
+    const room = Math.max(1, cols - (0, cellWidth_1.visibleLen)(indent));
+    if ((0, cellWidth_1.visibleLen)(body) <= room)
+        return indent + body;
+    const cut = (0, cellWidth_1.truncateCells)(body, room);
+    // A cut lands mid-style (the closing code of the run it interrupted is never reached), and an
+    // SGR left open bleeds into every row printed after it. Only styled rows get the reset, so
+    // NO_COLOR output stays byte-identical to what it always was.
+    return indent + (cut.includes('\u001b') ? cut + '\u001b[0m' : cut);
+}
+/**
+ * Rank one text against the query. `Infinity` = no match.
+ *
+ * Substring only, case-insensitive — this is a search box for code, where a fuzzy match is
+ * noise. The ladder, weakest last:
+ *
+ *   0  the text IS the query                     `auth`      vs `auth`
+ *   1  the text begins with the query             `auth.ts`   vs `auth`
+ *   2  the query begins a word                    `src/auth.ts`, `jwt-refresh.ts`
+ *   3  the query starts mid-word                  `myjwthelper.ts`, `contest/a.ts`
+ *
+ * Rung 1 exists on its own because a tie between `auth.ts` and `x/auth-mid.ts` used to be
+ * settled by whatever order the scope listed them in, which put the worse match first.
+ */
+function scoreText(query, text) {
+    const q = query.toLowerCase();
+    if (!q)
+        return Infinity;
+    const t = text.toLowerCase();
+    const at = t.indexOf(q);
+    if (at < 0)
+        return Infinity;
+    if (t === q)
+        return 0;
+    if (at === 0)
+        return 1;
+    if (!/[a-z0-9]/.test(t[at - 1]))
+        return 2;
+    return 3;
+}
+/** Best first: score, then the order the source listed them in. */
+function top(hits, limit) {
+    const sorted = hits.sort((a, b) => a.score - b.score || a.index - b.index);
+    return limit === Infinity ? sorted : sorted.slice(0, limit);
+}
+function push(hits, scope, index, label, detail, score) {
+    hits.push({
+        scope,
+        key: `${scope}:${index}`,
+        label: clip(label, exports.LABEL_CLIP),
+        detail: detail && clip(detail, exports.DETAIL_CLIP),
+        score,
+        index,
+    });
+}
+// ─── Per-scope matchers ───────────────────────────────────────────────────────
+/** Files: the path itself. */
+function searchFiles(query, files) {
+    const hits = [];
+    files.forEach((f, i) => {
+        const score = scoreText(query, f);
+        if (score !== Infinity)
+            push(hits, 'files', i + 1, f, undefined, score);
+    });
+    return top(hits, Infinity);
+}
+/** Conversation: prompts and reply lines, via the transcript the turn navigation already builds. */
+function searchConversation(query, turns) {
+    const hits = [];
+    turns.forEach((t) => {
+        const score = scoreText(query, t.prompt);
+        if (score !== Infinity)
+            push(hits, 'conversation', t.index, `turn ${t.index}  you  ${t.prompt}`, undefined, score);
+        t.lines.forEach((line) => {
+            const s = scoreText(query, line);
+            if (s !== Infinity)
+                push(hits, 'conversation', t.index, `turn ${t.index}`, line, s + 1);
+        });
+    });
+    return top(hits, Infinity);
+}
+/** Tools: the call label and the output the transcript folded away. */
+function searchTools(query, entries) {
+    const hits = [];
+    entries.forEach((e) => {
+        const label = `${e.name}: ${e.label}`;
+        let best = scoreText(query, label);
+        let detail;
+        for (const line of e.output.split('\n')) {
+            const s = scoreText(query, line);
+            if (s !== Infinity) {
+                if (s + 1 < best)
+                    best = s + 1;
+                detail = line; // one output line is enough to recognise the call; /expand <id> shows the rest
+                break;
+            }
+        }
+        // ONE row per tool call: the count then answers "how many calls mention this", and the
+        // command that is itself the query does not show up as a second, identical-looking hit.
+        if (best !== Infinity)
+            push(hits, 'tools', e.id, `#${e.id} ${label}`, detail, best);
+    });
+    return top(hits, Infinity);
+}
+/** Git: changed paths, with the status letter kept in front so `M`/`??` is visible. */
+function searchGit(query, changes) {
+    const hits = [];
+    changes.forEach((c, i) => {
+        const score = scoreText(query, c.path);
+        if (score !== Infinity)
+            push(hits, 'git', i + 1, `${c.status ? c.status + ' ' : ''}${c.path}`, undefined, score);
+    });
+    return top(hits, Infinity);
+}
+/** Errors: the failing command, the files it touched, and the re-tests. */
+function searchErrors(query, incidents) {
+    const hits = [];
+    incidents.forEach((inc) => {
+        const head = `#${inc.id} ${inc.command}`;
+        const inHead = scoreText(query, head);
+        if (inHead !== Infinity)
+            push(hits, 'errors', inc.id, head, undefined, inHead);
+        for (const f of inc.files) {
+            const s = scoreText(query, f);
+            if (s !== Infinity)
+                push(hits, 'errors', inc.id, head, f, s + 1);
+        }
+        for (const r of inc.retests) {
+            const s = scoreText(query, r.command);
+            if (s !== Infinity)
+                push(hits, 'errors', inc.id, head, `[${r.ok ? 'ok' : 'fail'}] ${r.command}`, s + 1);
+        }
+    });
+    return top(hits, Infinity);
+}
+/** Agents: type, task label and the files each one touched. */
+function searchAgents(query, nodes) {
+    const hits = [];
+    nodes.forEach((n, i) => {
+        const head = `${n.name}  ${n.label}`;
+        const inHead = scoreText(query, head);
+        if (inHead !== Infinity)
+            push(hits, 'agents', i + 1, head, n.error, inHead);
+        for (const f of n.files) {
+            const s = scoreText(query, f);
+            if (s !== Infinity)
+                push(hits, 'agents', i + 1, head, f, s + 1);
+        }
+        if (n.report) {
+            const s = scoreText(query, n.report);
+            if (s !== Infinity)
+                push(hits, 'agents', i + 1, head, 'report', s + 2);
+        }
+    });
+    return top(hits, Infinity);
+}
+// ─── The search itself ───────────────────────────────────────────────────────
+function globalSearch(query, sources, perScope = exports.MAX_PER_SCOPE) {
+    const q = query.trim();
+    if (!q)
+        return { query: '', hits: [], counts: [] };
+    const all = [];
+    if (sources.files)
+        all.push(...searchFiles(q, sources.files));
+    if (sources.turns)
+        all.push(...searchConversation(q, sources.turns));
+    if (sources.tools)
+        all.push(...searchTools(q, sources.tools));
+    if (sources.git)
+        all.push(...searchGit(q, sources.git));
+    if (sources.errors)
+        all.push(...searchErrors(q, sources.errors));
+    if (sources.agents)
+        all.push(...searchAgents(q, sources.agents));
+    const counts = exports.SCOPES.map((scope) => ({ scope, count: all.filter((h) => h.scope === scope).length })).filter((c) => c.count > 0);
+    const hits = [];
+    for (const scope of exports.SCOPES) {
+        hits.push(...top(all.filter((h) => h.scope === scope), perScope));
+    }
+    return { query: q, hits, counts };
+}
+function filterScope(hits, scope) {
+    return scope ? hits.filter((h) => h.scope === scope) : hits;
+}
+// ─── Rendering ────────────────────────────────────────────────────────────────
+/**
+ * The §52 counts block:
+ *
+ *     > JWT
+ *
+ *     Files        12
+ *     Conversation  8
+ *     Git           3
+ *     Agents        2
+ *
+ * Labels pad to the widest, counts right-align to the widest — so the numbers line up even
+ * when "Conversation" sits next to "Files". Every line is clipped to `cols`; at narrow widths
+ * the label is what gets cut, never the count.
+ */
+function formatCounts(result, cols, opts = {}) {
+    const out = [];
+    if (!result.query)
+        return out;
+    out.push(fitLine(`> ${result.query}`, cols));
+    if (!result.counts.length) {
+        out.push('');
+        out.push(fitLine('No match in files, conversation, tools, git, errors or agents.', cols, '  '));
+        return out;
+    }
+    // With one scope selected the section heading below already carries its count (`Git  1`),
+    // so the table would only repeat it — but the `> query` header still belongs to the result.
+    if (opts.table === false)
+        return out;
+    const labelW = Math.max(...result.counts.map((c) => exports.SCOPE_LABEL[c.scope].length)) + 1;
+    const numW = Math.max(...result.counts.map((c) => String(c.count).length));
+    out.push('');
+    for (const c of result.counts) {
+        const label = exports.SCOPE_LABEL[c.scope].padEnd(labelW);
+        const num = String(c.count).padStart(numW);
+        out.push(fitLine(`${label}${num}`, cols, '  '));
+    }
+    return out;
+}
+/**
+ * One printed row per hit: `  3. Git  M src/app.js`, with the matched line under it when the
+ * label alone would not say why it matched.
+ *
+ * `tag` prepends the 3-letter scope — on when the rows are mixed, off inside a per-scope
+ * section where the heading already said it.
+ */
+function formatHits(hits, cols, indent = '  ', tag = true) {
+    const out = [];
+    hits.forEach((h, i) => {
+        const n = String(i + 1).padStart(3);
+        const mark = tag ? `${exports.SCOPE_LABEL[h.scope].slice(0, 3)}  ` : '';
+        out.push(fitLine(`${n}. ${mark}${h.label}`, cols, indent));
+        if (h.detail && h.detail !== h.label)
+            out.push(fitLine(h.detail, cols, indent + '     '));
+    });
+    return out;
+}
+/** `Scopes: /find <q> --files --git` — only the flags that would actually narrow this result. */
+function scopeHint(counts) {
+    if (!counts.length)
+        return '';
+    const flags = counts.map((c) => '--' + c.scope);
+    return `Scopes: /find <query> ${flags.join(' ')}`;
+}
+/** `/find JWT --git --tools` → query "JWT", scopes [git, tools]. `--all` clears the narrowing. */
+function parseSearchArgs(arg) {
+    const words = arg.trim().split(/\s+/).filter(Boolean);
+    const scopes = [];
+    const bad = [];
+    const rest = [];
+    let all = false;
+    for (const w of words) {
+        const scope = SCOPE_FLAG[w.toLowerCase()];
+        if (scope) {
+            scopes.push(scope);
+            continue;
+        }
+        if (w.toLowerCase() === '--all') {
+            all = true;
+            continue;
+        }
+        if (w.startsWith('--')) {
+            bad.push(w);
+            continue;
+        }
+        rest.push(w);
+    }
+    return { query: rest.join(' '), scopes: all || !scopes.length ? null : [...new Set(scopes)], bad };
+}
+function searchUsage() {
+    const flags = exports.SCOPES.map((s) => (s === 'conversation' ? '--conversation|--chat' : `--${s}`));
+    return `Usage: /find <text> ${flags.map((f) => `[${f}]`).join(' ')}`;
+}
+//# sourceMappingURL=globalSearch.js.map

package/dist/share/sessionChannel.d.ts

@@ -0,0 +1,136 @@
+import type { ShareIoFactory, ShareStatus } from './sessionShare';
+/** One pushed message, as it came off the wire (already shape-checked). */
+export interface ChannelMessage {
+    nonce: string;
+    source: string;
+    text: string;
+    ts: number;
+}
+/** `ask` holds pushes for a human verdict; `auto` delivers them on arrival. */
+export type ChannelPolicy = 'ask' | 'auto';
+/** What the module reports for the terminal to render — data, not prose. */
+export type ChannelNotice = {
+    kind: 'queued';
+    msg: ChannelMessage;
+    position: number;
+} | {
+    kind: 'delivered';
+    msg: ChannelMessage;
+    auto: boolean;
+    folded: boolean;
+} | {
+    kind: 'discarded';
+    msg: ChannelMessage;
+} | {
+    kind: 'dropped';
+    msg: ChannelMessage;
+    reason: 'queue_full';
+};
+export interface SessionChannelDeps {
+    /** Origin of the platform API — the Socket.IO server shares the host. */
+    url: string;
+    sessionId: string;
+    /** Called before EVERY (re)connect attempt, so a rotated token is picked up. */
+    tokenProvider: () => string | null;
+    /** Called once after an auth-shaped connect error, like the share half. */
+    refreshToken?: () => Promise<boolean>;
+    ioFactory?: ShareIoFactory;
+    onStatus?: (s: ShareStatus) => void;
+    onNotice?: (n: ChannelNotice) => void;
+    /**
+     * Deliver an accepted (or auto) message: `formatted` is what the model sees.
+     * Returns `queued` when the message was folded into a running turn instead
+     * of starting one (the REPL's busy path) — reported to watchers verbatim.
+     */
+    onDeliver?: (formatted: string, msg: ChannelMessage) => 'accepted' | 'queued' | void;
+    /** Test seam — the only reason a token is not always crypto-random. */
+    mintToken?: () => string;
+}
+/** Token shape the CLI mints and the relay/route only ever hash. */
+export declare const CHANNEL_TOKEN_PREFIX = "nxch_";
+/** More undecided pushes than this and new ones are refused, not queued — an
+ *  external source must not be able to bury the one message a human needs. */
+export declare const CHANNEL_QUEUE_CAP = 10;
+/** Matches the relay's and the route's own cap (defense in depth). */
+export declare const CHANNEL_TEXT_MAX_CHARS = 8192;
+/** S13c: what a source may read back — one turn's closing text, same bound. */
+export declare const CHANNEL_REPLY_MAX_CHARS = 8192;
+export declare function hashChannelToken(token: string): string;
+/**
+ * The push endpoint for a session. Built here so the CLI prints exactly the
+ * URL the route serves — one string, one place.
+ */
+export declare function channelPushUrl(id: string, url: string): string;
+/**
+ * Escape `<` so a hostile push cannot close the wrapper tag early; `&` and
+ * `>` stay readable because CI URLs are the common case and the model reads
+ * this text, not an XML parser.
+ */
+export declare function escapeChannelText(text: string): string;
+/**
+ * What the conversation receives. Same `<channel source=…>` shape Claude Code
+ * documents for its own channels, so prompts and habits built for one read
+ * the same here — and it can never parse as a slash command.
+ */
+export declare function formatChannelEvent(msg: ChannelMessage): string;
+export declare class SessionChannel {
+    private readonly deps;
+    private socket;
+    private id;
+    private status;
+    private stopped;
+    private refreshing;
+    private policy;
+    private queue;
+    private seenNonces;
+    /** S13c: nonces delivered but not yet answered by a finished turn. */
+    private awaitingReply;
+    /** Minted once per open; rotated by a re-open after /channel close. */
+    private token;
+    private tokenHash;
+    constructor(deps: SessionChannelDeps);
+    get sessionId(): string;
+    get state(): ShareStatus;
+    get activePolicy(): ChannelPolicy;
+    /** The push URL a human pastes into CI; the token is NOT part of it. */
+    get pushUrl(): string;
+    /** Shown once by `/channel open` — memory only, never persisted anywhere. */
+    get rawToken(): string | null;
+    /** Pending pushes, oldest first. A copy: callers cannot mutate the queue. */
+    pending(): ChannelMessage[];
+    start(policy?: ChannelPolicy): this;
+    /** Switch policy — `auto` drains whatever is already queued, oldest first. */
+    setPolicy(policy: ChannelPolicy): ChannelPolicy;
+    /** Accept (deliver) one pending push — 1-based `index`, default the oldest. */
+    accept(index?: number): ChannelMessage | null;
+    /** Refuse one pending push — same indexing as accept. */
+    discard(index?: number): ChannelMessage | null;
+    /** /clear and /fork: a rebind reuses the token for the new session id. */
+    rebind(id: string): void;
+    stop(reason?: string): void;
+    private take;
+    private deliver;
+    /**
+     * S13c — close the loop: hand every delivered-but-unanswered push the
+     * closing text of the turn that consumed it (chat.ts calls this when a turn
+     * ends; `null`/blank means the turn said nothing useful, which is reported
+     * as an EXPLICIT no-text marker rather than silence). Frames are keyed by
+     * nonce and stored by the relay, readable only with the channel token.
+     * Returns how many nonces were answered.
+     */
+    publishReplies(reply: string | null, opts?: {
+        interrupted?: boolean;
+    }): number;
+    /** Shape-check a pushed frame — the relay is a pipe, delivery trusts nothing. */
+    private validateMessage;
+    private ack;
+    private notice;
+    private emitOpen;
+    private emitTo;
+    private setStatus;
+}
+export declare function startSessionChannel(deps: SessionChannelDeps, policy?: ChannelPolicy): SessionChannel;
+export declare function activeSessionChannel(): SessionChannel | null;
+export declare function rebindSessionChannel(id: string): void;
+export declare function stopSessionChannel(reason?: string): void;
+//# sourceMappingURL=sessionChannel.d.ts.map

package/dist/share/sessionChannel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessionChannel.d.ts","sourceRoot":"","sources":["../../src/share/sessionChannel.ts"],"names":[],"mappings":"AAyBA,OAAO,KAAK,EAAE,cAAc,EAAe,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAE/E,2EAA2E;AAC3E,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,+EAA+E;AAC/E,MAAM,MAAM,aAAa,GAAG,KAAK,GAAG,MAAM,CAAC;AAE3C,4EAA4E;AAC5E,MAAM,MAAM,aAAa,GACrB;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,GAAG,EAAE,cAAc,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GACzD;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,GAAG,EAAE,cAAc,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAE,GAC1E;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,GAAG,EAAE,cAAc,CAAA;CAAE,GAC1C;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,GAAG,EAAE,cAAc,CAAC;IAAC,MAAM,EAAE,YAAY,CAAA;CAAE,CAAC;AAEnE,MAAM,WAAW,kBAAkB;IACjC,yEAAyE;IACzE,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,gFAAgF;IAChF,aAAa,EAAE,MAAM,MAAM,GAAG,IAAI,CAAC;IACnC,2EAA2E;IAC3E,YAAY,CAAC,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;IACtC,SAAS,CAAC,EAAE,cAAc,CAAC;IAC3B,QAAQ,CAAC,EAAE,CAAC,CAAC,EAAE,WAAW,KAAK,IAAI,CAAC;IACpC,QAAQ,CAAC,EAAE,CAAC,CAAC,EAAE,aAAa,KAAK,IAAI,CAAC;IACtC;;;;OAIG;IACH,SAAS,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,cAAc,KAAK,UAAU,GAAG,QAAQ,GAAG,IAAI,CAAC;IACrF,uEAAuE;IACvE,SAAS,CAAC,EAAE,MAAM,MAAM,CAAC;CAC1B;AAED,oEAAoE;AACpE,eAAO,MAAM,oBAAoB,UAAU,CAAC;AAC5C;8EAC8E;AAC9E,eAAO,MAAM,iBAAiB,KAAK,CAAC;AACpC,sEAAsE;AACtE,eAAO,MAAM,sBAAsB,OAAO,CAAC;AAC3C,+EAA+E;AAC/E,eAAO,MAAM,uBAAuB,OAAO,CAAC;AAc5C,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEtD;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAE9D;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEtD;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM,CAE9D;AAKD,qBAAa,cAAc;IAeb,OAAO,CAAC,QAAQ,CAAC,IAAI;IAdjC,OAAO,CAAC,MAAM,CAA4B;IAC1C,OAAO,CAAC,EAAE,CAAS;IACnB,OAAO,CAAC,MAAM,CAAwC;IACtD,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,MAAM,CAAwB;IACtC,OAAO,CAAC,KAAK,CAAwB;IACrC,OAAO,CAAC,UAAU,CAAqB;IACvC,sEAAsE;IACtE,OAAO,CAAC,aAAa,CAAqB;IAC1C,uEAAuE;IACvE,OAAO,CAAC,KAAK,CAAuB;IACpC,OAAO,CAAC,SAAS,CAAuB;gBAEX,IAAI,EAAE,kBAAkB;IAIrD,IAAI,SAAS,IAAI,MAAM,CAEtB;IACD,IAAI,KAAK,IAAI,WAAW,CAEvB;IACD,IAAI,YAAY,IAAI,aAAa,CAEhC;IACD,wEAAwE;IACxE,IAAI,OAAO,IAAI,MAAM,CAEpB;IACD,6EAA6E;IAC7E,IAAI,QAAQ,IAAI,MAAM,GAAG,IAAI,CAE5B;IACD,6EAA6E;IAC7E,OAAO,IAAI,cAAc,EAAE;IAI3B,KAAK,CAAC,MAAM,GAAE,aAAqB,GAAG,IAAI;IA0E1C,8EAA8E;IAC9E,SAAS,CAAC,MAAM,EAAE,aAAa,GAAG,aAAa;IAU/C,+EAA+E;IAC/E,MAAM,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI;IAO7C,yDAAyD;IACzD,OAAO,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI;IAQ9C,0EAA0E;IAC1E,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAQxB,IAAI,CAAC,MAAM,SAAW,GAAG,IAAI;IAkB7B,OAAO,CAAC,IAAI;IAOZ,OAAO,CAAC,OAAO;IAiBf;;;;;;;OAOG;IACH,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,EAAE,IAAI,GAAE;QAAE,WAAW,CAAC,EAAE,OAAO,CAAA;KAAO,GAAG,MAAM;IAkBlF,iFAAiF;IACjF,OAAO,CAAC,eAAe;IAUvB,OAAO,CAAC,GAAG;IAIX,OAAO,CAAC,MAAM;IAQd,OAAO,CAAC,QAAQ;IAKhB,OAAO,CAAC,MAAM;IAQd,OAAO,CAAC,SAAS;CAWlB;AAMD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,kBAAkB,EAAE,MAAM,GAAE,aAAqB,GAAG,cAAc,CAI3G;AAED,wBAAgB,oBAAoB,IAAI,cAAc,GAAG,IAAI,CAE5D;AAED,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAErD;AAED,wBAAgB,kBAAkB,CAAC,MAAM,SAAW,GAAG,IAAI,CAG1D"}