agent-nuvira 3.5.0 → 3.5.2

package/dist/tools/run-registry.js

@@ -0,0 +1,544 @@
+/**
+ * The durable half of the monitored-run registry.
+ *
+ * WHY THIS EXISTS. Monitoring a long command in memory (see `run-terminal.ts`)
+ * fixed the killing, but it made the record as fragile as the process holding it:
+ * a CLI exit, a dashboard restart, a crash — all normal — and a command that is
+ * still running becomes unpollable. Nothing is left to follow it with, its real
+ * exit code is never collected, and the turn that started it can only re-run the
+ * work (wrong) or guess at the outcome. Two facts have to outlive the process:
+ *
+ *   what is running  — id, command, cwd, pid, start time, and how it ended;
+ *   what it said     — its output, from the FIRST byte as well as the last.
+ *
+ * The second one is why there is a spool file and not just a record. The
+ * in-memory buffer is a bounded TAIL (a 40MB build log must not be held), so the
+ * beginning of a long run was simply gone — the model could read the end of a
+ * failure and not the line that explained it. The spool keeps a bounded HEAD and
+ * a bounded TAIL (rewritten whole, so the file never grows past the cap), which
+ * is the part a diagnosis actually uses.
+ *
+ * Everything here is best-effort and must never break a turn: a missing, unreadable
+ * or corrupt registry is an empty registry, never a throw.
+ */
+import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync, } from 'node:fs';
+import { join } from 'node:path';
+import { resolveNuviraDataPath } from '../config/paths.js';
+import { lookupProcess } from './process-liveness.js';
+/** The full-log cap, with an env override read at construction (test-friendly). */
+function envFullBytes() {
+    const raw = Number.parseInt(String(process.env.NUVIRA_RUN_LOG_FULL_BYTES ?? '').trim(), 10);
+    return Number.isFinite(raw) && raw >= 0 ? raw : SPOOL_FULL_BYTES;
+}
+/** How much of the BEGINNING of a run's output is kept. */
+export const SPOOL_HEAD_BYTES = 32_768;
+/** How much of the END of a run's output is kept. */
+export const SPOOL_TAIL_BYTES = 32_768;
+/**
+ * How much of a run's output is kept IN FULL before the window collapses to
+ * head+tail.
+ *
+ * WHY THIS EXISTS. A bounded window throws away the MIDDLE of a long run, and
+ * that is exactly where a failure explains itself — so the honest trade is to
+ * keep everything while everything is small. Most runs never reach this cap, so
+ * the common case stops losing anything at all; past it the file collapses to
+ * head+tail (with the dropped count stated), which keeps the guarantee that a
+ * chatty command cannot fill the disk. `NUVIRA_RUN_LOG_FULL_BYTES=0` restores
+ * "always a bounded window".
+ */
+export const SPOOL_FULL_BYTES = 2_000_000;
+/** Pending appends are flushed once they reach this, so memory stays bounded. */
+const SPOOL_PENDING_BYTES = 262_144;
+/** Bounded history: the registry cannot grow with the session. */
+const MAX_PERSISTED_RUNS = 30;
+/** How often an in-flight spool is written out (a crash loses at most this much). */
+export const SPOOL_FLUSH_MS = 2_000;
+/** `<config dir>/run-terminal` — isolated by `$NUVIRA_CONFIG_DIR`, like the rest. */
+export function runsDir() {
+    return resolveNuviraDataPath('run-terminal');
+}
+export function spoolPath(id) {
+    return join(runsDir(), 'out', `${id}.log`);
+}
+function registryPath() {
+    return join(runsDir(), 'runs.json');
+}
+/** Read the registry. A missing/corrupt file is an empty registry. */
+export function loadRuns() {
+    try {
+        const path = registryPath();
+        if (!existsSync(path))
+            return [];
+        const parsed = JSON.parse(readFileSync(path, 'utf-8'));
+        if (!parsed || !Array.isArray(parsed.runs))
+            return [];
+        return parsed.runs.filter((r) => !!r &&
+            typeof r.id === 'string' &&
+            typeof r.command === 'string' &&
+            typeof r.pid === 'number' &&
+            typeof r.startedAt === 'number' &&
+            (r.status === 'running' || r.status === 'done'));
+    }
+    catch {
+        return [];
+    }
+}
+function writeRuns(runs) {
+    try {
+        mkdirSync(runsDir(), { recursive: true });
+        const path = registryPath();
+        // Atomic-ish: a crash mid-write must not leave a half file that reads as an
+        // empty registry (which would silently lose every live run).
+        const tmp = `${path}.tmp`;
+        writeFileSync(tmp, JSON.stringify({ version: 1, runs }, null, 2), 'utf-8');
+        renameSync(tmp, path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Add or update one run. Finished entries are kept (so a restart can still report
+ * the real exit code) and the oldest are dropped past the cap.
+ */
+export function saveRun(entry) {
+    const runs = loadRuns().filter((r) => r.id !== entry.id);
+    runs.push(entry);
+    const finished = runs.filter((r) => r.status === 'done');
+    while (runs.length > MAX_PERSISTED_RUNS && finished.length > 0) {
+        const oldest = finished.shift();
+        const at = runs.findIndex((r) => r.id === oldest.id);
+        if (at >= 0)
+            runs.splice(at, 1);
+    }
+    // Never drop a LIVE run to satisfy the cap — the record of running work is the
+    // whole point of the file.
+    while (runs.length > MAX_PERSISTED_RUNS) {
+        const oldest = runs.find((r) => r.status === 'done');
+        if (!oldest)
+            break;
+        runs.splice(runs.indexOf(oldest), 1);
+    }
+    writeRuns(runs);
+}
+/** The spooled output of one run, or null when there is none. */
+export function readSpool(id) {
+    try {
+        const path = spoolPath(id);
+        if (!existsSync(path))
+            return null;
+        const text = readFileSync(path, 'utf-8');
+        return text.length > 0 ? text : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function spoolBytes(id) {
+    try {
+        const path = spoolPath(id);
+        if (!existsSync(path))
+            return 0;
+        return readFileSync(path).length;
+    }
+    catch {
+        return 0;
+    }
+}
+export function discardSpool(id) {
+    try {
+        rmSync(spoolPath(id), { force: true });
+    }
+    catch {
+        /* best-effort */
+    }
+}
+/**
+ * Delete spool files no record refers to.
+ *
+ * The registry is capped, but a file is not a record: without this, every run
+ * that was ever monitored would leave its log behind forever, and "bounded state"
+ * would be true of the JSON and false of the disk. Run on hydrate, when the live
+ * set is exactly known.
+ */
+export function sweepSpools(liveIds) {
+    try {
+        const keep = new Set(liveIds);
+        const dir = join(runsDir(), 'out');
+        if (!existsSync(dir))
+            return;
+        for (const name of readdirSync(dir)) {
+            if (!name.endsWith('.log'))
+                continue;
+            const id = name.slice(0, -4);
+            if (keep.has(id))
+                continue;
+            rmSync(join(dir, name), { force: true });
+        }
+    }
+    catch {
+        /* best-effort: a sweep that fails must not stop a turn */
+    }
+}
+/**
+ * A bounded head+tail window over some text.
+ *
+ * The head is kept because a run's first lines name what it is doing and how it
+ * was invoked; the tail is kept because that is where the failure is. The middle
+ * is what gets dropped — bounded, explicit, and never silently a lie about size.
+ */
+export function outputWindow(text, maxChars, headChars = SPOOL_HEAD_BYTES, tailChars = SPOOL_TAIL_BYTES) {
+    const clean = text.replace(/\r\n/g, '\n');
+    if (clean.length <= maxChars)
+        return { text: clean, omittedChars: 0 };
+    const head = clean.slice(0, Math.min(headChars, Math.floor(maxChars / 2)));
+    const tail = clean.slice(-Math.min(tailChars, Math.floor(maxChars / 2)));
+    const omittedChars = Math.max(0, clean.length - head.length - tail.length);
+    return {
+        text: `${head}\n\n… [${omittedChars} characters omitted — the middle of a long run, kept at the ends] …\n\n${tail}`,
+        omittedChars,
+    };
+}
+/**
+ * Write the spool for one run: HEAD (until it is full) + a rolling TAIL.
+ *
+ * The file is REWRITTEN whole rather than appended to, which is what keeps it
+ * bounded: a chatty command can write gigabytes in an hour and the spool still
+ * stays at ~64KB. Flushing is throttled (`SPOOL_FLUSH_MS`) so the write cost is
+ * independent of the output rate; `close()` does the final write.
+ *
+ * NOTHING IS WRITTEN UNTIL {@link startPersisting}. Until a run is handed to
+ * monitoring it is not durable (there is no registry entry to read it back), so a
+ * file on disk would be litter the user never asked for — and litter they do get:
+ * MEASURED, the first output chunk of an ordinary `npm test` created
+ * `<config>/run-terminal/out/<id>.log` in the developer's REAL profile on every
+ * test that spawned a command and finished inside its budget, for a spool that
+ * was then discarded. Buffering in memory until hand-off loses nothing (the head
+ * is bounded, and the window written at hand-off is the same one) and keeps the
+ * suite out of the profile it runs in.
+ */
+export class SpoolWriter {
+    id;
+    headBytes;
+    tailBytes;
+    dir;
+    head = '';
+    tail = '';
+    /** Everything ever written, so the window can say how much it dropped. */
+    total = 0;
+    dirty = false;
+    lastFlush = 0;
+    closed = false;
+    discarded = false;
+    /** False until the run is durable — see {@link startPersisting}. */
+    persisting = false;
+    /**
+     * `append` — the file is growing with the run, byte for byte, because it is
+     * still under the full-log cap. `window` — the cap was passed, so the file is
+     * the bounded head+tail window from here on.
+     */
+    mode = 'append';
+    /** Text written since the last flush, in append mode. */
+    pending = '';
+    fullBytes;
+    constructor(id, headBytes = SPOOL_HEAD_BYTES, tailBytes = SPOOL_TAIL_BYTES, 
+    /**
+     * Where the window is written. Defaults to the monitored-run spool dir; the
+     * dashboard's tasks keep theirs beside their own records. Parameterised
+     * rather than duplicated because the discipline — bounded, rewritten whole,
+     * throttled, discarded when nobody will read it — is the part worth sharing.
+     */
+    dir = join(runsDir(), 'out'), fullBytes = envFullBytes()) {
+        this.id = id;
+        this.headBytes = headBytes;
+        this.tailBytes = tailBytes;
+        this.dir = dir;
+        this.fullBytes = fullBytes;
+    }
+    /** The file this window lives in. */
+    path() {
+        return join(this.dir, `${this.id}.log`);
+    }
+    /**
+     * Begin writing to disk: the run has outlived its wait budget and is now
+     * durable (`persistRun`), so its output has to be readable by another process.
+     */
+    startPersisting() {
+        this.persisting = true;
+    }
+    write(text) {
+        if (this.closed || this.discarded || !text)
+            return;
+        this.total += text.length;
+        if (this.head.length < this.headBytes) {
+            this.head += text.slice(0, this.headBytes - this.head.length);
+        }
+        // The tail only needs to remember the last `tailBytes`; a 2x window lets the
+        // slice below stay cheap without re-slicing on every chunk.
+        this.tail += text;
+        if (this.tail.length > this.tailBytes * 2)
+            this.tail = this.tail.slice(-this.tailBytes);
+        this.dirty = true;
+        if (this.persisting && this.mode === 'append') {
+            if (this.total > this.fullBytes) {
+                // The run outgrew the cap: drop what the window cannot hold, once.
+                this.collapse();
+                return;
+            }
+            this.pending += text;
+            // A chatty command must not be able to buffer megabytes between flushes.
+            if (this.pending.length >= SPOOL_PENDING_BYTES)
+                this.flush();
+        }
+        this.flushIfDue();
+    }
+    flushIfDue() {
+        if (!this.persisting)
+            return;
+        const now = Date.now();
+        if (now - this.lastFlush < SPOOL_FLUSH_MS)
+            return;
+        this.flush();
+    }
+    /**
+     * Cross the cap: write the bounded window ONCE, and stop growing the file.
+     *
+     * The bytes already appended are what a run's middle looked like while it still
+     * fit; rewriting the file is what keeps a gigabyte of output from becoming a
+     * gigabyte of disk.
+     */
+    collapse() {
+        this.mode = 'window';
+        this.pending = '';
+        this.flush();
+    }
+    /**
+     * Write what has accumulated. Safe to call at any time.
+     *
+     * The file is the HEAD plus the LAST `tailBytes` of the tail — taken from the
+     * END, because the tail is where a failure explains itself. When everything
+     * fits in the head, only the head is written: otherwise a short run's output
+     * would be stored twice and read back doubled.
+     */
+    flush() {
+        if (!this.persisting || !this.dirty || this.discarded || this.closed)
+            return;
+        this.dirty = false;
+        this.lastFlush = Date.now();
+        const tail = this.tail.slice(-this.tailBytes);
+        const omitted = Math.max(0, this.total - this.head.length - tail.length);
+        const body = omitted > 0
+            ? `${this.head}\n… [${omitted} characters omitted — kept at the ends] …\n${tail}`
+            : this.head || tail;
+        try {
+            mkdirSync(this.dir, { recursive: true });
+            if (this.mode === 'append' && this.pending) {
+                // UNDER THE CAP: append what the run actually printed, so the middle of a
+                // long-but-not-huge run is still readable afterwards.
+                appendFileSync(this.path(), this.pending, 'utf-8');
+                this.pending = '';
+                return;
+            }
+            writeFileSync(this.path(), body, 'utf-8');
+        }
+        catch {
+            /* the spool is a convenience — never break the run for it */
+        }
+    }
+    /**
+     * Make sure the bytes still held in memory reach the file.
+     *
+     * `close()` cannot use `flush()` for this: in append mode a pause in output
+     * older than the throttle leaves `pending` unwritten, and those are exactly the
+     * last lines of a run — the ones that explain why it failed.
+     */
+    drainPending() {
+        if (!this.persisting || this.discarded || !this.pending)
+            return;
+        try {
+            mkdirSync(this.dir, { recursive: true });
+            appendFileSync(this.path(), this.pending, 'utf-8');
+            this.pending = '';
+        }
+        catch {
+            /* best-effort */
+        }
+    }
+    /** Final write. The file stays (a finished run's output is still worth reading). */
+    close() {
+        if (this.closed)
+            return;
+        if (this.mode === 'append')
+            this.drainPending();
+        else
+            this.flush();
+        this.closed = true;
+    }
+    /** Drop the spool: the run finished inside its wait budget, so nobody will poll it. */
+    discard() {
+        this.discarded = true;
+        this.closed = true;
+        try {
+            rmSync(this.path(), { force: true });
+        }
+        catch {
+            /* best-effort */
+        }
+    }
+}
+/**
+ * Is `pid` still the process we started, or has the pid been recycled?
+ *
+ * A run recovered from the registry is identified by a NUMBER that outlived the
+ * process table it came from. Between the crash and the re-attach, that pid can
+ * belong to something else entirely — and this tool's whole safety story is that
+ * it only ever signals commands IT started. So before any recovered run is
+ * signalled, it is identified all over again.
+ *
+ * The process line — `ps` on POSIX, the same `Get-CimInstance Win32_Process`
+ * query the liveness sampler already runs on Windows — shows the shell we spawned
+ * (`/bin/sh -c <command>`) or, when the shell exec'd a simple command, that
+ * command's own line; both contain the command text, which is why the check is a
+ * containment test rather than equality.
+ */
+export function commandMatchesProcess(pid, command) {
+    const row = lookupProcess(pid);
+    if (row === null)
+        return null; // this platform cannot read the process table
+    if (!row.found)
+        return false; // the pid is gone — definitely not ours
+    return commandVerdict(command, row.command);
+}
+/**
+ * The command-line witness alone, as a verdict: `true` ours, `false` not ours,
+ * `null` no reading (which is NOT a match, and must never be treated as one).
+ */
+function commandVerdict(command, liveLine) {
+    const wanted = command.trim();
+    if (!wanted)
+        return null;
+    if (!liveLine)
+        return null; // a row whose command line could not be read
+    try {
+        // Quotes and runs of whitespace are NOT differences of identity: the shell
+        // strips the quotes from `node -e "…"` before the process exists, so a naive
+        // containment test would refuse to stop a run we really do own.
+        const normalize = (s) => s.replace(/["']/g, '').replace(/\s+/g, ' ').trim();
+        const actual = normalize(liveLine);
+        const wantedNorm = normalize(wanted);
+        // The process line CONTAINS what we recorded — the shell carries it
+        // (`sh -c npm test`), or the command is what the shell exec'd into.
+        if (actual.includes(wantedNorm))
+            return true;
+        // A process listing can TRUNCATE a very long command line, so a substantial
+        // PREFIX of what we recorded is accepted — but only with the same binary,
+        // and never a short bare name: a recycled pid showing just `node` must NOT
+        // satisfy a recorded `node -e …`, which is how a stranger would be adopted.
+        const first = wantedNorm.split(' ')[0];
+        if (actual.length >= 16 && wantedNorm.startsWith(actual) && actual.split(' ')[0] === first)
+            return true;
+        return false;
+    }
+    catch {
+        return null; // unknown — the caller must not treat this as a match
+    }
+}
+/**
+ * Identity, decided by TWO independent witnesses — pure, so every branch can be
+ * asserted instead of hoped for.
+ *
+ *   pid + command line        what the run was started as
+ *   pid + OS start token      when the OS says that process began
+ *
+ * The rule that makes this safe rather than merely clever:
+ *
+ *   a witness may VETO, and only the start token may ACCEPT ALONE.
+ *
+ *  - A different command line is not our process, so `false` wins over any
+ *    agreement elsewhere — a recycled pid running something else is refused.
+ *  - When the command lines agree, a start token that DISAGREES refuses too: the
+ *    same command started as a different process (another `npm test` in another
+ *    directory, a stranger's `node`) is precisely the case that used to be
+ *    adopted. This is the new refusal, and it can only ever refuse.
+ *  - When the command line cannot be read at all (some platforms hide it, and a
+ *    kernel process has none), a MATCHING start token is accepted: that is a
+ *    value the kernel does not hand out twice, and it is the difference between
+ *    a recovered run that can be stopped and one that can only be stopped by
+ *    hand. Anything short of a match stays `null` — unknown, never ours.
+ */
+export function processIdentityVerdict(recorded, live) {
+    return processIdentityCheck(recorded, live).verdict;
+}
+/**
+ * The verdict AND the evidence behind it.
+ *
+ * A refusal the operator cannot act on is barely better than a crash: the whole
+ * consequence of `false` here is that a real command keeps running and can only
+ * be stopped by hand, so the message has to say WHICH witness failed — a
+ * different command line and a mismatched start time are different problems, and
+ * "could not tell" is a third.
+ */
+export function processIdentityCheck(recorded, live) {
+    if (live === null) {
+        return {
+            verdict: null,
+            why: 'this platform could not read a process table, so the pid cannot be checked',
+            kind: 'unreadable-table',
+        };
+    }
+    // A FACT, as opposed to an inference: the pid is not in the table at all. Only
+    // this branch may ever be read as "it is over" — every other refusal says
+    // something about IDENTITY, which is not the same claim (see the callers).
+    if (!live.found)
+        return { verdict: false, why: 'the pid is not running any more', kind: 'gone' };
+    const byCommand = commandVerdict(recorded.command, live.command);
+    const start = recorded.osStartedAt;
+    const byStart = start && live.startedAtText ? start === live.startedAtText : null;
+    if (byCommand === false) {
+        return {
+            verdict: false,
+            kind: 'not-ours',
+            why: `the pid now runs a different command line (\`${live.command}\`), so it is not the ` +
+                `process that was started`,
+        };
+    }
+    if (byCommand === true) {
+        if (byStart === false) {
+            return {
+                verdict: false,
+                kind: 'not-ours',
+                why: `its command line matches, but the OS start time differs from the one recorded for this run ` +
+                    `(\`${live.startedAtText}\` now vs \`${start}\` then) — the pid was RECYCLED by a different process ` +
+                    `that happens to run the same command`,
+            };
+        }
+        return {
+            verdict: true,
+            kind: 'verified',
+            why: byStart === true
+                ? 'its command line AND its OS start time match what was recorded when it was started'
+                : 'its command line matches what was recorded (no start-time token was recorded to compare)',
+        };
+    }
+    if (byStart === true) {
+        return {
+            verdict: true,
+            kind: 'verified',
+            why: 'its OS start time matches the token recorded when it was started, which is a value the OS does not ' +
+                'hand to two different processes (its command line could not be read)',
+        };
+    }
+    return {
+        verdict: null,
+        kind: 'unknown',
+        why: byStart === false
+            ? 'its start time does not match, and its command line could not be read'
+            : 'neither its command line nor its start time could be read',
+    };
+}
+/** `processIdentityVerdict` against the live table: one read, both witnesses. */
+export function processIdentityMatches(pid, recorded) {
+    return processIdentityVerdict(recorded, lookupProcess(pid));
+}
+//# sourceMappingURL=run-registry.js.map

package/dist/tools/run-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-registry.js","sourceRoot":"","sources":["../../src/tools/run-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EACL,cAAc,EACd,UAAU,EACV,SAAS,EACT,YAAY,EACZ,WAAW,EACX,UAAU,EACV,MAAM,EACN,aAAa,GACd,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAEtD,mFAAmF;AACnF,SAAS,YAAY;IACnB,MAAM,GAAG,GAAG,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,yBAAyB,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC;IAC5F,OAAO,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,gBAAgB,CAAC;AACnE,CAAC;AAED,2DAA2D;AAC3D,MAAM,CAAC,MAAM,gBAAgB,GAAG,MAAM,CAAC;AACvC,qDAAqD;AACrD,MAAM,CAAC,MAAM,gBAAgB,GAAG,MAAM,CAAC;AACvC;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,SAAS,CAAC;AAC1C,iFAAiF;AACjF,MAAM,mBAAmB,GAAG,OAAO,CAAC;AACpC,kEAAkE;AAClE,MAAM,kBAAkB,GAAG,EAAE,CAAC;AAC9B,qFAAqF;AACrF,MAAM,CAAC,MAAM,cAAc,GAAG,KAAK,CAAC;AA8BpC,qFAAqF;AACrF,MAAM,UAAU,OAAO;IACrB,OAAO,qBAAqB,CAAC,cAAc,CAAC,CAAC;AAC/C,CAAC;AAED,MAAM,UAAU,SAAS,CAAC,EAAU;IAClC,OAAO,IAAI,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,CAAC,CAAC;AAC7C,CAAC;AAED,SAAS,YAAY;IACnB,OAAO,IAAI,CAAC,OAAO,EAAE,EAAE,WAAW,CAAC,CAAC;AACtC,CAAC;AAED,sEAAsE;AACtE,MAAM,UAAU,QAAQ;IACtB,IAAI,CAAC;QACH,MAAM,IAAI,GAAG,YAAY,EAAE,CAAC;QAC5B,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC;YAAE,OAAO,EAAE,CAAC;QACjC,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,IAAI,EAAE,OAAO,CAAC,CAAsB,CAAC;QAC5E,IAAI,CAAC,MAAM,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC;YAAE,OAAO,EAAE,CAAC;QACtD,OAAO,MAAM,CAAC,IAAI,CAAC,MAAM,CACvB,CAAC,CAAC,EAAqB,EAAE,CACvB,CAAC,CAAC,CAAC;YACH,OAAO,CAAC,CAAC,EAAE,KAAK,QAAQ;YACxB,OAAO,CAAC,CAAC,OAAO,KAAK,QAAQ;YAC7B,OAAO,CAAC,CAAC,GAAG,KAAK,QAAQ;YACzB,OAAO,CAAC,CAAC,SAAS,KAAK,QAAQ;YAC/B,CAAC,CAAC,CAAC,MAAM,KAAK,SAAS,IAAI,CAAC,CAAC,MAAM,KAAK,MAAM,CAAC,CAClD,CAAC;IACJ,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,EAAE,CAAC;IACZ,CAAC;AACH,CAAC;AAED,SAAS,SAAS,CAAC,IAAoB;IACrC,IAAI,CAAC;QACH,SAAS,CAAC,OAAO,EAAE,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QAC1C,MAAM,IAAI,GAAG,YAAY,EAAE,CAAC;QAC5B,4EAA4E;QAC5E,6DAA6D;QAC7D,MAAM,GAAG,GAAG,GAAG,IAAI,MAAM,CAAC;QAC1B,aAAa,CAAC,GAAG,EAAE,IAAI,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,IAAI,EAAqB,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;QAC9F,UAAU,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;QACtB,OAAO,IAAI,CAAC;IACd,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,OAAO,CAAC,KAAmB;IACzC,MAAM,IAAI,GAAG,QAAQ,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,KAAK,CAAC,EAAE,CAAC,CAAC;IACzD,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACjB,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,MAAM,CAAC,CAAC;IACzD,OAAO,IAAI,CAAC,MAAM,GAAG,kBAAkB,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC/D,MAAM,MAAM,GAAG,QAAQ,CAAC,KAAK,EAAG,CAAC;QACjC,MAAM,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,MAAM,CAAC,EAAE,CAAC,CAAC;QACrD,IAAI,EAAE,IAAI,CAAC;YAAE,IAAI,CAAC,MAAM,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;IAClC,CAAC;IACD,+EAA+E;IAC/E,2BAA2B;IAC3B,OAAO,IAAI,CAAC,MAAM,GAAG,kBAAkB,EAAE,CAAC;QACxC,MAAM,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,MAAM,CAAC,CAAC;QACrD,IAAI,CAAC,MAAM;YAAE,MAAM;QACnB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC;IACvC,CAAC;IACD,SAAS,CAAC,IAAI,CAAC,CAAC;AAClB,CAAC;AAED,iEAAiE;AACjE,MAAM,UAAU,SAAS,CAAC,EAAU;IAClC,IAAI,CAAC;QACH,MAAM,IAAI,GAAG,SAAS,CAAC,EAAE,CAAC,CAAC;QAC3B,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC;YAAE,OAAO,IAAI,CAAC;QACnC,MAAM,IAAI,GAAG,YAAY,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;QACzC,OAAO,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC;IACvC,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC;AAED,MAAM,UAAU,UAAU,CAAC,EAAU;IACnC,IAAI,CAAC;QACH,MAAM,IAAI,GAAG,SAAS,CAAC,EAAE,CAAC,CAAC;QAC3B,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC;YAAE,OAAO,CAAC,CAAC;QAChC,OAAO,YAAY,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC;IACnC,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,CAAC,CAAC;IACX,CAAC;AACH,CAAC;AAED,MAAM,UAAU,YAAY,CAAC,EAAU;IACrC,IAAI,CAAC;QACH,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;IACzC,CAAC;IAAC,MAAM,CAAC;QACP,iBAAiB;IACnB,CAAC;AACH,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,WAAW,CAAC,OAA0B;IACpD,IAAI,CAAC;QACH,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,CAAC;QAC9B,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,EAAE,EAAE,KAAK,CAAC,CAAC;QACnC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC;YAAE,OAAO;QAC7B,KAAK,MAAM,IAAI,IAAI,WAAW,CAAC,GAAG,CAAC,EAAE,CAAC;YACpC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC;gBAAE,SAAS;YACrC,MAAM,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;YAC7B,IAAI,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;gBAAE,SAAS;YAC3B,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;QAC3C,CAAC;IACH,CAAC;IAAC,MAAM,CAAC;QACP,0DAA0D;IAC5D,CAAC;AACH,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,YAAY,CAC1B,IAAY,EACZ,QAAgB,EAChB,YAAoB,gBAAgB,EACpC,YAAoB,gBAAgB;IAEpC,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;IAC1C,IAAI,KAAK,CAAC,MAAM,IAAI,QAAQ;QAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,YAAY,EAAE,CAAC,EAAE,CAAC;IACtE,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC,QAAQ,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3E,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC,QAAQ,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;IACzE,MAAM,YAAY,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;IAC3E,OAAO;QACL,IAAI,EAAE,GAAG,IAAI,UAAU,YAAY,0EAA0E,IAAI,EAAE;QACnH,YAAY;KACb,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,OAAO,WAAW;IAsBH;IACA;IACA;IAOA;IA9BX,IAAI,GAAG,EAAE,CAAC;IACV,IAAI,GAAG,EAAE,CAAC;IAClB,0EAA0E;IAClE,KAAK,GAAG,CAAC,CAAC;IACV,KAAK,GAAG,KAAK,CAAC;IACd,SAAS,GAAG,CAAC,CAAC;IACd,MAAM,GAAG,KAAK,CAAC;IACf,SAAS,GAAG,KAAK,CAAC;IAC1B,oEAAoE;IAC5D,UAAU,GAAG,KAAK,CAAC;IAC3B;;;;OAIG;IACK,IAAI,GAAwB,QAAQ,CAAC;IAC7C,yDAAyD;IACjD,OAAO,GAAG,EAAE,CAAC;IACJ,SAAS,CAAS;IAEnC,YACmB,EAAU,EACV,YAAoB,gBAAgB,EACpC,YAAoB,gBAAgB;IACrD;;;;;OAKG;IACc,MAAc,IAAI,CAAC,OAAO,EAAE,EAAE,KAAK,CAAC,EACrD,YAAoB,YAAY,EAAE;QAVjB,OAAE,GAAF,EAAE,CAAQ;QACV,cAAS,GAAT,SAAS,CAA2B;QACpC,cAAS,GAAT,SAAS,CAA2B;QAOpC,QAAG,GAAH,GAAG,CAAiC;QAGrD,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;IAC7B,CAAC;IAED,qCAAqC;IACrC,IAAI;QACF,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,EAAE,MAAM,CAAC,CAAC;IAC1C,CAAC;IAED;;;OAGG;IACH,eAAe;QACb,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;IACzB,CAAC;IAED,KAAK,CAAC,IAAY;QAChB,IAAI,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,SAAS,IAAI,CAAC,IAAI;YAAE,OAAO;QACnD,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,MAAM,CAAC;QAC1B,IAAI,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;YACtC,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAChE,CAAC;QACD,6EAA6E;QAC7E,4DAA4D;QAC5D,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC;QAClB,IAAI,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,SAAS,GAAG,CAAC;YAAE,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACxF,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;QAElB,IAAI,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;YAC9C,IAAI,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;gBAChC,mEAAmE;gBACnE,IAAI,CAAC,QAAQ,EAAE,CAAC;gBAChB,OAAO;YACT,CAAC;YACD,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC;YACrB,yEAAyE;YACzE,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,IAAI,mBAAmB;gBAAE,IAAI,CAAC,KAAK,EAAE,CAAC;QAC/D,CAAC;QACD,IAAI,CAAC,UAAU,EAAE,CAAC;IACpB,CAAC;IAEO,UAAU;QAChB,IAAI,CAAC,IAAI,CAAC,UAAU;YAAE,OAAO;QAC7B,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACvB,IAAI,GAAG,GAAG,IAAI,CAAC,SAAS,GAAG,cAAc;YAAE,OAAO;QAClD,IAAI,CAAC,KAAK,EAAE,CAAC;IACf,CAAC;IAED;;;;;;OAMG;IACK,QAAQ;QACd,IAAI,CAAC,IAAI,GAAG,QAAQ,CAAC;QACrB,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;QAClB,IAAI,CAAC,KAAK,EAAE,CAAC;IACf,CAAC;IAED;;;;;;;OAOG;IACH,KAAK;QACH,IAAI,CAAC,IAAI,CAAC,UAAU,IAAI,CAAC,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,MAAM;YAAE,OAAO;QAC7E,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAC5B,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAC9C,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;QACzE,MAAM,IAAI,GACR,OAAO,GAAG,CAAC;YACT,CAAC,CAAC,GAAG,IAAI,CAAC,IAAI,QAAQ,OAAO,8CAA8C,IAAI,EAAE;YACjF,CAAC,CAAC,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC;QACxB,IAAI,CAAC;YACH,SAAS,CAAC,IAAI,CAAC,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;YACzC,IAAI,IAAI,CAAC,IAAI,KAAK,QAAQ,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;gBAC3C,0EAA0E;gBAC1E,sDAAsD;gBACtD,cAAc,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;gBACnD,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;gBAClB,OAAO;YACT,CAAC;YACD,aAAa,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;QAC5C,CAAC;QAAC,MAAM,CAAC;YACP,6DAA6D;QAC/D,CAAC;IACH,CAAC;IAED;;;;;;OAMG;IACK,YAAY;QAClB,IAAI,CAAC,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,SAAS,IAAI,CAAC,IAAI,CAAC,OAAO;YAAE,OAAO;QAChE,IAAI,CAAC;YACH,SAAS,CAAC,IAAI,CAAC,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;YACzC,cAAc,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;YACnD,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;QACpB,CAAC;QAAC,MAAM,CAAC;YACP,iBAAiB;QACnB,CAAC;IACH,CAAC;IAED,oFAAoF;IACpF,KAAK;QACH,IAAI,IAAI,CAAC,MAAM;YAAE,OAAO;QACxB,IAAI,IAAI,CAAC,IAAI,KAAK,QAAQ;YAAE,IAAI,CAAC,YAAY,EAAE,CAAC;;YAC3C,IAAI,CAAC,KAAK,EAAE,CAAC;QAClB,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;IACrB,CAAC;IAED,uFAAuF;IACvF,OAAO;QACL,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QACtB,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;QACnB,IAAI,CAAC;YACH,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;QACvC,CAAC;QAAC,MAAM,CAAC;YACP,iBAAiB;QACnB,CAAC;IACH,CAAC;CACF;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,qBAAqB,CAAC,GAAW,EAAE,OAAe;IAChE,MAAM,GAAG,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC;IAC/B,IAAI,GAAG,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC,CAAC,8CAA8C;IAC7E,IAAI,CAAC,GAAG,CAAC,KAAK;QAAE,OAAO,KAAK,CAAC,CAAC,wCAAwC;IACtE,OAAO,cAAc,CAAC,OAAO,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;AAC9C,CAAC;AAED;;;GAGG;AACH,SAAS,cAAc,CAAC,OAAe,EAAE,QAAuB;IAC9D,MAAM,MAAM,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;IAC9B,IAAI,CAAC,MAAM;QAAE,OAAO,IAAI,CAAC;IACzB,IAAI,CAAC,QAAQ;QAAE,OAAO,IAAI,CAAC,CAAC,6CAA6C;IACzE,IAAI,CAAC;QACH,2EAA2E;QAC3E,6EAA6E;QAC7E,gEAAgE;QAChE,MAAM,SAAS,GAAG,CAAC,CAAS,EAAU,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC;QAC5F,MAAM,MAAM,GAAG,SAAS,CAAC,QAAQ,CAAC,CAAC;QACnC,MAAM,UAAU,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC;QACrC,oEAAoE;QACpE,oEAAoE;QACpE,IAAI,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAC;YAAE,OAAO,IAAI,CAAC;QAC7C,4EAA4E;QAC5E,0EAA0E;QAC1E,2EAA2E;QAC3E,4EAA4E;QAC5E,MAAM,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QACvC,IAAI,MAAM,CAAC,MAAM,IAAI,EAAE,IAAI,UAAU,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,KAAK;YAAE,OAAO,IAAI,CAAC;QACxG,OAAO,KAAK,CAAC;IACf,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC,CAAC,sDAAsD;IACrE,CAAC;AACH,CAAC;AAqCD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,UAAU,sBAAsB,CACpC,QAAyB,EACzB,IAAwB;IAExB,OAAO,oBAAoB,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC,OAAO,CAAC;AACtD,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,oBAAoB,CAClC,QAAyB,EACzB,IAAwB;IAExB,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;QAClB,OAAO;YACL,OAAO,EAAE,IAAI;YACb,GAAG,EAAE,4EAA4E;YACjF,IAAI,EAAE,kBAAkB;SACzB,CAAC;IACJ,CAAC;IACD,+EAA+E;IAC/E,0EAA0E;IAC1E,2EAA2E;IAC3E,IAAI,CAAC,IAAI,CAAC,KAAK;QAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,iCAAiC,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;IAEjG,MAAM,SAAS,GAAG,cAAc,CAAC,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;IACjE,MAAM,KAAK,GAAG,QAAQ,CAAC,WAAW,CAAC;IACnC,MAAM,OAAO,GAAG,KAAK,IAAI,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC;IAAE,IAAI,SAAS,KAAK,KAAK,EAAE,CAAC;QAC5G,OAAO;YACL,OAAO,EAAE,KAAK;YACd,IAAI,EAAE,UAAU;YAChB,GAAG,EACD,gDAAgD,IAAI,CAAC,OAAO,wBAAwB;gBACpF,0BAA0B;SAC7B,CAAC;IACJ,CAAC;IACD,IAAI,SAAS,KAAK,IAAI,EAAE,CAAC;QACvB,IAAI,OAAO,KAAK,KAAK,EAAE,CAAC;YACtB,OAAO;gBACL,OAAO,EAAE,KAAK;gBACd,IAAI,EAAE,UAAU;gBAChB,GAAG,EACD,6FAA6F;oBAC7F,MAAM,IAAI,CAAC,aAAa,eAAe,KAAK,yDAAyD;oBACrG,sCAAsC;aACzC,CAAC;QACJ,CAAC;QACD,OAAO;YACL,OAAO,EAAE,IAAI;YACb,IAAI,EAAE,UAAU;YAChB,GAAG,EACD,OAAO,KAAK,IAAI;gBACd,CAAC,CAAC,oFAAoF;gBACtF,CAAC,CAAC,0FAA0F;SACjG,CAAC;IACJ,CAAC;IACD,IAAI,OAAO,KAAK,IAAI,EAAE,CAAC;QACrB,OAAO;YACL,OAAO,EAAE,IAAI;YACb,IAAI,EAAE,UAAU;YAChB,GAAG,EACD,qGAAqG;gBACrG,sEAAsE;SACzE,CAAC;IACJ,CAAC;IACD,OAAO;QACL,OAAO,EAAE,IAAI;QACb,IAAI,EAAE,SAAS;QACf,GAAG,EAAE,OAAO,KAAK,KAAK;YACpB,CAAC,CAAC,uEAAuE;YACzE,CAAC,CAAC,2DAA2D;KAChE,CAAC;AACJ,CAAC;AAED,iFAAiF;AACjF,MAAM,UAAU,sBAAsB,CAAC,GAAW,EAAE,QAAyB;IAC3E,OAAO,sBAAsB,CAAC,QAAQ,EAAE,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC;AAC9D,CAAC"}