vite-plus 0.1.3 → 0.1.4

package/dist/global/staged.js

@@ -1,34 +1,32 @@
 import { i as __toESM, r as __require, t as __commonJSMin } from "./chunk-CgnkrU7a.js";
 import { t as lib_default } from "./lib-DxappLRQ.js";
 import { r as log, t as renderCliDoc } from "./help-BAGHa8fD.js";
-import path from "node:path";
-import { formatWithOptions, inspect, stripVTControlCharacters } from "node:util";
-import process$1 from "node:process";
+import path, { delimiter, dirname, normalize, resolve } from "node:path";
+import { formatWithOptions, inspect, promisify } from "node:util";
+import { cwd } from "node:process";
+import ot from "node:readline";
 import nodeTty from "node:tty";
 import { constants } from "node:fs";
 import { vitePlusHeader } from "../../binding/index.js";
 import { createRequire } from "node:module";
 import fsPromises, { constants as constants$1 } from "node:fs/promises";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import { on, once } from "node:events";
-import { Writable } from "node:stream";
-import { spawn } from "node:child_process";
-import { pipeline } from "node:stream/promises";
-import * as readline from "node:readline/promises";
+import { pathToFileURL } from "node:url";
+import { PassThrough, Writable } from "node:stream";
+import { exec, spawn } from "node:child_process";
+import { createRequire as createRequire$1 } from "module";
 import * as tty from "tty";
 import { format } from "util";
 import { EOL } from "os";
 import { StringDecoder } from "string_decoder";
 import { Writable as Writable$1 } from "stream";
 import { randomUUID } from "crypto";
-import EventEmitter$1 from "events";
 import { EOL as EOL$1 } from "node:os";
 import crypto from "node:crypto";
-//#region ../../node_modules/.pnpm/lint-staged@16.2.7/node_modules/lint-staged/lib/colors.js
+//#region ../../node_modules/.pnpm/lint-staged@16.3.2/node_modules/lint-staged/lib/colors.js
 /**
 * @example NO_COLOR
-* @exmaple NO_COLOR=1
-* @exmaple NO_COLOR=true
+* @example NO_COLOR=1
+* @example NO_COLOR=true
 */
 const TRUTHRY_ENV_VAR_VALUES = [
 	"",
@@ -36,8 +34,8 @@ const TRUTHRY_ENV_VAR_VALUES = [
 	"true"
 ];
 /**
-* @exmaple FORCE_COLOR=0
-* @exmaple FORCE_COLOR=false
+* @example FORCE_COLOR=0
+* @example FORCE_COLOR=false
 */
 const FALSY_ENV_VAR_VALUES = ["0", "false"];
 /**
@@ -102,7 +100,7 @@ const blue$1 = wrapAnsiColor("\x1B[0;34m");
 const blackBright$1 = wrapAnsiColor("\x1B[0;90m");
 const bold$1 = wrapAnsiColor("\x1B[1m");
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@16.2.7/node_modules/lint-staged/lib/debug.js
+//#region ../../node_modules/.pnpm/lint-staged@16.3.2/node_modules/lint-staged/lib/debug.js
 const format$1 = (...args) => formatWithOptions({ colors: SUPPORTS_COLOR }, ...args);
 let activeLogger;
 const enableDebug = (logger = console) => {
@@ -120,260 +118,625 @@ const createDebug = (name) => {
 	};
 };
 //#endregion
-//#region ../../node_modules/.pnpm/nano-spawn@2.0.0/node_modules/nano-spawn/source/context.js
-const getContext = (raw) => ({
-	start: process$1.hrtime.bigint(),
-	command: raw.map((part) => getCommandPart(stripVTControlCharacters(part))).join(" "),
-	state: {
-		stdout: "",
-		stderr: "",
-		output: "",
-		isIterating: {},
-		nonIterable: [false, false]
+//#region ../../node_modules/.pnpm/tinyexec@1.0.2/node_modules/tinyexec/dist/main.js
+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
+		});
 	}
-});
-const getCommandPart = (part) => /[^\w./-]/.test(part) ? `'${part.replaceAll("'", "'\\''")}'` : part;
-//#endregion
-//#region ../../node_modules/.pnpm/nano-spawn@2.0.0/node_modules/nano-spawn/source/options.js
-const getOptions = ({ stdin, stdout, stderr, stdio = [
-	stdin,
-	stdout,
-	stderr
-], env: envOption, preferLocal, cwd: cwdOption = ".", ...options }) => {
-	const cwd = cwdOption instanceof URL ? fileURLToPath(cwdOption) : path.resolve(cwdOption);
-	const env = envOption ? {
-		...process$1.env,
-		...envOption
-	} : void 0;
-	const input = stdio[0]?.string;
-	return {
-		...options,
-		input,
-		stdio: input === void 0 ? stdio : ["pipe", ...stdio.slice(1)],
-		env: preferLocal ? addLocalPath(env ?? process$1.env, cwd) : env,
-		cwd
-	};
+	return e;
 };
-const addLocalPath = ({ Path = "", PATH = Path, ...env }, cwd) => {
-	const pathParts = PATH.split(path.delimiter);
-	const localPaths = getLocalPaths([], path.resolve(cwd)).map((localPath) => path.join(localPath, "node_modules/.bin")).filter((localPath) => !pathParts.includes(localPath));
+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__ */ createRequire$1(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(delimiter);
+	let o = e;
+	let s;
+	do {
+		i.push(resolve(o, "node_modules", ".bin"));
+		s = o;
+		o = dirname(o);
+	} while (o !== s);
 	return {
-		...env,
-		PATH: [...localPaths, PATH].filter(Boolean).join(path.delimiter)
+		key: t.key,
+		value: i.join(delimiter)
+	};
+}
+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 PassThrough();
+	const r = () => {
+		if (--t === 0) n.emit("end");
+	};
+	for (const t of e) {
+		t.pipe(n, { end: false });
+		t.on("end", r);
+	}
+	return n;
 };
