@maizzle/framework 6.1.3 → 6.1.5

package/node_modules/tinyexec/dist/main.mjs

@@ -1,165 +1,168 @@
-import { spawn as e, spawnSync as t } from "node:child_process";
-import { cwd as n } from "node:process";
-import { basename as r, delimiter as i, dirname as a, normalize as o, resolve as s } from "node:path";
-import { pipeline as c } from "node:stream/promises";
-import { PassThrough as l } from "node:stream";
-import u from "node:readline";
-import { closeSync as d, openSync as f, readSync as p, statSync as m } from "node:fs";
+import { spawn, spawnSync } from "node:child_process";
+import { cwd } from "node:process";
+import { basename, delimiter, dirname, normalize, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { pipeline } from "node:stream/promises";
+import { PassThrough } from "node:stream";
+import readline from "node:readline";
+import { closeSync, openSync, readSync, statSync } from "node:fs";
 //#region src/env.ts
-const h = /^path$/i;
-const g = {
+const isPathLikePattern = /^path$/i;
+const defaultEnvPathInfo = {
 	key: "PATH",
 	value: ""
 };
-function _(e) {
-	for (const t in e) {
-		if (!Object.prototype.hasOwnProperty.call(e, t) || !h.test(t)) continue;
-		const n = e[t];
-		if (!n) return g;
+function getPathFromEnv(env) {
+	for (const key in env) {
+		if (!Object.prototype.hasOwnProperty.call(env, key) || !isPathLikePattern.test(key)) continue;
+		const value = env[key];
+		if (!value) return defaultEnvPathInfo;
 		return {
-			key: t,
-			value: n
+			key,
+			value
 		};
 	}
-	return g;
+	return defaultEnvPathInfo;
 }
-function v(e, t) {
-	const n = t.value.split(i);
-	const r = [];
-	let o = e;
-	let c;
+function addNodeBinToPath(cwd, path) {
+	const parts = path.value.split(delimiter);
+	const nodeBinPaths = [];
+	let currentPath = typeof cwd === "string" ? cwd : fileURLToPath(cwd, { windows: false });
+	let lastPath;
 	do {
-		r.push(s(o, "node_modules", ".bin"));
-		c = o;
-		o = a(o);
-	} while (o !== c);
-	r.push(a(process.execPath));
-	const l = r.concat(n).join(i);
+		nodeBinPaths.push(resolve(currentPath, "node_modules", ".bin"));
+		lastPath = currentPath;
+		currentPath = dirname(currentPath);
+	} while (currentPath !== lastPath);
+	nodeBinPaths.push(dirname(process.execPath));
+	const newPath = nodeBinPaths.concat(parts).join(delimiter);
 	return {
-		key: t.key,
-		value: l
+		key: path.key,
+		value: newPath
 	};
 }
-function y(e, t, n = true) {
-	const r = {
+function computeEnv(cwd, env, nodePath = true) {
+	const envWithDefault = {
 		...process.env,
-		...t
+		...env
 	};
-	if (!n) return r;
-	const i = v(e, _(r));
-	r[i.key] = i.value;
-	return r;
+	if (!nodePath) return envWithDefault;
+	const envPathInfo = addNodeBinToPath(cwd, getPathFromEnv(envWithDefault));
+	envWithDefault[envPathInfo.key] = envPathInfo.value;
+	return envWithDefault;
 }
 //#endregion
 //#region src/stream.ts
-const b = (e) => {
-	let t = e.length;
-	const n = new l();
-	const r = () => {
-		if (--t === 0) n.end();
+const combineStreams = (streams) => {
+	let streamCount = streams.length;
+	const combined = new PassThrough();
+	const maybeEmitEnd = () => {
+		if (--streamCount === 0) combined.end();
 	};
-	for (const t of e) c(t, n, { end: false }).then(r).catch(r);
-	return n;
+	for (const stream of streams) pipeline(stream, combined, { end: false }).then(maybeEmitEnd).catch(maybeEmitEnd);
+	return combined;
 };
 //#endregion
 //#region src/normalize.ts
-const x = /([()\][%!^"`<>&|;, *?])/g;
-const S = /^#!\s*(.+)/;
-const C = /\.(?:com|exe)$/i;
-const w = /node_modules[\\/]\.bin[\\/][^\\/]+\.cmd$/i;
-const T = process.platform === "win32";
-const E = [
+const metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
+const shebangRegExp = /^#!\s*(.+)/;
+const isWindowsExecutableRegExp = /\.(?:com|exe)$/i;
+const isNodeModulesCmdRegExp = /node_modules[\\/]\.bin[\\/][^\\/]+\.cmd$/i;
+const isWindows = process.platform === "win32";
+const defaultPathExt = [
 	".EXE",
 	".CMD",
 	".BAT",
 	".COM"
 ];
+const noPathExt = [""];
 /**
 * Normalizes the command and arguments to work cross-platform.
 * On Windows, this basically handles things like shebangs, calling
 * `node_modules/.bin` commands, and escaping meta characters.
 * On other platforms, it just returns the command and arguments as-is.
 */
-function D(e, t = [], n = {}) {
-	if (n.shell === true || !T) return {
-		command: e,
-		args: t,
-		options: n
+function normalizeSpawnCommand(command, args = [], options = {}) {
+	if (options.shell === true || !isWindows) return {
+		command,
+		args,
+		options
 	};
-	let i = O(e, n);
-	let a = null;
-	if (i !== null) {
-		const e = 150;
-		const t = Buffer.alloc(e);
-		let n = null;
+	let file = resolveCommand(command, options);
+	let shebang = null;
+	if (file !== null) {
+		const size = 150;
+		const buffer = Buffer.alloc(size);
+		let fd = null;
 		try {
-			n = f(i, "r");
-			p(n, t, 0, e, 0);
+			fd = openSync(file, "r");
+			readSync(fd, buffer, 0, size, 0);
 		} catch {} finally {
-			if (n !== null) d(n);
+			if (fd !== null) closeSync(fd);
 		}
-		const o = t.toString().match(S);
-		if (o !== null) {
-			const e = o[1].trim();
-			const t = e.indexOf(" ");
-			const n = t !== -1 ? e.slice(0, t) : e;
-			const i = t !== -1 ? e.slice(t + 1) : "";
-			const s = r(n);
-			a = s === "env" ? i || null : s;
+		const match = buffer.toString().match(shebangRegExp);
+		if (match !== null) {
+			const line = match[1].trim();
+			const separatorIndex = line.indexOf(" ");
+			const path = separatorIndex !== -1 ? line.slice(0, separatorIndex) : line;
+			const argument = separatorIndex !== -1 ? line.slice(separatorIndex + 1) : "";
+			const binary = basename(path);
+			shebang = binary === "env" ? argument || null : binary;
 		}
 	}
-	if (a !== null && i !== null) {
-		t = [i, ...t];
-		e = a;
-		i = O(e, n);
+	if (shebang !== null && file !== null) {
+		args = [file, ...args];
+		command = shebang;
+		file = resolveCommand(command, options);
 	}
-	if (i === null || !C.test(i)) {
-		const r = i !== null && w.test(i);
-		e = o(e);
-		e = e.replace(x, "^$1");
-		t = t.map((e) => {
-			e = e.replace(/(?=(\\+?)?)\1"/g, "$1$1\\\"");
-			e = e.replace(/(?=(\\+?)?)\1$/, "$1$1");
-			e = `"${e}"`;
-			e = e.replace(x, "^$1");
-			if (r) e = e.replace(x, "^$1");
-			return e;
+	if (file === null || !isWindowsExecutableRegExp.test(file)) {
+		const needsDoubleEscapeMetaChars = file !== null && isNodeModulesCmdRegExp.test(file);
+		command = normalize(command);
+		command = command.replace(metaCharsRegExp, "^$1");
+		args = args.map((arg) => {
+			arg = arg.replace(/(?=(\\+?)?)\1"/g, "$1$1\\\"");
+			arg = arg.replace(/(?=(\\+?)?)\1$/, "$1$1");
+			arg = `"${arg}"`;
+			arg = arg.replace(metaCharsRegExp, "^$1");
+			if (needsDoubleEscapeMetaChars) arg = arg.replace(metaCharsRegExp, "^$1");
+			return arg;
 		});
-		t = [
+		args = [
 			"/d",
 			"/s",
 			"/c",
-			`"${[e, ...t].join(" ")}"`
+			`"${[command, ...args].join(" ")}"`
 		];
-		e = n.env?.comspec ?? "cmd.exe";
-		n = {
-			...n,
+		command = options.env?.comspec ?? "cmd.exe";
+		options = {
+			...options,
 			windowsVerbatimArguments: true
 		};
 	}
 	return {
-		command: e,
-		args: t,
-		options: n
+		command,
+		args,
+		options
 	};
 }
 /**
 * Resolves the command to an absolute path if possible.
 * Handles things like traversing PATH and adding extensions from PATHEXT
 */
-function O(e, t) {
-	const r = (t.cwd ?? n()).toString();
-	const a = t.env ?? process.env;
-	const o = _(a).value;
-	const c = e.includes("/") || e.includes("\\") ? [""] : [r, ...o.split(i)];
-	const l = a.PATHEXT ? a.PATHEXT.split(i) : E;
-	if (e.includes(".") && l[0] !== "") l.unshift("");
-	for (const t of c) {
-		const n = s(r, t.startsWith("\"") && t.endsWith("\"") && t.length > 1 ? t.slice(1, -1) : t, e);
-		for (const e of l) {
-			const t = n + e;
+function resolveCommand(command, options) {
+	const cwd$3 = (options.cwd ?? cwd()).toString();
+	const env = options.env ?? process.env;
+	const PATH = getPathFromEnv(env).value;
+	const pathEnv = command.includes("/") || command.includes("\\") ? [""] : [cwd$3, ...PATH.split(delimiter)];
+	let pathExt = env.PATHEXT ? env.PATHEXT.split(delimiter) : defaultPathExt;
+	if (command.includes(".") && pathExt[0] !== "") pathExt = ["", ...pathExt];
+	for (const extensions of [pathExt, noPathExt]) for (const path of pathEnv) {
+		const unquoted = path.startsWith("\"") && path.endsWith("\"") && path.length > 1 ? path.slice(1, -1) : path;
+		const dest = resolve(cwd$3, unquoted, command);
+		for (const ext of extensions) {
+			const destWithExt = dest + ext;
 			try {
-				if (m(t).isFile()) return t;
+				if (statSync(destWithExt).isFile()) return destWithExt;
 			} catch {}
 		}
 	}
@@ -167,49 +170,59 @@ function O(e, t) {
 }
 //#endregion
 //#region src/non-zero-exit-error.ts
-var k = class extends Error {
+var NonZeroExitError = class extends Error {
 	result;
 	output;
-	get exitCode() {
-		if (this.result.exitCode !== null) return this.result.exitCode;
+	exitCode;
+	get signalCode() {
+		return this.result.signalCode;
 	}
-	constructor(e, t) {
-		super(`Process exited with non-zero status (${e.exitCode})`);
-		this.result = e;
-		this.output = t;
+	constructor(result, output, command, args) {
+		let target = "The process";
+		if (command) target = `The command \`${args?.length ? `${command} ${args.map((a) => /[ "'`()]/.test(a) ? JSON.stringify(a) : a).join(" ")}` : command}\``;
+		const exitCode = result.exitCode ?? 1;
+		super(result.signalCode !== null ? `${target} was killed by the signal ${result.signalCode}` : `${target} exited with a non-zero status (${exitCode})`);
+		this.result = result;
+		this.output = output;
+		this.exitCode = exitCode;
+		Object.defineProperty(this, "result", {
+			enumerable: false,
+			writable: false,
+			configurable: false
+		});
 	}
 };
 //#endregion
 //#region src/main.ts
-const A = /\r?\n/;
-const j = {
+const LINE_SEPARATOR_REGEX = /\r?\n/;
+const defaultOptions = {
 	timeout: void 0,
 	persist: false
 };
-const M = { timeout: void 0 };
-const N = { windowsHide: true };
-function P(e) {
-	const t = new AbortController();
-	for (const n of e) {
-		if (n.aborted) {
-			t.abort();
-			return n;
+const defaultSyncOptions = { timeout: void 0 };
+const defaultNodeOptions = { windowsHide: true };
+function combineSignals(signals) {
+	const controller = new AbortController();
+	for (const signal of signals) {
+		if (signal.aborted) {
+			controller.abort();
+			return signal;
 		}
-		const e = () => {
-			t.abort(n.reason);
+		const onAbort = () => {
+			controller.abort(signal.reason);
 		};
-		n.addEventListener("abort", e, { signal: t.signal });
+		signal.addEventListener("abort", onAbort, { signal: controller.signal });
 	}
-	return t.signal;
+	return controller.signal;
 }
-async function F(e) {
-	let t = "";
+async function readStream(stream) {
+	let output = "";
 	try {
-		for await (const n of e) t += n.toString();
+		for await (const chunk of stream) output += chunk.toString();
 	} catch {}
-	return t;
+	return output;
 }
-var I = class {
+var ExecProcess = class {
 	_process;
 	_aborted = false;
 	_options;
@@ -227,19 +240,22 @@ var I = class {
 	get exitCode() {
 		if (this._process && this._process.exitCode !== null) return this._process.exitCode;
 	}
-	constructor(e, t, n) {
+	get signalCode() {
+		return this._process?.signalCode ?? null;
+	}
+	constructor(command, args, options) {
 		this._options = {
-			...j,
-			...n
+			...defaultOptions,
+			...options
 		};
-		this._command = e;
-		this._args = t ?? [];
-		this._processClosed = new Promise((e) => {
-			this._resolveClose = e;
+		this._command = command;
+		this._args = args ?? [];
+		this._processClosed = new Promise((resolve) => {
+			this._resolveClose = resolve;
 		});
 	}
-	kill(e) {
-		return this._process?.kill(e) === true;
+	kill(signal) {
+		return this._process?.kill(signal) === true;
 	}
 	get aborted() {
 		return this._aborted;
@@ -247,142 +263,150 @@ var I = class {
 	get killed() {
 		return this._process?.killed === true;
 	}
-	pipe(e, t, n) {
-		return z(e, t, {
-			...n,
+	pipe(command, args, options) {
+		return exec(command, args, {
+			...options,
 			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 = b(t);
-		const r = u.createInterface({ input: n });
-		for await (const e of r) yield e.toString();
+		const proc = this._process;
+		if (!proc) return;
+		const streams = [];
+		if (this._streamErr) streams.push(this._streamErr);
+		if (this._streamOut) streams.push(this._streamOut);
+		const streamCombined = combineStreams(streams);
+		const rl = readline.createInterface({ input: streamCombined });
+		for await (const chunk of rl) yield chunk.toString();
 		await this._processClosed;
-		e.removeAllListeners();
+		proc.removeAllListeners();
 		if (this._thrownError) throw this._thrownError;
-		if (this._options?.throwOnError && this.exitCode !== 0 && this.exitCode !== void 0) throw new k(this);
+		if (this._options?.throwOnError && (this.exitCode !== 0 && this.exitCode !== void 0 || this.signalCode !== null)) throw new NonZeroExitError(this, void 0, this._command, this._args);
 	}
 	async _waitForOutput() {
-		const e = this._process;
-		if (!e) throw new Error("No process was started");
-		const [t, n] = await Promise.all([this._streamOut ? F(this._streamOut) : "", this._streamErr ? F(this._streamErr) : ""]);
+		const proc = this._process;
+		if (!proc) throw new Error("No process was started");
+		const [stdout, stderr] = await Promise.all([this._streamOut ? readStream(this._streamOut) : "", this._streamErr ? readStream(this._streamErr) : ""]);
 		await this._processClosed;
-		const { stdin: r } = this._options;
-		if (r && typeof r !== "string") await r;
-		e.removeAllListeners();
+		const { stdin } = this._options;
+		if (stdin && typeof stdin !== "string") await stdin;
+		proc.removeAllListeners();
 		if (this._thrownError) throw this._thrownError;
-		const i = {
-			stderr: n,
-			stdout: t,
+		const result = {
+			stderr,
+			stdout,
 			exitCode: this.exitCode
 		};
-		if (this._options.throwOnError && this.exitCode !== 0 && this.exitCode !== void 0) throw new k(this, i);
-		return i;
+		if (this._options.throwOnError && (this.exitCode !== 0 && this.exitCode !== void 0 || this.signalCode !== null)) throw new NonZeroExitError(this, result, this._command, this._args);
+		return result;
 	}
-	then(e, t) {
-		return this._waitForOutput().then(e, t);
+	then(onfulfilled, onrejected) {
+		return this._waitForOutput().then(onfulfilled, onrejected);
 	}
 	_streamOut;
 	_streamErr;
 	spawn() {
-		const t = n();
-		const r = this._options;
-		const i = {
-			...N,
-			...r.nodeOptions
+		const options = this._options;
+		const nodeOptions = {
+			...defaultNodeOptions,
+			...options.nodeOptions
 		};
-		const a = [];
+		const cwd$1 = nodeOptions?.cwd ?? cwd();
+		const signals = [];
 		this._resetState();
-		if (r.timeout !== void 0) a.push(AbortSignal.timeout(r.timeout));
-		if (r.signal !== void 0) a.push(r.signal);
-		if (r.persist === true) i.detached = true;
-		if (a.length > 0) i.signal = P(a);
-		i.env = y(t, i.env, r.nodePath);
-		const o = D(this._command, this._args, i);
-		const s = e(o.command, o.args, o.options);
-		if (s.stderr) this._streamErr = s.stderr;
-		if (s.stdout) this._streamOut = s.stdout;
-		this._process = s;
-		s.once("error", this._onError);
-		s.once("close", this._onClose);
-		if (s.stdin) {
-			const { stdin: e } = r;
-			if (typeof e === "string") s.stdin.end(e);
-			else e?.process?.stdout?.pipe(s.stdin);
+		if (options.timeout !== void 0) signals.push(AbortSignal.timeout(options.timeout));
+		if (options.signal !== void 0) signals.push(options.signal);
+		if (options.persist === true) nodeOptions.detached = true;
+		if (signals.length > 0) nodeOptions.signal = combineSignals(signals);
+		nodeOptions.env = computeEnv(cwd$1, nodeOptions.env, options.nodePath);
+		const crossResult = normalizeSpawnCommand(this._command, this._args, nodeOptions);
+		const handle = spawn(crossResult.command, crossResult.args, crossResult.options);
+		if (handle.stderr) this._streamErr = handle.stderr;
+		if (handle.stdout) this._streamOut = handle.stdout;
+		this._process = handle;
+		handle.once("error", this._onError);
+		handle.once("close", this._onClose);
+		if (handle.stdin) {
+			const { stdin } = options;
+			if (typeof stdin === "string") handle.stdin.end(stdin);
+			else stdin?.process?.stdout?.pipe(handle.stdin);
 		}
 	}
 	_resetState() {
 		this._aborted = false;
-		this._processClosed = new Promise((e) => {
-			this._resolveClose = e;
+		this._processClosed = new Promise((resolve) => {
+			this._resolveClose = resolve;
 		});
 		this._thrownError = void 0;
 	}
-	_onError = (e) => {
-		if (e.name === "AbortError" && (!(e.cause instanceof Error) || e.cause.name !== "TimeoutError")) {
+	_onError = (err) => {
+		if (err.name === "AbortError" && (!(err.cause instanceof Error) || err.cause.name !== "TimeoutError")) {
 			this._aborted = true;
 			return;
 		}
-		this._thrownError = e;
+		this._thrownError = err;
 	};
 	_onClose = () => {
 		if (this._resolveClose) this._resolveClose();
 	};
 };
-function L(e, r, i) {
-	const a = {
-		...M,
-		...i
+function xSync(command, args, options) {
+	const opts = {
+		...defaultSyncOptions,
+		...options
 	};
-	const o = n();
-	const s = {
-		windowsHide: true,
-		...a.nodeOptions
+	const nodeOptions = {
+		...defaultNodeOptions,
+		...opts.nodeOptions
 	};
-	if (a.timeout !== void 0) s.timeout = a.timeout;
-	s.env = y(o, s.env, a.nodePath);
-	const c = D(e, r ?? [], s);
-	const l = t(c.command, c.args, c.options);
-	if (l.error) throw l.error;
-	const u = l.stdout?.toString() ?? "";
-	const d = l.stderr?.toString() ?? "";
-	const f = l.status ?? void 0;
-	const p = l.signal != null;
-	const m = {
-		stdout: u,
-		stderr: d,
+	const cwd$2 = nodeOptions?.cwd ?? cwd();
+	if (opts.timeout !== void 0) nodeOptions.timeout = opts.timeout;
+	nodeOptions.env = computeEnv(cwd$2, nodeOptions.env, opts.nodePath);
+	const crossResult = normalizeSpawnCommand(command, args ?? [], nodeOptions);
+	const spawnResult = spawnSync(crossResult.command, crossResult.args, crossResult.options);
+	if (spawnResult.error) throw spawnResult.error;
+	const stdout = spawnResult.stdout?.toString() ?? "";
+	const stderr = spawnResult.stderr?.toString() ?? "";
+	const exitCode = spawnResult.status ?? void 0;
+	const signalCode = spawnResult.signal ?? null;
+	const killed = signalCode !== null;
+	const result = {
+		stdout,
+		stderr,
 		get exitCode() {
-			return f;
+			return exitCode;
+		},
+		get signalCode() {
+			return signalCode;
 		},
 		get pid() {
-			return l.pid;
+			return spawnResult.pid;
 		},
 		get killed() {
-			return p;
+			return killed;
 		},
 		*[Symbol.iterator]() {
-			for (const e of [u, d]) {
-				if (!e) continue;
-				const t = e.split(A);
-				if (t[t.length - 1] === "") t.pop();
-				yield* t;
+			for (const text of [stdout, stderr]) {
+				if (!text) continue;
+				const lines = text.split(LINE_SEPARATOR_REGEX);
+				if (lines[lines.length - 1] === "") lines.pop();
+				yield* lines;
 			}
 		}
 	};
-	if (a.throwOnError && f !== 0 && f !== void 0) throw new k(m, m);
-	return m;
+	if (opts.throwOnError && (exitCode !== 0 && exitCode !== void 0 || signalCode !== null)) throw new NonZeroExitError(result, {
+		stdout: result.stdout,
+		stderr: result.stderr,
+		exitCode: result.exitCode
+	}, command, args);
+	return result;
 }
-const R = (e, t, n) => {
-	const r = new I(e, t, n);
-	r.spawn();
-	return r;
+const x = (command, args, userOptions) => {
+	const proc = new ExecProcess(command, args, userOptions);
+	proc.spawn();
+	return proc;
 };
-const z = R;
-const B = L;
+const exec = x;
+const execSync = xSync;
 //#endregion
-export { I as ExecProcess, k as NonZeroExitError, z as exec, B as execSync, D as normalizeSpawnCommand, R as x, L as xSync };
+export { ExecProcess, NonZeroExitError, exec, execSync, normalizeSpawnCommand, x, xSync };