brian/TreasureTrails
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Initial commit

Browse source
This commit is contained in:
Brian McGonagill 2026-03-18 09:02:21 -05:00
commit b3a51a4115
10336 changed files with 2381973 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

21
node_modules/tinyexec/LICENSE generated vendored Normal file
View file

@ -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.

269
node_modules/tinyexec/README.md generated vendored Normal file
View file

@ -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).

83
node_modules/tinyexec/dist/LICENSES.txt generated vendored Normal file
View file

@ -0,0 +1,83 @@
isexe:2.0.0 -- The ISC License
Copyright (c) Isaac Z. Schlueter and Contributors
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
which:2.0.2 -- The ISC License
Copyright (c) Isaac Z. Schlueter and Contributors
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
path-key:3.1.1 -- MIT License
Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
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.
cross-spawn:7.0.6 -- The MIT License (MIT)
Copyright (c) 2018 Made With MOXY Lda <hello@moxy.studio>
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.
shebang-regex:3.0.0 -- MIT License
Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
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.
shebang-command:2.0.0 -- MIT License
Copyright (c) Kevin Mårtensson <kevinmartensson@gmail.com> (github.com/kevva)
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.

71
node_modules/tinyexec/dist/main.d.mts generated vendored Normal file
View file

@ -0,0 +1,71 @@
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 };

642
node_modules/tinyexec/dist/main.mjs generated vendored Normal file
View file

