vite-plus 1.2.0 → 1.4.0

package/dist/staged/bin.js

@@ -1,21 +1,22 @@
-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-x47JetlI.js";
-import { t as unwrapCliParseOutcome } from "../cli-parse-DHE8NrBU.js";
+import { r as __toESM } from "../rolldown-runtime-DegdyBIC.js";
+import { i as log, n as errorMsg, o as printHeader } from "../terminal-BcuPUy-j.js";
+import { a as resolveViteConfig } from "../resolve-vite-config-Dn5896A4.js";
+import { t as require_picomatch } from "../picomatch-DEUoj81q.js";
+import { t as unwrapCliParseOutcome } from "../cli-parse-aeUeFDlC.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, { format, formatWithOptions, inspect, promisify } from "node:util";
+import util, { format, formatWithOptions, inspect, promisify, stripVTControlCharacters } from "node:util";
 import { closeSync, constants, openSync, readSync, statSync } from "node:fs";
 import { cwd } from "node:process";
 import l__default from "node:readline";
 import crypto from "node:crypto";
-import fsPromises, { constants as constants$1 } from "node:fs/promises";
-import { PassThrough } from "node:stream";
 import { exec, spawn } from "node:child_process";
+import fsPromises, { constants as constants$1 } from "node:fs/promises";
 import { pipeline } from "node:stream/promises";
-//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/assertGitVersion.js
+import { PassThrough } from "node:stream";
+// ../../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;
@@ -60,8 +61,7 @@ const assertGitVersion = (gitVersionOutput) => {
 		return false;
 	}
 };
-//#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/colors.js
+// ../../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";
@@ -80,8 +80,7 @@ const yellow = styleText$1("yellow");
 const blue = styleText$1("blue");
 const dim = styleText$1("dim");
 const bold = styleText$1("bold");
-//#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/debug.js
+// ../../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) => {
@@ -98,8 +97,7 @@ const createDebug = (name) => {
 		activeLogger.debug(dim(name + ": ") + format$1(...args) + dim(` +${ms}ms`));
 	};
 };
-//#endregion
-//#region ../../node_modules/.pnpm/tinyexec@1.3.1/node_modules/tinyexec/dist/main.mjs
+// ../../node_modules/.pnpm/tinyexec@1.3.1/node_modules/tinyexec/dist/main.mjs
 const isPathLikePattern = /^path$/i;
 const defaultEnvPathInfo = {
 	key: "PATH",
@@ -439,8 +437,7 @@ const x = (command, args, userOptions) => {
 	return proc;
 };
 const exec$1 = x;
-//#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/execGit.js
+// ../../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.
@@ -463,8 +460,7 @@ const execGit = async (cmd, options) => {
 	if (options?.trim === false) return result.stdout;
 	return result.stdout.trimEnd();
 };
-//#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/figures.js
+// ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/figures.js
 const wip = () => blue("⋯");
 const done = () => green("✔");
 const info = () => blue("→");
@@ -474,8 +470,7 @@ const cancelled = () => dim("↓");
 const parallelGroupStart = () => dim("┌");
 const parallelGroupMiddle = () => dim("│");
 const parallelGroupStop = () => dim("└");
-//#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/messages.js
+// ../../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))}
@@ -529,8 +524,7 @@ const unstagedChangesBackupStashLocation = () => "Unstaged changes have been kep
 const minGitVersionRequired = (expected) => red(`${error()} lint-staged requires at least Git version ${bold(expected)}.
 
 Please update Git: https://git-scm.com/downloads`);
-//#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/getMaxArgLength.js
+// ../../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
 *
@@ -545,8 +539,7 @@ const getMaxArgLength = (platform = process.platform) => {
 		default: return 131072;
 	}
 };
