vite-plus 1.0.0 → 1.2.0

package/dist/staged/bin.js

@@ -1,12 +1,12 @@
 import { r as __toESM, t as __commonJSMin } from "../rolldown-runtime-CMFfr-1z.js";
 import { i as log, n as errorMsg, o as printHeader } from "../terminal-MKGAuy-p.js";
-import { o as resolveViteConfig } from "../resolve-vite-config-BJYYtfY3.js";
+import { o as resolveViteConfig } from "../resolve-vite-config-x47JetlI.js";
 import { t as unwrapCliParseOutcome } from "../cli-parse-DHE8NrBU.js";
 import { createRequire } from "node:module";
 import path, { basename, delimiter, dirname, normalize, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { parseStagedArgs } from "../../binding/index.js";
-import util, { formatWithOptions, inspect, promisify } from "node:util";
+import util, { format, formatWithOptions, inspect, promisify } from "node:util";
 import { closeSync, constants, openSync, readSync, statSync } from "node:fs";
 import { cwd } from "node:process";
 import l__default from "node:readline";
@@ -15,7 +15,7 @@ import fsPromises, { constants as constants$1 } from "node:fs/promises";
 import { PassThrough } from "node:stream";
 import { exec, spawn } from "node:child_process";
 import { pipeline } from "node:stream/promises";
-//#region ../../node_modules/.pnpm/lint-staged@17.5.1/node_modules/lint-staged/lib/assertGitVersion.js
+//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/assertGitVersion.js
 /** @see {@link https://github.com/git/git/blob/master/Documentation/RelNotes/2.32.0.adoc} */
 const MIN_GIT_VERSION = "2.32.0";
 const GIT_VERSION_REGEXP = /git version\s+(\d+\.\d+\.\d+)/i;
@@ -61,7 +61,7 @@ const assertGitVersion = (gitVersionOutput) => {
 	}
 };
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.5.1/node_modules/lint-staged/lib/colors.js
+//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/colors.js
 let COLORS_ENABLED = false;
 /** Node.js util checks for FORCE_COLOR/NO_COLOR and whether TTY supports ANSI colors */
 const supportsColors = (stream = process.stdout) => util.styleText("red", "test", { stream }) !== "test";
@@ -81,8 +81,8 @@ const blue = styleText$1("blue");
 const dim = styleText$1("dim");
 const bold = styleText$1("bold");
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.5.1/node_modules/lint-staged/lib/debug.js
-const format = (...args) => formatWithOptions({ colors: COLORS_ENABLED }, ...args);
+//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/debug.js
+const format$1 = (...args) => formatWithOptions({ colors: COLORS_ENABLED }, ...args);
 let activeLogger;
 const enableDebug = (logger = console) => {
 	activeLogger = logger;
@@ -95,7 +95,7 @@ const createDebug = (name) => {
 		const now = process.hrtime.bigint();
 		const ms = (now - previous) / 1000000n;
 		previous = now;
-		activeLogger.debug(dim(name + ": ") + format(...args) + dim(` +${ms}ms`));
+		activeLogger.debug(dim(name + ": ") + format$1(...args) + dim(` +${ms}ms`));
 	};
 };
 //#endregion
@@ -440,7 +440,7 @@ const x = (command, args, userOptions) => {
 };
 const exec$1 = x;
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.5.1/node_modules/lint-staged/lib/execGit.js
+//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/execGit.js
 const debugLog$17 = createDebug("lint-staged:execGit");
 /**
 * Explicitly never recurse commands into submodules, overriding local/global configuration.
@@ -448,7 +448,11 @@ const debugLog$17 = createDebug("lint-staged:execGit");
 */
 const NO_SUBMODULE_RECURSE = ["-c", "submodule.recurse=false"];
 [...NO_SUBMODULE_RECURSE];