-const getLocalPaths = (localPaths, localPath) => localPaths.at(-1) === localPath ? localPaths : getLocalPaths([...localPaths, localPath], path.resolve(localPath, ".."));
-//#endregion
-//#region ../../node_modules/.pnpm/nano-spawn@2.0.0/node_modules/nano-spawn/source/windows.js
-const applyForceShell = async (file, commandArguments, options) => await shouldForceShell(file, options) ? [
-	escapeFile(file),
-	commandArguments.map((argument) => escapeArgument(argument)),
-	{
-		...options,
-		shell: true
-	}
-] : [
-	file,
-	commandArguments,
-	options
-];
-const shouldForceShell = async (file, { shell, cwd, env = process$1.env }) => process$1.platform === "win32" && !shell && !await isExe(file, cwd, env);
-const isExe = (file, cwd, { Path = "", PATH = Path }) => exeExtensions.some((extension) => file.toLowerCase().endsWith(extension)) || mIsExe(file, cwd, PATH);
-const EXE_MEMO = {};
-const memoize = (function_) => (...arguments_) => EXE_MEMO[arguments_.join("\0")] ??= function_(...arguments_);
-const access = memoize(fsPromises.access);
-const mIsExe = memoize(async (file, cwd, PATH) => {
-	const parts = PATH.split(path.delimiter).filter(Boolean).map((part) => part.replace(/^"(.*)"$/, "$1"));
-	try {
-		await Promise.any([cwd, ...parts].flatMap((part) => exeExtensions.map((extension) => access(`${path.resolve(part, file)}${extension}`))));
-	} catch {
+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;
 	}
-	return true;
-});
-const exeExtensions = [".exe", ".com"];
-const escapeArgument = (argument) => escapeFile(escapeFile(`"${argument.replaceAll(/(\\*)"/g, "$1$1\\\"").replace(/(\\*)$/, "$1$1")}"`));
-const escapeFile = (file) => file.replaceAll(/([()\][%!^"`<>&|;, *?])/g, "^$1");
-//#endregion
-//#region ../../node_modules/.pnpm/nano-spawn@2.0.0/node_modules/nano-spawn/source/result.js
-const getResult = async (nodeChildProcess, { input }, context) => {
-	const instance = await nodeChildProcess;
-	if (input !== void 0) instance.stdin.end(input);
-	const onClose = once(instance, "close");
-	try {
-		await Promise.race([onClose, ...instance.stdio.filter(Boolean).map((stream) => onStreamError(stream))]);
-		checkFailure(context, getErrorOutput(instance));
-		return getOutputs(context);
-	} catch (error) {
-		await Promise.allSettled([onClose]);
-		throw getResultError(error, instance, context);
+	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);
 	}
-};
-const onStreamError = async (stream) => {
-	for await (const [error] of on(stream, "error")) if (!["ERR_STREAM_PREMATURE_CLOSE", "EPIPE"].includes(error?.code)) throw error;
-};
-const checkFailure = ({ command }, { exitCode, signalName }) => {
-	if (signalName !== void 0) throw new SubprocessError(`Command was terminated with ${signalName}: ${command}`);
-	if (exitCode !== void 0) throw new SubprocessError(`Command failed with exit code ${exitCode}: ${command}`);
-};
-const getResultError = (error, instance, context) => Object.assign(getErrorInstance(error, context), getErrorOutput(instance), getOutputs(context));
-const getErrorInstance = (error, { command }) => error instanceof SubprocessError ? error : new SubprocessError(`Command failed: ${command}`, { cause: error });
-var SubprocessError = class extends Error {
-	name = "SubprocessError";
-};
-const getErrorOutput = ({ exitCode, signalCode }) => ({
-	...exitCode < 1 ? {} : { exitCode },
-	...signalCode === null ? {} : { signalName: signalCode }
 });
-const getOutputs = ({ state: { stdout, stderr, output }, command, start }) => ({
-	stdout: getOutput(stdout),
-	stderr: getOutput(stderr),
-	output: getOutput(output),
-	command,
-	durationMs: Number(process$1.hrtime.bigint() - start) / 1e6
+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;
+		return n & l || n & c && i === o || n & s && r === a || n & u && a === 0;
+	}
 });
-const getOutput = (output) => output.at(-1) === "\n" ? output.slice(0, output.at(-2) === "\r" ? -2 : -1) : output;
-//#endregion
-//#region ../../node_modules/.pnpm/nano-spawn@2.0.0/node_modules/nano-spawn/source/spawn.js
-const spawnSubprocess = async (file, commandArguments, options, context) => {
-	try {
-		if (["node", "node.exe"].includes(file.toLowerCase())) {
-			file = process$1.execPath;
-			commandArguments = [...process$1.execArgv.filter((flag) => !flag.startsWith("--inspect")), ...commandArguments];
+var D = h((exports, t) => {
+	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 = {};
 		}
-		[file, commandArguments, options] = await applyForceShell(file, commandArguments, options);
-		[file, commandArguments, options] = concatenateShell(file, commandArguments, options);
-		const instance = spawn(file, commandArguments, options);
-		bufferOutput(instance.stdout, context, "stdout");
-		bufferOutput(instance.stderr, context, "stderr");
-		instance.once("error", () => {});
-		await once(instance, "spawn");
-		return instance;
-	} catch (error) {
-		throw getResultError(error, {}, context);
+		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);
+		});
 	}
-};
-const concatenateShell = (file, commandArguments, options) => options.shell && commandArguments.length > 0 ? [
-	[file, ...commandArguments].join(" "),
-	[],
-	options
-] : [
-	file,
-	commandArguments,
-	options
-];
-const bufferOutput = (stream, { state }, streamName) => {
-	if (stream) {
-		stream.setEncoding("utf8");
-		if (!state.isIterating[streamName]) {
-			state.isIterating[streamName] = false;
-			stream.on("data", (chunk) => {
-				state[streamName] += chunk;
-				state.output += chunk;
+	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(/* @__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;
+});
+var k = h((exports, 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;
+});
+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;
 	}
-};
-//#endregion
-//#region ../../node_modules/.pnpm/nano-spawn@2.0.0/node_modules/nano-spawn/source/pipe.js
-const handlePipe = async (subprocesses) => {
-	const [[from, to]] = await Promise.all([Promise.allSettled(subprocesses), pipeStreams(subprocesses)]);
-	if (to.reason) {
-		to.reason.pipedFrom = from.reason ?? from.value;
-		throw to.reason;
-	}
-	if (from.reason) throw from.reason;
-	return {
-		...to.value,
-		pipedFrom: from.value
+	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;
 	};
-};
-const pipeStreams = async (subprocesses) => {
-	try {
-		const [{ stdout }, { stdin }] = await Promise.all(subprocesses.map(({ nodeChildProcess }) => nodeChildProcess));
-		if (stdin === null) throw new Error("The \"stdin\" option must be set on the first \"spawn()\" call in the pipeline.");
-		if (stdout === null) throw new Error("The \"stdout\" option must be set on the last \"spawn()\" call in the pipeline.");
-		pipeline(stdout, stdin).catch(() => {});
-	} catch (error) {
-		await Promise.allSettled(subprocesses.map(({ nodeChildProcess }) => closeStdin(nodeChildProcess)));
-		throw error;
+});
+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());
 	}
-};
-const closeStdin = async (nodeChildProcess) => {
-	const { stdin } = await nodeChildProcess;
-	stdin.end();
-};
-//#endregion
-//#region ../../node_modules/.pnpm/nano-spawn@2.0.0/node_modules/nano-spawn/source/iterable.js
-const lineIterator = async function* (subprocess, { state }, streamName, index) {
-	if (state.isIterating[streamName] === false) throw new Error(`The subprocess must be iterated right away, for example:
-	for await (const line of spawn(...)) { ... }`);
-	state.isIterating[streamName] = true;
-	try {
-		const { [streamName]: stream } = await subprocess.nodeChildProcess;
-		if (!stream) {
-			state.nonIterable[index] = true;
-			const message = state.nonIterable.every(Boolean) ? "either the option `stdout` or `stderr`" : `the option \`${streamName}\``;
-			throw new TypeError(`The subprocess cannot be iterated unless ${message} is 'pipe'.`);
+	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));
+			e.args = [
+				"/d",
+				"/s",
+				"/c",
+				`"${[e.command].concat(e.args).join(" ")}"`
+			];
+			e.command = process.env.comspec || "cmd.exe";
+			e.options.windowsVerbatimArguments = true;
 		}
-		handleErrors(subprocess);
-		yield* readline.createInterface({ input: stream });
-	} finally {
-		await subprocess;
+		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(/* @__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, "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 R = _(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;
+})(), 1);
+var z = 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;
 	}
 };
-const handleErrors = async (subprocess) => {
-	try {
-		await subprocess;
-	} catch {}
+const B = {
+	timeout: void 0,
+	persist: false
 };
-const combineAsyncIterators = async function* ({ state }, ...iterators) {
-	try {
-		let promises = [];
-		while (iterators.length > 0) {
-			promises = iterators.map((iterator, index) => promises[index] ?? getNext(iterator, index, state));
-			const [{ value, done }, index] = await Promise.race(promises.map((promise, index) => Promise.all([promise, index])));
-			const [iterator] = iterators.splice(index, 1);
-			promises.splice(index, 1);
-			if (!done) {
-				iterators.push(iterator);
-				yield value;
-			}
+const V = { windowsHide: true };
+function H(e, t) {
+	return {
+		command: normalize(e),
+		args: t ?? []
+	};
+}
+function U(e) {
+	const t = new AbortController();
+	for (const n of e) {
+		if (n.aborted) {
+			t.abort();
+			return n;
 		}
-	} finally {
-		await Promise.all(iterators.map((iterator) => iterator.return()));
+		const e = () => {
+			t.abort(n.reason);
+		};
+		n.addEventListener("abort", e, { signal: t.signal });
 	}
-};
-const getNext = async (iterator, index, { nonIterable }) => {
-	try {
-		return await iterator.next();
-	} catch (error) {
-		return shouldIgnoreError(nonIterable, index) ? iterator.return() : iterator.throw(error);
+	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;
+	}
+	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 = ot.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 = cwd();
+		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 = spawn(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 shouldIgnoreError = (nonIterable, index) => nonIterable.every(Boolean) ? index !== nonIterable.length - 1 : nonIterable[index];
-//#endregion
-//#region ../../node_modules/.pnpm/nano-spawn@2.0.0/node_modules/nano-spawn/source/index.js
-function spawn$2(file, second, third, previous) {
-	const [commandArguments = [], options = {}] = Array.isArray(second) ? [second, third] : [[], second];
-	const context = getContext([file, ...commandArguments]);
-	const spawnOptions = getOptions(options);
-	const nodeChildProcess = spawnSubprocess(file, commandArguments, spawnOptions, context);
-	let subprocess = getResult(nodeChildProcess, spawnOptions, context);
-	Object.assign(subprocess, { nodeChildProcess });
-	subprocess = previous ? handlePipe([previous, subprocess]) : subprocess;
-	const stdout = lineIterator(subprocess, context, "stdout", 0);
-	const stderr = lineIterator(subprocess, context, "stderr", 1);
-	return Object.assign(subprocess, {
-		nodeChildProcess,
-		stdout,
-		stderr,
-		[Symbol.asyncIterator]: () => combineAsyncIterators(context, stdout, stderr),
-		pipe: (file, second, third) => spawn$2(file, second, third, subprocess)
-	});
-}
+const K = (e, t, n) => {
+	const r = new G(e, t, n);
+	r.spawn();
+	return r;
+};
+const q = K;
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@16.2.7/node_modules/lint-staged/lib/execGit.js
+//#region ../../node_modules/.pnpm/lint-staged@16.3.2/node_modules/lint-staged/lib/execGit.js
 const debugLog$15 = createDebug("lint-staged:execGit");
 /**
 * Explicitly never recurse commands into submodules, overriding local/global configuration.
@@ -381,19 +744,18 @@ const debugLog$15 = createDebug("lint-staged:execGit");
 */
 const NO_SUBMODULE_RECURSE = ["-c", "submodule.recurse=false"];
 [...NO_SUBMODULE_RECURSE];
-/** @type {(cmd: string[], options?: import('nano-spawn').Options) => Promise<string>} */
+/** @type {(cmd: string[], options?: { cwd?: string }) => Promise<string>} */
 const execGit = async (cmd, options) => {
-	debugLog$15("Running git command", cmd);
-	try {
-		return (await spawn$2("git", [...NO_SUBMODULE_RECURSE, ...cmd], {
-			...options,
-			cwd: options?.cwd ?? process.cwd(),
-			stdin: "ignore"
-		})).stdout;
-	} catch (error) {
-		if (error instanceof SubprocessError) throw new Error(error.output, { cause: error });
-		throw error;
-	}
+	debugLog$15("Running git command:", cmd);
+	const result = q("git", [...NO_SUBMODULE_RECURSE, ...cmd], { nodeOptions: {
+		cwd: options?.cwd,
+		stdio: ["ignore"]
+	} });
+	let output = "";
+	for await (const line of result) output += line + "\n";
+	output = output.trimEnd();
+	if (result.exitCode > 0) throw new Error(output, { cause: result });
+	return output;
 };
 var eventemitter3_default = (/* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
 	var has = Object.prototype.hasOwnProperty, prefix = "~";
@@ -2726,12 +3088,12 @@ var Listr = class {
 	}
 };
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@16.2.7/node_modules/lint-staged/lib/figures.js
+//#region ../../node_modules/.pnpm/lint-staged@16.3.2/node_modules/lint-staged/lib/figures.js
 const info = blue$1(figures.arrowRight);
 const error = red$1(figures.cross);
 const warning = yellow$1(figures.warning);
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@16.2.7/node_modules/lint-staged/lib/messages.js
+//#region ../../node_modules/.pnpm/lint-staged@16.3.2/node_modules/lint-staged/lib/messages.js
 const configurationError = (opt, helpMsg, value) => `${red$1(`${error} Validation Error:`)}
 
   Invalid value for '${bold$1(opt)}': ${bold$1(inspect(value))}
@@ -2750,7 +3112,7 @@ const skippingBackup = (hasInitialCommit, diff) => {
 const SKIPPING_HIDE_PARTIALLY_CHANGED = yellow$1(`${warning} Skipping hiding unstaged changes from partially staged files because \`--no-hide-partially-staged\` was used.\n`);
 const DEPRECATED_GIT_ADD = yellow$1(`${warning} Some of your tasks use \`git add\` command. Please remove it from the config since all modifications made by tasks will be automatically added to the git commit index.
 `);
-const TASK_ERROR$1 = "Skipped because of errors from tasks.";
+const TASK_ERROR = "Skipped because of errors from tasks.";
 const PREVENTED_TASK_MODIFICATIONS = `\n${error} lint-staged failed because \`--fail-on-changes\` was used.`;
 const SKIPPED_GIT_ERROR = "Skipped because of previous git error.";
 const GIT_ERROR = `\n  ${red$1(`${error} lint-staged failed due to a git error.`)}`;
@@ -2779,7 +3141,7 @@ ${error}
 See https://github.com/okonet/lint-staged#configuration.`;
 const UNSTAGED_CHANGES_BACKUP_STASH_LOCATION = `Unstaged changes have been kept back in a patch file:`;
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@16.2.7/node_modules/lint-staged/lib/printTaskOutput.js
+//#region ../../node_modules/.pnpm/lint-staged@16.3.2/node_modules/lint-staged/lib/printTaskOutput.js
 /**
 * Handle logging of listr `ctx.output` to the specified `logger`
 * @param {Object} ctx - The listr initial state
@@ -2791,7 +3153,7 @@ const printTaskOutput = (ctx = {}, logger) => {
 	for (const line of ctx.output) log(line);
 };
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@16.2.7/node_modules/lint-staged/lib/normalizePath.js
+//#region ../../node_modules/.pnpm/lint-staged@16.3.2/node_modules/lint-staged/lib/normalizePath.js
 /**
 * Reimplementation of "normalize-path"
 * @see https://github.com/jonschlinkert/normalize-path/blob/52c3a95ebebc2d98c1ad7606cbafa7e658656899/index.js
@@ -2827,7 +3189,7 @@ const normalizePath = (input) => {
 	return normalized;
 };
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@16.2.7/node_modules/lint-staged/lib/chunkFiles.js
+//#region ../../node_modules/.pnpm/lint-staged@16.3.2/node_modules/lint-staged/lib/chunkFiles.js
 const debugLog$14 = createDebug("lint-staged:chunkFiles");
 /**
 * Chunk array into sub-arrays
@@ -5604,7 +5966,7 @@ var require_picomatch = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports = require_picomatch$1();
 }));
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@16.2.7/node_modules/lint-staged/lib/generateTasks.js
+//#region ../../node_modules/.pnpm/lint-staged@16.3.2/node_modules/lint-staged/lib/generateTasks.js
 var import_micromatch = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const util = __require("util");
 	const braces = require_braces();
@@ -6040,280 +6402,24 @@ const generateTasks = ({ config, cwd = process.cwd(), files, relative = false })
 	});
 };
 //#endregion
-//#region ../../node_modules/.pnpm/pidtree@0.6.0/node_modules/pidtree/lib/bin.js
-var require_bin = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var spawn$1 = __require("child_process").spawn;
-	function stripStderr(stderr) {
-		if (!stderr) return;
-		stderr = stderr.trim();
-		stderr = stderr.replace(/your \d+x\d+ screen size is bogus\. expect trouble/gi, "");
-		return stderr.trim();
-	}
-	/**
-	* Spawn a binary and read its stdout.
-	* @param  {String} cmd The name of the binary to spawn.
-	* @param  {String[]} args The arguments for the binary.
-	* @param  {Object} [options] Optional option for the spawn function.
-	* @param  {Function} done(err, stdout)
-	*/
-	function run(cmd, args, options, done) {
-		if (typeof options === "function") {
-			done = options;
-			options = void 0;
-		}
-		var executed = false;
-		var ch = spawn$1(cmd, args, options);
-		var stdout = "";
-		var stderr = "";
-		ch.stdout.on("data", function(d) {
-			stdout += d.toString();
-		});
-		ch.stderr.on("data", function(d) {
-			stderr += d.toString();
-		});
-		ch.on("error", function(err) {
-			if (executed) return;
-			executed = true;
-			done(new Error(err));
-		});
-		ch.on("close", function(code) {
-			if (executed) return;
-			executed = true;
-			stderr = stripStderr(stderr);
-			if (stderr) return done(new Error(stderr));
-			done(null, stdout, code);
-		});
-	}
-	module.exports = run;
-}));
-//#endregion
-//#region ../../node_modules/.pnpm/pidtree@0.6.0/node_modules/pidtree/lib/ps.js
-var require_ps = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var os$2 = __require("os");
-	var bin = require_bin();
-	/**
-	* Gets the list of all the pids of the system through the ps command.
-	* @param  {Function} callback(err, list)
-	*/
-	function ps(callback) {
-		bin("ps", [
-			"-A",
-			"-o",
-			"ppid,pid"
-		], function(err, stdout, code) {
-			if (err) return callback(err);
-			if (code !== 0) return callback(/* @__PURE__ */ new Error("pidtree ps command exited with code " + code));
-			try {
-				stdout = stdout.split(os$2.EOL);
-				var list = [];
-				for (var i = 1; i < stdout.length; i++) {
-					stdout[i] = stdout[i].trim();
-					if (!stdout[i]) continue;
-					stdout[i] = stdout[i].split(/\s+/);
-					stdout[i][0] = parseInt(stdout[i][0], 10);
-					stdout[i][1] = parseInt(stdout[i][1], 10);
-					list.push(stdout[i]);
-				}
-				callback(null, list);
-			} catch (error) {
-				callback(error);
-			}
-		});
-	}
-	module.exports = ps;
-}));
-//#endregion
-//#region ../../node_modules/.pnpm/pidtree@0.6.0/node_modules/pidtree/lib/wmic.js
-var require_wmic = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var os$1 = __require("os");
-	var bin = require_bin();
-	/**
-	* Gets the list of all the pids of the system through the wmic command.
-	* @param  {Function} callback(err, list)
-	*/
-	function wmic(callback) {
-		bin("wmic", [
-			"PROCESS",
-			"get",
-			"ParentProcessId,ProcessId"
-		], {
-			windowsHide: true,
-			windowsVerbatimArguments: true
-		}, function(err, stdout, code) {
-			if (err) {
-				callback(err);
-				return;
-			}
-			if (code !== 0) {
-				callback(/* @__PURE__ */ new Error("pidtree wmic command exited with code " + code));
-				return;
-			}
-			try {
-				stdout = stdout.split(os$1.EOL);
-				var list = [];
-				for (var i = 1; i < stdout.length; i++) {
-					stdout[i] = stdout[i].trim();
-					if (!stdout[i]) continue;
-					stdout[i] = stdout[i].split(/\s+/);
-					stdout[i][0] = parseInt(stdout[i][0], 10);
-					stdout[i][1] = parseInt(stdout[i][1], 10);
-					list.push(stdout[i]);
-				}
-				callback(null, list);
-			} catch (error) {
-				callback(error);
-			}
-		});
-	}
-	module.exports = wmic;
-}));
-//#endregion
-//#region ../../node_modules/.pnpm/pidtree@0.6.0/node_modules/pidtree/lib/get.js
-var require_get = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var os = __require("os");
-	var platformToMethod = {
-		darwin: "ps",
-		sunos: "ps",
-		freebsd: "ps",
-		netbsd: "ps",
-		win: "wmic",
-		linux: "ps",
-		aix: "ps"
-	};
-	var methodToRequireFn = {
-		ps: () => require_ps(),
-		wmic: () => require_wmic()
-	};
-	var platform = os.platform();
-	if (platform.startsWith("win")) platform = "win";
-	var method = platformToMethod[platform];
-	/**
-	* Gets the list of all the pids of the system.
-	* @param  {Function} callback Called when the list is ready.
-	*/
-	function get(callback) {
-		if (method === void 0) callback(/* @__PURE__ */ new Error(os.platform() + " is not supported yet, please open an issue (https://github.com/simonepri/pidtree)"));
-		methodToRequireFn[method]()(callback);
-	}
-	module.exports = get;
-}));
-//#endregion
-//#region ../../node_modules/.pnpm/pidtree@0.6.0/node_modules/pidtree/lib/pidtree.js
-var require_pidtree$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var getAll = require_get();
-	/**
-	* Get the list of children and grandchildren pids of the given PID.
-	* @param  {Number|String} PID A PID. If -1 will return all the pids.
-	* @param  {Object} [options] Optional options object.
-	* @param  {Boolean} [options.root=false] Include the provided PID in the list.
-	* @param  {Boolean} [options.advanced=false] Returns a list of objects in the
-	* format {pid: X, ppid: Y}.
-	* @param  {Function} callback(err, list) Called when the list is ready.
-	*/
-	function list(PID, options, callback) {
-		if (typeof options === "function") {
-			callback = options;
-			options = {};
-		}
-		if (typeof options !== "object") options = {};
-		PID = parseInt(PID, 10);
-		if (isNaN(PID) || PID < -1) {
-			callback(/* @__PURE__ */ new TypeError("The pid provided is invalid"));
-			return;
-		}
-		getAll(function(err, list) {
-			if (err) {
-				callback(err);
-				return;
-			}
-			if (PID === -1) {
-				for (var i = 0; i < list.length; i++) list[i] = options.advanced ? {
-					ppid: list[i][0],
-					pid: list[i][1]
-				} : list[i] = list[i][1];
-				callback(null, list);
-				return;
-			}
-			var root;
-			for (var l = 0; l < list.length; l++) {
-				if (list[l][1] === PID) {
-					root = options.advanced ? {
-						ppid: list[l][0],
-						pid: PID
-					} : PID;
-					break;
-				}
-				if (list[l][0] === PID) root = options.advanced ? { pid: PID } : PID;
-			}
-			if (!root) {
-				callback(/* @__PURE__ */ new Error("No matching pid found"));
-				return;
-			}
-			var tree = {};
-			while (list.length > 0) {
-				var element = list.pop();
-				if (tree[element[0]]) tree[element[0]].push(element[1]);
-				else tree[element[0]] = [element[1]];
-			}
-			var idx = 0;
-			var pids = [root];
-			while (idx < pids.length) {
-				var curpid = options.advanced ? pids[idx++].pid : pids[idx++];
-				if (!tree[curpid]) continue;
-				var length = tree[curpid].length;
-				for (var j = 0; j < length; j++) pids.push(options.advanced ? {
-					ppid: curpid,
-					pid: tree[curpid][j]
-				} : tree[curpid][j]);
-				delete tree[curpid];
-			}
-			if (!options.root) pids.shift();
-			callback(null, pids);
-		});
-	}
-	module.exports = list;
-}));
+//#region ../../node_modules/.pnpm/lint-staged@16.3.2/node_modules/lint-staged/lib/getAbortController.js
+const Signal = {
+	SIGINT: "SIGINT",
+	SIGKILL: "SIGKILL"
+};
+/**
+* Get an AbortController used to cancel running tasks on failure/interruption.
+* @returns AbortController
+*/
+const getAbortController = (nodeProcess = process) => {
+	const abortController = new AbortController();
+	nodeProcess.on(Signal.SIGINT, () => {
+		abortController.abort(Signal.SIGINT);
+	});
+	return abortController;
+};
 //#endregion
 //#region ../../node_modules/.pnpm/string-argv@0.3.2/node_modules/string-argv/index.js
