@goodbyenjn/utils 26.2.0 → 26.4.0

package/dist/fs.js

@@ -1,5 +1,6 @@
-import { A as Result, D as safeParse, F as __commonJSMin, I as __toESM, M as ok, N as safeTry, O as stringify, j as err, l as removePrefix } from "./chunks/chunk-5ed3bc8a.js";
-import { Fn as e$1, Jt as n, Sn as e$2, gn as e } from "./chunks/chunk-b970a8d0.js";
+import { i as __toESM, t as __commonJSMin } from "./chunks/chunk-7ffde8d4.js";
+import { Gt as isString, Tt as isArray, pn as omit, zt as isNumber } from "./chunks/chunk-b61db0a7.js";
+import { A as Result, D as safeParse, M as ok, O as stringify, j as err, l as removePrefix } from "./chunks/chunk-486f65b0.js";
 import * as nativeFs$1 from "fs";
 import nativeFs from "fs";
 import path, { basename, dirname, normalize, posix, relative, resolve, sep } from "path";
@@ -9,27 +10,27 @@ import fs, { promises } from "node:fs";
 import path$1, { dirname as dirname$1 } from "node:path";
 
 //#region node_modules/.pnpm/fdir@6.5.0_picomatch@4.0.3/node_modules/fdir/dist/index.mjs
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-function cleanPath(path$2) {
-	let normalized = normalize(path$2);
+var __require = createRequire(import.meta.url);
+function cleanPath(path) {
+	let normalized = normalize(path);
 	if (normalized.length > 1 && normalized[normalized.length - 1] === sep) normalized = normalized.substring(0, normalized.length - 1);
 	return normalized;
 }
 const SLASHES_REGEX = /[\\/]/g;
-function convertSlashes(path$2, separator) {
-	return path$2.replace(SLASHES_REGEX, separator);
+function convertSlashes(path, separator) {
+	return path.replace(SLASHES_REGEX, separator);
 }
 const WINDOWS_ROOT_DIR_REGEX = /^[a-z]:[\\/]$/i;
-function isRootDirectory(path$2) {
-	return path$2 === "/" || WINDOWS_ROOT_DIR_REGEX.test(path$2);
+function isRootDirectory(path) {
+	return path === "/" || WINDOWS_ROOT_DIR_REGEX.test(path);
 }
-function normalizePath(path$2, options) {
+function normalizePath(path, options) {
 	const { resolvePaths, normalizePath: normalizePath$1, pathSeparator } = options;
-	const pathNeedsCleaning = process.platform === "win32" && path$2.includes("/") || path$2.startsWith(".");
-	if (resolvePaths) path$2 = resolve(path$2);
-	if (normalizePath$1 || pathNeedsCleaning) path$2 = cleanPath(path$2);
-	if (path$2 === ".") return "";
-	return convertSlashes(path$2[path$2.length - 1] !== pathSeparator ? path$2 + pathSeparator : path$2, pathSeparator);
+	const pathNeedsCleaning = process.platform === "win32" && path.includes("/") || path.startsWith(".");
+	if (resolvePaths) path = resolve(path);
+	if (normalizePath$1 || pathNeedsCleaning) path = cleanPath(path);
+	if (path === ".") return "";
+	return convertSlashes(path[path.length - 1] !== pathSeparator ? path + pathSeparator : path, pathSeparator);
 }
 function joinPathWithBasePath(filename, directoryPath) {
 	return directoryPath + filename;
@@ -65,8 +66,8 @@ const pushDirectory = (directoryPath, paths) => {
 	paths.push(directoryPath || ".");
 };
 const pushDirectoryFilter = (directoryPath, paths, filters) => {
-	const path$2 = directoryPath || ".";
-	if (filters.every((filter) => filter(path$2, true))) paths.push(path$2);
+	const path = directoryPath || ".";
+	if (filters.every((filter) => filter(path, true))) paths.push(path);
 };
 const empty$2 = () => {};
 function build$6(root, options) {
@@ -115,45 +116,45 @@ const empty = () => {};
 function build$3(options) {
 	return options.group ? groupFiles : empty;
 }
-const resolveSymlinksAsync = function(path$2, state, callback$1) {
-	const { queue, fs: fs$1, options: { suppressErrors } } = state;
+const resolveSymlinksAsync = function(path, state, callback$1) {
+	const { queue, fs, options: { suppressErrors } } = state;
 	queue.enqueue();
-	fs$1.realpath(path$2, (error, resolvedPath) => {
+	fs.realpath(path, (error, resolvedPath) => {
 		if (error) return queue.dequeue(suppressErrors ? null : error, state);
-		fs$1.stat(resolvedPath, (error$1, stat) => {
+		fs.stat(resolvedPath, (error$1, stat) => {
 			if (error$1) return queue.dequeue(suppressErrors ? null : error$1, state);
-			if (stat.isDirectory() && isRecursive(path$2, resolvedPath, state)) return queue.dequeue(null, state);
+			if (stat.isDirectory() && isRecursive(path, resolvedPath, state)) return queue.dequeue(null, state);
 			callback$1(stat, resolvedPath);
 			queue.dequeue(null, state);
 		});
 	});
 };
-const resolveSymlinks = function(path$2, state, callback$1) {
-	const { queue, fs: fs$1, options: { suppressErrors } } = state;
+const resolveSymlinks = function(path, state, callback$1) {
+	const { queue, fs, options: { suppressErrors } } = state;
 	queue.enqueue();
 	try {
-		const resolvedPath = fs$1.realpathSync(path$2);
-		const stat = fs$1.statSync(resolvedPath);
-		if (stat.isDirectory() && isRecursive(path$2, resolvedPath, state)) return;
+		const resolvedPath = fs.realpathSync(path);
+		const stat = fs.statSync(resolvedPath);
+		if (stat.isDirectory() && isRecursive(path, resolvedPath, state)) return;
 		callback$1(stat, resolvedPath);
-	} catch (e$3) {
-		if (!suppressErrors) throw e$3;
+	} catch (e) {
+		if (!suppressErrors) throw e;
 	}
 };
 function build$2(options, isSynchronous) {
 	if (!options.resolveSymlinks || options.excludeSymlinks) return null;
 	return isSynchronous ? resolveSymlinks : resolveSymlinksAsync;
 }
-function isRecursive(path$2, resolved, state) {
+function isRecursive(path, resolved, state) {
 	if (state.options.useRealPaths) return isRecursiveUsingRealPaths(resolved, state);
-	let parent = dirname(path$2);
+	let parent = dirname(path);
 	let depth = 1;
 	while (parent !== state.root && depth < 2) {
 		const resolvedPath = state.symlinks.get(parent);
 		if (!!resolvedPath && (resolvedPath === resolved || resolvedPath.startsWith(resolved) || resolved.startsWith(resolvedPath))) depth++;
 		else parent = dirname(parent);
 	}
-	state.symlinks.set(path$2, resolved);
+	state.symlinks.set(path, resolved);
 	return depth > 1;
 }
 function isRecursiveUsingRealPaths(resolved, state) {
@@ -202,35 +203,30 @@ const readdirOpts = { withFileTypes: true };
 const walkAsync = (state, crawlPath, directoryPath, currentDepth, callback$1) => {
 	state.queue.enqueue();
 	if (currentDepth < 0) return state.queue.dequeue(null, state);
-	const { fs: fs$1 } = state;
+	const { fs } = state;
 	state.visited.push(crawlPath);
 	state.counts.directories++;
-	fs$1.readdir(crawlPath || ".", readdirOpts, (error, entries = []) => {
+	fs.readdir(crawlPath || ".", readdirOpts, (error, entries = []) => {
 		callback$1(entries, directoryPath, currentDepth);
 		state.queue.dequeue(state.options.suppressErrors ? null : error, state);
 	});
 };
 const walkSync = (state, crawlPath, directoryPath, currentDepth, callback$1) => {
-	const { fs: fs$1 } = state;
+	const { fs } = state;
 	if (currentDepth < 0) return;
 	state.visited.push(crawlPath);
 	state.counts.directories++;
 	let entries = [];
 	try {
-		entries = fs$1.readdirSync(crawlPath || ".", readdirOpts);
-	} catch (e$3) {
-		if (!state.options.suppressErrors) throw e$3;
+		entries = fs.readdirSync(crawlPath || ".", readdirOpts);
+	} catch (e) {
+		if (!state.options.suppressErrors) throw e;
 	}
 	callback$1(entries, directoryPath, currentDepth);
 };
 function build(isSynchronous) {
 	return isSynchronous ? walkSync : walkAsync;
 }
-/**
-* This is a custom stateless queue to track concurrent async fs calls.
-* It increments a counter whenever a call is queued and decrements it
-* as soon as it completes. When the counter hits 0, it calls onQueueEmpty.
-*/
 var Queue = class {
 	count = 0;
 	constructor(onQueueEmpty) {
@@ -265,18 +261,10 @@ var Counter = class {
 	get directories() {
 		return this._directories;
 	}
-	/**
-	* @deprecated use `directories` instead
-	*/
-	/* c8 ignore next 3 */
 	get dirs() {
 		return this._directories;
 	}
 };
-/**
-* AbortController is not supported on Node 14 so we use this until we can drop
-* support for Node 14.
-*/
 var Aborter = class {
 	aborted = false;
 	abort() {
@@ -306,7 +294,7 @@ var Walker = class {
 			counts: new Counter(),
 			options,
 			queue: new Queue((error, state) => this.callbackInvoker(state, error, callback$1)),
-			symlinks: /* @__PURE__ */ new Map(),
+			symlinks: new Map(),
 			visited: [""].slice(0, 0),
 			controller: new Aborter(),
 			fs: options.fs || nativeFs$1
@@ -334,19 +322,19 @@ var Walker = class {
 				const filename = this.joinPath(entry.name, directoryPath);
 				this.pushFile(filename, files, this.state.counts, filters);
 			} else if (entry.isDirectory()) {
-				let path$2 = joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
-				if (exclude && exclude(entry.name, path$2)) continue;
-				this.pushDirectory(path$2, paths, filters);
-				this.walkDirectory(this.state, path$2, path$2, depth - 1, this.walk);
+				let path = joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
+				if (exclude && exclude(entry.name, path)) continue;
+				this.pushDirectory(path, paths, filters);
+				this.walkDirectory(this.state, path, path, depth - 1, this.walk);
 			} else if (this.resolveSymlink && entry.isSymbolicLink()) {
-				let path$2 = joinPathWithBasePath(entry.name, directoryPath);
-				this.resolveSymlink(path$2, this.state, (stat, resolvedPath) => {
+				let path = joinPathWithBasePath(entry.name, directoryPath);
+				this.resolveSymlink(path, this.state, (stat, resolvedPath) => {
 					if (stat.isDirectory()) {
 						resolvedPath = normalizePath(resolvedPath, this.state.options);
-						if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path$2 + pathSeparator)) return;
-						this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path$2 + pathSeparator, depth - 1, this.walk);
+						if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path + pathSeparator)) return;
+						this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path + pathSeparator, depth - 1, this.walk);
 					} else {
-						resolvedPath = useRealPaths ? resolvedPath : path$2;
+						resolvedPath = useRealPaths ? resolvedPath : path;
 						const filename = basename(resolvedPath);
 						const directoryPath$1 = normalizePath(dirname(resolvedPath), this.state.options);
 						resolvedPath = this.joinPath(filename, directoryPath$1);
@@ -359,10 +347,10 @@ var Walker = class {
 	};
 };
 function promise(root, options) {
-	return new Promise((resolve$1$1, reject) => {
-		callback(root, options, (err$1, output) => {
-			if (err$1) return reject(err$1);
-			resolve$1$1(output);
+	return new Promise((resolve$1, reject) => {
+		callback(root, options, (err, output) => {
+			if (err) return reject(err);
+			resolve$1(output);
 		});
 	});
 }
@@ -388,7 +376,6 @@ var APIBuilder = class {
 	}
 };
 let pm = null;
-/* c8 ignore next 6 */
 try {
 	__require.resolve("picomatch");
 	pm = __require("picomatch");
@@ -483,14 +470,6 @@ var Builder = class {
 		this.globFunction = fn;
 		return this;
 	}
-	/**
-	* @deprecated Pass options using the constructor instead:
-	* ```ts
-	* new fdir(options).crawl("/path/to/root");
-	* ```
-	* This method will be removed in v7.0
-	*/
-	/* c8 ignore next 4 */
 	crawlWithOptions(root, options) {
 		this.options = {
 			...this.options,
@@ -504,26 +483,22 @@ var Builder = class {
 	}
 	globWithOptions(patterns, ...options) {
 		const globFn = this.globFunction || pm;
-		/* c8 ignore next 5 */
 		if (!globFn) throw new Error("Please specify a glob function to use glob matching.");
 		var isMatch = this.globCache[patterns.join("\0")];
 		if (!isMatch) {
 			isMatch = globFn(patterns, ...options);
 			this.globCache[patterns.join("\0")] = isMatch;
 		}
-		this.options.filters.push((path$2) => isMatch(path$2));
+		this.options.filters.push((path) => isMatch(path));
 		return this;
 	}
 };
 
 //#endregion
 //#region node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/constants.js
-var require_constants = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+var require_constants = __commonJSMin(((exports, module) => {
 	const WIN_SLASH = "\\\\/";
 	const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
-	/**
-	* Posix glob regex
-	*/
 	const DOT_LITERAL = "\\.";
 	const PLUS_LITERAL = "\\+";
 	const QMARK_LITERAL = "\\?";
@@ -551,9 +526,6 @@ var require_constants = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		START_ANCHOR,
 		SEP: "/"
 	};
-	/**
-	* Windows glob regex
-	*/
 	const WINDOWS_CHARS = {
 		...POSIX_CHARS,
 		SLASH_LITERAL: `[${WIN_SLASH}]`,
@@ -569,9 +541,6 @@ var require_constants = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		END_ANCHOR: `(?:[${WIN_SLASH}]|$)`,
 		SEP: "\\"
 	};
-	/**
-	* POSIX Bracket Regex
-	*/
 	const POSIX_REGEX_SOURCE = {
 		alnum: "a-zA-Z0-9",
 		alpha: "a-zA-Z",
@@ -683,7 +652,7 @@ var require_constants = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 
 //#endregion
 //#region node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/utils.js
-var require_utils = /* @__PURE__ */ __commonJSMin(((exports) => {
+var require_utils = __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);
@@ -722,8 +691,8 @@ var require_utils = /* @__PURE__ */ __commonJSMin(((exports) => {
 		if (state.negated === true) output = `(?:^(?!${output}).*$)`;
 		return output;
 	};
-	exports.basename = (path$2, { windows } = {}) => {
-		const segs = path$2.split(windows ? /[\\/]/ : "/");
+	exports.basename = (path, { windows } = {}) => {
+		const segs = path.split(windows ? /[\\/]/ : "/");
 		const last = segs[segs.length - 1];
 		if (last === "") return segs[segs.length - 2];
 		return last;
@@ -732,7 +701,7 @@ var require_utils = /* @__PURE__ */ __commonJSMin(((exports) => {
 
 //#endregion
 //#region node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/scan.js
-var require_scan = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+var require_scan = __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) => {
@@ -741,22 +710,6 @@ var require_scan = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	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;
@@ -945,7 +898,7 @@ var require_scan = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		}
 		let base = str;
 		let prefix = "";
-		let glob$2 = "";
+		let glob = "";
 		if (start > 0) {
 			prefix = str.slice(0, start);
 			str = str.slice(start);
@@ -953,16 +906,16 @@ var require_scan = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		}
 		if (base && isGlob === true && lastIndex > 0) {
 			base = str.slice(0, lastIndex);
-			glob$2 = str.slice(lastIndex);
+			glob = str.slice(lastIndex);
 		} else if (isGlob === true) {
 			base = "";
-			glob$2 = str;
+			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$2) glob$2 = utils.removeBackslashes(glob$2);
+			if (glob) glob = utils.removeBackslashes(glob);
 			if (base && backslashes === true) base = utils.removeBackslashes(base);
 		}
 		const state = {
@@ -970,7 +923,7 @@ var require_scan = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			input,
 			start,
 			base,
-			glob: glob$2,
+			glob,
 			isBrace,
 			isBracket,
 			isGlob,
@@ -987,9 +940,9 @@ var require_scan = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		if (opts.parts === true || opts.tokens === true) {
 			let prevIndex;
 			for (let idx = 0; idx < slashes.length; idx++) {
-				const n$1 = prevIndex ? prevIndex + 1 : start;
+				const n = prevIndex ? prevIndex + 1 : start;
 				const i = slashes[idx];
-				const value = input.slice(n$1, i);
+				const value = input.slice(n, i);
 				if (opts.tokens) {
 					if (idx === 0 && start !== 0) {
 						tokens[idx].isPrefix = true;
@@ -1020,16 +973,10 @@ var require_scan = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 
 //#endregion
 //#region node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/parse.js
-var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+var require_parse = __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();
@@ -1041,18 +988,9 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		}
 		return value;
 	};
-	/**
-	* Create the message for a syntax error
-	*/
 	const syntaxError = (type, char) => {
 		return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
 	};
-	/**
-	* 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;
@@ -1070,8 +1008,8 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		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$1) => {
-			return `(${capture}(?:(?!${START_ANCHOR}${opts$1.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+		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;
@@ -1102,15 +1040,12 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		const stack = [];
 		let prev = bos;
 		let value;
-		/**
-		* Tokenizing helpers
-		*/
 		const eos = () => state.index === len - 1;
-		const peek = state.peek = (n$1 = 1) => input[state.index + n$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$1 = "", num = 0) => {
-			state.consumed += value$1;
+		const consume = (value = "", num = 0) => {
+			state.consumed += value;
 			state.index += num;
 		};
 		const append = (token) => {
@@ -1137,13 +1072,6 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			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");
@@ -1167,9 +1095,9 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			tokens.push(tok);
 			prev = tok;
 		};
-		const extglobOpen = (type, value$1) => {
+		const extglobOpen = (type, value) => {
 			const token = {
-				...EXTGLOB_CHARS[value$1],
+				...EXTGLOB_CHARS[value],
 				conditions: 1,
 				inner: ""
 			};
@@ -1180,7 +1108,7 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			increment("parens");
 			push({
 				type,
-				value: value$1,
+				value,
 				output: state.output ? "" : ONE_CHAR
 			});
 			push({
@@ -1212,9 +1140,6 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			});
 			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) => {
@@ -1245,15 +1170,9 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			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;
@@ -1283,10 +1202,6 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 					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);
@@ -1295,9 +1210,9 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 						if (inner.includes(":")) {
 							const idx = prev.value.lastIndexOf("[");
 							const pre = prev.value.slice(0, idx);
-							const posix$1 = POSIX_REGEX_SOURCE[prev.value.slice(idx + 2)];
-							if (posix$1) {
-								prev.value = pre + posix$1;
+							const posix = POSIX_REGEX_SOURCE[prev.value.slice(idx + 2)];
+							if (posix) {
+								prev.value = pre + posix;
 								state.backtrack = true;
 								advance();
 								if (!bos.output && tokens.indexOf(prev) === 1) bos.output = ONE_CHAR;
@@ -1313,19 +1228,12 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				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({
@@ -1334,9 +1242,6 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				});
 				continue;
 			}
-			/**
-			* Parentheses
-			*/
 			if (value === "(") {
 				increment("parens");
 				push({
@@ -1360,9 +1265,6 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				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", "]"));
@@ -1409,9 +1311,6 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				state.output += prev.value;
 				continue;
 			}
-			/**
-			* Braces
-			*/
 			if (value === "{" && opts.nobrace !== true) {
 				increment("braces");
 				const open = {
@@ -1464,9 +1363,6 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				braces.pop();
 				continue;
 			}
-			/**
-			* Pipes
-			*/
 			if (value === "|") {
 				if (extglobs.length > 0) extglobs[extglobs.length - 1].conditions++;
 				push({
@@ -1475,9 +1371,6 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				});
 				continue;
 			}
-			/**
-			* Commas
-			*/
 			if (value === ",") {
 				let output = value;
 				const brace = braces[braces.length - 1];
@@ -1492,9 +1385,6 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				});
 				continue;
 			}
-			/**
-			* Slashes
-			*/
 			if (value === "/") {
 				if (prev.type === "dot" && state.index === state.start + 1) {
 					state.start = state.index + 1;
@@ -1511,9 +1401,6 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				});
 				continue;
 			}
-			/**
-			* Dots
-			*/
 			if (value === ".") {
 				if (state.braces > 0 && prev.type === "dot") {
 					if (prev.value === ".") prev.output = DOT_LITERAL;
@@ -1539,9 +1426,6 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				});
 				continue;
 			}
-			/**
-			* Question marks
-			*/
 			if (value === "?") {
 				if (!(prev && prev.value === "(") && opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
 					extglobOpen("qmark", value);
@@ -1573,9 +1457,6 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				});
 				continue;
 			}
-			/**
-			* Exclamation
-			*/
 			if (value === "!") {
 				if (opts.noextglob !== true && peek() === "(") {
 					if (peek(2) !== "?" || !/[!=<:]/.test(peek(3))) {
@@ -1588,9 +1469,6 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 					continue;
 				}
 			}
-			/**
-			* Plus
-			*/
 			if (value === "+") {
 				if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
 					extglobOpen("plus", value);
@@ -1617,9 +1495,6 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				});
 				continue;
 			}
-			/**
-			* Plain text
-			*/
 			if (value === "@") {
 				if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
 					push({
@@ -1636,9 +1511,6 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				});
 				continue;
 			}
-			/**
-			* Plain text
-			*/
 			if (value !== "*") {
 				if (value === "$" || value === "^") value = `\\${value}`;
 				const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
@@ -1652,9 +1524,6 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				});
 				continue;
 			}
-			/**
-			* Stars
-			*/
 			if (prev && (prev.type === "globstar" || prev.star === true)) {
 				prev.type = "star";
 				prev.star = true;
@@ -1826,11 +1695,6 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		}
 		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;
@@ -1847,9 +1711,9 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		};
 		let star = opts.bash === true ? ".*?" : STAR;
 		if (opts.capture) star = `(${star})`;
-		const globstar = (opts$1) => {
-			if (opts$1.noglobstar === true) return star;
-			return `(${capture}(?:(?!${START_ANCHOR}${opts$1.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+		const globstar = (opts) => {
+			if (opts.noglobstar === true) return star;
+			return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
 		};
 		const create = (str) => {
 			switch (str) {
@@ -1864,9 +1728,9 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				default: {
 					const match = /^(.*?)\.(\w+)$/.exec(str);
 					if (!match) return;
-					const source$1 = create(match[1]);
-					if (!source$1) return;
-					return source$1 + DOT_LITERAL + match[2];
+					const source = create(match[1]);
+					if (!source) return;
+					return source + DOT_LITERAL + match[2];
 				}
 			}
 		};
@@ -1879,50 +1743,29 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 
 //#endregion
 //#region node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/picomatch.js
-var require_picomatch$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+var require_picomatch$1 = __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
-	* ```
-	* @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$2, options, returnState = false) => {
-		if (Array.isArray(glob$2)) {
-			const fns = glob$2.map((input) => picomatch(input, options, returnState));
+	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$1 = isMatch(str);
-					if (state$1) return state$1;
+					const state = isMatch(str);
+					if (state) return state;
 				}
 				return false;
 			};
 			return arrayMatcher;
 		}
-		const isState = isObject(glob$2) && glob$2.tokens && glob$2.input;
-		if (glob$2 === "" || typeof glob$2 !== "string" && !isState) throw new TypeError("Expected pattern to be a non-empty string");
+		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$1 = opts.windows;
-		const regex = isState ? picomatch.compileRe(glob$2, options) : picomatch.makeRe(glob$2, options, false, true);
+		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;
@@ -1937,14 +1780,14 @@ var require_picomatch$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		}
 		const matcher = (input, returnObject = false) => {
 			const { isMatch, match, output } = picomatch.test(input, regex, options, {
-				glob: glob$2,
-				posix: posix$1
+				glob,
+				posix
 			});
 			const result = {
-				glob: glob$2,
+				glob,
 				state,
 				regex,
-				posix: posix$1,
+				posix,
 				input,
 				output,
 				match,
@@ -1966,37 +1809,21 @@ var require_picomatch$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		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: glob$2, posix: posix$1 } = {}) => {
+	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$1 ? utils.toPosixSlashes : null);
-		let match = input === glob$2;
+		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$2;
+			match = output === glob;
 		}
-		if (match === false || opts.capture === true) if (opts.matchBase === true || opts.basename === true) match = picomatch.matchBase(input, regex, options, posix$1);
+		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),
@@ -2004,52 +1831,10 @@ var require_picomatch$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			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$2, options) => {
-		return (glob$2 instanceof RegExp ? glob$2 : picomatch.makeRe(glob$2, options)).test(utils.basename(input));
+	picomatch.matchBase = (input, glob, options) => {
+		return (glob instanceof RegExp ? glob : picomatch.makeRe(glob, options)).test(utils.basename(input));
 	};
-	/**
-	* 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, {
@@ -2057,44 +1842,7 @@ var require_picomatch$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			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.
-	*
-	* @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 || {};
@@ -2106,24 +1854,6 @@ var require_picomatch$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		if (returnState === true) regex.state = state;
 		return regex;
 	};
-	/**
-	* Create a regular expression from a parsed glob pattern.
-	*
-	* ```js
-	* const picomatch = require('picomatch');
-	* const state = picomatch.parse('*.js');
-	* // picomatch.compileRe(state[, options]);
-	*
-	* console.log(picomatch.compileRe(state));
-	* //=> /^(?:(?!\.)(?=.)[^/]*?\.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 = {
@@ -2134,53 +1864,30 @@ var require_picomatch$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		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$1) {
-			if (options && options.debug === true) throw err$1;
+		} 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/picomatch@4.0.3/node_modules/picomatch/index.js
-var require_picomatch = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+var require_picomatch = __commonJSMin(((exports, module) => {
 	const pico = require_picomatch$1();
 	const utils = require_utils();
-	function picomatch(glob$2, options, returnState = false) {
+	function picomatch(glob, options, returnState = false) {
 		if (options && (options.windows === null || options.windows === void 0)) options = {
 			...options,
 			windows: utils.isWindows()
 		};
-		return pico(glob$2, options, returnState);
+		return pico(glob, options, returnState);
 	}
 	Object.assign(picomatch, pico);
 	module.exports = picomatch;
@@ -2188,7 +1895,7 @@ var require_picomatch = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 
 //#endregion
 //#region node_modules/.pnpm/tinyglobby@0.2.15/node_modules/tinyglobby/dist/index.mjs
-var import_picomatch = /* @__PURE__ */ __toESM(require_picomatch(), 1);
+var import_picomatch = __toESM(require_picomatch(), 1);
 const isReadonlyArray = Array.isArray;
 const isWin = process.platform === "win32";
 const ONLY_PARENT_DIRECTORIES = /^(\/?\.\.)+$/;
@@ -2226,7 +1933,6 @@ function getPartialMatcher(patterns, options = {}) {
 		return false;
 	};
 }
-/* node:coverage ignore next 2 */
 const WIN32_ROOT_DIR = /^[A-Z]:\/$/i;
 const isRoot = isWin ? (p) => WIN32_ROOT_DIR.test(p) : (p) => p === "/";
 function buildFormat(cwd, root, absolute) {
@@ -2258,54 +1964,31 @@ function buildRelative(cwd, root) {
 	};
 }
 const splitPatternOptions = { parts: true };
-function splitPattern(path$1$1) {
+function splitPattern(path$1) {
 	var _result$parts;
-	const result = import_picomatch.default.scan(path$1$1, splitPatternOptions);
-	return ((_result$parts = result.parts) === null || _result$parts === void 0 ? void 0 : _result$parts.length) ? result.parts : [path$1$1];
+	const result = import_picomatch.default.scan(path$1, splitPatternOptions);
+	return ((_result$parts = result.parts) === null || _result$parts === void 0 ? void 0 : _result$parts.length) ? result.parts : [path$1];
 }
 const ESCAPED_WIN32_BACKSLASHES = /\\(?![()[\]{}!+@])/g;
-function convertPosixPathToPattern(path$1$1) {
-	return escapePosixPath(path$1$1);
+function convertPosixPathToPattern(path$1) {
+	return escapePosixPath(path$1);
 }
-function convertWin32PathToPattern(path$1$1) {
-	return escapeWin32Path(path$1$1).replace(ESCAPED_WIN32_BACKSLASHES, "/");
+function convertWin32PathToPattern(path$1) {
+	return escapeWin32Path(path$1).replace(ESCAPED_WIN32_BACKSLASHES, "/");
 }
-/**
-* Converts a path to a pattern depending on the platform.
-* Identical to {@link escapePath} on POSIX systems.
-* @see {@link https://superchupu.dev/tinyglobby/documentation#convertPathToPattern}
-*/
-/* node:coverage ignore next 3 */
 const convertPathToPattern = isWin ? convertWin32PathToPattern : convertPosixPathToPattern;
 const POSIX_UNESCAPED_GLOB_SYMBOLS = /(?<!\\)([()[\]{}*?|]|^!|[!+@](?=\()|\\(?![()[\]{}!*+?@|]))/g;
 const WIN32_UNESCAPED_GLOB_SYMBOLS = /(?<!\\)([()[\]{}]|^!|[!+@](?=\())/g;
-const escapePosixPath = (path$1$1) => path$1$1.replace(POSIX_UNESCAPED_GLOB_SYMBOLS, "\\$&");
-const escapeWin32Path = (path$1$1) => path$1$1.replace(WIN32_UNESCAPED_GLOB_SYMBOLS, "\\$&");
-/**
-* Escapes a path's special characters depending on the platform.
-* @see {@link https://superchupu.dev/tinyglobby/documentation#escapePath}
-*/
-/* node:coverage ignore next */
+const escapePosixPath = (path$1) => path$1.replace(POSIX_UNESCAPED_GLOB_SYMBOLS, "\\$&");
+const escapeWin32Path = (path$1) => path$1.replace(WIN32_UNESCAPED_GLOB_SYMBOLS, "\\$&");
 const escapePath = isWin ? escapeWin32Path : escapePosixPath;
-/**
-* Checks if a pattern has dynamic parts.
-*
-* Has a few minor differences with [`fast-glob`](https://github.com/mrmlnc/fast-glob) for better accuracy:
-*
-* - Doesn't necessarily return `false` on patterns that include `\`.
-* - Returns `true` if the pattern includes parentheses, regardless of them representing one single pattern or not.
-* - Returns `true` for unfinished glob extensions i.e. `(h`, `+(h`.
-* - Returns `true` for unfinished brace expansions as long as they include `,` or `..`.
-*
-* @see {@link https://superchupu.dev/tinyglobby/documentation#isDynamicPattern}
-*/
 function isDynamicPattern(pattern, options) {
 	if ((options === null || options === void 0 ? void 0 : options.caseSensitiveMatch) === false) return true;
 	const scan = import_picomatch.default.scan(pattern);
 	return scan.isGlob || scan.negated;
 }
 function log(...tasks) {
-	console.log(`[tinyglobby ${(/* @__PURE__ */ new Date()).toLocaleTimeString("es")}]`, ...tasks);
+	console.log(`[tinyglobby ${new Date().toLocaleTimeString("es")}]`, ...tasks);
 }
 const PARENT_DIRECTORY = /^(\/?\.\.)+/;
 const ESCAPING_BACKSLASHES = /\\(?=[()[\]{}!*+?@|])/g;
@@ -2320,17 +2003,17 @@ function normalizePattern(pattern, expandDirectories, cwd, props, isIgnore) {
 	const parentDirectoryMatch = PARENT_DIRECTORY.exec(result);
 	const parts = splitPattern(result);
 	if (parentDirectoryMatch === null || parentDirectoryMatch === void 0 ? void 0 : parentDirectoryMatch[0]) {
-		const n$1 = (parentDirectoryMatch[0].length + 1) / 3;
+		const n = (parentDirectoryMatch[0].length + 1) / 3;
 		let i = 0;
 		const cwdParts = escapedCwd.split("/");
-		while (i < n$1 && parts[i + n$1] === cwdParts[cwdParts.length + i - n$1]) {
-			result = result.slice(0, (n$1 - i - 1) * 3) + result.slice((n$1 - i) * 3 + parts[i + n$1].length + 1) || ".";
+		while (i < n && parts[i + n] === cwdParts[cwdParts.length + i - n]) {
+			result = result.slice(0, (n - i - 1) * 3) + result.slice((n - i) * 3 + parts[i + n].length + 1) || ".";
 			i++;
 		}
 		const potentialRoot = posix.join(cwd, parentDirectoryMatch[0].slice(i * 3));
 		if (!potentialRoot.startsWith(".") && props.root.length > potentialRoot.length) {
 			props.root = potentialRoot;
-			props.depthOffset = -n$1 + i;
+			props.depthOffset = -n + i;
 		}
 	}
 	if (!isIgnore && props.depthOffset >= 0) {
@@ -2372,10 +2055,10 @@ function processPatterns({ patterns = ["**/*"], ignore = [], expandDirectories =
 		ignore: ignorePatterns
 	};
 }
-function formatPaths(paths, relative$1) {
+function formatPaths(paths, relative) {
 	for (let i = paths.length - 1; i >= 0; i--) {
-		const path$1$1 = paths[i];
-		paths[i] = relative$1(path$1$1);
+		const path$1 = paths[i];
+		paths[i] = relative(path$1);
 	}
 	return paths;
 }
@@ -2427,9 +2110,9 @@ function getCrawler(patterns, inputOptions = {}) {
 	const formatExclude = options.absolute ? format : buildFormat(cwd, props.root, true);
 	const fdirOptions = {
 		filters: [options.debug ? (p, isDirectory) => {
-			const path$1$1 = format(p, isDirectory);
-			const matches = matcher(path$1$1);
-			if (matches) log(`matched ${path$1$1}`);
+			const path$1 = format(p, isDirectory);
+			const matches = matcher(path$1);
+			if (matches) log(`matched ${path$1}`);
 			return matches;
 		} : (p, isDirectory) => matcher(format(p, isDirectory))],
 		exclude: options.debug ? (_, p) => {
@@ -2472,33 +2155,33 @@ function getCrawler(patterns, inputOptions = {}) {
 	props.root = props.root.replace(BACKSLASHES, "");
 	const root = props.root;
 	if (options.debug) log("internal properties:", props);
-	const relative$1 = cwd !== root && !options.absolute && buildRelative(cwd, props.root);
-	return [new Builder(fdirOptions).crawl(root), relative$1];
+	const relative = cwd !== root && !options.absolute && buildRelative(cwd, props.root);
+	return [new Builder(fdirOptions).crawl(root), relative];
 }
 async function glob$1(patternsOrOptions, options) {
 	if (patternsOrOptions && (options === null || options === void 0 ? void 0 : options.patterns)) throw new Error("Cannot pass patterns as both an argument and an option");
 	const isModern = isReadonlyArray(patternsOrOptions) || typeof patternsOrOptions === "string";
 	const opts = isModern ? options : patternsOrOptions;
-	const [crawler, relative$1] = getCrawler(isModern ? patternsOrOptions : patternsOrOptions.patterns, opts);
-	if (!relative$1) return crawler.withPromise();
-	return formatPaths(await crawler.withPromise(), relative$1);
+	const [crawler, relative] = getCrawler(isModern ? patternsOrOptions : patternsOrOptions.patterns, opts);
+	if (!relative) return crawler.withPromise();
+	return formatPaths(await crawler.withPromise(), relative);
 }
 function globSync$1(patternsOrOptions, options) {
 	if (patternsOrOptions && (options === null || options === void 0 ? void 0 : options.patterns)) throw new Error("Cannot pass patterns as both an argument and an option");
 	const isModern = isReadonlyArray(patternsOrOptions) || typeof patternsOrOptions === "string";
 	const opts = isModern ? options : patternsOrOptions;
-	const [crawler, relative$1] = getCrawler(isModern ? patternsOrOptions : patternsOrOptions.patterns, opts);
-	if (!relative$1) return crawler.sync();
-	return formatPaths(crawler.sync(), relative$1);
+	const [crawler, relative] = getCrawler(isModern ? patternsOrOptions : patternsOrOptions.patterns, opts);
+	if (!relative) return crawler.sync();
+	return formatPaths(crawler.sync(), relative);
 }
 
 //#endregion
 //#region src/fs/glob.ts
 const normalizeArgs = (patternsOrOptions, maybeOptions) => {
-	const patternsAsArgument = e(patternsOrOptions) || e$1(patternsOrOptions);
+	const patternsAsArgument = isString(patternsOrOptions) || isArray(patternsOrOptions);
 	return {
 		patterns: patternsAsArgument ? patternsOrOptions : patternsOrOptions.patterns,
-		options: patternsAsArgument ? maybeOptions || {} : n(patternsOrOptions, ["patterns"])
+		options: patternsAsArgument ? maybeOptions || {} : omit(patternsOrOptions, ["patterns"])
 	};
 };
 function glob(...args) {
@@ -2524,7 +2207,7 @@ const parseEncodingOptions = (options) => {
 	return encoding === "buffer" ? {} : { encoding };
 };
 const parseWriteJsonOptions = (options) => {
-	if (e$2(options)) return {
+	if (isNumber(options)) return {
 		indent: options,
 		encoding: parseEncodingOptions()
 	};
@@ -2533,89 +2216,89 @@ const parseWriteJsonOptions = (options) => {
 		encoding: parseEncodingOptions(options)
 	};
 };
-const appendFile$1 = async (path$2, data, options) => safeTry(async function* () {
+const appendFile$1 = async (path, data, options) => Result.gen(async function* () {
 	const newline = options?.newline ?? true;
-	yield* await mkdir$1(dirname$1(pathLikeToPath(path$2).toString()));
+	yield* await mkdir$1(dirname$1(pathLikeToPath(path).toString()));
 	const fn = async () => {
-		await promises.appendFile(path$2, newline ? `\n${data}` : data, parseEncodingOptions(options));
+		await promises.appendFile(path, newline ? `\n${data}` : data, parseEncodingOptions(options));
 	};
-	return (await Result.fromCallable(fn, Error)).context(`Failed to append file: ${path$2}`);
+	return (await Result.try(fn, Error)).context(`Failed to append file: ${path}`);
 });
-const appendFileSync$1 = (path$2, data, options) => safeTry(function* () {
+const appendFileSync$1 = (path, data, options) => Result.gen(function* () {
 	const newline = options?.newline ?? true;
-	yield* mkdirSync$1(dirname$1(pathLikeToPath(path$2).toString()));
+	yield* mkdirSync$1(dirname$1(pathLikeToPath(path).toString()));
 	const fn = () => {
-		fs.appendFileSync(path$2, newline ? `\n${data}` : data, parseEncodingOptions(options));
+		fs.appendFileSync(path, newline ? `\n${data}` : data, parseEncodingOptions(options));
 	};
-	return Result.fromCallable(fn, Error).context(`Failed to append file: ${path$2}`);
+	return Result.try(fn, Error).context(`Failed to append file: ${path}`);
 });
 const cp$1 = async (source, destination, options) => {
 	const { recursive = true } = options || {};
 	const fn = async () => {
 		await promises.cp(source, destination, { recursive });
 	};
-	return (await Result.fromCallable(fn, Error)).context(`Failed to copy path: ${source} to ${destination}`);
+	return (await Result.try(fn, Error)).context(`Failed to copy path: ${source} to ${destination}`);
 };
 const cpSync$1 = (source, destination, options) => {
 	const { recursive = true } = options || {};
 	const fn = () => {
 		fs.cpSync(source, destination, { recursive });
 	};
-	return Result.fromCallable(fn, Error).context(`Failed to copy path: ${source} to ${destination}`);
+	return Result.try(fn, Error).context(`Failed to copy path: ${source} to ${destination}`);
 };
-const exists$1 = async (path$2) => {
+const exists$1 = async (path) => {
 	const fn = async () => {
-		await promises.access(path$2);
+		await promises.access(path);
 		return true;
 	};
-	return (await Result.fromCallable(fn, Error)).context(`Failed to check exists for path: ${path$2}`);
+	return (await Result.try(fn, Error)).context(`Failed to check exists for path: ${path}`);
 };
-const existsSync$1 = (path$2) => {
+const existsSync$1 = (path) => {
 	const fn = () => {
-		fs.accessSync(path$2);
+		fs.accessSync(path);
 		return true;
 	};
-	return Result.fromCallable(fn, Error).context(`Failed to check exists for path: ${path$2}`);
+	return Result.try(fn, Error).context(`Failed to check exists for path: ${path}`);
 };
-const mkdir$1 = async (path$2, options) => {
+const mkdir$1 = async (path, options) => {
 	const { recursive = true } = options || {};
-	if ((await exists$1(path$2)).isOk()) return ok();
+	if ((await exists$1(path)).isOk()) return ok();
 	const fn = async () => {
-		await promises.mkdir(path$2, { recursive });
+		await promises.mkdir(path, { recursive });
 	};
-	return (await Result.fromCallable(fn, Error)).context(`Failed to create directory: ${path$2}`);
+	return (await Result.try(fn, Error)).context(`Failed to create directory: ${path}`);
 };
-const mkdirSync$1 = (path$2, options) => {
+const mkdirSync$1 = (path, options) => {
 	const { recursive = true } = options || {};
-	if (existsSync$1(path$2).isOk()) return ok();
+	if (existsSync$1(path).isOk()) return ok();
 	const fn = () => {
-		fs.mkdirSync(path$2, { recursive });
+		fs.mkdirSync(path, { recursive });
 	};
-	return Result.fromCallable(fn, Error).context(`Failed to create directory: ${path$2}`);
+	return Result.try(fn, Error).context(`Failed to create directory: ${path}`);
 };
-async function readFile$1(path$2, options) {
-	return safeTry(async function* () {
-		yield* await exists$1(path$2);
+async function readFile$1(path, options) {
+	return Result.gen(async function* () {
+		yield* await exists$1(path);
 		const fn = async () => {
-			return await promises.readFile(path$2, parseEncodingOptions(options));
+			return await promises.readFile(path, parseEncodingOptions(options));
 		};
-		return (await Result.fromCallable(fn, Error)).context(`Failed to read file: ${path$2}`);
+		return (await Result.try(fn, Error)).context(`Failed to read file: ${path}`);
 	});
 }
-function readFileSync$1(path$2, options) {
-	return safeTry(function* () {
-		yield* existsSync$1(path$2);
+function readFileSync$1(path, options) {
+	return Result.gen(function* () {
+		yield* existsSync$1(path);
 		const fn = () => {
-			return fs.readFileSync(path$2, parseEncodingOptions(options));
+			return fs.readFileSync(path, parseEncodingOptions(options));
 		};
-		return Result.fromCallable(fn, Error).context(`Failed to read file: ${path$2}`);
+		return Result.try(fn, Error).context(`Failed to read file: ${path}`);
 	});
 }
-const readFileByLine$1 = (path$2, options) => safeTry(async function* () {
-	yield* await exists$1(path$2);
+const readFileByLine$1 = (path, options) => Result.gen(async function* () {
+	yield* await exists$1(path);
 	const { createInterface } = await import("node:readline");
 	const fn = () => {
-		const stream = fs.createReadStream(path$2, {
+		const stream = fs.createReadStream(path, {
 			...parseEncodingOptions(options),
 			autoClose: true
 		});
@@ -2627,67 +2310,67 @@ const readFileByLine$1 = (path$2, options) => safeTry(async function* () {
 			crlfDelay: Infinity
 		});
 	};
-	return Result.fromCallable(fn, Error).context(`Failed to read file: ${path$2}`);
+	return Result.try(fn, Error).context(`Failed to read file: ${path}`);
 });
-const readJson$1 = async (path$2, options) => safeTry(async function* () {
-	const content = yield* await readFile$1(path$2, options);
-	if (!content) return err(/* @__PURE__ */ new Error(`JSON file is empty: ${path$2}`));
-	return safeParse(content).context(`Failed to parse JSON file: ${path$2}`);
+const readJson$1 = async (path, options) => Result.gen(async function* () {
+	const content = yield* await readFile$1(path, options);
+	if (!content) return err(new Error(`JSON file is empty: ${path}`));
+	return safeParse(content).context(`Failed to parse JSON file: ${path}`);
 });
-const readJsonSync$1 = (path$2, options) => safeTry(function* () {
-	const content = yield* readFileSync$1(path$2, options);
-	if (!content) return err(/* @__PURE__ */ new Error(`JSON file is empty: ${path$2}`));
-	return safeParse(content).context(`Failed to parse JSON file: ${path$2}`);
+const readJsonSync$1 = (path, options) => Result.gen(function* () {
+	const content = yield* readFileSync$1(path, options);
+	if (!content) return err(new Error(`JSON file is empty: ${path}`));
+	return safeParse(content).context(`Failed to parse JSON file: ${path}`);
 });
-const rm$1 = async (path$2, options) => {
+const rm$1 = async (path, options) => {
 	const { force = true, recursive = true } = options || {};
 	const fn = async () => {
-		await promises.rm(path$2, {
+		await promises.rm(path, {
 			force,
 			recursive
 		});
 	};
-	return (await Result.fromCallable(fn, Error)).context(`Failed to remove path: ${path$2}`);
+	return (await Result.try(fn, Error)).context(`Failed to remove path: ${path}`);
 };
-const rmSync$1 = (path$2, options) => {
+const rmSync$1 = (path, options) => {
 	const { force = true, recursive = true } = options || {};
 	const fn = () => {
-		fs.rmSync(path$2, {
+		fs.rmSync(path, {
 			force,
 			recursive
 		});
 	};
-	return Result.fromCallable(fn, Error).context(`Failed to remove path: ${path$2}`);
+	return Result.try(fn, Error).context(`Failed to remove path: ${path}`);
 };
-const writeFile = async (path$2, data, options) => safeTry(async function* () {
-	yield* await mkdir$1(dirname$1(pathLikeToPath(path$2).toString()));
+const writeFile = async (path, data, options) => Result.gen(async function* () {
+	yield* await mkdir$1(dirname$1(pathLikeToPath(path).toString()));
 	const fn = async () => {
-		await promises.writeFile(path$2, data, parseEncodingOptions(options));
+		await promises.writeFile(path, data, parseEncodingOptions(options));
 	};
-	return (await Result.fromCallable(fn, Error)).context(`Failed to write file: ${path$2}`);
+	return (await Result.try(fn, Error)).context(`Failed to write file: ${path}`);
 });
-const writeFileSync = (path$2, data, options) => {
+const writeFileSync = (path, data, options) => {
 	const fn = () => {
-		fs.writeFileSync(path$2, data, parseEncodingOptions(options));
+		fs.writeFileSync(path, data, parseEncodingOptions(options));
 	};
-	return Result.fromCallable(fn, Error).context(`Failed to write file: ${path$2}`);
+	return Result.try(fn, Error).context(`Failed to write file: ${path}`);
 };
-const writeJson = async (path$2, data, indentOrOptions) => {
+const writeJson = async (path, data, indentOrOptions) => {
 	const { indent, encoding } = parseWriteJsonOptions(indentOrOptions);
-	return writeFile(path$2, stringify(data, null, indent) ?? "", encoding);
+	return writeFile(path, stringify(data, null, indent) ?? "", encoding);
 };
-const writeJsonSync = (path$2, data, indentOrOptions) => {
+const writeJsonSync = (path, data, indentOrOptions) => {
 	const { indent, encoding } = parseWriteJsonOptions(indentOrOptions);
-	return writeFileSync(path$2, stringify(data, null, indent) ?? "", encoding);
+	return writeFileSync(path, stringify(data, null, indent) ?? "", encoding);
 };
 
 //#endregion
 //#region src/fs/unsafe.ts
-const appendFile = async (path$2, data, options) => {
-	await appendFile$1(path$2, data, options);
+const appendFile = async (path, data, options) => {
+	await appendFile$1(path, data, options);
 };
-const appendFileSync = (path$2, data, options) => {
-	appendFileSync$1(path$2, data, options);
+const appendFileSync = (path, data, options) => {
+	appendFileSync$1(path, data, options);
 };
 const cp = async (source, destination, options) => {
 	await cp$1(source, destination, options);
@@ -2695,60 +2378,60 @@ const cp = async (source, destination, options) => {
 const cpSync = (source, destination, options) => {
 	cpSync$1(source, destination, options);
 };
-const exists = async (path$2) => {
-	return (await exists$1(path$2)).isOk();
+const exists = async (path) => {
+	return (await exists$1(path)).isOk();
 };
-const existsSync = (path$2) => {
-	return existsSync$1(path$2).isOk();
+const existsSync = (path) => {
+	return existsSync$1(path).isOk();
 };
-const mkdir = async (path$2, options) => {
-	await mkdir$1(path$2, options);
+const mkdir = async (path, options) => {
+	await mkdir$1(path, options);
 };
-const mkdirSync = (path$2, options) => {
-	mkdirSync$1(path$2, options);
+const mkdirSync = (path, options) => {
+	mkdirSync$1(path, options);
 };
-async function readFile(path$2, options) {
-	const result = await readFile$1(path$2, options);
+async function readFile(path, options) {
+	const result = await readFile$1(path, options);
 	if (result.isErr()) return void 0;
 	return result.unwrap(null);
 }
-function readFileSync(path$2, options) {
-	const result = readFileSync$1(path$2, options);
+function readFileSync(path, options) {
+	const result = readFileSync$1(path, options);
 	if (result.isErr()) return void 0;
 	return result.unwrap(null);
 }
-const readFileByLine = async (path$2, options) => {
-	const result = await readFileByLine$1(path$2, options);
+const readFileByLine = async (path, options) => {
+	const result = await readFileByLine$1(path, options);
 	if (result.isErr()) return void 0;
 	return result.unwrap(null);
 };
-const readJson = async (path$2, options) => {
-	const result = await readJson$1(path$2, options);
+const readJson = async (path, options) => {
+	const result = await readJson$1(path, options);
 	if (result.isErr()) return void 0;
 	return result.unwrap(null);
 };
-const readJsonSync = (path$2, options) => {
-	const result = readJsonSync$1(path$2, options);
+const readJsonSync = (path, options) => {
+	const result = readJsonSync$1(path, options);
 	if (result.isErr()) return void 0;
 	return result.unwrap(null);
 };
-const rm = async (path$2, options) => {
-	await rm$1(path$2, options);
+const rm = async (path, options) => {
+	await rm$1(path, options);
 };
-const rmSync = (path$2, options) => {
-	rmSync$1(path$2, options);
+const rmSync = (path, options) => {
+	rmSync$1(path, options);
 };
-const writeFile$1 = async (path$2, data, options) => {
-	await writeFile(path$2, data, options);
+const writeFile$1 = async (path, data, options) => {
+	await writeFile(path, data, options);
 };
-const writeFileSync$1 = (path$2, data, options) => {
-	writeFileSync(path$2, data, options);
+const writeFileSync$1 = (path, data, options) => {
+	writeFileSync(path, data, options);
 };
-const writeJson$1 = async (path$2, data, indentOrOptions) => {
-	await writeJson(path$2, data, indentOrOptions);
+const writeJson$1 = async (path, data, indentOrOptions) => {
+	await writeJson(path, data, indentOrOptions);
 };
-const writeJsonSync$1 = (path$2, data, indentOrOptions) => {
-	writeJsonSync(path$2, data, indentOrOptions);
+const writeJsonSync$1 = (path, data, indentOrOptions) => {
+	writeJsonSync(path, data, indentOrOptions);
 };
 
 //#endregion
@@ -2765,68 +2448,37 @@ var VFile = class VFile {
 		});
 	}
 	content = "";
-	/**
-	* @example
-	* `/home/user/project`
-	*/
 	cwd = process.cwd();
-	/**
-	* @example
-	* `src`
-	*/
 	dirname = "";
-	/**
-	* @example
-	* `index`
-	*/
 	filename = "";
-	/**
-	* @example
-	* `js`
-	*/
 	extname = "";
 	constructor(options) {
 		const { pathname, content, cwd } = options;
-		this.pathname = pathname;
 		if (content) this.content = content;
 		if (cwd) this.cwd = cwd;
+		if (path$1.isAbsolute(pathname)) this.pathname = pathname;
+		else this.relativePathname = pathname;
 	}
-	/**
-	* @example
-	* `/home/user/project/src/index.js`
-	*/
 	get pathname() {
 		return path$1.resolve(this.cwd, this.dirname, this.basename);
 	}
 	set pathname(value) {
 		this.parse(value);
 	}
-	/**
-	* @example
-	* `index.js`
-	*/
 	get basename() {
-		return this.filename + "." + this.extname;
+		return this.extname ? this.filename + "." + this.extname : this.filename;
 	}
 	set basename(value) {
 		const { name, ext } = path$1.parse(value);
 		this.filename = name;
-		this.extname = removePrefix(ext, ".");
+		this.extname = removePrefix(".", ext);
 	}
-	/**
-	* @example
-	* `/home/user/project/src`
-	*/
 	get absoluteDirname() {
 		return path$1.resolve(this.cwd, this.dirname);
 	}
 	set absoluteDirname(value) {
 		this.dirname = path$1.relative(this.cwd, value);
 	}
-	/**
-	* @example
-	* `src/index.js`
-	*/
 	get relativePathname() {
 		return path$1.relative(this.cwd, this.pathname);
 	}
@@ -2841,9 +2493,10 @@ var VFile = class VFile {
 		});
 	}
 	parse(value) {
+		const { name, ext } = path$1.parse(value);
 		this.dirname = path$1.relative(this.cwd, path$1.dirname(value));
-		this.extname = path$1.extname(value);
-		this.filename = path$1.basename(value, this.extname);
+		this.filename = name;
+		this.extname = removePrefix(".", ext);
 	}
 };