-//#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/parseOptions.js
+// ../../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 } = {}) => {
@@ -600,8 +593,7 @@ const parseOptions = ({ all, allowEmpty, color, concurrent, config: configObject
 	debugLog$16("Parsed options: %o", options);
 	return options;
 };
-//#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/printTaskOutput.js
+// ../../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
@@ -612,1926 +604,8 @@ const printTaskOutput = (ctx = {}, logger) => {
 	const log = ctx.errors?.size > 0 ? logger.error : logger.log;
 	for (const line of ctx.output) log(line);
 };
-//#endregion
-//#region ../../node_modules/.pnpm/picomatch@4.0.7/node_modules/picomatch/lib/constants.js
-var require_constants = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	const WIN_SLASH = "\\\\/";
-	const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
-	const DEFAULT_MAX_EXTGLOB_RECURSION = 0;
-	/**
-	* Posix glob regex
-	*/
-	const DOT_LITERAL = "\\.";
-	const PLUS_LITERAL = "\\+";
-	const QMARK_LITERAL = "\\?";
-	const SLASH_LITERAL = "\\/";
-	const ONE_CHAR = "(?=.)";
-	const QMARK = "[^/]";
-	const END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
-	const START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
-	const DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
-	const POSIX_CHARS = {
-		DOT_LITERAL,
-		PLUS_LITERAL,
-		QMARK_LITERAL,
-		SLASH_LITERAL,
-		ONE_CHAR,
-		QMARK,
-		END_ANCHOR,
-		DOTS_SLASH,
-		NO_DOT: `(?!${DOT_LITERAL})`,
-		NO_DOTS: `(?!${START_ANCHOR}${DOTS_SLASH})`,
-		NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`,
-		NO_DOTS_SLASH: `(?!${DOTS_SLASH})`,
-		QMARK_NO_DOT: `[^.${SLASH_LITERAL}]`,
-		STAR: `${QMARK}*?`,
-		START_ANCHOR,
-		SEP: "/"
-	};
-	/**
-	* Windows glob regex
-	*/
-	const WINDOWS_CHARS = {
-		...POSIX_CHARS,
-		SLASH_LITERAL: `[${WIN_SLASH}]`,
-		QMARK: WIN_NO_SLASH,
-		STAR: `${WIN_NO_SLASH}*?`,
-		DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,
-		NO_DOT: `(?!${DOT_LITERAL})`,
-		NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
-		NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,
-		NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
-		QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
-		START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
-		END_ANCHOR: `(?:[${WIN_SLASH}]|$)`,
-		SEP: "\\"
-	};
-	module.exports = {
-		DEFAULT_MAX_EXTGLOB_RECURSION,
-		MAX_LENGTH: 65536,
-		POSIX_REGEX_SOURCE: {
-			__proto__: null,
-			alnum: "a-zA-Z0-9",
-			alpha: "a-zA-Z",
-			ascii: "\\x00-\\x7F",
-			blank: " \\t",
-			cntrl: "\\x00-\\x1F\\x7F",
-			digit: "0-9",
-			graph: "\\x21-\\x7E",
-			lower: "a-z",
-			print: "\\x20-\\x7E ",
-			punct: "\\-!\"#$%&'()\\*+,./:;<=>?@[\\]^_`{|}~",
-			space: " \\t\\r\\n\\v\\f",
-			upper: "A-Z",
-			word: "A-Za-z0-9_",
-			xdigit: "A-Fa-f0-9"
-		},
-		REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
-		REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
-		REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
-		REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
-		REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
-		REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
-		REPLACEMENTS: {
-			__proto__: null,
-			"***": "*",
-			"**/**": "**",
-			"**/**/**": "**"
-		},
-		CHAR_0: 48,
-		CHAR_9: 57,
-		CHAR_UPPERCASE_A: 65,
-		CHAR_LOWERCASE_A: 97,
-		CHAR_UPPERCASE_Z: 90,
-		CHAR_LOWERCASE_Z: 122,
-		CHAR_LEFT_PARENTHESES: 40,
-		CHAR_RIGHT_PARENTHESES: 41,
-		CHAR_ASTERISK: 42,
-		CHAR_AMPERSAND: 38,
-		CHAR_AT: 64,
-		CHAR_BACKWARD_SLASH: 92,
-		CHAR_CARRIAGE_RETURN: 13,
-		CHAR_CIRCUMFLEX_ACCENT: 94,
-		CHAR_COLON: 58,
-		CHAR_COMMA: 44,
-		CHAR_DOT: 46,
-		CHAR_DOUBLE_QUOTE: 34,
-		CHAR_EQUAL: 61,
-		CHAR_EXCLAMATION_MARK: 33,
-		CHAR_FORM_FEED: 12,
-		CHAR_FORWARD_SLASH: 47,
-		CHAR_GRAVE_ACCENT: 96,
-		CHAR_HASH: 35,
-		CHAR_HYPHEN_MINUS: 45,
-		CHAR_LEFT_ANGLE_BRACKET: 60,
-		CHAR_LEFT_CURLY_BRACE: 123,
-		CHAR_LEFT_SQUARE_BRACKET: 91,
-		CHAR_LINE_FEED: 10,
-		CHAR_NO_BREAK_SPACE: 160,
-		CHAR_PERCENT: 37,
-		CHAR_PLUS: 43,
-		CHAR_QUESTION_MARK: 63,
-		CHAR_RIGHT_ANGLE_BRACKET: 62,
-		CHAR_RIGHT_CURLY_BRACE: 125,
-		CHAR_RIGHT_SQUARE_BRACKET: 93,
-		CHAR_SEMICOLON: 59,
-		CHAR_SINGLE_QUOTE: 39,
-		CHAR_SPACE: 32,
-		CHAR_TAB: 9,
-		CHAR_UNDERSCORE: 95,
-		CHAR_VERTICAL_LINE: 124,
-		CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
-		/**
-		* Create EXTGLOB_CHARS
-		*/
-		extglobChars(chars) {
-			return {
-				"!": {
-					type: "negate",
-					open: "(?:(?!(?:",
-					close: `))${chars.STAR})`
-				},
-				"?": {
-					type: "qmark",
-					open: "(?:",
-					close: ")?"
-				},
-				"+": {
-					type: "plus",
-					open: "(?:",
-					close: ")+"
-				},
-				"*": {
-					type: "star",
-					open: "(?:",
-					close: ")*"
-				},
-				"@": {
-					type: "at",
-					open: "(?:",
-					close: ")"
-				}
-			};
-		},
-		/**
-		* Create GLOB_CHARS
-		*/
-		globChars(win32) {
-			return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;
-		}
-	};
-}));
-//#endregion
-//#region ../../node_modules/.pnpm/picomatch@4.0.7/node_modules/picomatch/lib/utils.js
-var require_utils = /* @__PURE__ */ __commonJSMin(((exports) => {
-	const { REGEX_BACKSLASH, REGEX_REMOVE_BACKSLASH, REGEX_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_GLOBAL } = require_constants();
-	exports.isObject = (val) => val !== null && typeof val === "object" && !Array.isArray(val);
-	exports.hasRegexChars = (str) => REGEX_SPECIAL_CHARS.test(str);
-	exports.isRegexChar = (str) => str.length === 1 && exports.hasRegexChars(str);
-	exports.escapeRegex = (str) => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, "\\$1");
-	exports.toPosixSlashes = (str) => str.replace(REGEX_BACKSLASH, "/");
-	exports.isWindows = () => {
-		if (typeof navigator !== "undefined" && navigator.platform) {
-			const platform = navigator.platform.toLowerCase();
-			return platform === "win32" || platform === "windows";
-		}
-		if (typeof process !== "undefined" && process.platform) return process.platform === "win32";
-		return false;
-	};
-	exports.removeBackslashes = (str) => {
-		return str.replace(REGEX_REMOVE_BACKSLASH, (match) => {
-			return match === "\\" ? "" : match;
-		});
-	};
-	exports.escapeLast = (input, char, lastIdx) => {
-		const idx = input.lastIndexOf(char, lastIdx);
-		if (idx === -1) return input;
-		if (input[idx - 1] === "\\") return exports.escapeLast(input, char, idx - 1);
-		return `${input.slice(0, idx)}\\${input.slice(idx)}`;
-	};
-	exports.removePrefix = (input, state = {}) => {
-		let output = input;
-		if (output.startsWith("./")) {
-			output = output.slice(2);
-			state.prefix = "./";
-		}
-		return output;
-	};
-	exports.wrapOutput = (input, state = {}, options = {}) => {
-		let output = `${options.contains ? "" : "^"}(?:${input})${options.contains ? "" : "$"}`;
-		if (state.negated === true) output = `(?:^(?!${output}).*$)`;
-		return output;
-	};
-	exports.basename = (path, { windows } = {}) => {
-		const segs = path.split(windows ? /[\\/]/ : "/");
-		const last = segs[segs.length - 1];
-		if (last === "") return segs[segs.length - 2];
-		return last;
-	};
-}));
-//#endregion
-//#region ../../node_modules/.pnpm/picomatch@4.0.7/node_modules/picomatch/lib/scan.js
-var require_scan = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	const utils = require_utils();
-	const { CHAR_ASTERISK, CHAR_AT, CHAR_BACKWARD_SLASH, CHAR_COMMA, CHAR_DOT, CHAR_EXCLAMATION_MARK, CHAR_FORWARD_SLASH, CHAR_LEFT_CURLY_BRACE, CHAR_LEFT_PARENTHESES, CHAR_LEFT_SQUARE_BRACKET, CHAR_PLUS, CHAR_QUESTION_MARK, CHAR_RIGHT_CURLY_BRACE, CHAR_RIGHT_PARENTHESES, CHAR_RIGHT_SQUARE_BRACKET } = require_constants();
-	const isPathSeparator = (code) => {
-		return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
-	};
-	const depth = (token) => {
-		if (token.isPrefix !== true) token.depth = token.isGlobstar ? Infinity : 1;
-	};
-	/**
-	* Quickly scans a glob pattern and returns an object with a handful of
-	* useful properties, like `isGlob`, `path` (the leading non-glob, if it exists),
-	* `glob` (the actual pattern), `negated` (true if the path starts with `!` but not
-	* with `!(`) and `negatedExtglob` (true if the path starts with `!(`).
-	*
-	* ```js
-	* const pm = require('picomatch');
-	* console.log(pm.scan('foo/bar/*.js'));
-	* { isGlob: true, input: 'foo/bar/*.js', base: 'foo/bar', glob: '*.js' }
-	* ```
-	* @param {String} `str`
-	* @param {Object} `options`
-	* @return {Object} Returns an object with tokens and regex source string.
-	* @api public
-	*/
-	const scan = (input, options) => {
-		const opts = options || {};
-		const length = input.length - 1;
-		const scanToEnd = opts.parts === true || opts.tokens === true || opts.scanToEnd === true;
-		const slashes = [];
-		const tokens = [];
-		const parts = [];
-		let str = input;
-		let index = -1;
-		let start = 0;
-		let lastIndex = 0;
-		let isBrace = false;
-		let isBracket = false;
-		let isGlob = false;
-		let isExtglob = false;
-		let isGlobstar = false;
-		let braceEscaped = false;
-		let backslashes = false;
-		let negated = false;
-		let negatedExtglob = false;
-		let finished = false;
-		let braces = 0;
-		let prev;
-		let code;
-		let token = {
-			value: "",
-			depth: 0,
-			isGlob: false
-		};
-		const eos = () => index >= length;
-		const peek = () => str.charCodeAt(index + 1);
-		const advance = () => {
-			prev = code;
-			return str.charCodeAt(++index);
-		};
-		while (index < length) {
-			code = advance();
-			let next;
-			if (code === CHAR_BACKWARD_SLASH) {
-				backslashes = token.backslashes = true;
-				code = advance();
-				if (code === CHAR_LEFT_CURLY_BRACE) braceEscaped = true;
-				continue;
-			}
-			if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE) {
-				braces++;
-				while (eos() !== true && (code = advance())) {
-					if (code === CHAR_BACKWARD_SLASH) {
-						backslashes = token.backslashes = true;
-						advance();
-						continue;
-					}
-					if (code === CHAR_LEFT_CURLY_BRACE) {
-						braces++;
-						continue;
-					}
-					if (braceEscaped !== true && code === CHAR_DOT && (code = advance()) === CHAR_DOT) {
-						isBrace = token.isBrace = true;
-						isGlob = token.isGlob = true;
-						finished = true;
-						if (scanToEnd === true) continue;
-						break;
-					}
-					if (braceEscaped !== true && code === CHAR_COMMA) {
-						isBrace = token.isBrace = true;
-						isGlob = token.isGlob = true;
-						finished = true;
-						if (scanToEnd === true) continue;
-						break;
-					}
-					if (code === CHAR_RIGHT_CURLY_BRACE) {
-						braces--;
-						if (braces === 0) {
-							braceEscaped = false;
-							isBrace = token.isBrace = true;
-							finished = true;
-							break;
-						}
-					}
-				}
-				if (scanToEnd === true) continue;
-				break;
-			}
-			if (code === CHAR_FORWARD_SLASH) {
-				slashes.push(index);
-				tokens.push(token);
-				token = {
-					value: "",
-					depth: 0,
-					isGlob: false
-				};
-				if (finished === true) continue;
-				if (prev === CHAR_DOT && index === start + 1) {
-					start += 2;
-					continue;
-				}
-				lastIndex = index + 1;
-				continue;
-			}
-			if (opts.noext !== true) {
-				if ((code === CHAR_PLUS || code === CHAR_AT || code === CHAR_ASTERISK || code === CHAR_QUESTION_MARK || code === CHAR_EXCLAMATION_MARK) === true && peek() === CHAR_LEFT_PARENTHESES) {
-					isGlob = token.isGlob = true;
-					isExtglob = token.isExtglob = true;
-					finished = true;
-					if (code === CHAR_EXCLAMATION_MARK && index === start) negatedExtglob = true;
-					if (scanToEnd === true) {
-						let parens = 0;
-						while (eos() !== true && (code = advance())) {
-							if (code === CHAR_BACKWARD_SLASH) {
-								backslashes = token.backslashes = true;
-								advance();
-								continue;
-							}
-							if (code === CHAR_LEFT_PARENTHESES) {
-								parens++;
-								continue;
-							}
-							if (code === CHAR_RIGHT_PARENTHESES && --parens === 0) {
-								finished = true;
-								break;
-							}
-						}
-						continue;
-					}
-					break;
-				}
-			}
-			if (code === CHAR_ASTERISK) {
-				if (prev === CHAR_ASTERISK) isGlobstar = token.isGlobstar = true;
-				isGlob = token.isGlob = true;
-				finished = true;
-				if (scanToEnd === true) continue;
-				break;
-			}
-			if (code === CHAR_QUESTION_MARK) {
-				isGlob = token.isGlob = true;
-				finished = true;
-				if (scanToEnd === true) continue;
-				break;
-			}
-			if (code === CHAR_LEFT_SQUARE_BRACKET) {
-				while (eos() !== true && (next = advance())) {
-					if (next === CHAR_BACKWARD_SLASH) {
-						backslashes = token.backslashes = true;
-						advance();
-						continue;
-					}
-					if (next === CHAR_RIGHT_SQUARE_BRACKET) {
-						isBracket = token.isBracket = true;
-						isGlob = token.isGlob = true;
-						finished = true;
-						break;
-					}
-				}
-				if (scanToEnd === true) continue;
-				break;
-			}
-			if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) {
-				negated = token.negated = true;
-				start++;
-				continue;
-			}
-			if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) {
-				isGlob = token.isGlob = true;
-				if (scanToEnd === true) {
-					let parens = 1;
-					while (eos() !== true && (code = advance())) {
-						if (code === CHAR_BACKWARD_SLASH) {
-							backslashes = token.backslashes = true;
-							advance();
-							continue;
-						}
-						if (code === CHAR_LEFT_PARENTHESES) {
-							parens++;
-							continue;
-						}
-						if (code === CHAR_RIGHT_PARENTHESES && --parens === 0) {
-							finished = true;
-							break;
-						}
-					}
-					continue;
-				}
-				break;
-			}
-			if (isGlob === true) {
-				finished = true;
-				if (scanToEnd === true) continue;
-				break;
-			}
-		}
-		if (opts.noext === true) {
-			isExtglob = false;
-			isGlob = false;
-		}
-		let base = str;
-		let prefix = "";
-		let glob = "";
-		if (start > 0) {
-			prefix = str.slice(0, start);
-			str = str.slice(start);
-			lastIndex -= start;
-		}
-		if (base && isGlob === true && lastIndex > 0) {
-			base = str.slice(0, lastIndex);
-			glob = str.slice(lastIndex);
-		} else if (isGlob === true) {
-			base = "";
-			glob = str;
-		} else base = str;
-		if (base && base !== "" && base !== "/" && base !== str) {
-			if (isPathSeparator(base.charCodeAt(base.length - 1))) base = base.slice(0, -1);
-		}
-		if (opts.unescape === true) {
-			if (glob) glob = utils.removeBackslashes(glob);
-			if (base && backslashes === true) base = utils.removeBackslashes(base);
-		}
-		const state = {
-			prefix,
-			input,
-			start,
-			base,
-			glob,
-			isBrace,
-			isBracket,
-			isGlob,
-			isExtglob,
-			isGlobstar,
-			negated,
-			negatedExtglob
-		};
-		if (opts.tokens === true) {
-			state.maxDepth = 0;
-			if (!isPathSeparator(code)) tokens.push(token);
-			state.tokens = tokens;
-		}
-		if (opts.parts === true || opts.tokens === true) {
-			let prevIndex;
-			for (let idx = 0; idx < slashes.length; idx++) {
-				const n = prevIndex !== void 0 ? prevIndex + 1 : start;
-				const i = slashes[idx];
-				const value = input.slice(n, i);
-				if (opts.tokens) {
-					if (idx === 0 && start !== 0) {
-						tokens[idx].isPrefix = true;
-						tokens[idx].value = prefix;
-					} else tokens[idx].value = value;
-					depth(tokens[idx]);
-					state.maxDepth += tokens[idx].depth;
-				}
-				if (i >= start) {
-					parts.push(value);
-					prevIndex = i;
-				}
-			}
-			const n = prevIndex !== void 0 ? prevIndex + 1 : start;
-			const value = input.slice(n);
-			parts.push(value);
-			if (opts.tokens && prevIndex && prevIndex + 1 < input.length) {
-				tokens[tokens.length - 1].value = value;
-				depth(tokens[tokens.length - 1]);
-				state.maxDepth += tokens[tokens.length - 1].depth;
-			}
-			state.slashes = slashes;
-			state.parts = parts;
-		}
-		return state;
-	};
-	module.exports = scan;
-}));
-//#endregion
-//#region ../../node_modules/.pnpm/picomatch@4.0.7/node_modules/picomatch/lib/parse.js
-var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	const constants = require_constants();
-	const utils = require_utils();
-	/**
-	* Constants
-	*/
-	const { MAX_LENGTH, POSIX_REGEX_SOURCE, REGEX_NON_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_BACKREF, REPLACEMENTS } = constants;
-	/**
-	* Helpers
-	*/
-	const expandRange = (args, options) => {
-		if (typeof options.expandRange === "function") return options.expandRange(...args, options);
-		args.sort();
-		const value = `[${args.join("-")}]`;
-		try {
-			new RegExp(value);
-		} catch (ex) {
-			return args.map((v) => utils.escapeRegex(v)).join("..");
-		}
-		return value;
-	};
-	/**
-	* Create the message for a syntax error
-	*/
-	const syntaxError = (type, char) => {
-		return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
-	};
-	const splitTopLevel = (input) => {
-		const parts = [];
-		let bracket = 0;
-		let paren = 0;
-		let quote = 0;
-		let value = "";
-		let escaped = false;
-		for (const ch of input) {
-			if (escaped === true) {
-				value += ch;
-				escaped = false;
-				continue;
-			}
-			if (ch === "\\") {
-				value += ch;
-				escaped = true;
-				continue;
-			}
-			if (ch === "\"") {
-				quote = quote === 1 ? 0 : 1;
-				value += ch;
-				continue;
-			}
-			if (quote === 0) {
-				if (ch === "[") bracket++;
-				else if (ch === "]" && bracket > 0) bracket--;
-				else if (bracket === 0) {
-					if (ch === "(") paren++;
-					else if (ch === ")" && paren > 0) paren--;
-					else if (ch === "|" && paren === 0) {
-						parts.push(value);
-						value = "";
-						continue;
-					}
-				}
-			}
-			value += ch;
-		}
-		parts.push(value);
-		return parts;
-	};
-	const isPlainBranch = (branch) => {
-		let escaped = false;
-		for (const ch of branch) {
-			if (escaped === true) {
-				escaped = false;
-				continue;
-			}
-			if (ch === "\\") {
-				escaped = true;
-				continue;
-			}
-			if (/[?*+@!()[\]{}]/.test(ch)) return false;
-		}
-		return true;
-	};
-	const normalizeSimpleBranch = (branch) => {
-		let value = branch.trim();
-		let changed = true;
-		while (changed === true) {
-			changed = false;
-			if (/^@\([^\\()[\]{}|]+\)$/.test(value)) {
-				value = value.slice(2, -1);
-				changed = true;
-			}
-		}
-		if (!isPlainBranch(value)) return;
-		return value.replace(/\\(.)/g, "$1");
-	};
-	const hasRepeatedCharPrefixOverlap = (branches) => {
-		const values = branches.map(normalizeSimpleBranch).filter(Boolean);
-		for (let i = 0; i < values.length; i++) for (let j = i + 1; j < values.length; j++) {
-			const a = values[i];
-			const b = values[j];
-			const char = a[0];
-			if (!char || a !== char.repeat(a.length) || b !== char.repeat(b.length)) continue;
-			if (a === b || a.startsWith(b) || b.startsWith(a)) return true;
-		}
-		return false;
-	};
-	const parseRepeatedExtglob = (pattern, requireEnd = true) => {
-		if (pattern[0] !== "+" && pattern[0] !== "*" || pattern[1] !== "(") return;
-		let bracket = 0;
-		let paren = 0;
-		let quote = 0;
-		let escaped = false;
-		for (let i = 1; i < pattern.length; i++) {
-			const ch = pattern[i];
-			if (escaped === true) {
-				escaped = false;
-				continue;
-			}
-			if (ch === "\\") {
-				escaped = true;
-				continue;
-			}
-			if (ch === "\"") {
-				quote = quote === 1 ? 0 : 1;
-				continue;
-			}
-			if (quote === 1) continue;
-			if (ch === "[") {
-				bracket++;
-				continue;
-			}
-			if (ch === "]" && bracket > 0) {
-				bracket--;
-				continue;
-			}
-			if (bracket > 0) continue;
-			if (ch === "(") {
-				paren++;
-				continue;
-			}
-			if (ch === ")") {
-				paren--;
-				if (paren === 0) {
-					if (requireEnd === true && i !== pattern.length - 1) return;
-					return {
-						type: pattern[0],
-						body: pattern.slice(2, i),
-						end: i
-					};
-				}
-			}
-		}
-	};
-	const buildCharClassStar = (chars) => {
-		return `${chars.length === 1 ? utils.escapeRegex(chars[0]) : `[${chars.map((ch) => utils.escapeRegex(ch)).join("")}]`}*`;
-	};
-	const getStarExtglobSequenceChars = (pattern) => {
-		let index = 0;
-		const chars = [];
-		while (index < pattern.length) {
-			const match = parseRepeatedExtglob(pattern.slice(index), false);
-			if (!match || match.type !== "*") return;
-			const branches = splitTopLevel(match.body).map((branch) => branch.trim());
-			if (branches.length !== 1) return;
-			const branch = normalizeSimpleBranch(branches[0]);
-			if (!branch || branch.length !== 1) return;
-			chars.push(branch);
-			index += match.end + 1;
-		}
-		if (chars.length < 1) return;
-		return chars;
-	};
-	const repeatedExtglobRecursion = (pattern) => {
-		let depth = 0;
-		let value = pattern.trim();
-		let match = parseRepeatedExtglob(value);
-		while (match) {
-			depth++;
-			value = match.body.trim();
-			match = parseRepeatedExtglob(value);
-		}
-		return depth;
-	};
-	const analyzeRepeatedExtglob = (body, options) => {
-		if (options.maxExtglobRecursion === false) return { risky: false };
-		const max = typeof options.maxExtglobRecursion === "number" ? options.maxExtglobRecursion : constants.DEFAULT_MAX_EXTGLOB_RECURSION;
-		const branches = splitTopLevel(body).map((branch) => branch.trim());
-		if (branches.length > 1) {
-			if (branches.some((branch) => branch === "") || branches.some((branch) => /^[*?]+$/.test(branch)) || hasRepeatedCharPrefixOverlap(branches)) return { risky: true };
-		}
-		const safeChars = [];
-		let sawStarSequence = false;
-		let combinable = true;
-		for (const branch of branches) {
-			const chars = getStarExtglobSequenceChars(branch);
-			if (chars) {
-				sawStarSequence = true;
-				safeChars.push(...chars);
-				continue;
-			}
-			const literal = normalizeSimpleBranch(branch);
-			if (literal && literal.length === 1) {
-				safeChars.push(literal);
-				continue;
-			}
-			combinable = false;
-			if (repeatedExtglobRecursion(branch) > max) return { risky: true };
-		}
-		if (sawStarSequence) return combinable ? {
-			risky: true,
-			safeOutput: buildCharClassStar([...new Set(safeChars)])
-		} : { risky: true };
-		return { risky: false };
-	};
-	/**
-	* Parse the given input string.
-	* @param {String} input
-	* @param {Object} options
-	* @return {Object}
-	*/
-	const parse = (input, options) => {
-		if (typeof input !== "string") throw new TypeError("Expected a string");
-		input = REPLACEMENTS[input] || input;
-		const opts = { ...options };
-		const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
-		let len = input.length;
-		if (len > max) throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
-		const bos = {
-			type: "bos",
-			value: "",
-			output: opts.prepend || ""
-		};
-		const tokens = [bos];
-		const capture = opts.capture ? "" : "?:";
-		const PLATFORM_CHARS = constants.globChars(opts.windows);
-		const EXTGLOB_CHARS = constants.extglobChars(PLATFORM_CHARS);
-		const { DOT_LITERAL, PLUS_LITERAL, SLASH_LITERAL, ONE_CHAR, DOTS_SLASH, NO_DOT, NO_DOT_SLASH, NO_DOTS_SLASH, QMARK, QMARK_NO_DOT, STAR, START_ANCHOR } = PLATFORM_CHARS;
-		const globstar = (opts) => {
-			return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
-		};
-		const nodot = opts.dot ? "" : NO_DOT;
-		const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT;
-		let star = opts.bash === true ? globstar(opts) : STAR;
-		if (opts.capture) star = `(${star})`;
-		if (typeof opts.noext === "boolean") opts.noextglob = opts.noext;
-		const state = {
-			input,
-			index: -1,
-			start: 0,
-			dot: opts.dot === true,
-			consumed: "",
-			output: "",
-			prefix: "",
-			backtrack: false,
-			negated: false,
-			brackets: 0,
-			braces: 0,
-			parens: 0,
-			quotes: 0,
-			globstar: false,
-			tokens
-		};
-		input = utils.removePrefix(input, state);
-		len = input.length;
-		const extglobs = [];
-		const braces = [];
-		const stack = [];
-		let prev = bos;
-		let value;
-		/**
-		* Tokenizing helpers
-		*/
-		const eos = () => state.index === len - 1;
-		const peek = state.peek = (n = 1) => input[state.index + n];
-		const advance = state.advance = () => input[++state.index] || "";
-		const remaining = () => input.slice(state.index + 1);
-		const consume = (value = "", num = 0) => {
-			state.consumed += value;
-			state.index += num;
-		};
-		const append = (token) => {
-			state.output += token.output != null ? token.output : token.value;
-			consume(token.value);
-		};
-		const negate = () => {
-			let count = 1;
-			while (peek() === "!" && (peek(2) !== "(" || peek(3) === "?")) {
-				advance();
-				state.start++;
-				count++;
-			}
-			if (count % 2 === 0) return false;
-			state.negated = true;
-			state.start++;
-			return true;
-		};
-		const increment = (type) => {
-			state[type]++;
-			stack.push(type);
-		};
-		const decrement = (type) => {
-			state[type]--;
-			stack.pop();
-		};
-		/**
-		* Push tokens onto the tokens array. This helper speeds up
-		* tokenizing by 1) helping us avoid backtracking as much as possible,
-		* and 2) helping us avoid creating extra tokens when consecutive
-		* characters are plain text. This improves performance and simplifies
-		* lookbehinds.
-		*/
-		const push = (tok) => {
-			if (prev.type === "globstar") {
-				const isBrace = state.braces > 0 && (tok.type === "comma" || tok.type === "brace");
-				const isExtglob = tok.extglob === true || extglobs.length && (tok.type === "pipe" || tok.type === "paren");
-				if (tok.type !== "slash" && tok.type !== "paren" && !isBrace && !isExtglob) {
-					state.output = state.output.slice(0, -prev.output.length);
-					prev.type = "star";
-					prev.value = "*";
-					prev.output = star;
-					state.output += prev.output;
-				}
-			}
-			if (extglobs.length && tok.type !== "paren") extglobs[extglobs.length - 1].inner += tok.value;
-			if (tok.value || tok.output) append(tok);
-			if (prev && prev.type === "text" && tok.type === "text") {
-				prev.output = (prev.output || prev.value) + tok.value;
-				prev.value += tok.value;
-				return;
-			}
-			tok.prev = prev;
-			tokens.push(tok);
-			prev = tok;
-		};
-		const extglobOpen = (type, value) => {
-			const token = {
-				...EXTGLOB_CHARS[value],
-				conditions: 1,
-				inner: ""
-			};
-			token.prev = prev;
-			token.parens = state.parens;
-			token.output = state.output;
-			token.startIndex = state.index;
-			token.tokensIndex = tokens.length;
-			const output = (opts.capture ? "(" : "") + token.open;
-			increment("parens");
-			push({
-				type,
-				value,
-				output: state.output ? "" : ONE_CHAR
-			});
-			push({
-				type: "paren",
-				extglob: true,
-				value: advance(),
-				output
-			});
-			extglobs.push(token);
-		};
-		const extglobClose = (token) => {
-			const literal = input.slice(token.startIndex, state.index + 1);
-			const body = input.slice(token.startIndex + 2, state.index);
-			const analysis = analyzeRepeatedExtglob(body, opts);
-			if ((token.type === "plus" || token.type === "star") && analysis.risky) {
-				const safeOutput = analysis.safeOutput ? (token.output ? "" : ONE_CHAR) + (opts.capture ? `(${analysis.safeOutput})` : analysis.safeOutput) : void 0;
-				const open = tokens[token.tokensIndex];
-				open.type = "text";
-				open.value = literal;
-				open.output = safeOutput || utils.escapeRegex(literal);
-				for (let i = token.tokensIndex + 1; i < tokens.length; i++) {
-					tokens[i].value = "";
-					tokens[i].output = "";
-					delete tokens[i].suffix;
-				}
-				state.output = token.output + open.output;
-				state.backtrack = true;
-				push({
-					type: "paren",
-					extglob: true,
-					value,
-					output: ""
-				});
-				decrement("parens");
-				return;
-			}
-			let output = token.close + (opts.capture ? ")" : "");
-			let rest;
-			if (token.type === "negate") {
-				let extglobStar = star;
-				if (token.inner && token.inner.length > 1 && token.inner.includes("/")) extglobStar = globstar(opts);
-				if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) output = token.close = `)$))${extglobStar}`;
-				if (token.inner.includes("*") && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) output = token.close = `)${parse(rest, {
-					...options,
-					fastpaths: false
-				}).output})${extglobStar})`;
-				if (token.prev.type === "bos") state.negatedExtglob = true;
-			}
-			push({
-				type: "paren",
-				extglob: true,
-				value,
-				output
-			});
-			decrement("parens");
-		};
-		/**
-		* Fast paths
-		*/
-		if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) {
-			let backslashes = false;
-			let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => {
-				if (first === "\\") {
-					backslashes = true;
-					return m;
-				}
-				if (first === "?") {
-					if (esc) return esc + first + (rest ? QMARK.repeat(rest.length) : "");
-					if (index === 0) return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : "");
-					return QMARK.repeat(chars.length);
-				}
-				if (first === ".") return DOT_LITERAL.repeat(chars.length);
-				if (first === "*") {
-					if (esc) return esc + first + (rest ? star : "");
-					return star;
-				}
-				return esc ? m : `\\${m}`;
-			});
-			if (backslashes === true) {
-				if (opts.unescape === true) output = output.replace(/\\/g, "");
-				else output = output.replace(/\\+/g, (m) => {
-					return m.length % 2 === 0 ? "\\\\" : m ? "\\" : "";
-				});
-			}
-			if (output === input && opts.contains === true) {
-				state.output = input;
-				return state;
-			}
-			state.output = utils.wrapOutput(output, state, options);
-			return state;
-		}
-		/**
-		* Tokenize input until we reach end-of-string
-		*/
-		while (!eos()) {
-			value = advance();
-			if (value === "\0") continue;
-			/**
-			* Escaped characters
-			*/
-			if (value === "\\") {
-				const next = peek();
-				if (next === "/" && opts.bash !== true) continue;
-				if (next === "." || next === ";") continue;
-				if (!next) {
-					value += "\\";
-					push({
-						type: "text",
-						value
-					});
-					continue;
-				}
-				const match = /^\\+/.exec(remaining());
-				let slashes = 0;
-				if (match && match[0].length > 2) {
-					slashes = match[0].length;
-					state.index += slashes;
-					if (slashes % 2 !== 0) value += "\\";
-				}
-				if (opts.unescape === true) value = advance();
-				else value += advance();
-				if (state.brackets === 0) {
-					push({
-						type: "text",
-						value
-					});
-					continue;
-				}
-			}
-			/**
-			* If we're inside a regex character class, continue
-			* until we reach the closing bracket.
-			*/
-			if (state.brackets > 0 && (value !== "]" || prev.value === "[" || prev.value === "[^")) {
-				if (opts.posix !== false && value === ":") {
-					const inner = prev.value.slice(1);
-					if (inner.includes("[")) {
-						prev.posix = true;
-						if (inner.includes(":")) {
-							const idx = prev.value.lastIndexOf("[");
-							const pre = prev.value.slice(0, idx);
-							const rest = prev.value.slice(idx + 2);
-							const posix = POSIX_REGEX_SOURCE[rest];
-							if (posix) {
-								prev.value = pre + posix;
-								state.backtrack = true;
-								advance();
-								if (!bos.output && tokens.indexOf(prev) === 1) bos.output = ONE_CHAR;
-								continue;
-							}
-						}
-					}
-				}
-				if (value === "[" && peek() !== ":" || value === "-" && peek() === "]") value = `\\${value}`;
-				if (value === "]" && (prev.value === "[" || prev.value === "[^")) value = `\\${value}`;
-				if (opts.posix === true && value === "!" && prev.value === "[") value = "^";
-				prev.value += value;
-				append({ value });
-				continue;
-			}
-			/**
-			* If we're inside a quoted string, continue
-			* until we reach the closing double quote.
-			*/
-			if (state.quotes === 1 && value !== "\"") {
-				value = utils.escapeRegex(value);
-				prev.value += value;
-				append({ value });
-				continue;
-			}
-			/**
-			* Double quotes
-			*/
-			if (value === "\"") {
-				state.quotes = state.quotes === 1 ? 0 : 1;
-				if (opts.keepQuotes === true) push({
-					type: "text",
-					value
-				});
-				continue;
-			}
-			/**
-			* Parentheses
-			*/
-			if (value === "(") {
-				increment("parens");
-				push({
-					type: "paren",
-					value
-				});
-				continue;
-			}
-			if (value === ")") {
-				if (state.parens === 0 && opts.strictBrackets === true) throw new SyntaxError(syntaxError("opening", "("));
-				const extglob = extglobs[extglobs.length - 1];
-				if (extglob && state.parens === extglob.parens + 1) {
-					extglobClose(extglobs.pop());
-					continue;
-				}
-				push({
-					type: "paren",
-					value,
-					output: state.parens ? ")" : "\\)"
-				});
-				decrement("parens");
-				continue;
-			}
-			/**
-			* Square brackets
-			*/
-			if (value === "[") {
-				if (opts.nobracket === true || !remaining().includes("]")) {
-					if (opts.nobracket !== true && opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "]"));
-					value = `\\${value}`;
-				} else increment("brackets");
-				push({
-					type: "bracket",
-					value
-				});
-				continue;
-			}
-			if (value === "]") {
-				if (opts.nobracket === true || prev && prev.type === "bracket" && prev.value.length === 1) {
-					push({
-						type: "text",
-						value,
-						output: `\\${value}`
-					});
-					continue;
-				}
-				if (state.brackets === 0) {
-					if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("opening", "["));
-					push({
-						type: "text",
-						value,
-						output: `\\${value}`
-					});
-					continue;
-				}
-				decrement("brackets");
-				const prevValue = prev.value.slice(1);
-				if (prev.posix !== true && prevValue[0] === "^" && !prevValue.includes("/")) value = `/${value}`;
-				prev.value += value;
-				append({ value });
-				if (opts.literalBrackets === false || utils.hasRegexChars(prevValue)) continue;
-				const escaped = utils.escapeRegex(prev.value);
-				state.output = state.output.slice(0, -prev.value.length);
-				if (opts.literalBrackets === true) {
-					state.output += escaped;
-					prev.value = escaped;
-					continue;
-				}
-				prev.value = `(${capture}${escaped}|${prev.value})`;
-				state.output += prev.value;
-				continue;
-			}
-			/**
-			* Braces
-			*/
-			if (value === "{" && opts.nobrace !== true) {
-				increment("braces");
-				const open = {
-					type: "brace",
-					value,
-					output: "(",
-					outputIndex: state.output.length,
-					tokensIndex: state.tokens.length
-				};
-				braces.push(open);
-				push(open);
-				continue;
-			}
-			if (value === "}") {
-				const brace = braces[braces.length - 1];
-				if (opts.nobrace === true || !brace) {
-					push({
-						type: "text",
-						value,
-						output: value
-					});
-					continue;
-				}
-				let output = ")";
-				if (brace.dots === true) {
-					const arr = tokens.slice();
-					const range = [];
-					for (let i = arr.length - 1; i >= 0; i--) {
-						tokens.pop();
-						if (arr[i].type === "brace") break;
-						if (arr[i].type !== "dots") range.unshift(arr[i].value);
-					}
-					output = expandRange(range, opts);
-					state.backtrack = true;
-				}
-				if (brace.comma !== true && brace.dots !== true) {
-					const out = state.output.slice(0, brace.outputIndex);
-					const toks = state.tokens.slice(brace.tokensIndex);
-					brace.value = brace.output = "\\{";
-					value = output = "\\}";
-					state.output = out;
-					for (const t of toks) state.output += t.output || t.value;
-				}
-				push({
-					type: "brace",
-					value,
-					output
-				});
-				decrement("braces");
-				braces.pop();
-				continue;
-			}
-			/**
-			* Pipes
-			*/
-			if (value === "|") {
-				if (extglobs.length > 0) extglobs[extglobs.length - 1].conditions++;
-				push({
-					type: "text",
-					value
-				});
-				continue;
-			}
-			/**
-			* Commas
-			*/
-			if (value === ",") {
-				let output = value;
-				const brace = braces[braces.length - 1];
-				if (brace && stack[stack.length - 1] === "braces") {
-					brace.comma = true;
-					output = "|";
-				}
-				push({
-					type: "comma",
-					value,
-					output
-				});
-				continue;
-			}
-			/**
-			* Slashes
-			*/
-			if (value === "/") {
-				if (prev.type === "dot" && state.index === state.start + 1) {
-					state.start = state.index + 1;
-					state.consumed = "";
-					state.output = "";
-					tokens.pop();
-					prev = bos;
-					continue;
-				}
-				push({
-					type: "slash",
-					value,
-					output: SLASH_LITERAL
-				});
-				continue;
-			}
-			/**
-			* Dots
-			*/
-			if (value === ".") {
-				if (state.braces > 0 && prev.type === "dot") {
-					if (prev.value === ".") prev.output = DOT_LITERAL;
-					const brace = braces[braces.length - 1];
-					prev.type = "dots";
-					prev.output += value;
-					prev.value += value;
-					brace.dots = true;
-					continue;
-				}
-				if (state.braces + state.parens === 0 && prev.type !== "bos" && prev.type !== "slash") {
-					push({
-						type: "text",
-						value,
-						output: DOT_LITERAL
-					});
-					continue;
-				}
-				push({
-					type: "dot",
-					value,
-					output: DOT_LITERAL
-				});
-				continue;
-			}
-			/**
-			* Question marks
-			*/
-			if (value === "?") {
-				if (!(prev && prev.value === "(") && opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
-					extglobOpen("qmark", value);
-					continue;
-				}
-				if (prev && prev.type === "paren") {
-					const next = peek();
-					let output = value;
-					if (prev.value === "(" && !/[!=<:]/.test(next) || next === "<" && !/<([!=]|\w+>)/.test(remaining())) output = `\\${value}`;
-					push({
-						type: "text",
-						value,
-						output
-					});
-					continue;
-				}
-				if (opts.dot !== true && (prev.type === "slash" || prev.type === "bos")) {
-					push({
-						type: "qmark",
-						value,
-						output: QMARK_NO_DOT
-					});
-					continue;
-				}
-				push({
-					type: "qmark",
-					value,
-					output: QMARK
-				});
-				continue;
-			}
-			/**
-			* Exclamation
-			*/
-			if (value === "!") {
-				if (opts.noextglob !== true && peek() === "(") {
-					if (peek(2) !== "?" || !/[!=<:]/.test(peek(3))) {
-						extglobOpen("negate", value);
-						continue;
-					}
-				}
-				if (opts.nonegate !== true && state.index === 0) {
-					negate();
-					continue;
-				}
-			}
-			/**
-			* Plus
-			*/
-			if (value === "+") {
-				if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
-					extglobOpen("plus", value);
-					continue;
-				}
-				if (prev && prev.value === "(" || opts.regex === false) {
-					push({
-						type: "plus",
-						value,
-						output: PLUS_LITERAL
-					});
-					continue;
-				}
-				if (prev && (prev.type === "bracket" || prev.type === "paren" || prev.type === "brace") || state.parens > 0) {
-					push({
-						type: "plus",
-						value
-					});
-					continue;
-				}
-				push({
-					type: "plus",
-					value: PLUS_LITERAL
-				});
-				continue;
-			}
-			/**
-			* Plain text
-			*/
-			if (value === "@") {
-				if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
-					push({
-						type: "at",
-						extglob: true,
-						value,
-						output: ""
-					});
-					continue;
-				}
-				push({
-					type: "text",
-					value
-				});
-				continue;
-			}
-			/**
-			* Plain text
-			*/
-			if (value !== "*") {
-				if (value === "$" || value === "^") value = `\\${value}`;
-				const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
-				if (match) {
-					value += match[0];
-					state.index += match[0].length;
-				}
-				push({
-					type: "text",
-					value
-				});
-				continue;
-			}
-			/**
-			* Stars
-			*/
-			if (prev && (prev.type === "globstar" || prev.star === true)) {
-				prev.type = "star";
-				prev.star = true;
-				prev.value += value;
-				prev.output = star;
-				state.backtrack = true;
-				state.globstar = true;
-				consume(value);
-				continue;
-			}
-			let rest = remaining();
-			if (opts.noextglob !== true && /^\([^?]/.test(rest)) {
-				extglobOpen("star", value);
-				continue;
-			}
-			if (prev.type === "star") {
-				if (opts.noglobstar === true) {
-					consume(value);
-					continue;
-				}
-				const prior = prev.prev;
-				const before = prior.prev;
-				const isStart = prior.type === "slash" || prior.type === "bos";
-				const afterStar = before && (before.type === "star" || before.type === "globstar");
-				if (opts.bash === true && (!isStart || rest[0] && rest[0] !== "/")) {
-					push({
-						type: "star",
-						value,
-						output: ""
-					});
-					continue;
-				}
-				const isBrace = state.braces > 0 && (prior.type === "comma" || prior.type === "brace");
-				const isExtglob = extglobs.length && (prior.type === "pipe" || prior.type === "paren");
-				if (!isStart && prior.type !== "paren" && !isBrace && !isExtglob) {
-					push({
-						type: "star",
-						value,
-						output: ""
-					});
-					continue;
-				}
-				while (rest.slice(0, 3) === "/**") {
-					const after = input[state.index + 4];
-					if (after && after !== "/") break;
-					rest = rest.slice(3);
-					consume("/**", 3);
-				}
-				const isEnd = eos() || state.parens > 0 && rest === ")".repeat(state.parens) && !extglobs.some((extglob) => extglob.type === "negate");
-				if (prior.type === "bos" && eos()) {
-					prev.type = "globstar";
-					prev.value += value;
-					prev.output = globstar(opts);
-					state.output = prev.output;
-					state.globstar = true;
-					consume(value);
-					continue;
-				}
-				if (prior.type === "slash" && prior.prev.type !== "bos" && !afterStar && isEnd) {
-					state.output = state.output.slice(0, -(prior.output + prev.output).length);
-					prior.output = `(?:${prior.output}`;
-					prev.type = "globstar";
-					prev.output = globstar(opts) + (opts.strictSlashes ? ")" : "|$)");
-					prev.value += value;
-					state.globstar = true;
-					state.output += prior.output + prev.output;
-					consume(value);
-					continue;
-				}
-				if (prior.type === "slash" && prior.prev.type !== "bos" && rest[0] === "/") {
-					const end = rest[1] !== void 0 ? "|$" : "";
-					state.output = state.output.slice(0, -(prior.output + prev.output).length);
-					prior.output = `(?:${prior.output}`;
-					prev.type = "globstar";
-					prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;
-					prev.value += value;
-					state.output += prior.output + prev.output;
-					state.globstar = true;
-					consume(value + advance());
-					push({
-						type: "slash",
-						value: "/",
-						output: ""
-					});
-					continue;
-				}
-				if (prior.type === "bos" && rest[0] === "/") {
-					prev.type = "globstar";
-					prev.value += value;
-					prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;
-					state.output = prev.output;
-					state.globstar = true;
-					consume(value + advance());
-					push({
-						type: "slash",
-						value: "/",
-						output: ""
-					});
-					continue;
-				}
-				state.output = state.output.slice(0, -prev.output.length);
-				prev.type = "globstar";
-				prev.output = globstar(opts);
-				prev.value += value;
-				state.output += prev.output;
-				state.globstar = true;
-				consume(value);
-				continue;
-			}
-			const token = {
-				type: "star",
-				value,
-				output: star
-			};
-			if (opts.bash === true) {
-				token.output = ".*?";
-				if (prev.type === "bos" || prev.type === "slash") token.output = nodot + token.output;
-				push(token);
-				continue;
-			}
-			if (prev && (prev.type === "bracket" || prev.type === "paren") && opts.regex === true) {
-				token.output = value;
-				push(token);
-				continue;
-			}
-			if (state.index === state.start || prev.type === "slash" || prev.type === "dot") {
-				if (prev.type === "dot") {
-					state.output += NO_DOT_SLASH;
-					prev.output += NO_DOT_SLASH;
-				} else if (opts.dot === true) {
-					state.output += NO_DOTS_SLASH;
-					prev.output += NO_DOTS_SLASH;
-				} else {
-					state.output += nodot;
-					prev.output += nodot;
-				}
-				if (peek() !== "*") {
-					state.output += ONE_CHAR;
-					prev.output += ONE_CHAR;
-				}
-			}
-			push(token);
-		}
-		while (state.brackets > 0) {
-			if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "]"));
-			state.output = utils.escapeLast(state.output, "[");
-			decrement("brackets");
-		}
-		while (state.parens > 0) {
-			if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", ")"));
-			state.output = utils.escapeLast(state.output, "(");
-			decrement("parens");
-		}
-		while (state.braces > 0) {
-			if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "}"));
-			state.output = utils.escapeLast(state.output, "{");
-			decrement("braces");
-		}
-		if (opts.strictSlashes !== true && (prev.type === "star" || prev.type === "bracket")) push({
-			type: "maybe_slash",
-			value: "",
-			output: `${SLASH_LITERAL}?`
-		});
-		if (state.backtrack === true) {
-			state.output = "";
-			for (const token of state.tokens) {
-				state.output += token.output != null ? token.output : token.value;
-				if (token.suffix) state.output += token.suffix;
-			}
-		}
-		return state;
-	};
-	/**
-	* Fast paths for creating regular expressions for common glob patterns.
-	* This can significantly speed up processing and has very little downside
-	* impact when none of the fast paths match.
-	*/
-	parse.fastpaths = (input, options) => {
-		const opts = { ...options };
-		const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
-		const len = input.length;
-		if (len > max) throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
-		input = REPLACEMENTS[input] || input;
-		const { DOT_LITERAL, SLASH_LITERAL, ONE_CHAR, DOTS_SLASH, NO_DOT, NO_DOTS, NO_DOTS_SLASH, STAR, START_ANCHOR } = constants.globChars(opts.windows);
-		const nodot = opts.dot ? NO_DOTS : NO_DOT;
-		const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
-		const capture = opts.capture ? "" : "?:";
-		const state = {
-			negated: false,
-			prefix: ""
-		};
-		let star = opts.bash === true ? ".*?" : STAR;
-		if (opts.capture) star = `(${star})`;
-		const globstar = (opts) => {
-			if (opts.noglobstar === true) return star;
-			return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
-		};
-		const create = (str) => {
-			switch (str) {
-				case "*": return `${nodot}${ONE_CHAR}${star}`;
-				case ".*": return `${DOT_LITERAL}${ONE_CHAR}${star}`;
-				case "*.*": return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
-				case "*/*": return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;
-				case "**": return nodot + globstar(opts);
-				case "**/*": return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;
-				case "**/*.*": return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
-				case "**/.*": return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;
-				default: {
-					const match = /^(.*?)\.(\w+)$/.exec(str);
-					if (!match) return;
-					const source = create(match[1]);
-					if (!source) return;
-					return source + DOT_LITERAL + match[2];
-				}
-			}
-		};
-		let source = create(utils.removePrefix(input, state));
-		if (source && opts.strictSlashes !== true) source += `${SLASH_LITERAL}?`;
-		return source;
-	};
-	module.exports = parse;
-}));
-//#endregion
-//#region ../../node_modules/.pnpm/picomatch@4.0.7/node_modules/picomatch/lib/picomatch.js
-var require_picomatch$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	const scan = require_scan();
-	const parse = require_parse();
-	const utils = require_utils();
-	const constants = require_constants();
-	const isObject = (val) => val && typeof val === "object" && !Array.isArray(val);
-	/**
-	* Creates a matcher function from one or more glob patterns. The
-	* returned function takes a string to match as its first argument,
-	* and returns true if the string is a match. The returned matcher
-	* function also takes a boolean as the second argument that, when true,
-	* returns an object with additional information.
-	*
-	* ```js
-	* const picomatch = require('picomatch');
-	* // picomatch(glob[, options]);
-	*
-	* const isMatch = picomatch('*.!(*a)');
-	* console.log(isMatch('a.a')); //=> false
-	* console.log(isMatch('a.b')); //=> true
-	*
-	* // For environments without `node.js`, `picomatch/posix` provides you a dependency-free matcher, without automatic OS detection.
-	* const picomatch = require('picomatch/posix');
-	* // the same API, defaulting to posix paths
-	* const isMatch = picomatch('a/*');
-	* console.log(isMatch('a\\b')); //=> false
-	* console.log(isMatch('a/b')); //=> true
-	*
-	* // you can still configure the matcher function to accept windows paths
-	* const isMatch = picomatch('a/*', { options: windows });
-	* console.log(isMatch('a\\b')); //=> true
-	* console.log(isMatch('a/b')); //=> true
-	* ```
-	* @name picomatch
-	* @param {String|Array} `globs` One or more glob patterns.
-	* @param {Object=} `options`
-	* @return {Function=} Returns a matcher function.
-	* @api public
-	*/
-	const picomatch = (glob, options, returnState = false) => {
-		if (Array.isArray(glob)) {
-			const fns = glob.map((input) => picomatch(input, options, returnState));
-			const arrayMatcher = (str) => {
-				for (const isMatch of fns) {
-					const state = isMatch(str);
-					if (state) return state;
-				}
-				return false;
-			};
-			return arrayMatcher;
-		}
-		const isState = isObject(glob) && glob.tokens && glob.input;
-		if (glob === "" || typeof glob !== "string" && !isState) throw new TypeError("Expected pattern to be a non-empty string");
-		const opts = options || {};
-		const posix = opts.windows;
-		const regex = isState ? picomatch.compileRe(glob, options) : picomatch.makeRe(glob, options, false, true);
-		const state = regex.state;
-		delete regex.state;
-		let isIgnored = () => false;
-		if (opts.ignore) {
-			const ignoreOpts = {
-				...options,
-				ignore: null,
-				onMatch: null,
-				onResult: null
-			};
-			isIgnored = picomatch(opts.ignore, ignoreOpts, returnState);
-		}
-		const matcher = (input, returnObject = false) => {
-			const { isMatch, match, output } = picomatch.test(input, regex, options, {
-				glob,
-				posix
-			});
-			const result = {
-				glob,
-				state,
-				regex,
-				posix,
-				input,
-				output,
-				match,
-				isMatch
-			};
-			if (typeof opts.onResult === "function") opts.onResult(result);
-			if (isMatch === false) {
-				result.isMatch = false;
-				return returnObject ? result : false;
-			}
-			if (isIgnored(input)) {
-				if (typeof opts.onIgnore === "function") opts.onIgnore(result);
-				result.isMatch = false;
-				return returnObject ? result : false;
-			}
-			if (typeof opts.onMatch === "function") opts.onMatch(result);
-			return returnObject ? result : true;
-		};
-		if (returnState) matcher.state = state;
-		return matcher;
-	};
-	/**
-	* Test `input` with the given `regex`. This is used by the main
-	* `picomatch()` function to test the input string.
-	*
-	* ```js
-	* const picomatch = require('picomatch');
-	* // picomatch.test(input, regex[, options]);
-	*
-	* console.log(picomatch.test('foo/bar', /^(?:([^/]*?)\/([^/]*?))$/));
-	* // { isMatch: true, match: [ 'foo/', 'foo', 'bar' ], output: 'foo/bar' }
-	* ```
-	* @param {String} `input` String to test.
-	* @param {RegExp} `regex`
-	* @return {Object} Returns an object with matching info.
-	* @api public
-	*/
-	picomatch.test = (input, regex, options, { glob, posix } = {}) => {
-		if (typeof input !== "string") throw new TypeError("Expected input to be a string");
-		if (input === "") return {
-			isMatch: false,
-			output: ""
-		};
-		const opts = options || {};
-		const format = opts.format || (posix ? utils.toPosixSlashes : null);
-		let match = input === glob;
-		let output = match && format ? format(input) : input;
-		if (match === false) {
-			output = format ? format(input) : input;
-			match = output === glob;
-		}
-		if (match === false || opts.capture === true) {
-			if (opts.matchBase === true || opts.basename === true) match = picomatch.matchBase(input, regex, options, posix);
-			else match = regex.exec(output);
-		}
-		return {
-			isMatch: Boolean(match),
-			match,
-			output
-		};
-	};
-	/**
-	* Match the basename of a filepath.
-	*
-	* ```js
-	* const picomatch = require('picomatch');
-	* // picomatch.matchBase(input, glob[, options]);
-	* console.log(picomatch.matchBase('foo/bar.js', '*.js'); // true
-	* ```
-	* @param {String} `input` String to test.
-	* @param {RegExp|String} `glob` Glob pattern or regex created by [.makeRe](#makeRe).
-	* @return {Boolean}
-	* @api public
-	*/
-	picomatch.matchBase = (input, glob, options, posix = options && options.windows) => {
-		return (glob instanceof RegExp ? glob : picomatch.makeRe(glob, options)).test(utils.basename(input, { windows: posix }));
-	};
-	/**
-	* Returns true if **any** of the given glob `patterns` match the specified `string`.
-	*
-	* ```js
-	* const picomatch = require('picomatch');
-	* // picomatch.isMatch(string, patterns[, options]);
-	*
-	* console.log(picomatch.isMatch('a.a', ['b.*', '*.a'])); //=> true
-	* console.log(picomatch.isMatch('a.a', 'b.*')); //=> false
-	* ```
-	* @param {String|Array} str The string to test.
-	* @param {String|Array} patterns One or more glob patterns to use for matching.
-	* @param {Object} [options] See available [options](#options).
-	* @return {Boolean} Returns true if any patterns match `str`
-	* @api public
-	*/
-	picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
-	/**
-	* Parse a glob pattern to create the source string for a regular
-	* expression.
-	*
-	* ```js
-	* const picomatch = require('picomatch');
-	* const result = picomatch.parse(pattern[, options]);
-	* ```
-	* @param {String} `pattern`
-	* @param {Object} `options`
-	* @return {Object} Returns an object with useful properties and output to be used as a regex source string.
-	* @api public
-	*/
-	picomatch.parse = (pattern, options) => {
-		if (Array.isArray(pattern)) return pattern.map((p) => picomatch.parse(p, options));
-		return parse(pattern, {
-			...options,
-			fastpaths: false
-		});
-	};
-	/**
-	* Scan a glob pattern to separate the pattern into segments.
-	*
-	* ```js
-	* const picomatch = require('picomatch');
-	* // picomatch.scan(input[, options]);
-	*
-	* const result = picomatch.scan('!./foo/*.js');
-	* console.log(result);
-	* { prefix: '!./',
-	*   input: '!./foo/*.js',
-	*   start: 3,
-	*   base: 'foo',
-	*   glob: '*.js',
-	*   isBrace: false,
-	*   isBracket: false,
-	*   isGlob: true,
-	*   isExtglob: false,
-	*   isGlobstar: false,
-	*   negated: true }
-	* ```
-	* @param {String} `input` Glob pattern to scan.
-	* @param {Object} `options`
-	* @return {Object} Returns an object with
-	* @api public
-	*/
-	picomatch.scan = (input, options) => scan(input, options);
-	/**
-	* Compile a regular expression from the `state` object returned by the
-	* [parse()](#parse) method.
-	*
-	* ```js
-	* const picomatch = require('picomatch');
-	* const state = picomatch.parse('*.js');
-	* // picomatch.compileRe(state[, options]);
-	*
-	* console.log(picomatch.compileRe(state));
-	* //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
-	* ```
-	* @param {Object} `state`
-	* @param {Object} `options`
-	* @param {Boolean} `returnOutput` Intended for implementors, this argument allows you to return the raw output from the parser.
-	* @param {Boolean} `returnState` Adds the state to a `state` property on the returned regex. Useful for implementors and debugging.
-	* @return {RegExp}
-	* @api public
-	*/
-	picomatch.compileRe = (state, options, returnOutput = false, returnState = false) => {
-		if (returnOutput === true) return state.output;
-		const opts = options || {};
-		const prepend = opts.contains ? "" : "^";
-		const append = opts.contains ? "" : "$";
-		let source = `${prepend}(?:${state.output})${append}`;
-		if (state && state.negated === true) source = `^(?!${source}).*$`;
-		const regex = picomatch.toRegex(source, options);
-		if (returnState === true) regex.state = state;
-		return regex;
-	};
-	/**
-	* Create a regular expression from a parsed glob pattern.
-	*
-	* ```js
-	* const picomatch = require('picomatch');
-	* // picomatch.makeRe(state[, options]);
-	*
-	* const result = picomatch.makeRe('*.js');
-	* console.log(result);
-	* //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
-	* ```
-	* @param {String} `state` The object returned from the `.parse` method.
-	* @param {Object} `options`
-	* @param {Boolean} `returnOutput` Implementors may use this argument to return the compiled output, instead of a regular expression. This is not exposed on the options to prevent end-users from mutating the result.
-	* @param {Boolean} `returnState` Implementors may use this argument to return the state from the parsed glob with the returned regular expression.
-	* @return {RegExp} Returns a regex created from the given pattern.
-	* @api public
-	*/
-	picomatch.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
-		if (!input || typeof input !== "string") throw new TypeError("Expected a non-empty string");
-		let parsed = {
-			negated: false,
-			fastpaths: true
-		};
-		if (options.fastpaths !== false && (input[0] === "." || input[0] === "*")) parsed.output = parse.fastpaths(input, options);
-		if (!parsed.output) parsed = parse(input, options);
-		return picomatch.compileRe(parsed, options, returnOutput, returnState);
-	};
-	/**
-	* Create a regular expression from the given regex source string.
-	*
-	* ```js
-	* const picomatch = require('picomatch');
-	* // picomatch.toRegex(source[, options]);
-	*
-	* const { output } = picomatch.parse('*.js');
-	* console.log(picomatch.toRegex(output));
-	* //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
-	* ```
-	* @param {String} `source` Regular expression source string.
-	* @param {Object} `options`
-	* @return {RegExp}
-	* @api public
-	*/
-	picomatch.toRegex = (source, options) => {
-		try {
-			const opts = options || {};
-			return new RegExp(source, opts.flags || (opts.nocase ? "i" : ""));
-		} catch (err) {
-			if (options && options.debug === true) throw err;
-			return /$^/;
-		}
-	};
-	/**
-	* Picomatch constants.
-	* @return {Object}
-	*/
-	picomatch.constants = constants;
-	/**
-	* Expose "picomatch"
-	*/
-	module.exports = picomatch;
-}));
-//#endregion
-//#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();
-	function picomatch(glob, options, returnState = false) {
-		if (options && (options.windows === null || options.windows === void 0)) options = {
-			...options,
-			windows: utils.isWindows()
-		};
-		return pico(glob, options, returnState);
-	}
-	Object.assign(picomatch, pico);
-	module.exports = picomatch;
-})))(), 1);
+// ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/matchFiles.js
+var import_picomatch = /* @__PURE__ */ __toESM(require_picomatch(), 1);
 /**
 * Match list of files against a pattern.
 *
@@ -2548,8 +622,7 @@ const matchFiles = (files, pattern, cwd = process.cwd()) => {
 	});
 	return files.filter((file) => isMatch(file.filepath));
 };
-//#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/normalizePath.js
+// ../../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
@@ -2586,8 +659,7 @@ const normalizePath = (input) => {
 	if (normalized.endsWith(path.posix.sep)) normalized = normalized.slice(0, -1);
 	return normalized;
 };
-//#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/generateTasks.js
+// ../../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
@@ -2623,8 +695,7 @@ const generateTasks = ({ config, cwd = process.cwd(), files, relative = false })
 		return task;
 	});
 };
-//#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/getAbortController.js
+// ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/getAbortController.js
 const Signal = {
 	SIGINT: "SIGINT",
 	SIGKILL: "SIGKILL"
@@ -2640,8 +711,7 @@ const getAbortController = (nodeProcess = process) => {
 	});
 	return abortController;
 };
-//#endregion
-//#region ../../node_modules/.pnpm/string-argv@0.3.2/node_modules/string-argv/index.js
+// ../../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;
@@ -2663,8 +733,7 @@ function firstString() {
 		if (typeof arg === "string") return arg;
 	}
 }
-//#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/killSubprocesses.js
+// ../../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
@@ -2696,8 +765,7 @@ const killSubProcesses = async (pid, isWin32 = process.platform === "win32") =>
 		else await killUnixSubprocesses(pid);
 	} catch {}
 };
-//#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/symbols.js
+// ../../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");
@@ -2713,8 +781,7 @@ 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
+// ../../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,
@@ -2763,8 +830,7 @@ const cleanupSkipped = (ctx) => {
 	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
+// ../../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.
@@ -2860,8 +926,7 @@ const getSpawnedTask = ({ abortController, command, continueOnError = false, cwd
 		if (verbose) handleTaskOutput(command, output, ctx, signal);
 	};
 };
-//#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/getFunctionTask.js
+// ../../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
@@ -2906,8 +971,7 @@ const getFunctionTask = async ({ abortController, command, continueOnError, file
 		task
 	}];
 };
-//#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/parseGitZOutput.js
+// ../../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`.
@@ -2918,8 +982,7 @@ const GIT_Z_REGEXP = /\u0000$/;
 * @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
+// ../../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([
@@ -2940,8 +1003,7 @@ const getIntentToAddFiles = async ({ cwd }) => {
 	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
+// ../../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.
@@ -3024,8 +1086,7 @@ const validateBraces = (pattern, logger) => {
 	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
+// ../../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");
 /**
@@ -3095,8 +1156,7 @@ const validateConfig = (config, configPath, logger) => {
 		throw error;
 	}
 };
-//#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/getSpawnedTasks.js
+// ../../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
@@ -3172,8 +1232,7 @@ const getSpawnedTasks = async ({ abortController, commands, continueOnError, cwd
 	});
 	return prepared.map((command) => Array.isArray(command) ? command.map(createTask) : createTask(command));
 };
-//#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/file.js
+// ../../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.
@@ -3224,8 +1283,7 @@ const writeFile = async (filename, buffer) => {
 	debugLog$9("Writing file `%s`", filename);
 	await fsPromises.writeFile(filename, buffer);
 };
-//#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/getDiffCommand.js
+// ../../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) => {
 	/**
@@ -3241,8 +1299,7 @@ const getDiffCommand = (diff, diffFilter) => {
 		...diffArgs
 	];
 };
-//#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/getStagedFiles.js
+// ../../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
@@ -3348,8 +1405,7 @@ const getStagedFiles = async ({ all, cwd, gitConfigDir, diff, diffFilter }) => {
 		return null;
 	}
 };
-//#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/runParallelTasks.js
+// ../../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) => {
@@ -3434,8 +1490,7 @@ const runParallelTasks = async (ctx, tasks, { abortController, concurrent = true
 	debugLog$8("Done running workers");
 	logger?.log("");
 };
-//#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/gitWorkflow.js
+// ../../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";
@@ -3908,8 +1963,7 @@ var GitWorkflow = class {
 		}
 	}
 };
-//#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/groupFilesByConfig.js
+// ../../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
@@ -3975,8 +2029,7 @@ const groupFilesByConfig = async ({ configs, files, singleConfigMode }) => {
 	}
 	return filesByConfig;
 };
-//#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/resolveGitRepo.js
+// ../../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
@@ -4034,8 +2087,7 @@ const resolveGitRepo = async (cwd = process.cwd()) => {
 		};
 	}
 };
-//#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/configFiles.js
+// ../../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"];
@@ -4063,22 +2115,20 @@ const CONFIG_FILE_NAMES = [
 	"lint-staged.config.cjs",
 	"lint-staged.config.cts"
 ];
-//#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/resolveConfig.js
+// ../../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
 */