-var import_pidtree = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
-	function pify(fn, arg1, arg2) {
-		return new Promise(function(resolve, reject) {
-			fn(arg1, arg2, function(err, data) {
-				if (err) return reject(err);
-				resolve(data);
-			});
-		});
-	}
-	/* istanbul ignore if */
-	if (!String.prototype.startsWith) String.prototype.startsWith = function(suffix) {
-		return this.substring(0, suffix.length) === suffix;
-	};
-	var pidtree = require_pidtree$1();
-	/**
-	* Get the list of children pids of the given pid.
-	* @public
-	* @param  {Number|String} pid A PID. If -1 will return all the pids.
-	* @param  {Object} [options] Optional options object.
-	* @param  {Boolean} [options.root=false] Include the provided PID in the list.
-	* @param  {Boolean} [options.advanced=false] Returns a list of objects in the
-	* format {pid: X, ppid: Y}.
-	* @param  {Function} [callback=undefined] Called when the list is ready. If not
-	* provided a promise is returned instead.
-	* @returns  {Promise.<Object[]>} Only when the callback is not provided.
-	*/
-	function list(pid, options, callback) {
-		if (typeof options === "function") {
-			callback = options;
-			options = void 0;
-		}
-		if (typeof callback === "function") {
-			pidtree(pid, options, callback);
-			return;
-		}
-		return pify(pidtree, pid, options);
-	}
-	module.exports = list;
-})))(), 1);
 function parseArgsStringToArgv(value, env, file) {
 	var myRegexp = /([^\s'"]([^\s'"]*(['"])([^\3]*?)\3)+[^\s'"]*)|[^\s'"]+|(['"])([^\5]*?)\5/gi;
 	var myString = value;