@ -0,0 +1,642 @@
import { createRequire as e } from "node: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";
//#region \0rolldown/runtime.js
var l = (e, t) => () => (t || e((t = { exports: {} }).exports, t), t.exports);
var u = /* @__PURE__ */ e(import.meta.url);
//#endregion
//#region src/env.ts
const d = /^path$/i;
const f = {
key: "PATH",
value: ""
};
function p(e) {
for (const t in e) {
if (!Object.prototype.hasOwnProperty.call(e, t) || !d.test(t)) continue;
const n = e[t];
if (!n) return f;
return {
key: t,
value: n
};
}
return f;
}
function m(e, t) {
const i = t.value.split(n);
const o = [];
let s = e;
let c;
do {
o.push(a(s, "node_modules", ".bin"));
c = s;
s = r(s);
} while (s !== c);
const l = o.concat(i).join(n);
return {
key: t.key,
value: l
};
}
function h(e, t) {
const n = {
...process.env,
...t
};
const r = m(e, p(n));
n[r.key] = r.value;
return n;
}
//#endregion
//#region src/stream.ts
const g = (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;
};
//#endregion
//#region node_modules/isexe/windows.js
var _ = /* @__PURE__ */ l(((e, t) => {
t.exports = a;
a.sync = o;
var n = u("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);
}
}));
//#endregion
//#region node_modules/isexe/mode.js
var v = /* @__PURE__ */ l(((e, t) => {
t.exports = r;
r.sync = i;
var n = u("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;
return n & l || n & c && i === o || n & s && r === a || n & u && a === 0;
}
}));
//#endregion
//#region node_modules/isexe/index.js
var y = /* @__PURE__ */ l(((e, t) => {
u("fs");
var n;
if (process.platform === "win32" || global.TESTING_WINDOWS) n = _();
else n = v();
t.exports = r;
r.sync = i;
function r(e, t, i) {
if (typeof t === "function") {
i = t;
t = {};
}
if (!i) {
if (typeof Promise !== "function") throw new TypeError("callback not provided");
return new Promise(function(n, i) {
r(e, t || {}, function(e, t) {
if (e) i(e);
else n(t);
});
});
}
n(e, t || {}, function(e, n) {
if (e) {
if (e.code === "EACCES" || t && t.ignoreErrors) {
e = null;
n = false;
}
}
i(e, n);
});
}
function i(e, t) {
try {
return n.sync(e, t || {});
} catch (e) {
if (t && t.ignoreErrors || e.code === "EACCES") return false;
else throw e;
}
}
}));
//#endregion
//#region node_modules/which/which.js
var b = /* @__PURE__ */ l(((e, t) => {
const n = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
const r = u("path");
const i = n ? ";" : ":";
const a = y();
const o = (e) => Object.assign(/* @__PURE__ */ 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);
a(f(!l && /^\.[\\\/]/.test(e) ? e.slice(0, 2) + d : d, 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 {
if (a.sync(n, { pathExt: c })) 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;
}));
//#endregion
//#region node_modules/path-key/index.js
var x = /* @__PURE__ */ l(((e, t) => {
const n = (e = {}) => {
const t = e.env || process.env;
if ((e.platform || process.platform) !== "win32") return "PATH";
return Object.keys(t).reverse().find((e) => e.toUpperCase() === "PATH") || "Path";
};
t.exports = n;
t.exports.default = n;
}));
//#endregion
//#region node_modules/cross-spawn/lib/util/resolveCommand.js
var S = /* @__PURE__ */ l(((e, t) => {
const n = u("path");
const r = b();
const i = x();
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;
}));
//#endregion
//#region node_modules/cross-spawn/lib/util/escape.js
var C = /* @__PURE__ */ l(((e, t) => {
const n = /([()\][%!^"`<>&|;, *?])/g;
function r(e) {
e = e.replace(n, "^$1");
return e;
}
function i(e, t) {
e = `${e}`;
e = e.replace(/(?=(\\+?)?)\1"/g, "$1$1\\\"");
e = e.replace(/(?=(\\+?)?)\1$/, "$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;
}));
//#endregion
//#region node_modules/shebang-regex/index.js
var w = /* @__PURE__ */ l(((e, t) => {
t.exports = /^#!(.*)/;
}));
//#endregion
//#region node_modules/shebang-command/index.js
var T = /* @__PURE__ */ l(((e, t) => {
const n = w();
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;
};
}));
//#endregion
//#region node_modules/cross-spawn/lib/util/readShebang.js
var E = /* @__PURE__ */ l(((e, t) => {
const n = u("fs");
const r = T();
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;
}));
//#endregion
//#region node_modules/cross-spawn/lib/parse.js
var D = /* @__PURE__ */ l(((e, t) => {
const n = u("path");
const r = S();
const i = C();
const a = E();
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 d(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));
e.args = [
"/d",
"/s",
"/c",
`"${[e.command].concat(e.args).join(" ")}"`
];
e.command = process.env.comspec || "cmd.exe";
e.options.windowsVerbatimArguments = true;
}
return e;
}
function f(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 : d(r);
}
t.exports = f;
}));
//#endregion
//#region node_modules/cross-spawn/lib/enoent.js
var O = /* @__PURE__ */ l(((e, t) => {
const n = process.platform === "win32";
function r(e, t) {
return Object.assign(/* @__PURE__ */ 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);
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
};
}));
//#endregion
//#region node_modules/cross-spawn/index.js
var k = /* @__PURE__ */ l(((e, t) => {
const n = u("child_process");
const r = D();
const i = O();
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;
}));
//#endregion
//#region src/non-zero-exit-error.ts
var A = k();
var j = class extends Error {
result;
output;
get exitCode() {
if (this.result.exitCode !== null) return this.result.exitCode;
}
constructor(e, t) {
super(`Process exited with non-zero status (${e.exitCode})`);
this.result = e;
this.output = t;
}
};
//#endregion
//#region src/main.ts
const M = {
timeout: void 0,
persist: false
};
const N = { windowsHide: true };
function P(e, t) {
return {
command: i(e),
args: t ?? []
};
}
function F(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 I(e) {
let t = "";
for await (const n of e) t += n.toString();
return t;
}
var L = 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;
}
constructor(e, t, n) {
this._options = {
...M,
...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 z(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 = g(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 j(this);
}
async _waitForOutput() {
const e = this._process;
if (!e) throw new Error("No process was started");
const [t, n] = await Promise.all([this._streamOut ? I(this._streamOut) : "", this._streamErr ? I(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 j(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 = {
...N,
...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 = F(i);
r.env = h(e, r.env);
const { command: a, args: s } = P(this._command, this._args);
const c = (0, A._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 R = (e, t, n) => {
const r = new L(e, t, n);
r.spawn();
return r;
};
const z = R;
//#endregion
export { L as ExecProcess, j as NonZeroExitError, z as exec, R as x };

62
node_modules/tinyexec/package.json generated vendored Normal file
View file

@ -0,0 +1,62 @@
{
"name": "tinyexec",
"version": "1.0.4",
"type": "module",
"description": "A minimal library for executing processes in Node",
"main": "./dist/main.mjs",
"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": "^10.0.1",
"@types/cross-spawn": "^6.0.6",
"@types/node": "^25.4.0",
"@vitest/coverage-v8": "^4.0.18",
"cross-spawn": "^7.0.6",
"eslint": "^10.0.3",
"prettier": "^3.8.1",
"rollup-plugin-license": "^3.7.0",
"tsdown": "^0.21.1",
"typescript": "^5.9.3",
"typescript-eslint": "^8.57.0",
"vitest": "^4.0.7"
},
"exports": {
".": {
"types": "./dist/main.d.mts",
"default": "./dist/main.mjs"
},
"./package.json": "./package.json"
},
"types": "./dist/main.d.mts"
}