-const require$1 = createRequire(import.meta.url);
+const require = createRequire(import.meta.url);
 function resolveConfig(configPath) {
 	try {
-		return require$1.resolve(configPath);
+		return require.resolve(configPath);
 	} catch {
 		return configPath;
 	}
 }
-//#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/loadConfig.js
+// ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/loadConfig.js
 /** @typedef {import('./index').Logger} Logger */
 const debugLog$4 = createDebug("lint-staged:loadConfig");
 const readFile = async (filename) => fsPromises.readFile(path.resolve(filename), "utf-8");
@@ -4099,7 +2149,7 @@ 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-CBWGibx8.js").then((m) => /* @__PURE__ */ __toESM(m.default, 1)), readFile(filename)]);
+		const [YAML, content] = await Promise.all([import("../dist-zDZV5eEc.js").then((m) => /* @__PURE__ */ __toESM(m.default, 1)), readFile(filename)]);
 		const yaml = YAML.parse(content);
 		return isPackageFile ? yaml[CONFIG_NAME] : yaml;
 	} catch (error) {
@@ -4158,8 +2208,7 @@ const loadConfig = async (configPath, logger) => {
 		return {};
 	}
 };
-//#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/searchConfigs.js
+// ../../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;
@@ -4272,8 +2321,7 @@ const searchConfigs = async ({ configObject, configPath, cwd = process.cwd(), to
 	debugLog$3("Found %d config files", Object.keys(foundConfigs).length);
 	return foundConfigs;
 };
-//#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/runAll.js
+// ../../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");
 /**
@@ -4478,8 +2526,7 @@ const runAll = async ({ all, allowEmpty, concurrent, configObject, configPath, c
 	if (ctx.errors.size > 0) throw createError(ctx);
 	return ctx;
 };
-//#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/validateOptions.js
+// ../../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;
@@ -4511,11 +2558,9 @@ const validateOptions = async (options = {}, logger) => {
 	}
 	debugLog$1("Validated options: %o", options);
 };
-//#endregion
-//#region ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/version.js
+// ../../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.6.0/node_modules/lint-staged/lib/index.js
+// ../../node_modules/.pnpm/lint-staged@17.6.0/node_modules/lint-staged/lib/index.js
 const debugLog = createDebug("lint-staged");
 /**
 * @typedef {(...any) => void} LogFunction
@@ -4588,8 +2633,34 @@ const lintStaged = async (options = {}, logger = console) => {
 		throw runAllError;
 	}
 };
-//#endregion
-//#region src/staged/bin.ts
+// src/staged/logger.ts
+const workflowSuccessMessages = /* @__PURE__ */ new Set([
+	"✔ Done preparing lint-staged!",
+	"✔ Done running tasks for staged files!",
+	"✔ Done running tasks for changed files!",
+	"✔ Done staging changes from tasks!",
+	"✔ Done hiding unstaged changes to partially staged files!",
+	"✔ Done restoring untracked files!",
+	"✔ Done cleaning up temporary files!"
+]);
+function isWorkflowProgress(message) {
+	const text = stripVTControlCharacters(message);
+	if (text.includes("\n")) return false;
+	return text === "" || text.startsWith("⋯ ") || text.startsWith("    ") || workflowSuccessMessages.has(text) || /^✔ Done backing up original state \([\da-f]+\)!$/.test(text);
+}
+function createStagedLogger(logger = {
+	...console,
+	log
+}) {
+	return {
+		...logger,
+		log(message, ...args) {
+			if (typeof message === "string" && args.length === 0 && isWorkflowProgress(message)) return;
+			logger.log(message, ...args);
+		}
+	};
+}
+// src/staged/bin.ts
 const args = unwrapCliParseOutcome(parseStagedArgs(process.argv.slice(3)));
 const options = {};
 if (args.allowEmpty != null) options.allowEmpty = args.allowEmpty;
@@ -4626,7 +2697,6 @@ if (args.cwd != null) options.cwd = args.cwd;
 if (args.diff != null) options.diff = args.diff;
 if (args.diffFilter != null) options.diffFilter = args.diffFilter;
 if (args.concurrent != null) options.concurrent = args.concurrent;
-const success = await lintStaged(options);
+const success = await lintStaged(options, options.debug || options.quiet ? void 0 : createStagedLogger());
 process.exit(success ? 0 : 1);
-//#endregion
 export {};