-/** @type {(cmd: string[], options?: { cwd?: string }) => Promise<string>} */
+/**
+* @param {string[]} cmd
+* @param {{ cwd?: string, env?: NodeJS.ProcessEnv, trim?: boolean }} [options]
+* @returns {Promise<string>}
+*/
 const execGit = async (cmd, options) => {
 	debugLog$17("Running git command:", cmd);
 	const result = await exec$1("git", [...NO_SUBMODULE_RECURSE, ...cmd], { nodeOptions: {
@@ -456,10 +460,11 @@ const execGit = async (cmd, options) => {
 		cwd: options?.cwd
 	} });
 	if (result.exitCode > 0) throw new Error(result.stderr.trimEnd(), { cause: result });
+	if (options?.trim === false) return result.stdout;
 	return result.stdout.trimEnd();
 };
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.5.1/node_modules/lint-staged/lib/figures.js
+//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/figures.js
 const wip = () => blue("⋯");
 const done = () => green("✔");
 const info = () => blue("→");
@@ -470,7 +475,7 @@ const parallelGroupStart = () => dim("┌");
 const parallelGroupMiddle = () => dim("│");
 const parallelGroupStop = () => dim("└");
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.5.1/node_modules/lint-staged/lib/messages.js
+//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/messages.js
 const configurationError = (opt, helpMsg, value) => `${red(`${error()} Validation Error:`)}
 
   Invalid value for '${bold(opt)}': ${bold(inspect(value))}
@@ -525,246 +530,7 @@ const minGitVersionRequired = (expected) => red(`${error()} lint-staged requires
 
 Please update Git: https://git-scm.com/downloads`);
 //#endregion
-//#region ../../node_modules/.pnpm/string-argv@0.3.2/node_modules/string-argv/index.js
-function parseArgsStringToArgv(value, env, file) {
-	var myRegexp = /([^\s'"]([^\s'"]*(['"])([^\3]*?)\3)+[^\s'"]*)|[^\s'"]+|(['"])([^\5]*?)\5/gi;
-	var myString = value;
-	var myArray = [];
-	if (env) myArray.push(env);
-	if (file) myArray.push(file);
-	var match;
-	do {
-		match = myRegexp.exec(myString);
-		if (match !== null) myArray.push(firstString(match[1], match[6], match[0]));
-	} while (match !== null);
-	return myArray;
-}
-function firstString() {
-	var args = [];
-	for (var _i = 0; _i < arguments.length; _i++) args[_i] = arguments[_i];
-	for (var i = 0; i < args.length; i++) {
-		var arg = args[i];
-		if (typeof arg === "string") return arg;
-	}
-}
-//#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.5.1/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/lint-staged@17.5.1/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@17.5.1/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");
-const ConfigEmptyError = /* @__PURE__ */ new Error("Configuration should not be empty");
-const GetStagedFilesError = Symbol("GetStagedFilesError");
-const IntentToAddError = Symbol("IntentToAddError");
-const GitError = Symbol("GitError");
-const GitRepoError = Symbol("GitRepoError");
-const HideUnstagedChangesError = Symbol("HideUnstagedChangesError");
-const InvalidOptionsError = /* @__PURE__ */ new Error("Invalid Options");
-const RestoreMergeStatusError = Symbol("RestoreMergeStatusError");
-const RestoreOriginalStateError = Symbol("RestoreOriginalStateError");
-const RestoreUnstagedChangesError = Symbol("RestoreUnstagedChangesError");
-const TaskError = Symbol("TaskError");
-const FailOnChangesError = Symbol("FailOnChangesError");
-//#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.5.1/node_modules/lint-staged/lib/state.js
-const getInitialState = ({ failOnChanges = false, hideAll = false, hideUnstaged = false, hidePartiallyStaged = !(hideAll || hideUnstaged), quiet = false, revert = true } = {}) => {
-	const initialState = {
-		backupHash: void 0,
-		errors: /* @__PURE__ */ new Set([]),
-		shouldFailOnChanges: failOnChanges,
-		hasFilesToHide: null,
-		output: [],
-		quiet,
-		runId: crypto.randomBytes(4).toString("hex"),
-		shouldBackup: null,
-		shouldHideAll: hideAll,
-		shouldHideUnstaged: hideUnstaged,
-		shouldHidePartiallyStaged: hidePartiallyStaged,
-		shouldRevert: revert,
-		unstagedDiffSha256: null,
-		unstagedPatch: null
-	};
-	if (initialState.shouldHideAll) {
-		initialState.shouldHideUnstaged = false;
-		initialState.shouldHidePartiallyStaged = false;
-	} else if (initialState.shouldHideUnstaged) initialState.shouldHidePartiallyStaged = false;
-	return initialState;
-};
-const shouldHidePartiallyStagedFiles = (ctx) => ctx.shouldHidePartiallyStaged && ctx.hasFilesToHide;
-const shouldRestoreUnstagedChanges = (ctx) => (ctx.shouldHideAll || ctx.shouldHideUnstaged || ctx.shouldHidePartiallyStaged) && ctx.hasFilesToHide;
-const shouldRestoreUntrackedFiles = (ctx) => !!ctx.shouldBackup && !!ctx.shouldHideAll;
-const updateIndexSkipped = (ctx) => {
-	if (!ctx.shouldRevert || !ctx.shouldBackup) return false;
-	if (ctx.errors.has(GitError)) return gitError();
-	if (ctx.errors.has(TaskError)) return taskError();
-};
-const restoreUnstagedChangesSkipped = (ctx) => {
-	if (ctx.errors.has(GitError)) return gitError();
-	if (!ctx.shouldRevert) return false;
-	if (ctx.errors.has(TaskError)) return taskError();
-};
-const restoreOriginalStateEnabled = (ctx) => !!ctx.shouldRevert && !!ctx.shouldBackup && (ctx.errors.has(FailOnChangesError) || ctx.errors.has(TaskError) || ctx.errors.has(RestoreUnstagedChangesError));
-const restoreOriginalStateSkipped = (ctx) => {
-	if (ctx.errors.has(GitError) && !ctx.errors.has(RestoreUnstagedChangesError)) return gitError();
-};
-const cleanupEnabled = (ctx) => ctx.shouldBackup;
-const cleanupSkipped = (ctx) => {
-	if (ctx.errors.has(FailOnChangesError) && !ctx.shouldRevert) return true;
-	/** Failed to restore hidden unstaged changes, shouldn't drop stash, @see restoreUnstagedChangesSkipped */
-	if (ctx.errors.has(RestoreUnstagedChangesError) && !ctx.shouldRevert) return gitError();
-	if (restoreOriginalStateSkipped(ctx)) return gitError();
-	if (ctx.errors.has(RestoreOriginalStateError)) return gitError();
-};
-//#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.5.1/node_modules/lint-staged/lib/getSpawnedTask.js
-const debugLog$16 = createDebug("lint-staged:getSpawnedTask");
-/**
-* Handle task console output.
-*
-* @param {string} command
-* @param {string} output
-* @param {ReturnType<typeof getInitialState>} ctx context
-* @param {keyof typeof Signal | undefined} signal
-* @param {import('tinyexec').Result} [errorResult]
-*/
-const handleTaskOutput = (command, output, ctx, signal, errorResult) => {
-	if (output) {
-		const outputTitle = errorResult ? red(`${error()} ${command}:`) : `${info()} ${command}:`;
-		ctx.output.push([...ctx.quiet ? [] : ["", outputTitle], output].join("\n"));
-		return;
-	}
-	if (ctx.quiet) return;
-	if (signal === "SIGINT") ctx.output.push(red(`\n${error()} Task interrupted: ${command}`));
-	else if (signal === "SIGKILL") ctx.output.push(red(`\n${error()} Task killed: ${command}`));
-	else if (errorResult) ctx.output.push(red(`\n${error()} Task failed to spawn: ${command}`), signal);
-};
-/**
-* Create a error output depending on process result.
-*
-* @param {string} command
-* @param {import('tinyexec').Result} result
-* @param {ReturnType<typeof getInitialState>} ctx context
-* @param {keyof typeof Signal | undefined} signal
-* @returns {Error}
-*/
-const createTaskError = (command, result, ctx, signal = "FAILED") => {
-	ctx.errors.add(TaskError);
-	return new Error(`${red(command)} ${dim(`[${signal}]`)}`, { cause: result });
-};
-const GIT_EXE_REGEXP = /^git(\.exe)?/i;
-/**
-* Returns the spawnable task.
-*
-* @param {Object} options
-* @param {AbortController} options.abortController
-* @param {string} options.command — the command to spawn
-* @param {string} [options.continueOnError]
-* @param {string} [options.cwd]
-* @param {String} options.topLevelDir - Current git repo top-level path
-* @param {Boolean} options.isFn - Whether the task is a function instead of a string
-* @param {string[]} options.files — Filepaths to run the task against
-* @param {Boolean} [options.verbose] — Always show task verbose
-* @returns {() => Promise<Array<string>>}
-*/
-const getSpawnedTask = ({ abortController, command, continueOnError = false, cwd = process.cwd(), files, topLevelDir, isFn, verbose = false }) => {
-	const [cmd, ...args] = parseArgsStringToArgv(command);
-	debugLog$16("cmd:", cmd);
-	debugLog$16("args:", args);
-	/** @type {import('tinyexec').Options}*/
-	const tinyExecOptions = { nodeOptions: {
-		cwd: GIT_EXE_REGEXP.test(cmd) ? topLevelDir : cwd,
-		env: COLORS_ENABLED ? { FORCE_COLOR: "true" } : { NO_COLOR: "true" }
-	} };
-	debugLog$16("Tinyexec options:", tinyExecOptions);
-	/** @param {ReturnType<typeof getInitialState>} ctx context */
-	return async (ctx = getInitialState()) => {
-		const result = exec$1(cmd, isFn ? args : [...args, ...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 {
-			for await (const line of result) output += line + "\n";
-		} catch (error) {
-			/** 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@17.5.1/node_modules/lint-staged/lib/getSpawnedTasks.js
-const debugLog$15 = createDebug("lint-staged:getSpawnedTasks");
+//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/getMaxArgLength.js
 /**
 * Get the maximum length of a command-line argument string based on current platform
 *
@@ -779,90 +545,9 @@ const getMaxArgLength = (platform = process.platform) => {
 		default: return 131072;
 	}
 };
-/**
-* Chunk `files` so that when joined with `command`, the resulting string fits into `maxArgLength`.
-* For function commands, they are evaluated with the list of files and measured afterwards.
-*
-* @param {string | Function} command
-* @param {string[]} files
-* @param {number} [maxArgLength]
-* @returns {Promise<Array<{ command: string, files: string[] }>>}
-*/
-const chunkFilesForCommand = async (command, files, maxArgLength) => {
-	const isFn = typeof command === "function";
-	const resolved = isFn ? await command([...files]) : command;
-	const resolvedCommands = Array.isArray(resolved) ? resolved : [resolved];
-	if (isFn && resolvedCommands.some((c) => typeof c !== "string")) throw new Error(configurationError("[Function]", "Function task should return a string or an array of strings", resolved));
-	if (!maxArgLength || maxArgLength === Infinity || files.length <= 1) {
-		debugLog$15("Skipping chunking because maxArgLength is %s and there are %s files", maxArgLength, files.length);
-		return resolvedCommands.map((resolvedCommand) => ({
-			command: resolvedCommand,
-			files
-		}));
-	}
-	if (resolvedCommands.every((resolvedCommand) => {
-		/**
-		* Really the command is spawned using `tinyexec` and the files passed as an array of
-		* arguments; but this approximates the length without quoting filenames.
-		*/
-		const finalCommandString = isFn ? resolvedCommand : resolvedCommand + " " + files.join(" ");
-		debugLog$15("Resolved an argument string length of %d characters from %d files", finalCommandString.length, files.length);
-		return finalCommandString.length <= maxArgLength;
-	})) return resolvedCommands.map((resolvedCommand) => ({
-		command: resolvedCommand,
-		files
-	}));
-	const middle = Math.ceil(files.length / 2);
-	const left = files.slice(0, middle);
-	const right = files.slice(middle);
-	debugLog$15("Splitting %d files into chunks of %d and %d for maxArgLength of %d", files.length, left.length, right.length, maxArgLength);
-	return (await Promise.all([chunkFilesForCommand(command, left, maxArgLength), chunkFilesForCommand(command, right, maxArgLength)])).flat();
-};
-/**
-* Creates and returns an array of tasks which map to the given commands.
-*
-* @param {object} options
-* @param {AbortController} options.abortController
-* @param {Array<string | Function | Array<string | Function>> | string | Function} options.commands
-* @param {string} options.continueOnError
-* @param {string} options.cwd
-* @param {import('./getStagedFiles.js').StagedFile[]} options.files
-* @param {number} [options.maxArgLength]
-* @param {string} options.topLevelDir
-* @param {Boolean} verbose
-*/
-const getSpawnedTasks = async ({ abortController, commands, continueOnError, cwd, files, maxArgLength, topLevelDir, verbose }) => {
-	debugLog$15("Creating tasks for commands %o", commands);
-	const commandArray = Array.isArray(commands) ? commands : [commands];
-	const filepaths = files.map((f) => f.filepath);
-	if (filepaths.length === 0) {
-		debugLog$15("Skipping task generation because no files matched", { commands });
-		return [];
-	}
-	const createTasks = async (command) => {
-		const isFn = typeof command === "function";
-		return (await chunkFilesForCommand(command, filepaths, maxArgLength)).map((chunk) => ({
-			title: chunk.command,
-			task: getSpawnedTask({
-				abortController,
-				command: chunk.command,
-				continueOnError,
-				cwd,
-				files: chunk.files,
-				topLevelDir,
-				isFn,
-				verbose
-			})
-		}));
-	};
-	return (await Promise.all(commandArray.map(async (command) => {
-		if (Array.isArray(command) && command.length > 1) return [(await Promise.all(command.map(createTasks))).flat()];
-		return createTasks(command);
-	}))).flat();
-};
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.5.1/node_modules/lint-staged/lib/parseOptions.js
-const debugLog$14 = createDebug("lint-staged:parseOptions");
+//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/parseOptions.js
+const debugLog$16 = createDebug("lint-staged:parseOptions");
 /** @param {import('./index').Options} [options] */
 const parseOptions = ({ all, allowEmpty, color, concurrent, config: configObject, configPath, continueOnError, cwd, debug, diff, diffFilter, failOnChanges, hideAll, hidePartiallyStaged, hideUnstaged, maxArgLength, quiet, relative, revert, stash, verbose } = {}) => {
 	if (all) {
@@ -912,11 +597,11 @@ const parseOptions = ({ all, allowEmpty, color, concurrent, config: configObject
 		stash,
 		verbose
 	};
-	debugLog$14("Parsed options: %o", options);
+	debugLog$16("Parsed options: %o", options);
 	return options;
 };
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.5.1/node_modules/lint-staged/lib/printTaskOutput.js
+//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/printTaskOutput.js
 /**
 * Handle logging of task `ctx.output` to the specified `logger`
 * @param {Object} ctx - The context
@@ -2833,7 +2518,7 @@ var require_picomatch$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports = picomatch;
 }));
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.5.1/node_modules/lint-staged/lib/matchFiles.js
+//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/matchFiles.js
 var import_picomatch = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const pico = require_picomatch$1();
 	const utils = require_utils();
@@ -2864,7 +2549,7 @@ const matchFiles = (files, pattern, cwd = process.cwd()) => {
 	return files.filter((file) => isMatch(file.filepath));
 };
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.5.1/node_modules/lint-staged/lib/normalizePath.js
+//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/normalizePath.js
 /**
 * Reimplementation of "normalize-path"
 * @see https://github.com/jonschlinkert/normalize-path/blob/52c3a95ebebc2d98c1ad7606cbafa7e658656899/index.js
@@ -2902,8 +2587,8 @@ const normalizePath = (input) => {
 	return normalized;
 };
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.5.1/node_modules/lint-staged/lib/generateTasks.js
-const debugLog$13 = createDebug("lint-staged:generateTasks");
+//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/generateTasks.js
+const debugLog$15 = createDebug("lint-staged:generateTasks");
 /**
 * Generates all task commands, and filelist
 *
@@ -2914,7 +2599,7 @@ const debugLog$13 = createDebug("lint-staged:generateTasks");
 * @param {boolean} [options.relative] - Whether filepaths to should be relative to cwd
 */
 const generateTasks = ({ config, cwd = process.cwd(), files, relative = false }) => {
-	debugLog$13("Generating tasks");
+	debugLog$15("Generating tasks");
 	/** @type {StagedFile[]} */
 	const relativeFiles = files.map((file) => ({
 		filepath: normalizePath(path.relative(cwd, file.filepath)),
@@ -2934,13 +2619,250 @@ const generateTasks = ({ config, cwd = process.cwd(), files, relative = false })
 				status: file.status
 			}))
 		};
-		debugLog$13("Generated task: \n%O", task);
+		debugLog$15("Generated task: \n%O", task);
 		return task;
 	});
 };
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.5.1/node_modules/lint-staged/lib/getFunctionTask.js
-const debugLog$12 = createDebug("lint-staged:getFunctionTasks");
+//#region ../../node_modules/.pnpm/lint-staged@17.6.0/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
+function parseArgsStringToArgv(value, env, file) {
+	var myRegexp = /([^\s'"]([^\s'"]*(['"])([^\3]*?)\3)+[^\s'"]*)|[^\s'"]+|(['"])([^\5]*?)\5/gi;
+	var myString = value;
+	var myArray = [];
+	if (env) myArray.push(env);
+	if (file) myArray.push(file);
+	var match;
+	do {
+		match = myRegexp.exec(myString);
+		if (match !== null) myArray.push(firstString(match[1], match[6], match[0]));
+	} while (match !== null);
+	return myArray;
+}
+function firstString() {
+	var args = [];
+	for (var _i = 0; _i < arguments.length; _i++) args[_i] = arguments[_i];
+	for (var i = 0; i < args.length; i++) {
+		var arg = args[i];
+		if (typeof arg === "string") return arg;
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/lint-staged@17.6.0/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@17.6.0/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");
+const ConfigEmptyError = /* @__PURE__ */ new Error("Configuration should not be empty");
+const GetStagedFilesError = Symbol("GetStagedFilesError");
+const IntentToAddError = Symbol("IntentToAddError");
+const GitError = Symbol("GitError");
+const GitRepoError = Symbol("GitRepoError");
+const HideUnstagedChangesError = Symbol("HideUnstagedChangesError");
+const InvalidOptionsError = /* @__PURE__ */ new Error("Invalid Options");
+const RestoreMergeStatusError = Symbol("RestoreMergeStatusError");
+const RestoreOriginalStateError = Symbol("RestoreOriginalStateError");
+const RestoreUnstagedChangesError = Symbol("RestoreUnstagedChangesError");
+const TaskError = Symbol("TaskError");
+const FailOnChangesError = Symbol("FailOnChangesError");
+//#endregion
+//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/state.js
+const getInitialState = ({ failOnChanges = false, hideAll = false, hideUnstaged = false, hidePartiallyStaged = !(hideAll || hideUnstaged), quiet = false, revert = true } = {}) => {
+	const initialState = {
+		backupHash: void 0,
+		errors: /* @__PURE__ */ new Set([]),
+		shouldFailOnChanges: failOnChanges,
+		hasFilesToHide: null,
+		output: [],
+		quiet,
+		runId: crypto.randomBytes(4).toString("hex"),
+		shouldBackup: null,
+		shouldHideAll: hideAll,
+		shouldHideUnstaged: hideUnstaged,
+		shouldHidePartiallyStaged: hidePartiallyStaged,
+		shouldRevert: revert,
+		unstagedDiff: null,
+		unstagedPatch: null
+	};
+	if (initialState.shouldHideAll) {
+		initialState.shouldHideUnstaged = false;
+		initialState.shouldHidePartiallyStaged = false;
+	} else if (initialState.shouldHideUnstaged) initialState.shouldHidePartiallyStaged = false;
+	return initialState;
+};
+const shouldHidePartiallyStagedFiles = (ctx) => ctx.shouldHidePartiallyStaged && ctx.hasFilesToHide;
+const shouldRestoreUnstagedChanges = (ctx) => (ctx.shouldHideAll || ctx.shouldHideUnstaged || ctx.shouldHidePartiallyStaged) && ctx.hasFilesToHide;
+const shouldRestoreUntrackedFiles = (ctx) => !!ctx.shouldBackup && !!ctx.shouldHideAll;
+const updateIndexSkipped = (ctx) => {
+	if (!ctx.shouldRevert || !ctx.shouldBackup) return false;
+	if (ctx.errors.has(GitError)) return gitError();
+	if (ctx.errors.has(TaskError)) return taskError();
+};
+const restoreUnstagedChangesSkipped = (ctx) => {
+	if (ctx.errors.has(GitError)) return gitError();
+	if (!ctx.shouldRevert) return false;
+	if (ctx.errors.has(TaskError)) return taskError();
+};
+const restoreOriginalStateEnabled = (ctx) => !!ctx.shouldRevert && !!ctx.shouldBackup && (ctx.errors.has(FailOnChangesError) || ctx.errors.has(TaskError) || ctx.errors.has(RestoreUnstagedChangesError));
+const restoreOriginalStateSkipped = (ctx) => {
+	if (ctx.errors.has(GitError) && !ctx.errors.has(RestoreUnstagedChangesError)) return gitError();
+};
+const cleanupEnabled = (ctx) => ctx.shouldBackup;
+const cleanupSkipped = (ctx) => {
+	if (ctx.errors.has(FailOnChangesError) && !ctx.shouldRevert) return true;
+	/** Failed to restore hidden unstaged changes, shouldn't drop stash, @see restoreUnstagedChangesSkipped */
+	if (ctx.errors.has(RestoreUnstagedChangesError) && !ctx.shouldRevert) return gitError();
+	if (restoreOriginalStateSkipped(ctx)) return gitError();
+	if (ctx.errors.has(RestoreOriginalStateError)) return gitError();
+};
+//#endregion
+//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/getSpawnedTask.js
+const debugLog$14 = createDebug("lint-staged:getSpawnedTask");
+/**
+* Handle task console output.
+*
+* @param {string} command
+* @param {string} output
+* @param {ReturnType<typeof getInitialState>} ctx context
+* @param {keyof typeof Signal | undefined} signal
+* @param {import('tinyexec').Result} [errorResult]
+*/
+const handleTaskOutput = (command, output, ctx, signal, errorResult) => {
+	if (output) {
+		const outputTitle = errorResult ? red(`${error()} ${command}:`) : `${info()} ${command}:`;
+		ctx.output.push([...ctx.quiet ? [] : ["", outputTitle], output].join("\n"));
+		return;
+	}
+	if (ctx.quiet) return;
+	if (signal === "SIGINT") ctx.output.push(red(`\n${error()} Task interrupted: ${command}`));
+	else if (signal === "SIGKILL") ctx.output.push(red(`\n${error()} Task killed: ${command}`));
+	else if (errorResult) ctx.output.push(red(`\n${error()} Task failed to spawn: ${command}`), signal);
+};
+/**
+* Create a error output depending on process result.
+*
+* @param {string} command
+* @param {import('tinyexec').Result} result
+* @param {ReturnType<typeof getInitialState>} ctx context
+* @param {keyof typeof Signal | undefined} signal
+* @returns {Error}
+*/
+const createTaskError = (command, result, ctx, signal = "FAILED") => {
+	ctx.errors.add(TaskError);
+	return new Error(`${red(command)} ${dim(`[${signal}]`)}`, { cause: result });
+};
+const GIT_EXE_REGEXP = /^git(\.exe)?/i;
+/**
+* Returns the spawnable task.
+*
+* @param {Object} options
+* @param {AbortController} options.abortController
+* @param {string} options.command — the command to spawn
+* @param {string} [options.continueOnError]
+* @param {string} [options.cwd]
+* @param {String} options.topLevelDir - Current git repo top-level path
+* @param {string[]} options.files — Filepaths to run the task against
+* @param {Boolean} [options.verbose] — Always show task verbose
+* @returns {() => Promise<Array<string>>}
+*/
+const getSpawnedTask = ({ abortController, command, continueOnError = false, cwd = process.cwd(), files, topLevelDir, verbose = false }) => {
+	const [cmd, ...args] = parseArgsStringToArgv(command);
+	debugLog$14("cmd:", cmd);
+	debugLog$14("args:", args);
+	/** @type {import('tinyexec').Options}*/
+	const tinyExecOptions = { nodeOptions: {
+		cwd: GIT_EXE_REGEXP.test(cmd) ? topLevelDir : cwd,
+		env: COLORS_ENABLED ? { FORCE_COLOR: "true" } : { NO_COLOR: "true" }
+	} };
+	debugLog$14("Tinyexec options:", tinyExecOptions);
+	/** @param {ReturnType<typeof getInitialState>} ctx context */
+	return async (ctx = getInitialState()) => {
+		const result = exec$1(cmd, [...args, ...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 {
+			for await (const line of result) output += line + "\n";
+		} catch (error) {
+			/** 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@17.6.0/node_modules/lint-staged/lib/getFunctionTask.js
+const debugLog$13 = createDebug("lint-staged:getFunctionTasks");
 /**
 * @typedef {{ title: string; task: Function }} FunctionTask
 * @type {(commands: FunctionTask|Array<string|Function>|string|Function) => boolean}
@@ -2955,62 +2877,327 @@ const isFunctionTask = (commands) => typeof commands === "object" && !Array.isAr
 * @param {FunctionTask} options.command
 * @param {boolean} options.continueOnError
 * @param {import('./getStagedFiles.js').StagedFile[]} options.files
+* @param {boolean} [options.verbose]
 * @throws {Error} If the function configuration is not valid
 */
-const getFunctionTask = async ({ abortController, command, continueOnError, files }) => {
-	debugLog$12("Creating task for function %o", command);
+const getFunctionTask = async ({ abortController, command, continueOnError, files, verbose }) => {
+	debugLog$13("Creating task for function %o", command);
 	const task = async (ctx) => {
+		const output = [];
+		const addOutput = (...args) => {
+			output.push(format(...args));
+		};
 		try {
-			await command.task(files.map((file) => file.filepath));
-		} catch (e) {
+			const filepaths = files.map((file) => file.filepath);
+			await command.task(filepaths, { log: addOutput });
+		} catch (error) {
 			if (continueOnError !== true)
  /** Other tasks should be killed */
 			abortController.abort(Signal.SIGKILL);
-			throw createTaskError(command.title, e, ctx);
+			addOutput(`\n%O`, error);
+			const taskOutput = output.join("\n").trimEnd();
+			handleTaskOutput(command.title, taskOutput, ctx, void 0, error);
+			throw createTaskError(command.title, error, ctx);
 		}
+		if (verbose) handleTaskOutput(command.title, output.join("\n").trimEnd(), ctx);
 	};
 	return [{
 		title: command.title,
 		task
 	}];
 };
-//#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.5.1/node_modules/lint-staged/lib/parseGitZOutput.js
-const GIT_Z_REGEXP = /\u0000$/;
+//#endregion
+//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/parseGitZOutput.js
+const GIT_Z_REGEXP = /\u0000$/;
+/**
+* Return array of strings split from the output of `git <something> -z`.
+* With `-z`, git prints `fileA\u0000fileB\u0000fileC\u0000` so we need to
+* remove the last occurrence of `\u0000` before splitting
+*
+* @param {string} input
+* @returns {string[]} parsed input
+*/
+const parseGitZOutput = (input) => input ? input.replace(GIT_Z_REGEXP, "").split("\0") : [];
+//#endregion
+//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/getIntentToAddFiles.js
+const debugLog$12 = createDebug("lint-staged:getIntentToAddFiles");
+const getIntentToAddFiles = async ({ cwd }) => {
+	const [stagedWithIta, stagedWithoutIta] = await Promise.all([execGit([
+		"diff",
+		"--staged",
+		"--ita-visible-in-index",
+		"--name-only",
+		"-z"
+	], { cwd }).then(parseGitZOutput), execGit([
+		"diff",
+		"--staged",
+		"--ita-invisible-in-index",
+		"--name-only",
+		"-z"
+	], { cwd }).then(parseGitZOutput)]);
+	const set = new Set(stagedWithoutIta);
+	const intentToAdd = stagedWithIta.filter((f) => !set.has(f)).map((f) => normalizePath(path.join(cwd, f)));
+	debugLog$12(`Detected ${intentToAdd.length} files staged with "--intent-to-add":`, intentToAdd);
+	return intentToAdd;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/lint-staged@17.6.0/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.
+* Any incorrectly formed brace expansion is left unchanged.
+*
+* @see https://www.gnu.org/software/bash/manual/html_node/Brace-Expansion.html
+*
+* Lint-staged uses `micromatch` for brace expansion, and its behavior is to treat
+* invalid brace expansions as literal strings, which means they (typically) do not match
+* anything.
+*
+* This RegExp tries to match most cases of invalid brace expansions, so that they can be
+* detected, warned about, and re-formatted by removing the braces and thus hopefully
+* matching the files as intended by the user. The only real fix is to remove the incorrect
+* braces from user configuration, but this is left to the user (after seeing the warning).
+*
+* @example <caption>Globs with brace expansions</caption>
+* - *.{js,tx}        // expanded as *.js, *.ts
+* - *.{{j,t}s,css}   // expanded as *.js, *.ts, *.css
+* - file_{1..10}.css  // expanded as file_1.css, file_2.css, …, file_10.css
+*
+* @example <caption>Globs with incorrect brace expansions</caption>
+* - *.{js}       // should just be *.js
+* - *.{js,{ts}}  // should just be *.{js,ts}
+* - *.\{js\}     // escaped braces, so they're treated literally
+* - *.${js}      // dollar-sign inhibits expansion, so treated literally
+* - *.{js\,ts}   // the comma is escaped, so treated literally
+*/
+const getIncorrectBracesRegexp = () => /(?<![\\$])({)(?:(?!(?<!\\),|\.\.|\{|\}).)*?(?<!\\)(})/g;
+const BRACE_OPEN_REGEXP = /{/;
+const BRACE_CLOSE_REGEXP = /}/;
+/**
+* @param {string} pattern
+* @returns {string}
+*/
+const stripIncorrectBraces = (pattern) => {
+	let output = `${pattern}`;
+	const regexp = getIncorrectBracesRegexp();
+	let match = regexp.exec(output);
+	while (match) {
+		const fullMatch = match[0];
+		const withoutBraces = fullMatch.replace(BRACE_OPEN_REGEXP, "").replace(BRACE_CLOSE_REGEXP, "");
+		output = output.replace(fullMatch, withoutBraces);
+		regexp.lastIndex = 0;
+		match = regexp.exec(output);
+	}
+	return output;
+};
+/**
+* This RegExp matches "duplicate" opening and closing braces, without any other braces
+* in between, where the duplication is redundant and should be removed.
+*
+* @example *.{{js,ts}}  // should just be *.{js,ts}
+*/
+const DOUBLE_BRACES_REGEXP = /{{[^}{]*}}/;
+/**
+* @param {string} pattern
+* @returns {string}
+*/
+const stripDoubleBraces = (pattern) => {
+	let output = `${pattern}`;
+	const match = DOUBLE_BRACES_REGEXP.exec(pattern)?.[0];
+	if (match) {
+		const withoutBraces = match.replace("{{", "{").replace("}}", "}");
+		output = output.replace(match, withoutBraces);
+	}
+	return output;
+};
+/**
+* Validate and remove incorrect brace expansions from glob pattern.
+* For example `*.{js}` is incorrect because it doesn't contain a `,` or `..`,
+* and will be reformatted as `*.js`.
+*
+* @param {string} pattern the glob pattern
+* @param {*} logger
+* @returns {string}
+*/
+const validateBraces = (pattern, logger) => {
+	const fixedPattern = stripDoubleBraces(stripIncorrectBraces(pattern));
+	if (fixedPattern !== pattern) logger.warn(incorrectBraces(pattern, fixedPattern));
+	return fixedPattern;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/validateConfig.js
+/** @typedef {import('./index').Logger} Logger */
+const debugLog$11 = createDebug("lint-staged:validateConfig");
+/**
+* Validate commands are sequential:
+* - a single string/task
+* - an array of strings/tasks, running sequentially, with at most one level of nested arrays
+*   for running inner strings/tasks in parallel
+*/
+const isSequentialTasks = (commands, depth = 0, allowFunctions = true) => {
+	if (Array.isArray(commands)) return depth < 2 && commands.every((command) => isSequentialTasks(command, depth + 1, allowFunctions));
+	return typeof commands === "string" || allowFunctions && typeof commands === "function";
+};
+const validateConfigLogic = (config, configPath, logger) => {
+	debugLog$11("Validating config from `%s`...", configPath);
+	if (!config || typeof config !== "object" && typeof config !== "function") throw ConfigFormatError;
+	/**
+	* Function configurations receive all staged files as their argument.
+	* They are not further validated here to make sure the function gets
+	* evaluated only once.
+	*
+	* @see getSpawnedTasks
+	*/
+	if (typeof config === "function") return { "*": config };
+	if (Object.entries(config).length === 0) throw ConfigEmptyError;
+	const errors = [];
+	/**
+	* Create a new validated config because the keys (patterns) might change.
+	* Since the Object.reduce method already loops through each entry in the config,
+	* it can be used for validating the values at the same time.
+	*/
+	const validatedConfig = Object.entries(config).reduce((collection, [pattern, task]) => {
+		if (Array.isArray(task)) {
+			if (!isSequentialTasks(task)) errors.push(configurationError(pattern, "Should be an array of strings or functions, or single-level nested array or strings of functions.", task));
+		} else if (typeof task === "object") {
+			/** Invalid function task */
+			if (typeof task.title !== "string" || typeof task.task !== "function") errors.push(configurationError(pattern, "Function task should contain `title` and `task` fields, where `title` should be a string and `task` should be a function.", task));
+		} else if (typeof task !== "string" && typeof task !== "function")
+ /** Singular invalid value */
+		errors.push(configurationError(pattern, "Should be a string, a function, an object or an array of strings and functions.", task));
+		/**
+		* A typical configuration error is using invalid brace expansion, like `*.{js}`.
+		* These are automatically fixed and warned about.
+		*/
+		const fixedPattern = validateBraces(pattern, logger);
+		return Object.assign(collection, { [fixedPattern]: task });
+	}, {});
+	if (errors.length) {
+		const message = errors.join("\n\n");
+		logger.error(failedToParseConfig(configPath, message));
+		throw new Error(message);
+	}
+	debugLog$11("Validated config from `%s`:\n%O", configPath, config);
+	return validatedConfig;
+};
+/**
+* Runs config validation. Throws error if the config is not valid.
+* @param {Object} config
+* @param {string} configPath
+* @param {Logger} logger
+* @returns {Object} config
+*/
+const validateConfig = (config, configPath, logger) => {
+	try {
+		return validateConfigLogic(config, configPath, logger);
+	} catch (error) {
+		logger.error(failedToParseConfig(configPath, error));
+		throw error;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/getSpawnedTasks.js
+const debugLog$10 = createDebug("lint-staged:getSpawnedTasks");
+/**
+* @param {import('./config.js').SequentialTasks} commands
+* @param {string[]} files
+* @param {number} [maxArgLength]
+* @param {number} [arrayDepth] the maximum depth of commands array is 2, the inner is for concurrent tasks
+* @returns
+*/
+const prepare = async (commands, files, maxArgLength, arrayDepth = 0) => {
+	const isFunction = typeof commands === "function";
+	const resolved = isFunction ? await commands([...files]) : commands;
+	if (!isSequentialTasks(resolved, arrayDepth, !isFunction)) throw new Error(configurationError(isFunction ? "[Function]" : "[Commands]", "Commands must be strings, with at most one nested array inside the sequential task list. Function results must preserve this nesting limit.", resolved));
+	if (Array.isArray(commands)) return [(await Promise.all(commands.map((command) => prepare(command, files, maxArgLength, arrayDepth + 1)))).flat()];
+	/** Function tasks are meant to generate the file list themselves */
+	const toCommand = (command) => Array.isArray(command) ? command.map(toCommand) : {
+		command,
+		files: isFunction ? [] : files
+	};
+	const prepared = toCommand(resolved);
+	const fits = (command) => {
+		if (Array.isArray(command)) return command.every(fits);
+		return command.command.length + (command.files.length ? 1 + command.files.join(" ").length : 0) <= maxArgLength;
+	};
+	if (!maxArgLength || maxArgLength === Infinity || files.length <= 1 || fits(prepared))
+ /** No need for chunking */
+	return [prepared];
+	/** Split into two chunks, and try again recursively */
+	const middle = Math.ceil(files.length / 2);
+	debugLog$10("Splitting %d files for maxArgLength of %d", files.length, maxArgLength);
+	return (await Promise.all([prepare(commands, files.slice(0, middle), maxArgLength, arrayDepth), prepare(commands, files.slice(middle), maxArgLength, arrayDepth)])).flat();
+};
+/**
+* Resolve and validate commands, preserving sequential and parallel groups.
+* Functions are reevaluated for smaller file lists when chunking is necessary.
+* Each resulting command contains only the filenames to append when spawning it.
+*
+* @param {import('./config.js').SequentialTasks} commands
+* @param {string[]} files
+* @param {number} [maxArgLength]
+* @returns {Promise<Array<{ command: string, files: string[] } | Array<{ command: string, files: string[] }>>>}
+*/
+const chunkFilesForCommand = async (commands, files, maxArgLength) => {
+	if (files.length === 0) return [];
+	return (await prepare(commands, files, maxArgLength)).flat();
+};
 /**
-* Return array of strings split from the output of `git <something> -z`.
-* With `-z`, git prints `fileA\u0000fileB\u0000fileC\u0000` so we need to
-* remove the last occurrence of `\u0000` before splitting
+* Creates and returns an array of tasks which map to the given commands.
 *
-* @param {string} input
-* @returns {string[]} parsed input
+* @param {object} options
+* @param {AbortController} options.abortController
+* @param {Array<string | Function | Array<string | Function>> | string | Function} options.commands
+* @param {string} options.continueOnError
+* @param {string} options.cwd
+* @param {import('./getStagedFiles.js').StagedFile[]} options.files
+* @param {number} [options.maxArgLength]
+* @param {string} options.topLevelDir
+* @param {Boolean} verbose
 */
-const parseGitZOutput = (input) => input ? input.replace(GIT_Z_REGEXP, "").split("\0") : [];
-//#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.5.1/node_modules/lint-staged/lib/getIntentToAddFiles.js
-const debugLog$11 = createDebug("lint-staged:getIntentToAddFiles");
-const getIntentToAddFiles = async ({ cwd }) => {
-	const [stagedWithIta, stagedWithoutIta] = await Promise.all([execGit([
-		"diff",
-		"--staged",
-		"--ita-visible-in-index",
-		"--name-only",
-		"-z"
-	], { cwd }).then(parseGitZOutput), execGit([
-		"diff",
-		"--staged",
-		"--ita-invisible-in-index",
-		"--name-only",
-		"-z"
-	], { cwd }).then(parseGitZOutput)]);
-	const set = new Set(stagedWithoutIta);
-	const intentToAdd = stagedWithIta.filter((f) => !set.has(f)).map((f) => normalizePath(path.join(cwd, f)));
-	debugLog$11(`Detected ${intentToAdd.length} files staged with "--intent-to-add":`, intentToAdd);
-	return intentToAdd;
+const getSpawnedTasks = async ({ abortController, commands, continueOnError, cwd, files, maxArgLength, topLevelDir, verbose }) => {
+	debugLog$10("Creating tasks for commands %o", commands);
+	const prepared = await chunkFilesForCommand(commands, files.map((file) => file.filepath), maxArgLength);
+	const createTask = (command) => ({
+		title: command.command,
+		task: getSpawnedTask({
+			abortController,
+			command: command.command,
+			continueOnError,
+			cwd,
+			files: command.files,
+			topLevelDir,
+			verbose
+		})
+	});
+	return prepared.map((command) => Array.isArray(command) ? command.map(createTask) : createTask(command));
 };
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.5.1/node_modules/lint-staged/lib/file.js
-const debugLog$10 = createDebug("lint-staged:file");
+//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/file.js
+const debugLog$9 = createDebug("lint-staged:file");
+/**
+* Ensure directory exists, creating it if not.
+* @param {string} dirname
+* @returns {Promise<string>} the dirname
+*/
+const ensureDir = async (dirname) => {
+	debugLog$9("Ensuring directory exists: %s", dirname);
+	await fsPromises.mkdir(dirname, { recursive: true });
+	return dirname;
+};
+/**
+* Try removing directory, ignoring errors
+* @param {string} dirname
+*/
+const removeDir = async (dirname) => {
+	debugLog$9("Removing directory: %s", dirname);
+	try {
+		await fsPromises.rm(dirname, {
+			recursive: true,
+			force: true
+		});
+	} catch {}
+};
 /**
 * Read contents of a file to buffer
 * @param {String} filename
@@ -3018,41 +3205,27 @@ const debugLog$10 = createDebug("lint-staged:file");
 * @returns {Promise<Buffer>}
 */
 const readFile$1 = async (filename, ignoreENOENT = true) => {
-	debugLog$10("Reading file `%s`", filename);
+	debugLog$9("Reading file `%s`", filename);
 	try {
 		return await fsPromises.readFile(filename);
 	} catch (error) {
 		if (ignoreENOENT && error.code === "ENOENT") {
-			debugLog$10("File `%s` doesn't exist, ignoring...", filename);
+			debugLog$9("File `%s` doesn't exist, ignoring...", filename);
 			return null;
 		} else throw error;
 	}
 };
 /**
-* Remove a file
-* @param {String} filename
-* @param {Boolean} [ignoreENOENT=true] — Whether to throw if the file doesn't exist
-*/
-const unlink = async (filename, ignoreENOENT = true) => {
-	debugLog$10("Removing file `%s`", filename);
-	try {
-		await fsPromises.unlink(filename);
-	} catch (error) {
-		if (ignoreENOENT && error.code === "ENOENT") debugLog$10("File `%s` doesn't exist, ignoring...", filename);
-		else throw error;
-	}
-};
-/**
 * Write buffer to file
 * @param {String} filename
 * @param {Buffer} buffer
 */
 const writeFile = async (filename, buffer) => {
-	debugLog$10("Writing file `%s`", filename);
+	debugLog$9("Writing file `%s`", filename);
 	await fsPromises.writeFile(filename, buffer);
 };
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.5.1/node_modules/lint-staged/lib/getDiffCommand.js
+//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/getDiffCommand.js
 /** @type {(diff?: string, diffFilter?: string) => string[]} */
 const getDiffCommand = (diff, diffFilter) => {
 	/**
@@ -3069,7 +3242,7 @@ const getDiffCommand = (diff, diffFilter) => {
 	];
 };
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.5.1/node_modules/lint-staged/lib/getStagedFiles.js
+//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/getStagedFiles.js
 /**
 * @typedef {'A'|'C'|'D'|'M'|'R'|'T'|'U'|'X'} FileSatus
 * @typedef { { filepath: string; status: FileSatus }} StagedFile
@@ -3176,8 +3349,8 @@ const getStagedFiles = async ({ all, cwd, gitConfigDir, diff, diffFilter }) => {
 	}
 };
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.5.1/node_modules/lint-staged/lib/runParallelTasks.js
-const debugLog$9 = createDebug("lint-staged:runParallelTasks");
+//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/runParallelTasks.js
+const debugLog$8 = createDebug("lint-staged:runParallelTasks");
 /** @param {Number | boolean} options.concurrent Boolean value for whether to run concurrently */
 const parseConcurrency = (concurrent) => {
 	if (concurrent === true || concurrent === Infinity) return Infinity;
@@ -3194,25 +3367,25 @@ const parseConcurrency = (concurrent) => {
 */
 const runParallelTasks = async (ctx, tasks, { abortController, concurrent = true, logger }) => {
 	const concurrency = parseConcurrency(concurrent);
-	debugLog$9("Running parallel tasks with concurrency:", concurrency);
+	debugLog$8("Running parallel tasks with concurrency:", concurrency);
 	const indent = tasks.length > 1 ? "    " : "  ";
 	const allPerGlobTasks = [];
 	for (const perConfig of tasks) {
-		if (perConfig.skip()) debugLog$9("Skipped configuration:", perConfig.title);
+		if (perConfig.skip()) debugLog$8("Skipped configuration:", perConfig.title);
 		else {
-			debugLog$9("Running configuration:", perConfig.title);
+			debugLog$8("Running configuration:", perConfig.title);
 			if (tasks.length > 1) logger?.log(dim(`${indent}${perConfig.title}`));
 		}
 		for (const perGlob of perConfig.task) {
 			if (perConfig.skip()) continue;
 			if (perGlob.skip()) {
-				debugLog$9("Skipped glob from configuration:", perConfig.title, perGlob.title);
+				debugLog$8("Skipped glob from configuration:", perConfig.title, perGlob.title);
 				continue;
 			}
-			debugLog$9("Running glob:", perGlob.title);
+			debugLog$8("Running glob:", perGlob.title);
 			logger?.log(dim(`${indent}  ${perGlob.title}`));
 			for (const sequentialTask of perGlob.task) if (Array.isArray(sequentialTask)) {
-				debugLog$9(`Running ${sequentialTask.length} parallel tasks:`, ...sequentialTask.map((t) => t.title));
+				debugLog$8(`Running ${sequentialTask.length} parallel tasks:`, ...sequentialTask.map((t) => t.title));
 				sequentialTask.forEach((parallelTask, index) => {
 					if (index === 0) logger?.log(`${indent}    ${parallelGroupStart()} ${wip()} ${parallelTask.title}`);
 					else {
@@ -3221,7 +3394,7 @@ const runParallelTasks = async (ctx, tasks, { abortController, concurrent = true
 					}
 				});
 			} else {
-				debugLog$9("Running task:", sequentialTask.title);
+				debugLog$8("Running task:", sequentialTask.title);
 				logger?.log(`${indent}    ${wip()} ${sequentialTask.title}`);
 			}
 			allPerGlobTasks.push(perGlob.task);
@@ -3230,17 +3403,17 @@ const runParallelTasks = async (ctx, tasks, { abortController, concurrent = true
 	logger?.log("");
 	const runSingle = async ({ title, task }) => {
 		if (abortController.signal.aborted) {
-			debugLog$9("Skipped task because aborted:", title);
+			debugLog$8("Skipped task because aborted:", title);
 			logger?.warn(`${cancelled()} ${title}`);
 			return;
 		}
 		try {
-			debugLog$9("Running task:", title);
+			debugLog$8("Running task:", title);
 			await task(ctx);
-			debugLog$9("Done running task:", title);
+			debugLog$8("Done running task:", title);
 			logger?.log(`${done()} ${title}`);
 		} catch {
-			debugLog$9("Failed to run task:", title);
+			debugLog$8("Failed to run task:", title);
 			logger?.error(red(`${error()} ${title}`));
 		}
 	};
@@ -3256,14 +3429,14 @@ const runParallelTasks = async (ctx, tasks, { abortController, concurrent = true
 		}
 	};
 	const length = Math.min(allPerGlobTasks.length, concurrency);
-	debugLog$9("Running workers with concurrency:", length);
+	debugLog$8("Running workers with concurrency:", length);
 	await Promise.all(Array.from({ length }, worker));
-	debugLog$9("Done running workers");
+	debugLog$8("Done running workers");
 	logger?.log("");
 };
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.5.1/node_modules/lint-staged/lib/gitWorkflow.js
-const debugLog$8 = createDebug("lint-staged:GitWorkflow");
+//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/gitWorkflow.js
+const debugLog$7 = createDebug("lint-staged:GitWorkflow");
 const MERGE_HEAD = "MERGE_HEAD";
 const MERGE_MODE = "MERGE_MODE";
 const MERGE_MSG = "MERGE_MSG";
@@ -3281,7 +3454,7 @@ const processRenames = (files, includeRenameFrom = true) => files.reduce((flatte
 	} else flattened.push(file);
 	return flattened;
 }, []);
-const PATCH_UNSTAGED = "lint-staged_unstaged.patch";
+const PATCH_UNSTAGED = "unstaged.patch";
 const GIT_DIFF_ARGS = [
 	"--binary",
 	"--unified=0",
@@ -3298,7 +3471,27 @@ const GIT_APPLY_ARGS = [
 	"--recount",
 	"--unidiff-zero"
 ];
-const calculateSha256 = (input) => crypto.createHash("sha256").update(input, "utf-8").digest("hex");
+const DIFF_GIT_REGEXP = /^diff --git /m;
+/** Parse `git diff -z --raw --patch` output to map of filename --> diff */
+const parseGitDiffRawWithPatch = (diff) => {
+	if (!diff) return /* @__PURE__ */ new Map();
+	const [raw, patch] = diff.split("\0\0");
+	const files = parseGitZOutput(raw).filter((_, index) => index % 2 === 1);
+	const patches = patch.split(DIFF_GIT_REGEXP).slice(1);
+	const filenames = files.values();
+	const result = /* @__PURE__ */ new Map();
+	let previousHeader;
+	let filename;
+	for (const filePatch of patches) {
+		const header = filePatch.slice(0, filePatch.indexOf("\n"));
+		if (header !== previousHeader) {
+			filename = filenames.next().value;
+			previousHeader = header;
+		}
+		result.set(filename, (result.get(filename) ?? "") + filePatch);
+	}
+	return result;
+};
 const QUOTES_REGEXP = /^"(.*)"$/;
 /**
 * The lines are wrapped in double quotes
@@ -3310,7 +3503,7 @@ var GitWorkflow = class {
 	/**
 	* @param {Object} opts
 	*/
-	constructor({ allowEmpty, diff, diffFilter, failOnChanges, gitConfigDir, logger, matchedFiles, maxArgLength, topLevelDir }) {
+	constructor({ allowEmpty, diff, diffFilter, failOnChanges, gitConfigDir, logger, maxArgLength, topLevelDir }) {
 		this.execGit = (args, options = {}) => execGit(args, {
 			...options,
 			cwd: topLevelDir
@@ -3321,8 +3514,6 @@ var GitWorkflow = class {
 		this.gitConfigDir = gitConfigDir;
 		this.failOnChanges = !!failOnChanges;
 		this.logger = logger;
-		/** @type {Set<import('./getStagedFiles.js').StagedFile>} */
-		this.matchedFiles = matchedFiles;
 		this.maxArgLength = maxArgLength;
 		this.topLevelDir = topLevelDir;
 		/**
@@ -3334,41 +3525,34 @@ var GitWorkflow = class {
 		this.mergeMsgFilename = path.resolve(gitConfigDir, MERGE_MSG);
 	}
 	/**
-	* Get absolute path to file hidden inside .git
-	* @param {string} filename
-	*/
-	getHiddenFilepath(filename) {
-		return path.resolve(this.gitConfigDir, `./${filename}`);
-	}
-	/**
 	* Save meta information about ongoing git merge
 	*/
 	async backupMergeStatus() {
-		debugLog$8("Backing up merge state...");
+		debugLog$7("Backing up merge state...");
 		await Promise.all([
 			readFile$1(this.mergeHeadFilename).then((buffer) => this.mergeHeadBuffer = buffer),
 			readFile$1(this.mergeModeFilename).then((buffer) => this.mergeModeBuffer = buffer),
 			readFile$1(this.mergeMsgFilename).then((buffer) => this.mergeMsgBuffer = buffer)
 		]);
-		debugLog$8("Done backing up merge state!");
+		debugLog$7("Done backing up merge state!");
 	}
 	/**
 	* Restore meta information about ongoing git merge
 	*/
 	async restoreMergeStatus(ctx) {
-		debugLog$8("Restoring merge state...");
+		debugLog$7("Restoring merge state...");
 		try {
 			await Promise.all([
 				this.mergeHeadBuffer && writeFile(this.mergeHeadFilename, this.mergeHeadBuffer),
 				this.mergeModeBuffer && writeFile(this.mergeModeFilename, this.mergeModeBuffer),
 				this.mergeMsgBuffer && writeFile(this.mergeMsgFilename, this.mergeMsgBuffer)
 			]);
-			debugLog$8("Done restoring merge state!");
+			debugLog$7("Done restoring merge state!");
 		} catch (error) {
 			ctx.errors.add(GitError);
 			ctx.errors.add(RestoreMergeStatusError);
-			debugLog$8("Failed restoring merge state with error:");
-			debugLog$8(error);
+			debugLog$7("Failed restoring merge state with error:");
+			debugLog$7(error);
 			throw error;
 		}
 	}
@@ -3378,7 +3562,7 @@ var GitWorkflow = class {
 	* both the "from" and "to" filenames, where "from" is no longer on disk.
 	*/
 	async getUnstagedFiles({ onlyPartial = false } = {}) {
-		debugLog$8("Getting partially staged files...");
+		debugLog$7("Getting partially staged files...");
 		/**
 		* See https://git-scm.com/docs/git-status#_short_format
 		* Entries returned in machine format are separated by a NUL character.
@@ -3388,14 +3572,18 @@ var GitWorkflow = class {
 		* renamed file, the file names are separated by a NUL character
 		* (e.g. `to`\0`from`)
 		*/
-		const unstagedFiles = (await this.execGit(["status", "-z"])).split(GIT_STATUS_Z_REGEXP).filter((line) => {
+		const unstagedFiles = (await this.execGit([
+			"status",
+			"-z",
+			"--untracked-files=no"
+		])).split(GIT_STATUS_Z_REGEXP).filter((line) => {
 			const [index, workingTree] = line;
-			const updatedInIndex = index !== " " && index !== "?";
-			const updatedInWorkingTree = workingTree !== " " && workingTree !== "?";
+			const updatedInIndex = index !== " ";
+			const updatedInWorkingTree = workingTree !== " ";
 			if (onlyPartial) return updatedInIndex && updatedInWorkingTree;
 			return updatedInWorkingTree;
 		}).map((line) => line.slice(3)).filter(Boolean);
-		debugLog$8(`Found ${onlyPartial ? "partially staged" : "unstaged"} files:`, unstagedFiles);
+		debugLog$7(`Found ${onlyPartial ? "partially staged" : "unstaged"} files:`, unstagedFiles);
 		return unstagedFiles.length ? unstagedFiles : null;
 	}
 	/** Print stash list with commit hash and subject */
@@ -3413,6 +3601,7 @@ var GitWorkflow = class {
 	async prepare(ctx) {
 		this.logger.log(dim(`${wip()} ${ctx.shouldBackup ? "Backing up original state…" : "Preparing lint-staged…"}`));
 		try {
+			this.hiddenPath = path.join(this.gitConfigDir, `./lint-staged/${ctx.runId}`);
 			if (ctx.shouldBackup) await this.backupMergeStatus();
 			if (ctx.shouldHideUnstaged || ctx.shouldHideAll) {
 				this.unstagedFiles = await this.getUnstagedFiles({ onlyPartial: false });
@@ -3422,14 +3611,14 @@ var GitWorkflow = class {
 				ctx.hasFilesToHide = !!this.unstagedFiles;
 			}
 			if (this.unstagedFiles) {
-				const unstagedPatch = this.getHiddenFilepath(PATCH_UNSTAGED);
-				ctx.unstagedPatch = unstagedPatch;
+				await ensureDir(this.hiddenPath);
+				ctx.unstagedPatch = path.join(this.hiddenPath, PATCH_UNSTAGED);
 				const files = processRenames(this.unstagedFiles);
 				await this.execGit([
 					"diff",
 					...GIT_DIFF_ARGS,
 					"--output",
-					unstagedPatch,
+					ctx.unstagedPatch,
 					"--",
 					...files
 				]);
@@ -3462,18 +3651,18 @@ var GitWorkflow = class {
 						ctx.backupHash
 					]);
 				}
-				debugLog$8("Created backup stash with commit hash %s", ctx.backupHash);
+				debugLog$7("Created backup stash with commit hash %s", ctx.backupHash);
 			}
 			this.logger.log(`${done()} ${ctx.shouldBackup ? `Done backing up original state (${await this.execGit([
 				"rev-parse",
 				"--short",
 				ctx.backupHash
 			])})!` : "Done preparing lint-staged!"}`);
-		} catch (error$2) {
+		} catch (error$1) {
 			ctx.errors.add(GitError);
 			const errorMessage = ctx.shouldBackup ? "Failed to back up original state!" : "Failed to prepare lint-staged!";
 			this.logger.error(`${error()} ${errorMessage}`);
-			debugLog$8(error$2);
+			debugLog$7(error$1);
 		}
 	}
 	async hidePartiallyStagedChanges(ctx) {
@@ -3487,7 +3676,7 @@ var GitWorkflow = class {
 				...files
 			]);
 			this.logger.log(`${done()} Done hiding unstaged changes to partially staged files!`);
-		} catch (error$4) {
+		} catch (error$3) {
 			/**
 			* `git checkout --force` doesn't throw errors, so it shouldn't be possible to get here.
 			*/
@@ -3495,24 +3684,24 @@ var GitWorkflow = class {
 			ctx.errors.add(HideUnstagedChangesError);
 			const errorMessage = `${error()} Failed to hude unstaged changes to partially staged files!`;
 			this.logger.error(errorMessage);
-			debugLog$8(error$4);
+			debugLog$7(error$3);
 		}
 	}
 	async runTasks(ctx, tasks, { abortController, concurrent }) {
 		this.logger.log(dim(`${wip()} Running tasks for ${this.diff ? "changed" : "staged"} files…`));
-		if (ctx.shouldFailOnChanges) try {
-			debugLog$8("Calculating SHA-256 hash of unstaged changes because \"--fail-on-changes\" was used...");
-			const diff = await this.execGit([
+		try {
+			ctx.unstagedDiff = await this.execGit([
 				"diff",
-				"--patch",
-				"--unified=0"
-			]);
-			ctx.unstagedDiffSha256 = calculateSha256(diff);
-			debugLog$8("SHA-256 hash of unstaged changes is %s", ctx.unstagedDiffSha256);
+				...GIT_DIFF_ARGS,
+				"--raw",
+				"-z",
+				"--no-renames",
+				"--no-textconv"
+			], { trim: false });
 		} catch (error) {
 			ctx.errors.add(GitError);
-			this.logger.error("Failed to calculate SHA-256 hash of unstaged changes!");
-			debugLog$8(error);
+			this.logger.error("Failed to get diff of unstaged changes!");
+			debugLog$7(error);
 			return;
 		}
 		const failureMessage = `${error()} Failed to run tasks for ${this.diff ? "changed" : "staged"} files!`;
@@ -3526,80 +3715,81 @@ var GitWorkflow = class {
 		} catch (error) {
 			ctx.errors.add(TaskError);
 			this.logger.error(failureMessage);
-			debugLog$8(error);
+			debugLog$7(error);
 		}
 	}
 	/** Update Git index again for the originally staged files to stage task modifications. */
 	async updateIndex(ctx) {
 		this.logger.log(dim(`${wip()} Staging changes from tasks…`));
 		try {
-			if (ctx.shouldFailOnChanges) {
-				debugLog$8("Calculating SHA-256 hash of changes after tasks because \"--fail-on-changes\" was used...");
-				const diff = await this.execGit([
-					"diff",
-					"--patch",
-					"--unified=0"
-				]);
-				const diffSha256 = calculateSha256(diff);
-				debugLog$8("SHA-256 hash of changes after tasks is %s", diffSha256);
-				if (ctx.unstagedDiffSha256 !== diffSha256) {
-					ctx.errors.add(FailOnChangesError);
-					this.logger.error(`${error()} Tasks modified files and --fail-on-changes was used!`);
-					return;
-				}
+			const diff = await this.execGit([
+				"diff",
+				...GIT_DIFF_ARGS,
+				"--raw",
+				"-z",
+				"--no-renames",
+				"--no-textconv"
+			], { trim: false });
+			const before = parseGitDiffRawWithPatch(ctx.unstagedDiff);
+			const after = parseGitDiffRawWithPatch(diff);
+			/** @type {Set<string>} */
+			const addableFiles = /* @__PURE__ */ new Set();
+			for (const file of /* @__PURE__ */ new Set([...before.keys(), ...after.keys()])) if (before.get(file) !== after.get(file)) addableFiles.add(normalizePath(path.resolve(this.topLevelDir, file)));
+			if (ctx.shouldFailOnChanges && addableFiles.size > 0) {
+				ctx.errors.add(FailOnChangesError);
+				this.logger.error(`${error()} Tasks modified files and --fail-on-changes was used!`);
+				return;
 			}
-			const activeIndexFile = process.env.GIT_INDEX_FILE ? normalizePath(process.env.GIT_INDEX_FILE) : process.env.GIT_INDEX_FILE;
-			const addableFiles = (await Promise.allSettled(Array.from(this.matchedFiles, async (f) => {
-				if (f.status === "D") {
-					await fsPromises.access(f.filepath);
-					return f.filepath;
-				} else return f.filepath;
-			}))).flatMap((r) => r.status === "fulfilled" ? [r.value] : []);
-			const addCommands = await chunkFilesForCommand("git add --", addableFiles, this.maxArgLength);
-			/** Needs to be run serially because of locking Git operation */
-			for (const { files } of addCommands) {
-				debugLog$8("Updating active Git index: %s", activeIndexFile);
-				await this.execGit([
-					"add",
-					"--",
-					...files
-				]);
-				debugLog$8("Done updating Git index: %s", activeIndexFile);
-				if (activeIndexFile?.endsWith(".lock")) {
-					const defaultIndexLock = normalizePath(await this.execGit([
-						"rev-parse",
-						"--path-format=absolute",
-						"--git-path",
-						"index.lock"
-					]));
+			if (addableFiles.size > 0) {
+				const addCommands = await chunkFilesForCommand("git add --", [...addableFiles], this.maxArgLength);
+				const activeIndexFile = process.env.GIT_INDEX_FILE ? normalizePath(process.env.GIT_INDEX_FILE) : process.env.GIT_INDEX_FILE;
+				const defaultIndexLock = activeIndexFile?.endsWith(".lock") ? normalizePath(await this.execGit([
+					"rev-parse",
+					"--path-format=absolute",
+					"--git-path",
+					"index.lock"
+				])) : void 0;
+				/** Needs to be run serially because of locking Git operation */
+				for (const { files } of addCommands) {
+					debugLog$7("Updating active Git index: %s", activeIndexFile);
+					await this.execGit([
+						"add",
+						"--",
+						...files
+					]);
+					debugLog$7("Done updating Git index: %s", activeIndexFile);
 					/**
 					* If the active index file is a non-default lockfile, we are committing with a pathspec
 					* without having explicitly run `git add`. In this case we need to also update the
 					* default index, otherwise there will be leftover diff after committing
 					*/
-					if (activeIndexFile !== defaultIndexLock) {
-						debugLog$8("Updating default Git index again: %s", defaultIndexLock);
+					if (defaultIndexLock && activeIndexFile !== defaultIndexLock) {
+						debugLog$7("Updating default Git index again: %s", defaultIndexLock);
 						await this.execGit([
 							"add",
 							"--",
 							...files
 						], { env: { GIT_INDEX_FILE: defaultIndexLock } });
-						debugLog$8("Done updating default Git index lock: %s", defaultIndexLock);
+						debugLog$7("Done updating default Git index lock: %s", defaultIndexLock);
 					}
 				}
 			}
-			if (!await this.execGit([
-				...getDiffCommand(this.diff, this.diffFilter),
-				"--name-only",
-				"-z"
-			]) && !this.allowEmpty) {
-				ctx.errors.add(ApplyEmptyCommitError);
-				this.logger.error(`${error()} Prevented an empty git commit!`);
-			} else this.logger.log(`${done()} Done staging changes from tasks!`);
-		} catch (error$1) {
+			if (!this.allowEmpty) {
+				if (parseGitZOutput(await this.execGit([
+					...getDiffCommand(this.diff, this.diffFilter),
+					"--name-only",
+					"-z"
+				])).length === 0) {
+					ctx.errors.add(ApplyEmptyCommitError);
+					this.logger.error(`${error()} Prevented an empty git commit!`);
+					return;
+				}
+			}
+			this.logger.log(`${done()} Done staging changes from tasks!`);
+		} catch (error$4) {
 			ctx.errors.add(GitError);
 			this.logger.log(`${error()} Failed to stage changes from tasks!`);
-			debugLog$8(error$1);
+			debugLog$7(error$4);
 		}
 	}
 	/**
@@ -3609,17 +3799,18 @@ var GitWorkflow = class {
 	*/
 	async restoreUnstagedChanges(ctx) {
 		this.logger.log(dim(`${wip()} Restoring unstaged changes…`));
-		const unstagedPatch = this.getHiddenFilepath(PATCH_UNSTAGED);
+		const unstagedPatch = path.join(this.hiddenPath, PATCH_UNSTAGED);
 		try {
 			await this.execGit([
 				"apply",
 				...GIT_APPLY_ARGS,
 				unstagedPatch
 			]);
+			await removeDir(this.hiddenPath);
 		} catch (applyError) {
-			debugLog$8("Error while restoring changes:");
-			debugLog$8(applyError);
-			debugLog$8("Retrying with 3-way merge");
+			debugLog$7("Error while restoring changes:");
+			debugLog$7(applyError);
+			debugLog$7("Retrying with 3-way merge");
 			try {
 				await this.execGit([
 					"apply",
@@ -3627,11 +3818,12 @@ var GitWorkflow = class {
 					"--3way",
 					unstagedPatch
 				]);
+				await removeDir(this.hiddenPath);
 			} catch (threeWayApplyError) {
 				ctx.errors.add(GitError);
 				ctx.errors.add(RestoreUnstagedChangesError);
 				this.logger.error(`${error()} Failed to restore unstaged changes!`);
-				debugLog$8(threeWayApplyError);
+				debugLog$7(threeWayApplyError);
 			}
 		}
 	}
@@ -3647,7 +3839,7 @@ var GitWorkflow = class {
 				untrackedTree
 			]).then(parseGitZOutput);
 			if (untrackedFiles.length) {
-				debugLog$8("Found untracked files: %s", untrackedFiles);
+				debugLog$7("Found untracked files: %s", untrackedFiles);
 				await this.execGit([
 					"restore",
 					"--source",
@@ -3661,7 +3853,7 @@ var GitWorkflow = class {
 			ctx.errors.add(GitError);
 			ctx.errors.add(RestoreUnstagedChangesError);
 			this.logger.error(`${error()} Failed to restore untracked files!`);
-			debugLog$8(restoreUntrackedFilesError);
+			debugLog$7(restoreUntrackedFilesError);
 		}
 	}
 	/**
@@ -3670,7 +3862,7 @@ var GitWorkflow = class {
 	async restoreOriginalState(ctx) {
 		this.logger.log(dim(`${wip()} Reverting to original state because of errors…`));
 		try {
-			debugLog$8("Restoring original state...");
+			debugLog$7("Restoring original state...");
 			await this.execGit([
 				"reset",
 				"--hard",
@@ -3684,13 +3876,13 @@ var GitWorkflow = class {
 				ctx.backupHash
 			]);
 			await this.restoreMergeStatus(ctx);
-			await unlink(this.getHiddenFilepath(PATCH_UNSTAGED));
+			await removeDir(this.hiddenPath);
 			this.logger.log(`${done()} Done reverting to original state!`);
 		} catch (error$5) {
 			ctx.errors.add(GitError);
 			ctx.errors.add(RestoreOriginalStateError);
 			this.logger.error(`${error()} Failed to revert to original state!`);
-			debugLog$8(error$5);
+			debugLog$7(error$5);
 		}
 	}
 	/**
@@ -3709,66 +3901,83 @@ var GitWorkflow = class {
 				]);
 				this.logger.log(`${done()} Done cleaning up temporary files!`);
 			} else this.logger.error(`${error()} lint-staged automatic backup is missing!`);
-		} catch (error$3) {
+		} catch (error$2) {
 			ctx.errors.add(GitError);
 			this.logger.error(`${error()} Failed to clean up temporary files!`);
-			debugLog$8(error$3);
+			debugLog$7(error$2);
 		}
 	}
 };
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.5.1/node_modules/lint-staged/lib/groupFilesByConfig.js
-const debugLog$7 = createDebug("lint-staged:groupFilesByConfig");
+//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/groupFilesByConfig.js
+const debugLog$6 = createDebug("lint-staged:groupFilesByConfig");
 /**
 * @typedef {import('./getStagedFiles.js').StagedFile} StagedFile
-* @type {(args: { config: {[key: string]: { config: any; files: string[] }}; files: StagedFile[]; singleConfigMode?: boolean }) => Promise<{[key: string]: { config: any; files: StagedFile[] } }>
+* @typedef {import('./config.js').Configuration} Configuration
+* @typedef {Record<string, { config: Configuration; files: StagedFile[] }>} FilesByConfig
+*
+* @param {object} params
+* @param {Record<string, Configuration>} params.configs
+* @param {StagedFile[]} params.files
+* @param {boolean} [params.singleConfigMode]
+* @returns {Promise<FilesByConfig>}
 */
 const groupFilesByConfig = async ({ configs, files, singleConfigMode }) => {
-	debugLog$7("Grouping %d files by %d configurations", files.length, Object.keys(configs).length);
-	/** @type {Set<StagedFile>} */
-	const filesSet = new Set(files);
-	/** @type {{[key: string]: { config: any; files: StagedFile[] } }} */
+	debugLog$6("Grouping %d files by %d configurations", files.length, Object.keys(configs).length);
+	/** @type {FilesByConfig} */
 	const filesByConfig = {};
-	/** Configs are sorted deepest first by `searchConfigs` */
-	for (const [filepath, config] of Object.entries(configs)) {
-		/** When passed an explicit config object via the Node.js API‚ or an explicit path, skip logic */
-		if (singleConfigMode) {
+	const configEntries = Object.entries(configs);
+	if (singleConfigMode) {
+		const firstEntry = configEntries[0];
+		if (firstEntry) {
+			const [filepath, config] = firstEntry;
 			filesByConfig[filepath] = {
 				config,
 				files
 			};
-			break;
 		}
-		const dir = path.normalize(path.dirname(filepath));
-		/** Check if file is inside directory of the configuration file */
-		const isInsideDir = (file) => {
-			const relative = path.relative(dir, file.filepath);
-			return relative && !relative.startsWith("..") && !path.isAbsolute(relative);
-		};
-		/** This config should match all files since it has a parent glob */
-		const includeAllFiles = Object.keys(config).some((glob) => glob.startsWith(".."));
-		const scopedFiles = new Set(includeAllFiles ? filesSet : void 0);
-		/**
-		* Without a parent glob, if file is inside the config file's directory,
-		* assign it to that configuration.
-		*/
-		if (!includeAllFiles) filesSet.forEach((file) => {
-			if (isInsideDir(file)) scopedFiles.add(file);
-		});
-		/** Files should only match a single config */
-		scopedFiles.forEach((file) => {
-			filesSet.delete(file);
-		});
+		return filesByConfig;
+	}
+	/** @type {Map<string, number>} */
+	const configIndexByDirectory = /* @__PURE__ */ new Map();
+	let firstParentGlobConfigIndex = Infinity;
+	for (const [configIndex, [filepath, config]] of configEntries.entries()) {
 		filesByConfig[filepath] = {
 			config,
-			files: [...scopedFiles]
+			files: []
 		};
+		const directory = path.dirname(filepath);
+		if (!configIndexByDirectory.has(directory)) configIndexByDirectory.set(directory, configIndex);
+		if (firstParentGlobConfigIndex === Infinity && Object.keys(config).some((glob) => glob.startsWith(".."))) firstParentGlobConfigIndex = configIndex;
+	}
+	/** @type {Map<string, number>} */
+	const containingConfigIndexCache = /* @__PURE__ */ new Map();
+	/**
+	* @param {string} directory
+	* @returns {number}
+	*/
+	const findContainingConfigIndex = (directory) => {
+		const cachedIndex = containingConfigIndexCache.get(directory);
+		if (cachedIndex !== void 0) return cachedIndex;
+		let configIndex = configIndexByDirectory.get(directory) ?? Infinity;
+		const parentDirectory = path.dirname(directory);
+		if (parentDirectory !== directory) configIndex = Math.min(configIndex, findContainingConfigIndex(parentDirectory));
+		containingConfigIndexCache.set(directory, configIndex);
+		return configIndex;
+	};
+	for (const file of new Set(files)) {
+		const containingConfigIndex = findContainingConfigIndex(path.dirname(file.filepath));
+		const configIndex = Math.min(containingConfigIndex, firstParentGlobConfigIndex);
+		if (configIndex !== Infinity) {
+			const [configPath] = configEntries[configIndex];
+			filesByConfig[configPath].files.push(file);
+		}
 	}
 	return filesByConfig;
 };
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.5.1/node_modules/lint-staged/lib/resolveGitRepo.js
-const debugLog$6 = createDebug("lint-staged:resolveGitRepo");
+//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/resolveGitRepo.js
+const debugLog$5 = createDebug("lint-staged:resolveGitRepo");
 /**
 * Relative path up to the repo top-level directory
 * @example "../"
@@ -3796,10 +4005,10 @@ const ABSOLUTE_GIT_DIR = "--absolute-git-dir";
 /** Resolve git directory and possible submodule paths */
 const resolveGitRepo = async (cwd = process.cwd()) => {
 	try {
-		debugLog$6("Resolving git repo from `%s`", cwd);
-		debugLog$6("Unset GIT_DIR (was `%s`)", process.env.GIT_DIR);
+		debugLog$5("Resolving git repo from `%s`", cwd);
+		debugLog$5("Unset GIT_DIR (was `%s`)", process.env.GIT_DIR);
 		delete process.env.GIT_DIR;
-		debugLog$6("Unset GIT_WORK_TREE (was `%s`)", process.env.GIT_WORK_TREE);
+		debugLog$5("Unset GIT_WORK_TREE (was `%s`)", process.env.GIT_WORK_TREE);
 		delete process.env.GIT_WORK_TREE;
 		const [relativeTopLevelDir, topLevel, absoluteGitDir] = (await execGit([
 			"rev-parse",
@@ -3808,16 +4017,16 @@ const resolveGitRepo = async (cwd = process.cwd()) => {
 			ABSOLUTE_GIT_DIR
 		], { cwd })).split("\n");
 		const topLevelDir = normalizePath(path.join(cwd, relativeTopLevelDir));
-		debugLog$6("Resolved git repository top-level directory to be `%s`", topLevelDir);
+		debugLog$5("Resolved git repository top-level directory to be `%s`", topLevelDir);
 		const relativeGitConfigDir = path.relative(topLevel, absoluteGitDir);
 		const gitConfigDir = normalizePath(path.join(topLevelDir, relativeGitConfigDir));
-		debugLog$6("Resolved git config directory to be `%s`", gitConfigDir);
+		debugLog$5("Resolved git config directory to be `%s`", gitConfigDir);
 		return {
 			topLevelDir,
 			gitConfigDir
 		};
 	} catch (error) {
-		debugLog$6("Failed to resolve git repo with error:", error);
+		debugLog$5("Failed to resolve git repo with error:", error);
 		return {
 			error,
 			topLevelDir: null,
@@ -3826,7 +4035,7 @@ const resolveGitRepo = async (cwd = process.cwd()) => {
 	}
 };
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.5.1/node_modules/lint-staged/lib/configFiles.js
+//#region ../../node_modules/.pnpm/lint-staged@17.6.0/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"];
@@ -3855,7 +4064,7 @@ const CONFIG_FILE_NAMES = [
 	"lint-staged.config.cts"
 ];
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.5.1/node_modules/lint-staged/lib/resolveConfig.js
+//#region ../../node_modules/.pnpm/lint-staged@17.6.0/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
@@ -3869,9 +4078,9 @@ function resolveConfig(configPath) {
 	}
 }
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.5.1/node_modules/lint-staged/lib/loadConfig.js
+//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/loadConfig.js
 /** @typedef {import('./index').Logger} Logger */
-const debugLog$5 = createDebug("lint-staged:loadConfig");
+const debugLog$4 = createDebug("lint-staged:loadConfig");
 const readFile = async (filename) => fsPromises.readFile(path.resolve(filename), "utf-8");
 const jsonParse = async (filename) => {
 	const isPackageFile = PACKAGE_JSON_FILE.includes(path.basename(filename));
@@ -3881,7 +4090,7 @@ const jsonParse = async (filename) => {
 		return isPackageFile ? json[CONFIG_NAME] : json;
 	} catch (error) {
 		if (path.basename(filename) === "package.json") {
-			debugLog$5("Ignoring invalid JSON file %s", filename);
+			debugLog$4("Ignoring invalid JSON file %s", filename);
 			return;
 		}
 		throw error;
@@ -3890,12 +4099,12 @@ const jsonParse = async (filename) => {
 const yamlParse = async (filename) => {
 	const isPackageFile = PACKAGE_YAML_FILES.includes(path.basename(filename));
 	try {
-		const [YAML, content] = await Promise.all([import("../dist-BsAzy8OW.js").then((m) => /* @__PURE__ */ __toESM(m.default, 1)), readFile(filename)]);
+		const [YAML, content] = await Promise.all([import("../dist-CBWGibx8.js").then((m) => /* @__PURE__ */ __toESM(m.default, 1)), readFile(filename)]);
 		const yaml = YAML.parse(content);
 		return isPackageFile ? yaml[CONFIG_NAME] : yaml;
 	} catch (error) {
 		if (isPackageFile) {
-			debugLog$5("Ignoring invalid YAML file %s", filename);
+			debugLog$4("Ignoring invalid YAML file %s", filename);
 			return;
 		}
 		throw error;
@@ -3933,175 +4142,24 @@ const loadConfigByExt = async (filename) => {
 /** @param {string} configPath */
 const loadConfig = async (configPath, logger) => {
 	try {
-		debugLog$5("Loading configuration from `%s`...", configPath);
+		debugLog$4("Loading configuration from `%s`...", configPath);
 		const result = await loadConfigByExt(resolveConfig(configPath));
 		const config = await result.config ?? null;
 		const filepath = result.filepath;
-		if (config) debugLog$5("Successfully loaded config from `%s`:\n%O", filepath, config);
-		else debugLog$5("Found no config in %s", filepath);
+		if (config) debugLog$4("Successfully loaded config from `%s`:\n%O", filepath, config);
+		else debugLog$4("Found no config in %s", filepath);
 		return {
 			config,
 			filepath
 		};
 	} catch (error) {
-		debugLog$5("Failed to load configuration from `%s` with error:\n", configPath, error);
+		debugLog$4("Failed to load configuration from `%s` with error:\n", configPath, error);
 		logger.error(failedToLoadConfig(configPath));
 		return {};
 	}
 };
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.5.1/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.
-* Any incorrectly formed brace expansion is left unchanged.
-*
-* @see https://www.gnu.org/software/bash/manual/html_node/Brace-Expansion.html
-*
-* Lint-staged uses `micromatch` for brace expansion, and its behavior is to treat
-* invalid brace expansions as literal strings, which means they (typically) do not match
-* anything.
-*
-* This RegExp tries to match most cases of invalid brace expansions, so that they can be
-* detected, warned about, and re-formatted by removing the braces and thus hopefully
-* matching the files as intended by the user. The only real fix is to remove the incorrect
-* braces from user configuration, but this is left to the user (after seeing the warning).
-*
-* @example <caption>Globs with brace expansions</caption>
-* - *.{js,tx}        // expanded as *.js, *.ts
-* - *.{{j,t}s,css}   // expanded as *.js, *.ts, *.css
-* - file_{1..10}.css  // expanded as file_1.css, file_2.css, …, file_10.css
-*
-* @example <caption>Globs with incorrect brace expansions</caption>
-* - *.{js}       // should just be *.js
-* - *.{js,{ts}}  // should just be *.{js,ts}
-* - *.\{js\}     // escaped braces, so they're treated literally
-* - *.${js}      // dollar-sign inhibits expansion, so treated literally
-* - *.{js\,ts}   // the comma is escaped, so treated literally
-*/
-const getIncorrectBracesRegexp = () => /(?<![\\$])({)(?:(?!(?<!\\),|\.\.|\{|\}).)*?(?<!\\)(})/g;
-const BRACE_OPEN_REGEXP = /{/;
-const BRACE_CLOSE_REGEXP = /}/;
-/**
-* @param {string} pattern
-* @returns {string}
-*/
-const stripIncorrectBraces = (pattern) => {
-	let output = `${pattern}`;
-	const regexp = getIncorrectBracesRegexp();
-	let match = regexp.exec(output);
-	while (match) {
-		const fullMatch = match[0];
-		const withoutBraces = fullMatch.replace(BRACE_OPEN_REGEXP, "").replace(BRACE_CLOSE_REGEXP, "");
-		output = output.replace(fullMatch, withoutBraces);
-		regexp.lastIndex = 0;
-		match = regexp.exec(output);
-	}
-	return output;
-};
-/**
-* This RegExp matches "duplicate" opening and closing braces, without any other braces
-* in between, where the duplication is redundant and should be removed.
-*
-* @example *.{{js,ts}}  // should just be *.{js,ts}
-*/
-const DOUBLE_BRACES_REGEXP = /{{[^}{]*}}/;
-/**
-* @param {string} pattern
-* @returns {string}
-*/
-const stripDoubleBraces = (pattern) => {
-	let output = `${pattern}`;
-	const match = DOUBLE_BRACES_REGEXP.exec(pattern)?.[0];
-	if (match) {
-		const withoutBraces = match.replace("{{", "{").replace("}}", "}");
-		output = output.replace(match, withoutBraces);
-	}
-	return output;
-};
-/**
-* Validate and remove incorrect brace expansions from glob pattern.
-* For example `*.{js}` is incorrect because it doesn't contain a `,` or `..`,
-* and will be reformatted as `*.js`.
-*
-* @param {string} pattern the glob pattern
-* @param {*} logger
-* @returns {string}
-*/
-const validateBraces = (pattern, logger) => {
-	const fixedPattern = stripDoubleBraces(stripIncorrectBraces(pattern));
-	if (fixedPattern !== pattern) logger.warn(incorrectBraces(pattern, fixedPattern));
-	return fixedPattern;
-};
-//#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.5.1/node_modules/lint-staged/lib/validateConfig.js
-/** @typedef {import('./index').Logger} Logger */
-const debugLog$4 = createDebug("lint-staged:validateConfig");
-const isTask = (task) => typeof task === "string" || typeof task === "function";
-const isSequentialTasks = (tasks) => tasks.every((task) => {
-	if (Array.isArray(task)) return task.every(isTask);
-	else return isTask(task);
-});
-const validateConfigLogic = (config, configPath, logger) => {
-	debugLog$4("Validating config from `%s`...", configPath);
-	if (!config || typeof config !== "object" && typeof config !== "function") throw ConfigFormatError;
-	/**
-	* Function configurations receive all staged files as their argument.
-	* They are not further validated here to make sure the function gets
-	* evaluated only once.
-	*
-	* @see getSpawnedTasks
-	*/
-	if (typeof config === "function") return { "*": config };
-	if (Object.entries(config).length === 0) throw ConfigEmptyError;
-	const errors = [];
-	/**
-	* Create a new validated config because the keys (patterns) might change.
-	* Since the Object.reduce method already loops through each entry in the config,
-	* it can be used for validating the values at the same time.
-	*/
-	const validatedConfig = Object.entries(config).reduce((collection, [pattern, task]) => {
-		if (Array.isArray(task)) {
-			if (!isSequentialTasks(task)) errors.push(configurationError(pattern, "Should be an array of strings or functions, or single-level nested array or strings of functions.", task));
-		} else if (typeof task === "object") {
-			/** Invalid function task */
-			if (typeof task.title !== "string" || typeof task.task !== "function") errors.push(configurationError(pattern, "Function task should contain `title` and `task` fields, where `title` should be a string and `task` should be a function.", task));
-		} else if (typeof task !== "string" && typeof task !== "function")
- /** Singular invalid value */
-		errors.push(configurationError(pattern, "Should be a string, a function, an object or an array of strings and functions.", task));
-		/**
-		* A typical configuration error is using invalid brace expansion, like `*.{js}`.
-		* These are automatically fixed and warned about.
-		*/
-		const fixedPattern = validateBraces(pattern, logger);
-		return Object.assign(collection, { [fixedPattern]: task });
-	}, {});
-	if (errors.length) {
-		const message = errors.join("\n\n");
-		logger.error(failedToParseConfig(configPath, message));
-		throw new Error(message);
-	}
-	debugLog$4("Validated config from `%s`:", configPath);
-	debugLog$4(inspect(config, { compact: false }));
-	return validatedConfig;
-};
-/**
-* Runs config validation. Throws error if the config is not valid.
-* @param {Object} config
-* @param {string} configPath
-* @param {Logger} logger
-* @returns {Object} config
-*/
-const validateConfig = (config, configPath, logger) => {
-	try {
-		return validateConfigLogic(config, configPath, logger);
-	} catch (error) {
-		logger.error(failedToParseConfig(configPath, error));
-		throw error;
-	}
-};
-//#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.5.1/node_modules/lint-staged/lib/searchConfigs.js
+//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/searchConfigs.js
 const debugLog$3 = createDebug("lint-staged:searchConfigs");
 const CONFIG_PATHSPEC = CONFIG_FILE_NAMES.map((f) => `:(glob)**/${f}`);
 const numberOfLevels = (file) => file.split("/").length;
@@ -4173,7 +4231,7 @@ const listConfigFilesFromFs = async ({ cwd }) => {
 * @param {string} [options.topLevelDir] - Top-level directory of the git repo
 * @param {import('./index').Logger} logger
 *
-* @returns {Promise<{ [key: string]: { config: *, files: string[] } }>} found configs with filepath as key, and config as value
+* @returns {Promise<Record<string, import('./config.js').Configuration>>} found configs with filepath as key, and config as value
 */
 const searchConfigs = async ({ configObject, configPath, cwd = process.cwd(), topLevelDir = cwd }, logger) => {
 	debugLog$3("Searching for configuration files...");
@@ -4215,7 +4273,7 @@ const searchConfigs = async ({ configObject, configPath, cwd = process.cwd(), to
 	return foundConfigs;
 };
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.5.1/node_modules/lint-staged/lib/runAll.js
+//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/runAll.js
 /** @typedef {import('./index').Logger} Logger */
 const debugLog$2 = createDebug("lint-staged:runAll");
 /**
@@ -4331,8 +4389,6 @@ const runAll = async ({ all, allowEmpty, concurrent, configObject, configPath, c
 	const hasMultipleConfigs = numberOfConfigs > 1;
 	let hasDeprecatedGitAdd = false;
 	const tasks = [];
-	/** @type {Set<import('./getStagedFiles.js').StagedFile>} */
-	const matchedFiles = /* @__PURE__ */ new Set();
 	const abortController = getAbortController();
 	for (const [groupConfigPath, { config, files }] of Object.entries(filesByConfig)) {
 		const configName = groupConfigPath ? normalizePath(path.relative(cwd, groupConfigPath)) : "Config object";
@@ -4346,7 +4402,8 @@ const runAll = async ({ all, allowEmpty, concurrent, configObject, configPath, c
 			abortController,
 			command: task.commands,
 			continueOnError,
-			files: task.fileList
+			files: task.fileList,
+			verbose
 		}) : getSpawnedTasks({
 			abortController,
 			commands: task.commands,
@@ -4357,13 +4414,6 @@ const runAll = async ({ all, allowEmpty, concurrent, configObject, configPath, c
 			topLevelDir,
 			verbose
 		})).then((subTasks) => {
-			task.fileList.forEach((file) => {
-				const normalizedFile = path.isAbsolute(file.filepath) ? file : {
-					filepath: normalizePath(path.join(groupCwd, file.filepath)),
-					status: file.status
-				};
-				matchedFiles.add(normalizedFile);
-			});
 			const includesGitAdd = (subTask) => subTask.title.includes("git add");
 			hasDeprecatedGitAdd = hasDeprecatedGitAdd || subTasks.some((subTask) => Array.isArray(subTask) ? subTask.some(includesGitAdd) : includesGitAdd(subTask));
 			const fileCount = task.fileList.length;
@@ -4397,7 +4447,6 @@ const runAll = async ({ all, allowEmpty, concurrent, configObject, configPath, c
 		failOnChanges,
 		gitConfigDir,
 		logger: thisLogger,
-		matchedFiles,
 		maxArgLength,
 		topLevelDir
 	});
@@ -4430,7 +4479,7 @@ const runAll = async ({ all, allowEmpty, concurrent, configObject, configPath, c
 	return ctx;
 };
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.5.1/node_modules/lint-staged/lib/validateOptions.js
+//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/validateOptions.js
 const debugLog$1 = createDebug("lint-staged:validateOptions");
 /** @type {(value: number) => boolean} */
 const isValidIntegerValue = (value) => Number.isInteger(value) || value === Infinity;
@@ -4463,10 +4512,10 @@ const validateOptions = async (options = {}, logger) => {
 	debugLog$1("Validated options: %o", options);
 };
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.5.1/node_modules/lint-staged/lib/version.js
-const getVersion = async () => "17.5.1";
+//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/version.js
+const getVersion = async () => "17.6.0";
 //#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.5.1/node_modules/lint-staged/lib/index.js
+//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/index.js
 const debugLog = createDebug("lint-staged");
 /**
 * @typedef {(...any) => void} LogFunction