@osdlc/command-seam 0.0.0-stage → 0.0.1-stage

package/dist/sync.js

@@ -0,0 +1,406 @@
+/**
+ * The synchronous capture runner: the {@link CommandRunner} interface and its
+ * `spawnSync`-backed default, {@link spawnRunner}. Code that runs commands
+ * takes a `CommandRunner`; tests pass a fake. Live output and long-lived
+ * processes have their own runners (`stream.ts`, `process.ts`).
+ *
+ * Two ways to call it, like zod's `safeParse` and `parse`:
+ *   - `runner.run(...)` never throws for a failed command; the caller reads
+ *     `exitCode`.
+ *   - `runChecked(runner, ...)` throws {@link CommandFailed} on a non-zero
+ *     exit, for callers whose only sensible response to failure is to stop.
+ */
+import { spawnSync } from 'node:child_process';
+import { accessSync, constants, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync, } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { delimiter, join, resolve } from 'node:path';
+import { shellJoin } from "./quote.js";
+import { failureText, stderrOrError } from "./result.js";
+/**
+ * `{ env }`: `process.env` merged with `opts.env`, minus any key whose
+ * override is `undefined`. Always an explicit object built from the current
+ * `process.env` at call time — never `undefined`, never an omitted key, and
+ * never `process.env` handed through verbatim either.
+ *
+ * Node's `child_process.spawnSync` inherits live `process.env` whether
+ * `env` is omitted, `undefined`, or `process.env` itself. Bun's does not:
+ * all three instead take a snapshot — of exactly when is unclear, but
+ * empirically it misses anything set on `process.env` after the process
+ * started, even as the very first spawn — so a test that points an env var
+ * at a fresh temp dir right before spawning would silently see the real,
+ * unwritten default instead. Only spreading `process.env`'s current
+ * key/values into a brand-new plain object at the call site sidesteps
+ * whatever Bun is snapshotting.
+ */
+export function mergedEnv(opts) {
+    const env = { ...process.env, ...opts.env };
+    for (const [key, value] of Object.entries(env))
+        if (value === undefined)
+            delete env[key];
+    return { env };
+}
+/** The largest delay `setTimeout` honours; a longer one fires at once. */
+const MAX_TIMER_MS = 2 ** 31 - 1;
+/**
+ * `timeoutMs` as every runner applies it: `undefined` for no cap, else a whole
+ * number of milliseconds, at most {@link MAX_TIMER_MS}. See
+ * {@link CommandRunOptions.timeoutMs}.
+ *
+ * @throws `TypeError` for a value that is not a number.
+ * @throws `RangeError` for `0`, a negative value or `NaN`.
+ */
+export function normalizeTimeout(timeoutMs) {
+    if (timeoutMs === undefined)
+        return undefined;
+    return timerMs('timeoutMs', timeoutMs, 'positive');
+}
+/**
+ * A delay option as a timer takes it: `undefined` for `Infinity`, else a whole
+ * number of milliseconds, at most {@link MAX_TIMER_MS}. `min` says whether `0`
+ * is allowed. `name` is the option's name, for the error message.
+ *
+ * @throws `TypeError` for a value that is not a number.
+ * @throws `RangeError` for a value below `min`, or `NaN`.
+ */
+export function timerMs(name, ms, min) {
+    if (ms === Infinity)
+        return undefined;
+    if (typeof ms !== 'number')
+        throw new TypeError(`${name} must be a number, got ${typeof ms}`);
+    if (min === 'positive' ? !(ms > 0) : !(ms >= 0)) {
+        const allowed = min === 'positive' ? 'a positive number' : '0 or more';
+        throw new RangeError(`${name} must be ${allowed} or Infinity, got ${ms}`);
+    }
+    return Math.min(Math.ceil(ms), MAX_TIMER_MS);
+}
+/**
+ * A spawn error message when `cwd` is missing or not a directory, else
+ * `undefined`. Checked before spawning: a spawn reports a missing `cwd` as
+ * `spawn <binary> ENOENT`, which reads as a missing binary, and Node's async
+ * `spawn` throws for a `cwd` that is a file.
+ *
+ * @param spawnName - The message prefix: `spawn` or `spawnSync`, then the binary.
+ * @throws `TypeError` for a NUL byte in `binary`, `argv` or `opts.env`, as the
+ * spawn would, so a bad `cwd` does not hide it.
+ */
+export function cwdError(spawnName, binary, argv, opts) {
+    let problem;
+    try {
+        if (statSync(opts.cwd).isDirectory())
+            return undefined;
+        problem = 'ENOTDIR: cwd %s is not a directory';
+    }
+    catch (e) {
+        const code = e.code;
+        if (code !== 'ENOENT' && code !== 'ENOTDIR')
+            return undefined; // the spawn reports it
+        problem = 'ENOENT: cwd %s does not exist';
+    }
+    assertNoNulByte(binary, argv, opts.env);
+    return `${spawnName} ${problem.replace('%s', JSON.stringify(opts.cwd))}`;
+}
+/** Throw the `TypeError` a spawn throws for a NUL byte in its arguments. */
+function assertNoNulByte(binary, argv, env) {
+    const values = [
+        ['binary', binary],
+        ...argv.map((a, i) => [`argv[${i}]`, a]),
+        ...Object.entries(env ?? {}).flatMap(([k, v]) => [
+            [`env key ${JSON.stringify(k)}`, k],
+            [`env.${k}`, v ?? ''],
+        ]),
+    ];
+    for (const [name, value] of values) {
+        if (typeof value !== 'string' || !value.includes('\0'))
+            continue;
+        const e = new TypeError(`${name} must not contain a NUL byte`);
+        e.code = 'ERR_INVALID_ARG_VALUE';
+        throw e;
+    }
+}
+/** The stand-in result for a child that never started. */
+export function spawnFailure(message) {
+    return {
+        exitCode: 1,
+        neverExited: true,
+        reason: 'spawn',
+        stdout: '',
+        stderr: '',
+        error: message,
+    };
+}
+/**
+ * How a `spawnSync` that reported no exit status ended. Shared by the sync
+ * capture and streaming runners.
+ */
+export function syncStop(proc) {
+    const signal = proc.signal ?? undefined;
+    const sig = signal === undefined ? {} : { signal };
+    const code = proc.error?.code;
+    if (code === 'ETIMEDOUT')
+        return { reason: 'timeout', ...sig };
+    // On the cap, `spawnSync` kills the child with `killSignal`.
+    if (code === 'ENOBUFS')
+        return { reason: 'output', ...sig };
+    if (signal !== undefined)
+        return { reason: 'signal', signal };
+    return { reason: 'spawn' };
+}
+/**
+ * Thrown by {@link runChecked} and `runCheckedAsync` on a non-zero exit.
+ * Carries the argv and the full {@link CommandResult}, so a caller can report
+ * the output without running the command again.
+ *
+ * `message` is `command failed (exit N): <argv>`, with argv quoted by
+ * `shellJoin`, followed on a new line by the trimmed stderr, or the trimmed
+ * `error` when stderr is empty. Nothing follows when both are empty. The argv
+ * appears in full, so error logs and reports carry it: pass secrets through
+ * `env` or `input`, not argv. Use `detail` to show a person
+ * why it failed.
+ */
+export class CommandFailed extends Error {
+    /** The arguments the command ran with, without the binary name. */
+    argv;
+    /** The full result of the failed run. */
+    result;
+    /**
+     * The failure text to show a human: both streams, trimmed, newline-joined,
+     * empty ones dropped, with the runner's `error` standing in for an empty
+     * stderr. Empty when there is no text at all. The same as
+     * `failureText(e.result, { both: true })`.
+     *
+     * `message` interpolates stderr only, and several commands write the
+     * sentence that explains the failure to stdout instead — a rejecting git
+     * hook, `git commit` on a clean tree, `git apply --check`. Read this rather
+     * than picking a stream at the call site.
+     *
+     * Both are joined rather than one preferred, because a rejecting hook is
+     * the case where both carry a distinct half: git's own "commit failed" on
+     * stderr, the hook's reason on stdout. Preferring either drops the half
+     * the reader needs.
+     */
+    get detail() {
+        return failureText(this.result, { both: true });
+    }
+    /**
+     * @param argv - The arguments the command ran with.
+     * @param result - The result of the failed run.
+     */
+    constructor(argv, result) {
+        const stderr = stderrOrError(result);
+        super(`command failed (exit ${result.exitCode}): ${shellJoin(argv)}` +
+            (stderr ? `\n${stderr}` : ''));
+        this.name = 'CommandFailed';
+        this.argv = argv;
+        this.result = result;
+    }
+}
+export function runChecked(runner, argv, ...opts) {
+    const result = runner.run(argv, ...opts);
+    if (result.exitCode !== 0)
+        throw new CommandFailed(argv, result);
+    return result;
+}
+/**
+ * Run `fn`; if it throws {@link CommandFailed}, throw `mapper(e)` instead.
+ * Any other error propagates untouched, as does `fn`'s return value. Replaces
+ * `catch (e) { if (e instanceof CommandFailed) throw new X(...); throw e }`.
+ *
+ * `mapper` may have side effects (print the output, say) before returning the
+ * error to throw. Async version: `mapFailedAsync`.
+ *
+ * @param fn - The code to run, usually a `runChecked` call.
+ * @param mapper - Turns the failure into the error to throw.
+ * @returns What `fn` returns.
+ * @throws The error `mapper` returns, when `fn` throws `CommandFailed`.
+ */
+export function mapFailed(fn, mapper) {
+    try {
+        return fn();
+    }
+    catch (e) {
+        if (e instanceof CommandFailed)
+            throw mapper(e);
+        throw e;
+    }
+}
+/**
+ * Run `fn`; if it throws {@link CommandFailed}, return `onFailed(e)` instead.
+ * Any other error propagates untouched. Async version: `catchFailedAsync`.
+ *
+ * @param fn - The code to run, usually a `runChecked` call.
+ * @param onFailed - Turns the failure into a value.
+ * @returns What `fn` returns, or what `onFailed` returns.
+ */
+export function catchFailed(fn, onFailed) {
+    try {
+        return fn();
+    }
+    catch (e) {
+        if (e instanceof CommandFailed)
+            return onFailed(e);
+        throw e;
+    }
+}
+// Bun's `bun test` runtime mis-wires child-process stdio once a large module
+// graph is loaded in the test process: the child runs — its own `<in >out`
+// redirects work, filesystem side effects land — but the stdin/stdout/stderr
+// the parent hands it come back empty. Confirmed for sync and async spawns,
+// pipes and parent-opened fds, across every Bun 1.2.x-1.3.x; not reproducible
+// under `bun run`. A suite that shells out after importing a heavy module
+// graph hits it on every run.
+// Only Bun's test runner is affected, so the workaround needs both the Bun
+// runtime and `NODE_ENV=test` (which `bun test` sets). Jest and Vitest also
+// set `NODE_ENV=test`, but they run on Node and keep the pipe path below.
+const CHILD_STDIO_CORRUPTED = process.versions['bun'] !== undefined && process.env['NODE_ENV'] === 'test';
+/**
+ * Whether `binary` resolves to an executable file the way a spawn would find
+ * it: a name with a `/` is taken relative to `cwd`; a bare name is looked up
+ * on the child's `PATH`.
+ */
+function findsExecutable(binary, cwd, path) {
+    const isExecutable = (p) => {
+        try {
+            accessSync(p, constants.X_OK);
+            return statSync(p).isFile();
+        }
+        catch {
+            return false;
+        }
+    };
+    if (binary === '')
+        return false;
+    if (binary.includes('/'))
+        return isExecutable(resolve(cwd, binary));
+    return (path ?? '/usr/bin:/bin')
+        .split(delimiter)
+        .some((dir) => isExecutable(resolve(cwd, dir, binary)));
+}
+/** Folds a finished `spawnSync` into a {@link CommandResult}. */
+function fromSpawnSync(proc, stdout, stderr) {
+    return {
+        exitCode: proc.status ?? 1,
+        // Bun reports a failed spawn with `status` undefined, not null.
+        ...(proc.status == null ? { neverExited: true, ...syncStop(proc) } : {}),
+        stdout,
+        stderr,
+        // `proc.error` is set for a failed spawn, a timeout, the output cap, or a
+        // failed stdin write; only the first three leave `status` null (and under
+        // Bun the cap can come with a real status too). A stdin write error can
+        // come with a child that did exit, so it is kept either way.
+        ...(proc.error ? { error: proc.error.message } : {}),
+    };
+}
+/**
+ * Capture output the one way Bun does not corrupt: let the child do its own
+ * `<in >out 2>err` redirects to temp files, then read the files back. `binary`
+ * and `argv` ride as separate `sh` positional args — never parsed as shell — so
+ * arguments containing spaces, metacharacters, or `$()` are inert. `exec`
+ * replaces `sh`, so the reported exit status (and the cwd/env/timeout) all
+ * belong to the child, matching the pipe path's contract.
+ */
+function runViaChildRedirect(binary, argv, opts, timeoutMs) {
+    const { env } = mergedEnv(opts);
+    // A binary that cannot be found would make `exec` fail and `sh` exit 127,
+    // which reads as the command's own answer. Check first, so the result is
+    // the same stand-in the pipe path reports for a failed spawn. This also
+    // keeps a binary named like an option (`-a`) from reaching `exec` as one,
+    // unless an executable named `-a` is on PATH.
+    if (!findsExecutable(binary, opts.cwd, env['PATH'])) {
+        return spawnFailure(`spawnSync ${binary} ENOENT`);
+    }
+    const dir = mkdtempSync(join(tmpdir(), 'command-seam-'));
+    try {
+        const inFile = join(dir, 'in');
+        const outFile = join(dir, 'out');
+        const errFile = join(dir, 'err');
+        writeFileSync(inFile, opts.input ?? '');
+        const proc = spawnSync(
+        // An absolute path, so an `env.PATH` override without `/bin` still
+        // finds the shell.
+        '/bin/sh', [
+            '-c',
+            'i="$1"; o="$2"; e="$3"; shift 3; exec "$@" <"$i" >"$o" 2>"$e"',
+            'sh', // $0
+            inFile,
+            outFile,
+            errFile,
+            binary,
+            ...argv,
+        ], {
+            cwd: opts.cwd,
+            timeout: timeoutMs,
+            // SIGKILL, not spawnSync's default SIGTERM: the contract is a hard
+            // cap, and a child that ignores TERM is left to run to completion —
+            // spawnSync signals on expiry and then keeps waiting for an exit.
+            killSignal: 'SIGKILL',
+            env,
+        });
+        // The redirect files are created by the child's `>` / `2>`, so neither
+        // exists when `sh` itself never ran — a spawn that fails with EAGAIN under
+        // a saturated process table is the case that matters, and it must not turn
+        // into an ENOENT thrown from the capture layer. Missing reads as empty,
+        // matching what the pipe path reports for a child that produced nothing.
+        const readOrEmpty = (p) => {
+            try {
+                return readFileSync(p, 'utf-8');
+            }
+            catch {
+                return '';
+            }
+        };
+        // Output goes to a file, so there is no maxBuffer: it is bounded only by
+        // disk.
+        return fromSpawnSync(proc, readOrEmpty(outFile), readOrEmpty(errFile));
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+}
+/**
+ * The injected runner when there is one, else `spawnRunner(binary)`.
+ *
+ * @param binary - The binary for the default runner.
+ * @param injected - A runner to use instead, such as a test fake.
+ */
+export function resolveRunner(binary, injected) {
+    return injected ?? spawnRunner(binary);
+}
+/**
+ * The default {@link CommandRunner}: runs `binary` with `spawnSync`, so each
+ * call blocks until the child exits. On timeout the child gets `SIGKILL`.
+ * Captured output is capped at 256 MB per stream. Under `bun test` (the Bun
+ * runtime with `NODE_ENV=test`) it captures through `/bin/sh` and temp files
+ * instead of pipes (see `runViaChildRedirect`).
+ *
+ * @param binary - A name looked up on `PATH`, or a path.
+ * @returns A runner for that binary.
+ *
+ * @example
+ * ```ts
+ * const git = spawnRunner('git')
+ * const r = git.run(['status', '--porcelain'], { cwd: '.', timeoutMs: 10_000 })
+ * if (r.exitCode === 0) console.log(r.stdout)
+ * ```
+ */
+export function spawnRunner(binary) {
+    return {
+        run(argv, opts) {
+            const timeoutMs = normalizeTimeout(opts.timeoutMs);
+            const cwdMessage = cwdError(`spawnSync ${binary}`, binary, argv, opts);
+            if (cwdMessage !== undefined)
+                return spawnFailure(cwdMessage);
+            if (CHILD_STDIO_CORRUPTED)
+                return runViaChildRedirect(binary, argv, opts, timeoutMs);
+            const proc = spawnSync(binary, argv, {
+                cwd: opts.cwd,
+                maxBuffer: 256 * 1024 * 1024,
+                timeout: timeoutMs,
+                // See `runViaChildRedirect`: the default SIGTERM is not a hard cap.
+                killSignal: 'SIGKILL',
+                input: opts.input,
+                ...mergedEnv(opts),
+            });
+            return fromSpawnSync(proc, proc.stdout?.toString() ?? '', proc.stderr?.toString() ?? '');
+        },
+    };
+}

package/dist/testing.d.ts

@@ -0,0 +1,158 @@
+/**
+ * `@osdlc/command-seam/testing`: fakes for tests, kept out of the main
+ * entry so production code never imports them.
+ *
+ * - `fakeRunner` answers capture-runner calls from a table and records them.
+ * - `fakeNeverExited` builds the result of a run that never exited.
+ * - `fakeProcess` is a managed-process handle the test ends by hand.
+ */
+import { type ManagedProcessExit, type ManagedProcessHandle, type ManagedProcessRunner, type ManagedProcessRunOptions } from './process.ts';
+import { type AsyncCommandRunner, type AsyncCommandRunOptions } from './async.ts';
+import type { CommandResult, CommandRunner, NeverExitedReason } from './sync.ts';
+/**
+ * One call a fake received.
+ *
+ * @experimental
+ */
+export interface FakeCall<O> {
+    argv: string[];
+    opts: O;
+}
+/** What a fake answers: fields over `{ exitCode: 0, stdout: '', stderr: '' }`. */
+type FakeAnswer = Partial<CommandResult>;
+/**
+ * What `fakeRunner` returns.
+ *
+ * @experimental
+ */
+export interface FakeRunner {
+    /** Pass this to the code under test. */
+    runner: CommandRunner;
+    /**
+     * The same fake as an {@link AsyncCommandRunner}, for async code. It shares
+     * the answers and `calls`.
+     */
+    asyncRunner: AsyncCommandRunner;
+    /**
+     * Every call, in order: a copy of its argv and a shallow copy of its
+     * options. Typed with the async options, so a call made through
+     * `asyncRunner` shows its `signal` or `processGroup`.
+     */
+    calls: FakeCall<AsyncCommandRunOptions>[];
+}
+/**
+ * A fake {@link CommandRunner} that answers from a table and records every
+ * call.
+ *
+ * `answers` maps an argv to the result fields that differ from a clean
+ * empty run: `{ exitCode: 0, stdout: '', stderr: '' }`. The key is each
+ * argument quoted with `shellQuote`, joined with single spaces: a plain
+ * argument stays as it is, and one with a space or a shell character is
+ * single-quoted, so `['-m', 'a b']` is `-m 'a b'` and cannot match
+ * `['-m', 'a', 'b']`. It can also be a function of the call; return
+ * `undefined` for no answer.
+ *
+ * A call with no answer reports a failed spawn, as a missing binary would:
+ * `exitCode: 1`, `neverExited: true`, `reason: 'spawn'`, and
+ * `fakeRunner: no answer for: <key>` in `error`, where `<key>` is the table
+ * key that would answer it. So `ran()` is false and `runChecked` throws.
+ * Code that reads a failed run as an answer may still go on, so assert on
+ * `calls` to be sure every call was expected.
+ *
+ * Through `asyncRunner`, `signal` and `processGroup` are recorded but do
+ * nothing, and `onSpawn` is never called.
+ *
+ * @param answers - Results by argv, or a function that picks one.
+ * @returns The runner, the same fake as an async runner, and the list of
+ * calls they received.
+ *
+ * @example
+ * ```ts
+ * const { runner, calls } = fakeRunner({ 'rev-parse --short HEAD': { stdout: 'abc\n' } })
+ * runner.run(['rev-parse', '--short', 'HEAD'], { cwd: '/repo' }).stdout // 'abc\n'
+ * calls[0]?.opts.cwd // '/repo'
+ * ```
+ *
+ * @experimental
+ */
+export declare function fakeRunner(answers: Readonly<Record<string, FakeAnswer>> | ((argv: string[], opts: AsyncCommandRunOptions) => FakeAnswer | undefined)): FakeRunner;
+/**
+ * A fake answer for a run that never exited, with the fields the real
+ * runners set together for `reason`: `exitCode: 1`, `neverExited: true`,
+ * `reason`, `error: 'fake: <reason>'`, and `signal` where the sync runner
+ * sets one (`SIGKILL` for `timeout` and `output`, `SIGTERM` for `signal`).
+ * A death by a signal from elsewhere has no `error`, as on the real runners.
+ * `fields` override any of these, such as the `signal` or the `error`.
+ *
+ * @param reason - Why the run never exited.
+ * @param fields - Fields to set over the defaults.
+ * @returns An answer for `fakeRunner`.
+ *
+ * @example
+ * ```ts
+ * const { runner } = fakeRunner({ 'fetch origin': fakeNeverExited('timeout') })
+ * runner.run(['fetch', 'origin'], { cwd: '/repo' }).reason // 'timeout'
+ * ```
+ *
+ * @experimental
+ */
+export declare function fakeNeverExited(reason: NeverExitedReason, fields?: Partial<CommandResult>): Partial<CommandResult>;
+/**
+ * Options for {@link fakeProcess}.
+ *
+ * @experimental
+ */
+export interface FakeProcessOptions {
+    /** The handle's pid. Default `4242`. */
+    pid?: number | undefined;
+    /**
+     * Which signals sent through `kill()` end the process, as for a process
+     * that does not handle them: `exited` settles with `reason: 'abort'`.
+     * `true` (the default) is every signal, `false` none, and a list only
+     * those, such as `['SIGKILL']` for a process that survives `SIGTERM`.
+     */
+    exitOnKill?: boolean | readonly NodeJS.Signals[] | undefined;
+}
+/**
+ * What `fakeProcess` returns: a handle, plus the controls a test needs.
+ *
+ * @experimental
+ */
+export interface FakeProcess extends ManagedProcessHandle {
+    /**
+     * End the process: settle `exited` with these fields over
+     * `{ exitCode: 0, signal: null }`. Only the first end counts, as for a
+     * real process. To fake a death by a signal from elsewhere, pass
+     * `{ exitCode: 1, signal, neverExited: true, reason: 'signal' }`, as
+     * `managedProcessRunner` reports it.
+     */
+    exit(result?: Partial<ManagedProcessExit>): void;
+    /** Every signal passed to `kill()`, in order; `SIGTERM` when none was given. */
+    signals: (NodeJS.Signals | number)[];
+    /** A runner that returns this handle from every `run`. */
+    runner: ManagedProcessRunner;
+    /** Every call `runner` received. */
+    calls: FakeCall<ManagedProcessRunOptions>[];
+}
+/**
+ * A fake {@link ManagedProcessHandle}: it starts nothing, and `exited`
+ * settles when the test calls `exit()`, or when the code under test calls
+ * `kill()` (see `exitOnKill`).
+ *
+ * @param opts - The pid, and which signals sent through `kill()` end the process.
+ * @returns The handle, with `exit()`, the signals sent and a runner that
+ * serves it.
+ *
+ * @example
+ * ```ts
+ * const proc = fakeProcess()
+ * const server = proc.runner.run(['server.js'], { cwd: '.' })
+ * proc.exit({ exitCode: 0 })
+ * await server.exited // { exitCode: 0, signal: null }
+ * ```
+ *
+ * @experimental
+ */
+export declare function fakeProcess(opts?: FakeProcessOptions): FakeProcess;
+export {};
+//# sourceMappingURL=testing.d.ts.map

package/dist/testing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../testing.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAEL,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,EACzB,KAAK,wBAAwB,EAC9B,MAAM,cAAc,CAAA;AACrB,OAAO,EAAW,KAAK,kBAAkB,EAAE,KAAK,sBAAsB,EAAE,MAAM,YAAY,CAAA;AAE1F,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAEhF;;;;GAIG;AACH,MAAM,WAAW,QAAQ,CAAC,CAAC;IACzB,IAAI,EAAE,MAAM,EAAE,CAAA;IACd,IAAI,EAAE,CAAC,CAAA;CACR;AAED,kFAAkF;AAClF,KAAK,UAAU,GAAG,OAAO,CAAC,aAAa,CAAC,CAAA;AAExC;;;;GAIG;AACH,MAAM,WAAW,UAAU;IACzB,wCAAwC;IACxC,MAAM,EAAE,aAAa,CAAA;IACrB;;;OAGG;IACH,WAAW,EAAE,kBAAkB,CAAA;IAC/B;;;;OAIG;IACH,KAAK,EAAE,QAAQ,CAAC,sBAAsB,CAAC,EAAE,CAAA;CAC1C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,UAAU,CACxB,OAAO,EACH,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,GACpC,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,sBAAsB,KAAK,UAAU,GAAG,SAAS,CAAC,GAC7E,UAAU,CAmBZ;AAWD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,iBAAiB,EACzB,MAAM,GAAE,OAAO,CAAC,aAAa,CAAM,GAClC,OAAO,CAAC,aAAa,CAAC,CAUxB;AAWD;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IACjC,wCAAwC;IACxC,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACxB;;;;;OAKG;IACH,UAAU,CAAC,EAAE,OAAO,GAAG,SAAS,MAAM,CAAC,OAAO,EAAE,GAAG,SAAS,CAAA;CAC7D;AAED;;;;GAIG;AACH,MAAM,WAAW,WAAY,SAAQ,oBAAoB;IACvD;;;;;;OAMG;IACH,IAAI,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,kBAAkB,CAAC,GAAG,IAAI,CAAA;IAChD,gFAAgF;IAChF,OAAO,EAAE,CAAC,MAAM,CAAC,OAAO,GAAG,MAAM,CAAC,EAAE,CAAA;IACpC,0DAA0D;IAC1D,MAAM,EAAE,oBAAoB,CAAA;IAC5B,oCAAoC;IACpC,KAAK,EAAE,QAAQ,CAAC,wBAAwB,CAAC,EAAE,CAAA;CAC5C;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,WAAW,CAAC,IAAI,GAAE,kBAAuB,GAAG,WAAW,CAqCtE"}