@@ -6336,7 +6442,40 @@ function firstString() {
 	}
 }
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@16.2.7/node_modules/lint-staged/lib/symbols.js
+//#region ../../node_modules/.pnpm/lint-staged@16.3.2/node_modules/lint-staged/lib/killSubprocesses.js
+const execAsync = promisify(exec);
+/**
+* End process by pid, forcefully, including child processes
+*
+* @see {@link https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/taskkill}
+*
+* @param {number} pid
+*/
+const killWin32Subprocesses = async (pid) => {
+	await execAsync(`taskkill /pid ${pid} /T /F`);
+};
+/**
+* Kill all processes in the group by using negative pid
+*
+* @see {@link https://pubs.opengroup.org/onlinepubs/9699919799/functions/kill.html}
+*
+* @param {number} pid
+*/
+const killUnixSubprocesses = async (pid) => {
+	process.kill(-pid, "SIGKILL");
+};
+/**
+* @param {number} pid
+* @param {boolean} [isWin32]
+*/
+const killSubProcesses = async (pid, isWin32 = process.platform === "win32") => {
+	try {
+		if (isWin32) await killWin32Subprocesses(pid);
+		else await killUnixSubprocesses(pid);
+	} catch {}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/lint-staged@16.3.2/node_modules/lint-staged/lib/symbols.js
 const ApplyEmptyCommitError = Symbol("ApplyEmptyCommitError");
 const ConfigNotFoundError = /* @__PURE__ */ new Error("Configuration could not be found");
 const ConfigFormatError = /* @__PURE__ */ new Error("Configuration should be an object or a function");
@@ -6353,11 +6492,10 @@ const RestoreUnstagedChangesError = Symbol("RestoreUnstagedChangesError");
 const TaskError = Symbol("TaskError");
 const FailOnChangesError = Symbol("FailOnChangesError");
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@16.2.7/node_modules/lint-staged/lib/state.js
+//#region ../../node_modules/.pnpm/lint-staged@16.3.2/node_modules/lint-staged/lib/state.js
 const getInitialState = ({ failOnChanges = false, hideUnstaged = false, hidePartiallyStaged = !hideUnstaged, quiet = false, revert = true } = {}) => ({
 	backupHash: null,
 	errors: /* @__PURE__ */ new Set([]),
-	events: new EventEmitter$1(),
 	shouldFailOnChanges: failOnChanges,
 	hasFilesToHide: null,
 	output: [],
@@ -6374,12 +6512,12 @@ const shouldRestoreUnstagedChanges = (ctx) => (ctx.shouldHideUnstaged || ctx.sho
 const applyModificationsSkipped = (ctx) => {
 	if (!ctx.shouldRevert || !ctx.shouldBackup) return false;
 	if (ctx.errors.has(GitError)) return GIT_ERROR;
-	if (ctx.errors.has(TaskError)) return TASK_ERROR$1;
+	if (ctx.errors.has(TaskError)) return TASK_ERROR;
 };
 const restoreUnstagedChangesSkipped = (ctx) => {
 	if (ctx.errors.has(GitError)) return GIT_ERROR;
 	if (!ctx.shouldRevert) {}
-	if (ctx.errors.has(TaskError)) return TASK_ERROR$1;
+	if (ctx.errors.has(TaskError)) return TASK_ERROR;
 };
 const restoreOriginalStateEnabled = (ctx) => !!ctx.shouldRevert && !!ctx.shouldBackup && (ctx.errors.has(FailOnChangesError) || ctx.errors.has(TaskError) || ctx.errors.has(RestoreUnstagedChangesError));
 const restoreOriginalStateSkipped = (ctx) => {
@@ -6392,95 +6530,46 @@ const cleanupSkipped = (ctx) => {
 	if (ctx.errors.has(RestoreOriginalStateError)) return GIT_ERROR;
 };
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@16.2.7/node_modules/lint-staged/lib/getSpawnedTask.js
-const TASK_ERROR = "lint-staged:taskError";
+//#region ../../node_modules/.pnpm/lint-staged@16.3.2/node_modules/lint-staged/lib/getSpawnedTask.js
 const debugLog$12 = createDebug("lint-staged:getSpawnedTask");
-/** @type {(error: import('nano-spawn').SubprocessError) => string} */
-const getTag = (error) => {
-	return error.signalName ?? "FAILED";
-};
 /**
 * Handle task console output.
 *
 * @param {string} command
-* @param {import('nano-spawn').Result | import('nano-spawn').SubprocessError} result
-* @param {Object} ctx
-* @returns {Error}
+* @param {string} output
+* @param {ReturnType<typeof getInitialState>} ctx context
+* @param {keyof typeof Signal | undefined} signal
+* @param {import('tinyexec').Result} [errorResult]
 */
-const handleOutput = (command, result, ctx, isError = false) => {
-	if (result.output) {
-		const outputTitle = isError ? red$1(`${error} ${command}:`) : `${info} ${command}:`;
-		const output = [...ctx.quiet ? [] : ["", outputTitle], result.output];
-		ctx.output.push(output.join("\n"));
+const handleTaskOutput = (command, output, ctx, signal, errorResult) => {
+	if (output) {
+		const outputTitle = errorResult ? red$1(`${error} ${command}:`) : `${info} ${command}:`;
+		ctx.output.push([...ctx.quiet ? [] : ["", outputTitle], output].join("\n"));
 		return;
 	}
 	if (ctx.quiet) return;
-	if (result instanceof SubprocessError) ctx.output.push(red$1(`\n${error} ${command} failed to spawn:`), result.message, result.cause);
-	else if (isError) {
-		const message = red$1(`\n${error} ${command} failed without output (${getTag(result)}).`);
-		ctx.output.push(message);
-	}
-};
-/**
-* Kill subprocess along with all its child processes.
-* @param {import('nano-spawn').Subprocess} subprocess
-*/
-const killSubprocess = async (subprocess) => {
-	let childProcess;
-	try {
-		childProcess = await subprocess.nodeChildProcess;
-	} catch {}
-	if (childProcess?.pid !== void 0) try {
-		for (const childPid of await (0, import_pidtree.default)(childProcess.pid)) try {
-			process.kill(childPid, "SIGKILL");
-		} catch (error) {
-			debugLog$12(`Failed to kill process with pid "%d": %o`, childPid, error);
-		}
-	} catch (error) {
-		debugLog$12(`Failed to list child processes of pid "%d": %o`, childProcess.pid, error);
-	}
-	childProcess?.kill("SIGKILL");
-};
-/**
-* Interrupts the execution of the subprocess that we spawned if
-* another task adds an error to the context.
-*
-* @param {Object} ctx
-* @param {import('nano-spawn').Subprocess} subprocess
-* @returns {() => Promise<void>} Function that clears the interval that
-* checks the context.
-*/
-const interruptExecutionOnError = (ctx, subprocess) => {
-	let killPromise;
-	const errorListener = async () => {
-		killPromise = killSubprocess(subprocess);
-		await killPromise;
-	};
-	ctx.events.on(TASK_ERROR, errorListener, { once: true });
-	return async () => {
-		ctx.events.off(TASK_ERROR, errorListener);
-		if (killPromise) await killPromise;
-	};
+	if (signal === "SIGINT") ctx.output.push(red$1(`\n${error} Task interrupted: ${command}`));
+	else if (signal === "SIGKILL") ctx.output.push(red$1(`\n${error} Task killed: ${command}`));
+	else if (errorResult) ctx.output.push(red$1(`\n${error} Task failed to spawn: ${command}`), signal);
 };
 /**
 * Create a error output depending on process result.
 *
 * @param {string} command
-* @param {import('nano-spawn').SubprocessError} error
-* @param {Object} ctx
+* @param {import('tinyexec').Result} result
+* @param {ReturnType<typeof getInitialState>} ctx context
+* @param {keyof typeof Signal | undefined} signal
 * @returns {Error}
 */
-const makeErr = (command, error, ctx) => {
+const createTaskError = (command, result, ctx, signal = "FAILED") => {
 	ctx.errors.add(TaskError);
-	ctx.events.emit(TASK_ERROR, TaskError);
-	handleOutput(command, error, ctx, true);
-	const tag = getTag(error);
-	return /* @__PURE__ */ new Error(`${red$1(command)} ${blackBright$1(`[${tag}]`)}`);
+	return new Error(`${red$1(command)} ${blackBright$1(`[${signal}]`)}`, { cause: result });
 };
 /**
 * Returns the task function for the linter.
 *
 * @param {Object} options
+* @param {AbortController} options.abortController
 * @param {boolean} [options.color]
 * @param {string} options.command — Linter task
 * @param {string} [options.continueOnError]
@@ -6491,33 +6580,56 @@ const makeErr = (command, error, ctx) => {
 * @param {Boolean} [options.verbose] — Always show task verbose
 * @returns {() => Promise<Array<string>>}
 */
-const getSpawnedTask = ({ color, command, continueOnError = false, cwd = process.cwd(), files, topLevelDir, isFn, verbose = false }) => {
+const getSpawnedTask = ({ abortController, color, command, continueOnError = false, cwd = process.cwd(), files, topLevelDir, isFn, verbose = false }) => {
 	const [cmd, ...args] = parseArgsStringToArgv(command);
 	debugLog$12("cmd:", cmd);
 	debugLog$12("args:", args);
-	const spawnOptions = {
+	/** @type {import('tinyexec').Options}*/
+	const tinyExecOptions = { nodeOptions: {
 		cwd: /^git(\.exe)?/i.test(cmd) ? topLevelDir : cwd,
-		preferLocal: true,
-		stdin: "ignore",
-		env: color ? { FORCE_COLOR: "true" } : { NO_COLOR: "true" }
-	};
-	debugLog$12("Spawn options:", spawnOptions);
+		env: color ? { FORCE_COLOR: "true" } : { NO_COLOR: "true" },
+		stdio: ["ignore"]
+	} };
+	debugLog$12("Tinyexec options:", tinyExecOptions);
+	/** @param {ReturnType<typeof getInitialState>} ctx context */
 	return async (ctx = getInitialState()) => {
-		let quitInterruptCheck;
+		const result = q(cmd, isFn ? args : args.concat(files), tinyExecOptions);
+		const taskFailed = () => result.exitCode > 0 || result.process?.signalCode;
+		/** @type {keyof typeof Signal | undefined} */
+		let signal;
+		abortController.signal.addEventListener("abort", async () => {
+			if (taskFailed() || !result.process) return;
+			signal = abortController.signal.reason;
+			const pid = result.process.pid;
+			result.process.kill(abortController.signal.reason);
+			await killSubProcesses(pid);
+		}, { once: true });
+		let output = "";
 		try {
-			const subprocess = spawn$2(cmd, isFn ? args : args.concat(files), spawnOptions);
-			if (!continueOnError) quitInterruptCheck = interruptExecutionOnError(ctx, subprocess);
-			const result = await subprocess;
-			if (verbose) handleOutput(command, result, ctx);
+			for await (const line of result) output += line + "\n";
 		} catch (error) {
-			throw makeErr(command, error, ctx);
-		} finally {
-			if (quitInterruptCheck) await quitInterruptCheck();
+			/** Probably failed to spawn (ENOENT) */
+			const errorSignal = error instanceof Error && error.code || "FAILED";
+			if (continueOnError !== true)
+ /** Other tasks should be killed */
+			abortController.abort(Signal.SIGKILL);
+			handleTaskOutput(command, output, ctx, errorSignal, result);
+			throw createTaskError(command, result, ctx, errorSignal);
+		}
+		output = output.trimEnd();
+		if (taskFailed()) {
+			if (continueOnError !== true)
+ /** Other tasks should be killed */
+			abortController.abort(Signal.SIGKILL);
+			if (result.process?.pid) await killSubProcesses(result.process.pid);
+			handleTaskOutput(command, output, ctx, signal, result);
+			throw createTaskError(command, result, ctx, result.process?.signalCode ?? signal);
 		}
+		if (verbose) handleTaskOutput(command, output, ctx, signal);
 	};
 };
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@16.2.7/node_modules/lint-staged/lib/getFunctionTask.js
+//#region ../../node_modules/.pnpm/lint-staged@16.3.2/node_modules/lint-staged/lib/getFunctionTask.js
 const debugLog$11 = createDebug("lint-staged:getFunctionTasks");
 /**
 * @typedef {{ title: string; task: Function }} FunctionTask
@@ -6538,7 +6650,7 @@ const getFunctionTask = async (command, files) => {
 		try {
 			await command.task(files.map((file) => file.filepath));
 		} catch (e) {
-			throw makeErr(command.title, e, ctx);
+			throw createTaskError(command.title, e, ctx);
 		}
 	};
 	return [{
@@ -6547,7 +6659,7 @@ const getFunctionTask = async (command, files) => {
 	}];
 };
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@16.2.7/node_modules/lint-staged/lib/getRenderer.js
+//#region ../../node_modules/.pnpm/lint-staged@16.3.2/node_modules/lint-staged/lib/getRenderer.js
 const EOLRegex = new RegExp(EOL$1 + "$");
 const bindLogger = (consoleLogMethod) => new Writable({ write: function(chunk, encoding, next) {
 	consoleLogMethod(chunk.toString().replace(EOLRegex, ""));
@@ -6581,12 +6693,13 @@ const getRenderer = ({ color, debug, quiet }, logger, env = process.env) => {
 	};
 };
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@16.2.7/node_modules/lint-staged/lib/getSpawnedTasks.js
+//#region ../../node_modules/.pnpm/lint-staged@16.3.2/node_modules/lint-staged/lib/getSpawnedTasks.js
 const debugLog$10 = createDebug("lint-staged:getSpawnedTasks");
 /**
 * Creates and returns an array of listr tasks which map to the given commands.
 *
 * @param {object} options
+* @param {AbortController} options.abortController
 * @param {boolean} [options.color]
 * @param {Array<string|Function>|string|Function} options.commands
 * @param {string} options.continueOnError
@@ -6595,7 +6708,7 @@ const debugLog$10 = createDebug("lint-staged:getSpawnedTasks");
 * @param {string} options.topLevelDir
 * @param {Boolean} verbose
 */
-const getSpawnedTasks = async ({ color, commands, continueOnError, cwd, files, topLevelDir, verbose }) => {
+const getSpawnedTasks = async ({ abortController, color, commands, continueOnError, cwd, files, topLevelDir, verbose }) => {
 	debugLog$10("Creating Listr tasks for commands %o", commands);
 	const cmdTasks = [];
 	const commandArray = Array.isArray(commands) ? commands : [commands];
@@ -6608,6 +6721,7 @@ const getSpawnedTasks = async ({ color, commands, continueOnError, cwd, files, t
 		for (const command of resolvedArray) {
 			if (isFn && typeof command !== "string") throw new Error(configurationError("[Function]", "Function task should return a string or an array of strings", resolved));
 			const task = getSpawnedTask({
+				abortController,
 				color,
 				command,
 				continueOnError,
@@ -6627,7 +6741,7 @@ const getSpawnedTasks = async ({ color, commands, continueOnError, cwd, files, t
 	return cmdTasks;
 };
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@16.2.7/node_modules/lint-staged/lib/getDiffCommand.js
+//#region ../../node_modules/.pnpm/lint-staged@16.3.2/node_modules/lint-staged/lib/getDiffCommand.js
 /** @type {(diff?: string, diffFilter?: string) => string[]} */
 const getDiffCommand = (diff, diffFilter) => {
 	/**
@@ -6644,7 +6758,7 @@ const getDiffCommand = (diff, diffFilter) => {
 	];
 };
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@16.2.7/node_modules/lint-staged/lib/parseGitZOutput.js
+//#region ../../node_modules/.pnpm/lint-staged@16.3.2/node_modules/lint-staged/lib/parseGitZOutput.js
 /**
 * Return array of strings split from the output of `git <something> -z`.
 * With `-z`, git prints `fileA\u0000fileB\u0000fileC\u0000` so we need to
@@ -6652,7 +6766,7 @@ const getDiffCommand = (diff, diffFilter) => {
 */
 const parseGitZOutput = (input) => input ? input.replace(/\u0000$/, "").split("\0") : [];
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@16.2.7/node_modules/lint-staged/lib/getStagedFiles.js
+//#region ../../node_modules/.pnpm/lint-staged@16.3.2/node_modules/lint-staged/lib/getStagedFiles.js
 /**
 * @typedef {'A'|'C'|'D'|'M'|'R'|'T'|'U'|'X'} FileSatus
 * @typedef { { filepath: string; status: FileSatus }} StagedFile
@@ -6723,7 +6837,7 @@ const getStagedFiles = async ({ cwd = process.cwd(), diff, diffFilter } = {}) =>
 	}
 };
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@16.2.7/node_modules/lint-staged/lib/file.js
+//#region ../../node_modules/.pnpm/lint-staged@16.3.2/node_modules/lint-staged/lib/file.js
 const debugLog$9 = createDebug("lint-staged:file");
 /**
 * Read contents of a file to buffer
@@ -6766,7 +6880,7 @@ const writeFile = async (filename, buffer) => {
 	await fsPromises.writeFile(filename, buffer);
 };
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@16.2.7/node_modules/lint-staged/lib/gitWorkflow.js
+//#region ../../node_modules/.pnpm/lint-staged@16.3.2/node_modules/lint-staged/lib/gitWorkflow.js
 const debugLog$8 = createDebug("lint-staged:GitWorkflow");
 const MERGE_HEAD = "MERGE_HEAD";
 const MERGE_MODE = "MERGE_MODE";
@@ -7145,7 +7259,7 @@ var GitWorkflow = class {
 	}
 };
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@16.2.7/node_modules/lint-staged/lib/groupFilesByConfig.js
+//#region ../../node_modules/.pnpm/lint-staged@16.3.2/node_modules/lint-staged/lib/groupFilesByConfig.js
 const debugLog$7 = createDebug("lint-staged:groupFilesByConfig");
 /**
 * @typedef {import('./getStagedFiles.js').StagedFile} StagedFile
@@ -7195,7 +7309,7 @@ const groupFilesByConfig = async ({ configs, files, singleConfigMode }) => {
 	return filesByConfig;
 };
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@16.2.7/node_modules/lint-staged/lib/resolveGitRepo.js
+//#region ../../node_modules/.pnpm/lint-staged@16.3.2/node_modules/lint-staged/lib/resolveGitRepo.js
 const debugLog$6 = createDebug("lint-staged:resolveGitRepo");
 /**
 * Relative path up to the repo top-level directory
@@ -7254,7 +7368,7 @@ const resolveGitRepo = async (cwd = process.cwd()) => {
 	}
 };
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@16.2.7/node_modules/lint-staged/lib/configFiles.js
+//#region ../../node_modules/.pnpm/lint-staged@16.3.2/node_modules/lint-staged/lib/configFiles.js
 const CONFIG_NAME = "lint-staged";
 const PACKAGE_JSON_FILE = "package.json";
 const PACKAGE_YAML_FILES = ["package.yaml", "package.yml"];
@@ -7283,7 +7397,7 @@ const CONFIG_FILE_NAMES = [
 	"lint-staged.config.cts"
 ];
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@16.2.7/node_modules/lint-staged/lib/resolveConfig.js
+//#region ../../node_modules/.pnpm/lint-staged@16.3.2/node_modules/lint-staged/lib/resolveConfig.js
 /**
 * require() does not exist for ESM, so we must create it to use require.resolve().
 * @see https://nodejs.org/api/module.html#modulecreaterequirefilename
@@ -7297,7 +7411,7 @@ function resolveConfig(configPath) {
 	}
 }
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@16.2.7/node_modules/lint-staged/lib/loadConfig.js
+//#region ../../node_modules/.pnpm/lint-staged@16.3.2/node_modules/lint-staged/lib/loadConfig.js
 /** @typedef {import('./index').Logger} Logger */
 const debugLog$5 = createDebug("lint-staged:loadConfig");
 const readFile = async (filename) => fsPromises.readFile(path.resolve(filename), "utf-8");
@@ -7377,7 +7491,7 @@ const loadConfig = async (configPath, logger) => {
 	}
 };
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@16.2.7/node_modules/lint-staged/lib/validateBraces.js
+//#region ../../node_modules/.pnpm/lint-staged@16.3.2/node_modules/lint-staged/lib/validateBraces.js
 /**
 * A correctly-formed brace expansion must contain unquoted opening and closing braces,
 * and at least one unquoted comma or a valid sequence expression.
@@ -7406,18 +7520,21 @@ const loadConfig = async (configPath, logger) => {
 * - *.${js}      // dollar-sign inhibits expansion, so treated literally
 * - *.{js\,ts}   // the comma is escaped, so treated literally
 */
-const INCORRECT_BRACES_REGEXP = /(?<![\\$])({)(?:(?!(?<!\\),|\.\.|\{|\}).)*?(?<!\\)(})/g;
+const getIncorrectBracesRegexp = () => /(?<![\\$])({)(?:(?!(?<!\\),|\.\.|\{|\}).)*?(?<!\\)(})/g;
 /**
 * @param {string} pattern
 * @returns {string}
 */
 const stripIncorrectBraces = (pattern) => {
 	let output = `${pattern}`;
-	let match = null;
-	while (match = INCORRECT_BRACES_REGEXP.exec(pattern)) {
+	const regexp = getIncorrectBracesRegexp();
+	let match = regexp.exec(output);
+	while (match) {
 		const fullMatch = match[0];
 		const withoutBraces = fullMatch.replace(/{/, "").replace(/}/, "");
 		output = output.replace(fullMatch, withoutBraces);
+		regexp.lastIndex = 0;
+		match = regexp.exec(output);
 	}
 	return output;
 };
@@ -7456,7 +7573,7 @@ const validateBraces = (pattern, logger) => {
 	return fixedPattern;
 };
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@16.2.7/node_modules/lint-staged/lib/validateConfig.js
+//#region ../../node_modules/.pnpm/lint-staged@16.3.2/node_modules/lint-staged/lib/validateConfig.js
 /** @typedef {import('./index').Logger} Logger */
 const debugLog$4 = createDebug("lint-staged:validateConfig");
 const validateConfigLogic = (config, configPath, logger) => {
@@ -7519,7 +7636,7 @@ const validateConfig = (config, configPath, logger) => {
 	}
 };
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@16.2.7/node_modules/lint-staged/lib/searchConfigs.js
+//#region ../../node_modules/.pnpm/lint-staged@16.3.2/node_modules/lint-staged/lib/searchConfigs.js
 /** @typedef {import('./index').Logger} Logger */
 const debugLog$3 = createDebug("lint-staged:searchConfigs");
 const EXEC_GIT = [
@@ -7637,7 +7754,7 @@ const searchConfigs = async ({ configObject, configPath, cwd = process.cwd(), to
 	return foundConfigs;
 };
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@16.2.7/node_modules/lint-staged/lib/runAll.js
+//#region ../../node_modules/.pnpm/lint-staged@16.3.2/node_modules/lint-staged/lib/runAll.js
 /** @typedef {import('./index').Logger} Logger */
 const debugLog$2 = createDebug("lint-staged:runAll");
 /**
@@ -7735,16 +7852,10 @@ const runAll = async ({ allowEmpty = false, color = false, concurrent = true, co
 			quiet
 		}, logger)
 	};
-	/**
-	* This is used to set max event listener count to the total number
-	* of generated tasks. The event listener is used to keep track of
-	* the interrupt signal and kill all tasks when it happens. See the
-	* `interruptExecutionOnError` in `getSpawnedTask`.
-	*/
-	let listrTaskCount = 0;
 	const listrTasks = [];
 	/** @type {Set<import('./getStagedFiles.js').StagedFile>} */
 	const matchedFiles = /* @__PURE__ */ new Set();
+	const abortController = getAbortController();
 	for (const [configPath, { config, files }] of Object.entries(filesByConfig)) {
 		const configName = configPath ? normalizePath(path.relative(cwd, configPath)) : "Config object";
 		const stagedFileChunks = chunkFiles({
@@ -7763,6 +7874,7 @@ const runAll = async ({ allowEmpty = false, color = false, concurrent = true, co
 				files,
 				relative
 			}).map((task) => (isFunctionTask(task.commands) ? getFunctionTask(task.commands, task.fileList) : getSpawnedTasks({
+				abortController,
 				color,
 				commands: task.commands,
 				continueOnError,
@@ -7792,7 +7904,6 @@ const runAll = async ({ allowEmpty = false, color = false, concurrent = true, co
 					}
 				};
 			})));
-			listrTaskCount += chunkListrTasks.length;
 			listrTasks.push({
 				title: `${configName}${blackBright$1(` — ${files.length} ${files.length > 1 ? "files" : "file"}`)}` + (chunkCount > 1 ? blackBright$1(` (chunk ${index + 1}/${chunkCount})...`) : ""),
 				task: (ctx, task) => task.newListr(chunkListrTasks, {
@@ -7826,7 +7937,7 @@ const runAll = async ({ allowEmpty = false, color = false, concurrent = true, co
 		}),
 		topLevelDir
 	});
-	const runner = new Listr([
+	await new Listr([
 		{
 			title: ctx.shouldBackup ? "Backing up original state..." : "Preparing lint-staged...",
 			task: (ctx, task) => git.prepare(ctx, task)
@@ -7867,15 +7978,12 @@ const runAll = async ({ allowEmpty = false, color = false, concurrent = true, co
 			enabled: cleanupEnabled,
 			skip: cleanupSkipped
 		}
-	], listrOptions);
-	debugLog$2("Set max event listeners to the number of tasks: %i", listrTaskCount);
-	ctx.events.setMaxListeners(listrTaskCount);
-	await runner.run();
+	], listrOptions).run();
 	if (ctx.errors.size > 0) throw createError(ctx);
 	return ctx;
 };
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@16.2.7/node_modules/lint-staged/lib/validateOptions.js
+//#region ../../node_modules/.pnpm/lint-staged@16.3.2/node_modules/lint-staged/lib/validateOptions.js
 const debugLog$1 = createDebug("lint-staged:validateOptions");
 /**
 * Validate lint-staged options, either from the Node.js API or the command line flags.
@@ -7897,12 +8005,12 @@ const validateOptions = async (options = {}, logger) => {
 	debugLog$1("Validated options: %o", options);
 };
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@16.2.7/node_modules/lint-staged/lib/version.js
+//#region ../../node_modules/.pnpm/lint-staged@16.3.2/node_modules/lint-staged/lib/version.js
 const getVersion = async () => {
 	return JSON.parse(await fsPromises.readFile(new URL("../package.json", import.meta.url))).version;
 };
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@16.2.7/node_modules/lint-staged/lib/index.js
+//#region ../../node_modules/.pnpm/lint-staged@16.3.2/node_modules/lint-staged/lib/index.js
 const debugLog = createDebug("lint-staged");
 /**
 * Get the maximum length of a command-line argument string based on current platform