first commit

2026-02-05 00:06:40 -05:00 · 2025-12-08 10:52:05 -05:00
commit 50737919fd
935 changed files with 782679 additions and 0 deletions
--- a/node_modules/tinyexec/LICENSE
+++ b/node_modules/tinyexec/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Tinylibs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
--- a/node_modules/tinyexec/README.md
+++ b/node_modules/tinyexec/README.md
@@ -0,0 +1,269 @@
+# tinyexec 📟
+
+> A minimal package for executing commands
+
+This package was created to provide a minimal way of interacting with child
+processes without having to manually deal with streams, piping, etc.
+
+## Installing
+
+```sh
+$ npm i -S tinyexec
+```
+
+## Usage
+
+A process can be spawned and awaited like so:
+
+```ts
+import {x} from 'tinyexec';
+
+const result = await x('ls', ['-l']);
+
+// result.stdout - the stdout as a string
+// result.stderr - the stderr as a string
+// result.exitCode - the process exit code as a number
+```
+
+By default, tinyexec does not throw on non‑zero exit codes. Check `result.exitCode` or pass `{throwOnError: true}`. 
+
+Output is returned exactly as produced; trailing newlines are not trimmed. If you need trimming, do it explicitly:
+
+```ts
+const clean = result.stdout.replace(/\r?\n$/, '');
+```
+
+You may also iterate over the lines of output via an async loop:
+
+```ts
+import {x} from 'tinyexec';
+
+const proc = x('ls', ['-l']);
+
+for await (const line of proc) {
+  // line will be from stderr/stdout in the order you'd see it in a term
+}
+```
+
+### Options
+
+Options can be passed to have finer control over spawning of the process:
+
+```ts
+await x('ls', [], {
+  timeout: 1000
+});
+```
+
+The options object can have the following properties:
+
+- `signal` - an `AbortSignal` to allow aborting of the execution
+- `timeout` - time in milliseconds at which the process will be forceably killed
+- `persist` - if `true`, the process will continue after the host exits
+- `stdin` - another `Result` can be used as the input to this process
+- `nodeOptions` - any valid options to node's underlying `spawn` function
+- `throwOnError` - if true, non-zero exit codes will throw an error
+
+### Piping to another process
+
+You can pipe a process to another via the `pipe` method:
+
+```ts
+const proc1 = x('ls', ['-l']);
+const proc2 = proc1.pipe('grep', ['.js']);
+const result = await proc2;
+
+console.log(result.stdout);
+```
+
+`pipe` takes the same options as a regular execution. For example, you can
+pass a timeout to the pipe call:
+
+```ts
+proc1.pipe('grep', ['.js'], {
+  timeout: 2000
+});
+```
+
+### Killing a process
+
+You can kill the process via the `kill` method:
+
+```ts
+const proc = x('ls');
+
+proc.kill();
+
+// or with a signal
+proc.kill('SIGHUP');
+```
+
+### Node modules/binaries
+
+By default, node's available binaries from `node_modules` will be accessible
+in your command.
+
+For example, in a repo which has `eslint` installed:
+
+```ts
+await x('eslint', ['.']);
+```
+
+In this example, `eslint` will come from the locally installed `node_modules`.
+
+### Using an abort signal
+
+An abort signal can be passed to a process in order to abort it at a later
+time. This will result in the process being killed and `aborted` being set
+to `true`.
+
+```ts
+const aborter = new AbortController();
+const proc = x('node', ['./foo.mjs'], {
+  signal: aborter.signal
+});
+
+// elsewhere...
+aborter.abort();
+
+await proc;
+
+proc.aborted; // true
+proc.killed; // true
+```
+
+### Using with command strings
+
+If you need to continue supporting commands as strings (e.g. "command arg0 arg1"),
+you can use [args-tokenizer](https://github.com/TrySound/args-tokenizer),
+a lightweight library for parsing shell command strings into an array.
+
+```ts
+import {x} from 'tinyexec';
+import {tokenizeArgs} from 'args-tokenizer';
+
+const commandString = 'echo "Hello, World!"';
+const [command, ...args] = tokenizeArgs(commandString);
+const result = await x(command, args);
+
+result.stdout; // Hello, World!
+```
+
+## API
+
+Calling `x(command[, args])` returns an awaitable `Result` which has the
+following API methods and properties available:
+
+### `pipe(command[, args[, options]])`
+
+Pipes the current command to another. For example:
+
+```ts
+x('ls', ['-l'])
+  .pipe('grep', ['js']);
+```
+
+The parameters are as follows:
+
+- `command` - the command to execute (_without any arguments_)
+- `args` - an array of arguments
+- `options` - options object
+
+### `process`
+
+The underlying Node.js `ChildProcess`. tinyexec keeps the surface minimal and does not re‑expose every child_process method/event. Use `proc.process` for advanced access (streams, events, etc.).
+
+```ts
+const proc = x('node', ['./foo.mjs']);
+
+proc.process?.stdout?.on('data', (chunk) => {
+  // ...
+});
+proc.process?.once('close', (code) => {
+  // ...
+});
+```
+
+### `kill([signal])`
+
+Kills the current process with the specified signal. By default, this will
+use the `SIGTERM` signal.
+
+For example:
+
+```ts
+const proc = x('ls');
+
+proc.kill();
+```
+
+### `pid`
+
+The current process ID. For example:
+
+```ts
+const proc = x('ls');
+
+proc.pid; // number
+```
+
+### `aborted`
+
+Whether the process has been aborted or not (via the `signal` originally
+passed in the options object).
+
+For example:
+
+```ts
+const proc = x('ls');
+
+proc.aborted; // bool
+```
+
+### `killed`
+
+Whether the process has been killed or not (e.g. via `kill()` or an abort
+signal).
+
+For example:
+
+```ts
+const proc = x('ls');
+
+proc.killed; // bool
+```
+
+### `exitCode`
+
+The exit code received when the process completed execution.
+
+For example:
+
+```ts
+const proc = x('ls');
+
+proc.exitCode; // number (e.g. 1)
+```
+
+## Comparison with other libraries
+
+`tinyexec` aims to provide a lightweight layer on top of Node's own
+`child_process` API.
+
+Some clear benefits compared to other libraries are that `tinyexec` will be much lighter, have a much
+smaller footprint and will have a less abstract interface (less "magic"). It
+will also have equal security and cross-platform support to popular
+alternatives.
+
+There are various features other libraries include which we are unlikely
+to ever implement, as they would prevent us from providing a lightweight layer.
+
+For example, if you'd like write scripts rather than individual commands, and
+prefer to use templating, we'd definitely recommend
+[zx](https://github.com/google/zx). zx is a much higher level library which
+does some of the same work `tinyexec` does but behind a template string
+interface.
+
+Similarly, libraries like `execa` will provide helpers for various things
+like passing files as input to processes. We opt not to support features like
+this since many of them are easy to do yourself (using Node's own APIs).
--- a/node_modules/tinyexec/dist/main.d.ts
+++ b/node_modules/tinyexec/dist/main.d.ts
@@ -0,0 +1,74 @@
+/// <reference types="node" resolution-mode="require"/>
+import { ChildProcess, SpawnOptions } from "node:child_process";
+import { Readable } from "node:stream";
+
+//#region src/non-zero-exit-error.d.ts
+declare class NonZeroExitError extends Error {
+  readonly result: Result;
+  readonly output?: Output;
+  get exitCode(): number | undefined;
+  constructor(result: Result, output?: Output);
+}
+
+//#endregion
+//#region src/main.d.ts
+interface Output {
+  stderr: string;
+  stdout: string;
+  exitCode: number | undefined;
+}
+interface PipeOptions extends Options {}
+type KillSignal = Parameters<ChildProcess['kill']>[0];
+interface OutputApi extends AsyncIterable<string> {
+  pipe(command: string, args?: string[], options?: Partial<PipeOptions>): Result;
+  process: ChildProcess | undefined;
+  kill(signal?: KillSignal): boolean;
+  get pid(): number | undefined;
+  get aborted(): boolean;
+  get killed(): boolean;
+  get exitCode(): number | undefined;
+}
+type Result = PromiseLike<Output> & OutputApi;
+interface Options {
+  signal: AbortSignal;
+  nodeOptions: SpawnOptions;
+  timeout: number;
+  persist: boolean;
+  stdin: ExecProcess;
+  throwOnError: boolean;
+}
+interface TinyExec {
+  (command: string, args?: string[], options?: Partial<Options>): Result;
+}
+declare class ExecProcess implements Result {
+  protected _process?: ChildProcess;
+  protected _aborted: boolean;
+  protected _options: Partial<Options>;
+  protected _command: string;
+  protected _args: string[];
+  protected _resolveClose?: () => void;
+  protected _processClosed: Promise<void>;
+  protected _thrownError?: Error;
+  get process(): ChildProcess | undefined;
+  get pid(): number | undefined;
+  get exitCode(): number | undefined;
+  constructor(command: string, args?: string[], options?: Partial<Options>);
+  kill(signal?: KillSignal): boolean;
+  get aborted(): boolean;
+  get killed(): boolean;
+  pipe(command: string, args?: string[], options?: Partial<PipeOptions>): Result;
+  [Symbol.asyncIterator](): AsyncIterator<string>;
+  protected _waitForOutput(): Promise<Output>;
+  then<TResult1 = Output, TResult2 = never>(onfulfilled?: ((value: Output) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+  protected _streamOut?: Readable;
+  protected _streamErr?: Readable;
+  spawn(): void;
+  protected _resetState(): void;
+  protected _onError: (err: Error) => void;
+  protected _onClose: () => void;
+}
+declare const x: TinyExec;
+declare const exec: TinyExec;
+
+//#endregion
+export { ExecProcess, KillSignal, NonZeroExitError, Options, Output, OutputApi, PipeOptions, Result, TinyExec, exec, x };
--- a/node_modules/tinyexec/dist/main.js
+++ b/node_modules/tinyexec/dist/main.js
@@ -0,0 +1,633 @@
+import { createRequire as e } from "module";
+import { spawn as t } from "node:child_process";
+import { delimiter as n, dirname as r, normalize as i, resolve as a } from "node:path";
+import { cwd as o } from "node:process";
+import { PassThrough as s } from "node:stream";
+import c from "node:readline";
+var l = Object.create;
+var u = Object.defineProperty;
+var d = Object.getOwnPropertyDescriptor;
+var f = Object.getOwnPropertyNames;
+var p = Object.getPrototypeOf;
+var m = Object.prototype.hasOwnProperty;
+var h = (e, t) => () => (t || e((t = { exports: {} }).exports, t), t.exports);
+var g = (e, t, n, r) => {
+	if (t && typeof t === "object" || typeof t === "function") for (var i = f(t), a = 0, o = i.length, s; a < o; a++) {
+		s = i[a];
+		if (!m.call(e, s) && s !== n) u(e, s, {
+			get: ((e) => t[e]).bind(null, s),
+			enumerable: !(r = d(t, s)) || r.enumerable
+		});
+	}
+	return e;
+};
+var _ = (e, t, n) => (n = e != null ? l(p(e)) : {}, g(t || !e || !e.__esModule ? u(n, "default", {
+	value: e,
+	enumerable: true
+}) : n, e));
+var v = /* @__PURE__ */ e(import.meta.url);
+const y = /^path$/i;
+const b = {
+	key: "PATH",
+	value: ""
+};
+function x(e) {
+	for (const t in e) {
+		if (!Object.prototype.hasOwnProperty.call(e, t) || !y.test(t)) continue;
+		const n = e[t];
+		if (!n) return b;
+		return {
+			key: t,
+			value: n
+		};
+	}
+	return b;
+}
+function S(e, t) {
+	const i = t.value.split(n);
+	let o = e;
+	let s;
+	do {
+		i.push(a(o, "node_modules", ".bin"));
+		s = o;
+		o = r(o);
+	} while (o !== s);
+	return {
+		key: t.key,
+		value: i.join(n)
+	};
+}
+function C(e, t) {
+	const n = {
+		...process.env,
+		...t
+	};
+	const r = S(e, x(n));
+	n[r.key] = r.value;
+	return n;
+}
+const w = (e) => {
+	let t = e.length;
+	const n = new s();
+	const r = () => {
+		if (--t === 0) n.emit("end");
+	};
+	for (const t of e) {
+		t.pipe(n, { end: false });
+		t.on("end", r);
+	}
+	return n;
+};
+var T = h((exports, t) => {
+	t.exports = a;
+	a.sync = o;
+	var n = v("fs");
+	function r(e, t) {
+		var n = t.pathExt !== void 0 ? t.pathExt : process.env.PATHEXT;
+		if (!n) return true;
+		n = n.split(";");
+		if (n.indexOf("") !== -1) return true;
+		for (var r = 0; r < n.length; r++) {
+			var i = n[r].toLowerCase();
+			if (i && e.substr(-i.length).toLowerCase() === i) return true;
+		}
+		return false;
+	}
+	function i(e, t, n) {
+		if (!e.isSymbolicLink() && !e.isFile()) return false;
+		return r(t, n);
+	}
+	function a(e, t, r) {
+		n.stat(e, function(n, a) {
+			r(n, n ? false : i(a, e, t));
+		});
+	}
+	function o(e, t) {
+		return i(n.statSync(e), e, t);
+	}
+});
+var E = h((exports, t) => {
+	t.exports = r;
+	r.sync = i;
+	var n = v("fs");
+	function r(e, t, r) {
+		n.stat(e, function(e, n) {
+			r(e, e ? false : a(n, t));
+		});
+	}
+	function i(e, t) {
+		return a(n.statSync(e), t);
+	}
+	function a(e, t) {
+		return e.isFile() && o(e, t);
+	}
+	function o(e, t) {
+		var n = e.mode;
+		var r = e.uid;
+		var i = e.gid;
+		var a = t.uid !== void 0 ? t.uid : process.getuid && process.getuid();
+		var o = t.gid !== void 0 ? t.gid : process.getgid && process.getgid();
+		var s = parseInt("100", 8);
+		var c = parseInt("010", 8);
+		var l = parseInt("001", 8);
+		var u = s | c;
+		var d = n & l || n & c && i === o || n & s && r === a || n & u && a === 0;
+		return d;
+	}
+});
+var D = h((exports, t) => {
+	var n = v("fs");
+	var r;
+	if (process.platform === "win32" || global.TESTING_WINDOWS) r = T();
+	else r = E();
+	t.exports = i;
+	i.sync = a;
+	function i(e, t, n) {
+		if (typeof t === "function") {
+			n = t;
+			t = {};
+		}
+		if (!n) {
+			if (typeof Promise !== "function") throw new TypeError("callback not provided");
+			return new Promise(function(n, r) {
+				i(e, t || {}, function(e, t) {
+					if (e) r(e);
+					else n(t);
+				});
+			});
+		}
+		r(e, t || {}, function(e, r) {
+			if (e) {
+				if (e.code === "EACCES" || t && t.ignoreErrors) {
+					e = null;
+					r = false;
+				}
+			}
+			n(e, r);
+		});
+	}
+	function a(e, t) {
+		try {
+			return r.sync(e, t || {});
+		} catch (e) {
+			if (t && t.ignoreErrors || e.code === "EACCES") return false;
+			else throw e;
+		}
+	}
+});
+var O = h((exports, t) => {
+	const n = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
+	const r = v("path");
+	const i = n ? ";" : ":";
+	const a = D();
+	const o = (e) => Object.assign(new Error(`not found: ${e}`), { code: "ENOENT" });
+	const s = (e, t) => {
+		const r = t.colon || i;
+		const a = e.match(/\//) || n && e.match(/\\/) ? [""] : [...n ? [process.cwd()] : [], ...(t.path || process.env.PATH || "").split(r)];
+		const o = n ? t.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "";
+		const s = n ? o.split(r) : [""];
+		if (n) {
+			if (e.indexOf(".") !== -1 && s[0] !== "") s.unshift("");
+		}
+		return {
+			pathEnv: a,
+			pathExt: s,
+			pathExtExe: o
+		};
+	};
+	const c = (e, t, n) => {
+		if (typeof t === "function") {
+			n = t;
+			t = {};
+		}
+		if (!t) t = {};
+		const { pathEnv: i, pathExt: c, pathExtExe: l } = s(e, t);
+		const u = [];
+		const d = (n) => new Promise((a, s) => {
+			if (n === i.length) return t.all && u.length ? a(u) : s(o(e));
+			const c = i[n];
+			const l = /^".*"$/.test(c) ? c.slice(1, -1) : c;
+			const d = r.join(l, e);
+			const p = !l && /^\.[\\\/]/.test(e) ? e.slice(0, 2) + d : d;
+			a(f(p, n, 0));
+		});
+		const f = (e, n, r) => new Promise((i, o) => {
+			if (r === c.length) return i(d(n + 1));
+			const s = c[r];
+			a(e + s, { pathExt: l }, (a, o) => {
+				if (!a && o) if (t.all) u.push(e + s);
+				else return i(e + s);
+				return i(f(e, n, r + 1));
+			});
+		});
+		return n ? d(0).then((e) => n(null, e), n) : d(0);
+	};
+	const l = (e, t) => {
+		t = t || {};
+		const { pathEnv: n, pathExt: i, pathExtExe: c } = s(e, t);
+		const l = [];
+		for (let o = 0; o < n.length; o++) {
+			const s = n[o];
+			const u = /^".*"$/.test(s) ? s.slice(1, -1) : s;
+			const d = r.join(u, e);
+			const f = !u && /^\.[\\\/]/.test(e) ? e.slice(0, 2) + d : d;
+			for (let e = 0; e < i.length; e++) {
+				const n = f + i[e];
+				try {
+					const e = a.sync(n, { pathExt: c });
+					if (e) if (t.all) l.push(n);
+					else return n;
+				} catch (e) {}
+			}
+		}
+		if (t.all && l.length) return l;
+		if (t.nothrow) return null;
+		throw o(e);
+	};
+	t.exports = c;
+	c.sync = l;
+});
+var k = h((exports, t) => {
+	const n = (e = {}) => {
+		const t = e.env || process.env;
+		const n = e.platform || process.platform;
+		if (n !== "win32") return "PATH";
+		return Object.keys(t).reverse().find((e) => e.toUpperCase() === "PATH") || "Path";
+	};
+	t.exports = n;
+	t.exports.default = n;
+});
+var A = h((exports, t) => {
+	const n = v("path");
+	const r = O();
+	const i = k();
+	function a(e, t) {
+		const a = e.options.env || process.env;
+		const o = process.cwd();
+		const s = e.options.cwd != null;
+		const c = s && process.chdir !== void 0 && !process.chdir.disabled;
+		if (c) try {
+			process.chdir(e.options.cwd);
+		} catch (e) {}
+		let l;
+		try {
+			l = r.sync(e.command, {
+				path: a[i({ env: a })],
+				pathExt: t ? n.delimiter : void 0
+			});
+		} catch (e) {} finally {
+			if (c) process.chdir(o);
+		}
+		if (l) l = n.resolve(s ? e.options.cwd : "", l);
+		return l;
+	}
+	function o(e) {
+		return a(e) || a(e, true);
+	}
+	t.exports = o;
+});
+var j = h((exports, t) => {
+	const n = /([()\][%!^"`<>&|;, *?])/g;
+	function r(e) {
+		e = e.replace(n, "^$1");
+		return e;
+	}
+	function i(e, t) {
+		e = `${e}`;
+		e = e.replace(/(\\*)"/g, "$1$1\\\"");
+		e = e.replace(/(\\*)$/, "$1$1");
+		e = `"${e}"`;
+		e = e.replace(n, "^$1");
+		if (t) e = e.replace(n, "^$1");
+		return e;
+	}
+	t.exports.command = r;
+	t.exports.argument = i;
+});
+var M = h((exports, t) => {
+	t.exports = /^#!(.*)/;
+});
+var N = h((exports, t) => {
+	const n = M();
+	t.exports = (e = "") => {
+		const t = e.match(n);
+		if (!t) return null;
+		const [r, i] = t[0].replace(/#! ?/, "").split(" ");
+		const a = r.split("/").pop();
+		if (a === "env") return i;
+		return i ? `${a} ${i}` : a;
+	};
+});
+var P = h((exports, t) => {
+	const n = v("fs");
+	const r = N();
+	function i(e) {
+		const t = 150;
+		const i = Buffer.alloc(t);
+		let a;
+		try {
+			a = n.openSync(e, "r");
+			n.readSync(a, i, 0, t, 0);
+			n.closeSync(a);
+		} catch (e) {}
+		return r(i.toString());
+	}
+	t.exports = i;
+});
+var F = h((exports, t) => {
+	const n = v("path");
+	const r = A();
+	const i = j();
+	const a = P();
+	const o = process.platform === "win32";
+	const s = /\.(?:com|exe)$/i;
+	const c = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+	function l(e) {
+		e.file = r(e);
+		const t = e.file && a(e.file);
+		if (t) {
+			e.args.unshift(e.file);
+			e.command = t;
+			return r(e);
+		}
+		return e.file;
+	}
+	function u(e) {
+		if (!o) return e;
+		const t = l(e);
+		const r = !s.test(t);
+		if (e.options.forceShell || r) {
+			const r = c.test(t);
+			e.command = n.normalize(e.command);
+			e.command = i.command(e.command);
+			e.args = e.args.map((e) => i.argument(e, r));
+			const a = [e.command].concat(e.args).join(" ");
+			e.args = [
+				"/d",
+				"/s",
+				"/c",
+				`"${a}"`
+			];
+			e.command = process.env.comspec || "cmd.exe";
+			e.options.windowsVerbatimArguments = true;
+		}
+		return e;
+	}
+	function d(e, t, n) {
+		if (t && !Array.isArray(t)) {
+			n = t;
+			t = null;
+		}
+		t = t ? t.slice(0) : [];
+		n = Object.assign({}, n);
+		const r = {
+			command: e,
+			args: t,
+			options: n,
+			file: void 0,
+			original: {
+				command: e,
+				args: t
+			}
+		};
+		return n.shell ? r : u(r);
+	}
+	t.exports = d;
+});
+var I = h((exports, t) => {
+	const n = process.platform === "win32";
+	function r(e, t) {
+		return Object.assign(new Error(`${t} ${e.command} ENOENT`), {
+			code: "ENOENT",
+			errno: "ENOENT",
+			syscall: `${t} ${e.command}`,
+			path: e.command,
+			spawnargs: e.args
+		});
+	}
+	function i(e, t) {
+		if (!n) return;
+		const r = e.emit;
+		e.emit = function(n, i) {
+			if (n === "exit") {
+				const n = a(i, t, "spawn");
+				if (n) return r.call(e, "error", n);
+			}
+			return r.apply(e, arguments);
+		};
+	}
+	function a(e, t) {
+		if (n && e === 1 && !t.file) return r(t.original, "spawn");
+		return null;
+	}
+	function o(e, t) {
+		if (n && e === 1 && !t.file) return r(t.original, "spawnSync");
+		return null;
+	}
+	t.exports = {
+		hookChildProcess: i,
+		verifyENOENT: a,
+		verifyENOENTSync: o,
+		notFoundError: r
+	};
+});
+var L = h((exports, t) => {
+	const n = v("child_process");
+	const r = F();
+	const i = I();
+	function a(e, t, a) {
+		const o = r(e, t, a);
+		const s = n.spawn(o.command, o.args, o.options);
+		i.hookChildProcess(s, o);
+		return s;
+	}
+	function o(e, t, a) {
+		const o = r(e, t, a);
+		const s = n.spawnSync(o.command, o.args, o.options);
+		s.error = s.error || i.verifyENOENTSync(s.status, o);
+		return s;
+	}
+	t.exports = a;
+	t.exports.spawn = a;
+	t.exports.sync = o;
+	t.exports._parse = r;
+	t.exports._enoent = i;
+});
+var R = _(L(), 1);
+var z = class extends Error {
+	result;
+	output;
+	get exitCode() {
+		if (this.result.exitCode !== null) return this.result.exitCode;
+		return void 0;
+	}
+	constructor(e, t) {
+		super(`Process exited with non-zero status (${e.exitCode})`);
+		this.result = e;
+		this.output = t;
+	}
+};
+const B = {
+	timeout: void 0,
+	persist: false
+};
+const V = { windowsHide: true };
+function H(e, t) {
+	const n = i(e);
+	const r = t ?? [];
+	return {
+		command: n,
+		args: r
+	};
+}
+function U(e) {
+	const t = new AbortController();
+	for (const n of e) {
+		if (n.aborted) {
+			t.abort();
+			return n;
+		}
+		const e = () => {
+			t.abort(n.reason);
+		};
+		n.addEventListener("abort", e, { signal: t.signal });
+	}
+	return t.signal;
+}
+async function W(e) {
+	let t = "";
+	for await (const n of e) t += n.toString();
+	return t;
+}
+var G = class {
+	_process;
+	_aborted = false;
+	_options;
+	_command;
+	_args;
+	_resolveClose;
+	_processClosed;
+	_thrownError;
+	get process() {
+		return this._process;
+	}
+	get pid() {
+		return this._process?.pid;
+	}
+	get exitCode() {
+		if (this._process && this._process.exitCode !== null) return this._process.exitCode;
+		return void 0;
+	}
+	constructor(e, t, n) {
+		this._options = {
+			...B,
+			...n
+		};
+		this._command = e;
+		this._args = t ?? [];
+		this._processClosed = new Promise((e) => {
+			this._resolveClose = e;
+		});
+	}
+	kill(e) {
+		return this._process?.kill(e) === true;
+	}
+	get aborted() {
+		return this._aborted;
+	}
+	get killed() {
+		return this._process?.killed === true;
+	}
+	pipe(e, t, n) {
+		return q(e, t, {
+			...n,
+			stdin: this
+		});
+	}
+	async *[Symbol.asyncIterator]() {
+		const e = this._process;
+		if (!e) return;
+		const t = [];
+		if (this._streamErr) t.push(this._streamErr);
+		if (this._streamOut) t.push(this._streamOut);
+		const n = w(t);
+		const r = c.createInterface({ input: n });
+		for await (const e of r) yield e.toString();
+		await this._processClosed;
+		e.removeAllListeners();
+		if (this._thrownError) throw this._thrownError;
+		if (this._options?.throwOnError && this.exitCode !== 0 && this.exitCode !== void 0) throw new z(this);
+	}
+	async _waitForOutput() {
+		const e = this._process;
+		if (!e) throw new Error("No process was started");
+		const [t, n] = await Promise.all([this._streamOut ? W(this._streamOut) : "", this._streamErr ? W(this._streamErr) : ""]);
+		await this._processClosed;
+		if (this._options?.stdin) await this._options.stdin;
+		e.removeAllListeners();
+		if (this._thrownError) throw this._thrownError;
+		const r = {
+			stderr: n,
+			stdout: t,
+			exitCode: this.exitCode
+		};
+		if (this._options.throwOnError && this.exitCode !== 0 && this.exitCode !== void 0) throw new z(this, r);
+		return r;
+	}
+	then(e, t) {
+		return this._waitForOutput().then(e, t);
+	}
+	_streamOut;
+	_streamErr;
+	spawn() {
+		const e = o();
+		const n = this._options;
+		const r = {
+			...V,
+			...n.nodeOptions
+		};
+		const i = [];
+		this._resetState();
+		if (n.timeout !== void 0) i.push(AbortSignal.timeout(n.timeout));
+		if (n.signal !== void 0) i.push(n.signal);
+		if (n.persist === true) r.detached = true;
+		if (i.length > 0) r.signal = U(i);
+		r.env = C(e, r.env);
+		const { command: a, args: s } = H(this._command, this._args);
+		const c = (0, R._parse)(a, s, r);
+		const l = t(c.command, c.args, c.options);
+		if (l.stderr) this._streamErr = l.stderr;
+		if (l.stdout) this._streamOut = l.stdout;
+		this._process = l;
+		l.once("error", this._onError);
+		l.once("close", this._onClose);
+		if (n.stdin !== void 0 && l.stdin && n.stdin.process) {
+			const { stdout: e } = n.stdin.process;
+			if (e) e.pipe(l.stdin);
+		}
+	}
+	_resetState() {
+		this._aborted = false;
+		this._processClosed = new Promise((e) => {
+			this._resolveClose = e;
+		});
+		this._thrownError = void 0;
+	}
+	_onError = (e) => {
+		if (e.name === "AbortError" && (!(e.cause instanceof Error) || e.cause.name !== "TimeoutError")) {
+			this._aborted = true;
+			return;
+		}
+		this._thrownError = e;
+	};
+	_onClose = () => {
+		if (this._resolveClose) this._resolveClose();
+	};
+};
+const K = (e, t, n) => {
+	const r = new G(e, t, n);
+	r.spawn();
+	return r;
+};
+const q = K;
+export { G as ExecProcess, z as NonZeroExitError, q as exec, K as x };
--- a/node_modules/tinyexec/package.json
+++ b/node_modules/tinyexec/package.json
@@ -0,0 +1,61 @@
+{
+  "name": "tinyexec",
+  "version": "1.0.2",
+  "type": "module",
+  "description": "A minimal library for executing processes in Node",
+  "main": "./dist/main.js",
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsdown",
+    "build:types": "tsc",
+    "dev": "tsdown --watch",
+    "format": "prettier --write src",
+    "format:check": "prettier --check src",
+    "lint": "eslint src",
+    "prepare": "npm run build",
+    "test": "npm run build && vitest run"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tinylibs/tinyexec.git"
+  },
+  "keywords": [
+    "execa",
+    "exec",
+    "tiny",
+    "child_process",
+    "spawn"
+  ],
+  "author": "James Garbutt (https://github.com/43081j)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/tinylibs/tinyexec/issues"
+  },
+  "homepage": "https://github.com/tinylibs/tinyexec#readme",
+  "devDependencies": {
+    "@eslint/js": "^9.0.0",
+    "@types/cross-spawn": "^6.0.6",
+    "@types/node": "^20.12.7",
+    "@vitest/coverage-v8": "^4.0.7",
+    "cross-spawn": "^7.0.3",
+    "eslint-config-google": "^0.14.0",
+    "prettier": "^3.2.5",
+    "tsdown": "^0.9.9",
+    "typescript": "^5.4.5",
+    "typescript-eslint": "^7.7.0",
+    "vitest": "^4.0.7"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/main.d.ts",
+      "default": "./dist/main.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "types": "./dist/main.d.ts"
+}