@goodbyenjn/utils 26.4.0 → 26.4.2

package/dist/fs.js

@@ -1,15 +1,15 @@
-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";
+import { a as __toESM, t as __commonJSMin } from "./chunks/chunk-3ce2ea14.js";
+import { $t as isArray, C as isNil, Si as err, Vn as omit, l as removePrefix, pn as isNumber, w as nil$2, wi as ok, xi as Result, yn as isString } from "./chunks/chunk-11b9216b.js";
+import { i as stringify, n as stringify$1, r as parse, t as parse$1 } from "./chunks/chunk-1b381080.js";
+import path, { dirname } from "node:path";
+import { basename, dirname as dirname$1, isAbsolute, normalize, posix, relative, resolve, sep } from "path";
+import * as nativeFs from "fs";
+import { readdir, readdirSync, realpath, realpathSync, stat, statSync } from "fs";
 import { fileURLToPath } from "url";
 import { createRequire } from "module";
+import url from "node:url";
 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
+//#region node_modules/.pnpm/fdir@6.5.0_picomatch@4.0.4/node_modules/fdir/dist/index.mjs
 var __require = createRequire(import.meta.url);
 function cleanPath(path) {
 	let normalized = normalize(path);
@@ -147,12 +147,12 @@ function build$2(options, isSynchronous) {
 }
 function isRecursive(path, resolved, state) {
 	if (state.options.useRealPaths) return isRecursiveUsingRealPaths(resolved, state);
-	let parent = dirname(path);
+	let parent = dirname$1(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);
+		else parent = dirname$1(parent);
 	}
 	state.symlinks.set(path, resolved);
 	return depth > 1;
@@ -297,7 +297,7 @@ var Walker = class {
 			symlinks: new Map(),
 			visited: [""].slice(0, 0),
 			controller: new Aborter(),
-			fs: options.fs || nativeFs$1
+			fs: options.fs || nativeFs
 		};
 		this.joinPath = build$7(this.root, options);
 		this.pushDirectory = build$6(this.root, options);
@@ -336,7 +336,7 @@ var Walker = class {
 					} else {
 						resolvedPath = useRealPaths ? resolvedPath : path;
 						const filename = basename(resolvedPath);
-						const directoryPath$1 = normalizePath(dirname(resolvedPath), this.state.options);
+						const directoryPath$1 = normalizePath(dirname$1(resolvedPath), this.state.options);
 						resolvedPath = this.joinPath(filename, directoryPath$1);
 						this.pushFile(resolvedPath, files, this.state.counts, filters);
 					}
@@ -493,12 +493,12 @@ var Builder = class {
 		return this;
 	}
 };
-
 //#endregion
-//#region node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/constants.js
+//#region node_modules/.pnpm/picomatch@4.0.4/node_modules/picomatch/lib/constants.js
 var require_constants = __commonJSMin(((exports, module) => {
 	const WIN_SLASH = "\\\\/";
 	const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
+	const DEFAULT_MAX_EXTGLOB_RECURSION = 0;
 	const DOT_LITERAL = "\\.";
 	const PLUS_LITERAL = "\\+";
 	const QMARK_LITERAL = "\\?";
@@ -541,25 +541,26 @@ var require_constants = __commonJSMin(((exports, module) => {
 		END_ANCHOR: `(?:[${WIN_SLASH}]|$)`,
 		SEP: "\\"
 	};
-	const POSIX_REGEX_SOURCE = {
-		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"
-	};
 	module.exports = {
+		DEFAULT_MAX_EXTGLOB_RECURSION,
 		MAX_LENGTH: 1024 * 64,
-		POSIX_REGEX_SOURCE,
+		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: /[-*+?.^${}(|)[\]]/,
@@ -649,9 +650,8 @@ var require_constants = __commonJSMin(((exports, module) => {
 		}
 	};
 }));
-
 //#endregion
-//#region node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/utils.js
+//#region node_modules/.pnpm/picomatch@4.0.4/node_modules/picomatch/lib/utils.js
 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);
@@ -698,9 +698,8 @@ var require_utils = __commonJSMin(((exports) => {
 		return last;
 	};
 }));
-
 //#endregion
-//#region node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/scan.js
+//#region node_modules/.pnpm/picomatch@4.0.4/node_modules/picomatch/lib/scan.js
 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();
@@ -970,9 +969,8 @@ var require_scan = __commonJSMin(((exports, module) => {
 	};
 	module.exports = scan;
 }));
-
 //#endregion
-//#region node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/parse.js
+//#region node_modules/.pnpm/picomatch@4.0.4/node_modules/picomatch/lib/parse.js
 var require_parse = __commonJSMin(((exports, module) => {
 	const constants = require_constants();
 	const utils = require_utils();
@@ -991,6 +989,177 @@ var require_parse = __commonJSMin(((exports, module) => {
 	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 getStarExtglobSequenceOutput = (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.length === 1 ? utils.escapeRegex(chars[0]) : `[${chars.map((ch) => utils.escapeRegex(ch)).join("")}]`}*`;
+	};
+	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 };
+		}
+		for (const branch of branches) {
+			const safeOutput = getStarExtglobSequenceOutput(branch);
+			if (safeOutput) return {
+				risky: true,
+				safeOutput
+			};
+			if (repeatedExtglobRecursion(branch) > max) return { risky: true };
+		}
+		return { risky: false };
+	};
 	const parse = (input, options) => {
 		if (typeof input !== "string") throw new TypeError("Expected a string");
 		input = REPLACEMENTS[input] || input;
@@ -1104,6 +1273,8 @@ var require_parse = __commonJSMin(((exports, module) => {
 			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({
@@ -1120,6 +1291,30 @@ var require_parse = __commonJSMin(((exports, module) => {
 			extglobs.push(token);
 		};
 		const extglobClose = (token) => {
+			const literal = input.slice(token.startIndex, state.index + 1);
+			const analysis = analyzeRepeatedExtglob(input.slice(token.startIndex + 2, state.index), 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") {
@@ -1740,9 +1935,8 @@ var require_parse = __commonJSMin(((exports, module) => {
 	};
 	module.exports = parse;
 }));
-
 //#endregion
-//#region node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/picomatch.js
+//#region node_modules/.pnpm/picomatch@4.0.4/node_modules/picomatch/lib/picomatch.js
 var require_picomatch$1 = __commonJSMin(((exports, module) => {
 	const scan = require_scan();
 	const parse = require_parse();
@@ -1876,10 +2070,9 @@ var require_picomatch$1 = __commonJSMin(((exports, module) => {
 	picomatch.constants = constants;
 	module.exports = picomatch;
 }));
-
 //#endregion
-//#region node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/index.js
-var require_picomatch = __commonJSMin(((exports, module) => {
+//#region node_modules/.pnpm/tinyglobby@0.2.16/node_modules/tinyglobby/dist/index.mjs
+var import_picomatch = __toESM(__commonJSMin(((exports, module) => {
 	const pico = require_picomatch$1();
 	const utils = require_utils();
 	function picomatch(glob, options, returnState = false) {
@@ -1891,41 +2084,38 @@ var require_picomatch = __commonJSMin(((exports, module) => {
 	}
 	Object.assign(picomatch, pico);
 	module.exports = picomatch;
-}));
-
-//#endregion
-//#region node_modules/.pnpm/tinyglobby@0.2.15/node_modules/tinyglobby/dist/index.mjs
-var import_picomatch = __toESM(require_picomatch(), 1);
+}))(), 1);
 const isReadonlyArray = Array.isArray;
+const BACKSLASHES = /\\/g;
 const isWin = process.platform === "win32";
 const ONLY_PARENT_DIRECTORIES = /^(\/?\.\.)+$/;
 function getPartialMatcher(patterns, options = {}) {
 	const patternsCount = patterns.length;
 	const patternsParts = Array(patternsCount);
 	const matchers = Array(patternsCount);
-	const globstarEnabled = !options.noglobstar;
-	for (let i = 0; i < patternsCount; i++) {
+	let i, j;
+	for (i = 0; i < patternsCount; i++) {
 		const parts = splitPattern(patterns[i]);
 		patternsParts[i] = parts;
 		const partsCount = parts.length;
 		const partMatchers = Array(partsCount);
-		for (let j = 0; j < partsCount; j++) partMatchers[j] = (0, import_picomatch.default)(parts[j], options);
+		for (j = 0; j < partsCount; j++) partMatchers[j] = (0, import_picomatch.default)(parts[j], options);
 		matchers[i] = partMatchers;
 	}
 	return (input) => {
 		const inputParts = input.split("/");
 		if (inputParts[0] === ".." && ONLY_PARENT_DIRECTORIES.test(input)) return true;
-		for (let i = 0; i < patterns.length; i++) {
+		for (i = 0; i < patternsCount; i++) {
 			const patternParts = patternsParts[i];
 			const matcher = matchers[i];
 			const inputPatternCount = inputParts.length;
 			const minParts = Math.min(inputPatternCount, patternParts.length);
-			let j = 0;
+			j = 0;
 			while (j < minParts) {
 				const part = patternParts[j];
 				if (part.includes("/")) return true;
 				if (!matcher[j](inputParts[j])) break;
-				if (globstarEnabled && part === "**") return true;
+				if (!options.noglobstar && part === "**") return true;
 				j++;
 			}
 			if (j === inputPatternCount) return true;
@@ -1938,7 +2128,7 @@ const isRoot = isWin ? (p) => WIN32_ROOT_DIR.test(p) : (p) => p === "/";
 function buildFormat(cwd, root, absolute) {
 	if (cwd === root || root.startsWith(`${cwd}/`)) {
 		if (absolute) {
-			const start = isRoot(cwd) ? cwd.length : cwd.length + 1;
+			const start = cwd.length + +!isRoot(cwd);
 			return (p, isDir) => p.slice(start, isDir ? -1 : void 0) || ".";
 		}
 		const prefix = root.slice(cwd.length + 1);
@@ -1959,28 +2149,27 @@ function buildRelative(cwd, root) {
 	}
 	return (p) => {
 		const result = posix.relative(cwd, `${root}/${p}`);
-		if (p.endsWith("/") && result !== "") return `${result}/`;
-		return result || ".";
+		return p[p.length - 1] === "/" && result !== "" ? `${result}/` : result || ".";
 	};
 }
 const splitPatternOptions = { parts: true };
-function splitPattern(path$1) {
+function splitPattern(path) {
 	var _result$parts;
-	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 result = import_picomatch.default.scan(path, splitPatternOptions);
+	return ((_result$parts = result.parts) === null || _result$parts === void 0 ? void 0 : _result$parts.length) ? result.parts : [path];
 }
 const ESCAPED_WIN32_BACKSLASHES = /\\(?![()[\]{}!+@])/g;
-function convertPosixPathToPattern(path$1) {
-	return escapePosixPath(path$1);
+function convertPosixPathToPattern(path) {
+	return escapePosixPath(path);
 }
-function convertWin32PathToPattern(path$1) {
-	return escapeWin32Path(path$1).replace(ESCAPED_WIN32_BACKSLASHES, "/");
+function convertWin32PathToPattern(path) {
+	return escapeWin32Path(path).replace(ESCAPED_WIN32_BACKSLASHES, "/");
 }
 const convertPathToPattern = isWin ? convertWin32PathToPattern : convertPosixPathToPattern;
 const POSIX_UNESCAPED_GLOB_SYMBOLS = /(?<!\\)([()[\]{}*?|]|^!|[!+@](?=\()|\\(?![()[\]{}!*+?@|]))/g;
 const WIN32_UNESCAPED_GLOB_SYMBOLS = /(?<!\\)([()[\]{}]|^!|[!+@](?=\())/g;
-const escapePosixPath = (path$1) => path$1.replace(POSIX_UNESCAPED_GLOB_SYMBOLS, "\\$&");
-const escapeWin32Path = (path$1) => path$1.replace(WIN32_UNESCAPED_GLOB_SYMBOLS, "\\$&");
+const escapePosixPath = (path) => path.replace(POSIX_UNESCAPED_GLOB_SYMBOLS, "\\$&");
+const escapeWin32Path = (path) => path.replace(WIN32_UNESCAPED_GLOB_SYMBOLS, "\\$&");
 const escapePath = isWin ? escapeWin32Path : escapePosixPath;
 function isDynamicPattern(pattern, options) {
 	if ((options === null || options === void 0 ? void 0 : options.caseSensitiveMatch) === false) return true;
@@ -1990,28 +2179,31 @@ function isDynamicPattern(pattern, options) {
 function log(...tasks) {
 	console.log(`[tinyglobby ${new Date().toLocaleTimeString("es")}]`, ...tasks);
 }
+function ensureStringArray(value) {
+	return typeof value === "string" ? [value] : value !== null && value !== void 0 ? value : [];
+}
 const PARENT_DIRECTORY = /^(\/?\.\.)+/;
 const ESCAPING_BACKSLASHES = /\\(?=[()[\]{}!*+?@|])/g;
-const BACKSLASHES = /\\/g;
-function normalizePattern(pattern, expandDirectories, cwd, props, isIgnore) {
+function normalizePattern(pattern, opts, props, isIgnore) {
+	var _PARENT_DIRECTORY$exe;
+	const cwd = opts.cwd;
 	let result = pattern;
-	if (pattern.endsWith("/")) result = pattern.slice(0, -1);
-	if (!result.endsWith("*") && expandDirectories) result += "/**";
+	if (pattern[pattern.length - 1] === "/") result = pattern.slice(0, -1);
+	if (result[result.length - 1] !== "*" && opts.expandDirectories) result += "/**";
 	const escapedCwd = escapePath(cwd);
-	if (path.isAbsolute(result.replace(ESCAPING_BACKSLASHES, ""))) result = posix.relative(escapedCwd, result);
-	else result = posix.normalize(result);
-	const parentDirectoryMatch = PARENT_DIRECTORY.exec(result);
+	result = isAbsolute(result.replace(ESCAPING_BACKSLASHES, "")) ? posix.relative(escapedCwd, result) : posix.normalize(result);
+	const parentDir = (_PARENT_DIRECTORY$exe = PARENT_DIRECTORY.exec(result)) === null || _PARENT_DIRECTORY$exe === void 0 ? void 0 : _PARENT_DIRECTORY$exe[0];
 	const parts = splitPattern(result);
-	if (parentDirectoryMatch === null || parentDirectoryMatch === void 0 ? void 0 : parentDirectoryMatch[0]) {
-		const n = (parentDirectoryMatch[0].length + 1) / 3;
+	if (parentDir) {
+		const n = (parentDir.length + 1) / 3;
 		let i = 0;
 		const cwdParts = escapedCwd.split("/");
 		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) {
+		const potentialRoot = posix.join(cwd, parentDir.slice(i * 3));
+		if (potentialRoot[0] !== "." && props.root.length > potentialRoot.length) {
 			props.root = potentialRoot;
 			props.depthOffset = -n + i;
 		}
@@ -2027,7 +2219,7 @@ function normalizePattern(pattern, expandDirectories, cwd, props, isIgnore) {
 				newCommonPath.pop();
 				break;
 			}
-			if (part !== props.commonPath[i] || isDynamicPattern(part) || i === parts.length - 1) break;
+			if (i === parts.length - 1 || part !== props.commonPath[i] || isDynamicPattern(part)) break;
 			newCommonPath.push(part);
 		}
 		props.depthOffset = newCommonPath.length;
@@ -2036,145 +2228,131 @@ function normalizePattern(pattern, expandDirectories, cwd, props, isIgnore) {
 	}
 	return result;
 }
-function processPatterns({ patterns = ["**/*"], ignore = [], expandDirectories = true }, cwd, props) {
-	if (typeof patterns === "string") patterns = [patterns];
-	if (typeof ignore === "string") ignore = [ignore];
+function processPatterns(options, patterns, props) {
 	const matchPatterns = [];
 	const ignorePatterns = [];
-	for (const pattern of ignore) {
+	for (const pattern of options.ignore) {
 		if (!pattern) continue;
-		if (pattern[0] !== "!" || pattern[1] === "(") ignorePatterns.push(normalizePattern(pattern, expandDirectories, cwd, props, true));
+		if (pattern[0] !== "!" || pattern[1] === "(") ignorePatterns.push(normalizePattern(pattern, options, props, true));
 	}
 	for (const pattern of patterns) {
 		if (!pattern) continue;
-		if (pattern[0] !== "!" || pattern[1] === "(") matchPatterns.push(normalizePattern(pattern, expandDirectories, cwd, props, false));
-		else if (pattern[1] !== "!" || pattern[2] === "(") ignorePatterns.push(normalizePattern(pattern.slice(1), expandDirectories, cwd, props, true));
+		if (pattern[0] !== "!" || pattern[1] === "(") matchPatterns.push(normalizePattern(pattern, options, props, false));
+		else if (pattern[1] !== "!" || pattern[2] === "(") ignorePatterns.push(normalizePattern(pattern.slice(1), options, props, true));
 	}
 	return {
 		match: matchPatterns,
 		ignore: ignorePatterns
 	};
 }
-function formatPaths(paths, relative) {
-	for (let i = paths.length - 1; i >= 0; i--) {
-		const path$1 = paths[i];
-		paths[i] = relative(path$1);
-	}
-	return paths;
-}
-function normalizeCwd(cwd) {
-	if (!cwd) return process.cwd().replace(BACKSLASHES, "/");
-	if (cwd instanceof URL) return fileURLToPath(cwd).replace(BACKSLASHES, "/");
-	return path.resolve(cwd).replace(BACKSLASHES, "/");
-}
-function getCrawler(patterns, inputOptions = {}) {
-	const options = process.env.TINYGLOBBY_DEBUG ? {
-		...inputOptions,
-		debug: true
-	} : inputOptions;
-	const cwd = normalizeCwd(options.cwd);
-	if (options.debug) log("globbing with:", {
-		patterns,
-		options,
-		cwd
-	});
-	if (Array.isArray(patterns) && patterns.length === 0) return [{
-		sync: () => [],
-		withPromise: async () => []
-	}, false];
+function buildCrawler(options, patterns) {
+	const cwd = options.cwd;
 	const props = {
 		root: cwd,
-		commonPath: null,
 		depthOffset: 0
 	};
-	const processed = processPatterns({
-		...options,
-		patterns
-	}, cwd, props);
+	const processed = processPatterns(options, patterns, props);
 	if (options.debug) log("internal processing patterns:", processed);
+	const { absolute, caseSensitiveMatch, debug, dot, followSymbolicLinks, onlyDirectories } = options;
+	const root = props.root.replace(BACKSLASHES, "");
 	const matchOptions = {
-		dot: options.dot,
+		dot,
 		nobrace: options.braceExpansion === false,
-		nocase: options.caseSensitiveMatch === false,
+		nocase: !caseSensitiveMatch,
 		noextglob: options.extglob === false,
 		noglobstar: options.globstar === false,
 		posix: true
 	};
-	const matcher = (0, import_picomatch.default)(processed.match, {
-		...matchOptions,
-		ignore: processed.ignore
-	});
+	const matcher = (0, import_picomatch.default)(processed.match, matchOptions);
 	const ignore = (0, import_picomatch.default)(processed.ignore, matchOptions);
 	const partialMatcher = getPartialMatcher(processed.match, matchOptions);
-	const format = buildFormat(cwd, props.root, options.absolute);
-	const formatExclude = options.absolute ? format : buildFormat(cwd, props.root, true);
-	const fdirOptions = {
-		filters: [options.debug ? (p, isDirectory) => {
-			const path$1 = format(p, isDirectory);
-			const matches = matcher(path$1);
-			if (matches) log(`matched ${path$1}`);
+	const format = buildFormat(cwd, root, absolute);
+	const excludeFormatter = absolute ? format : buildFormat(cwd, root, true);
+	const excludePredicate = (_, p) => {
+		const relativePath = excludeFormatter(p, true);
+		return relativePath !== "." && !partialMatcher(relativePath) || ignore(relativePath);
+	};
+	let maxDepth;
+	if (options.deep !== void 0) maxDepth = Math.round(options.deep - props.depthOffset);
+	const crawler = new Builder({
+		filters: [debug ? (p, isDirectory) => {
+			const path = format(p, isDirectory);
+			const matches = matcher(path) && !ignore(path);
+			if (matches) log(`matched ${path}`);
 			return matches;
-		} : (p, isDirectory) => matcher(format(p, isDirectory))],
-		exclude: options.debug ? (_, p) => {
-			const relativePath = formatExclude(p, true);
-			const skipped = relativePath !== "." && !partialMatcher(relativePath) || ignore(relativePath);
-			if (skipped) log(`skipped ${p}`);
-			else log(`crawling ${p}`);
+		} : (p, isDirectory) => {
+			const path = format(p, isDirectory);
+			return matcher(path) && !ignore(path);
+		}],
+		exclude: debug ? (_, p) => {
+			const skipped = excludePredicate(_, p);
+			log(`${skipped ? "skipped" : "crawling"} ${p}`);
 			return skipped;
-		} : (_, p) => {
-			const relativePath = formatExclude(p, true);
-			return relativePath !== "." && !partialMatcher(relativePath) || ignore(relativePath);
-		},
-		fs: options.fs ? {
-			readdir: options.fs.readdir || nativeFs.readdir,
-			readdirSync: options.fs.readdirSync || nativeFs.readdirSync,
-			realpath: options.fs.realpath || nativeFs.realpath,
-			realpathSync: options.fs.realpathSync || nativeFs.realpathSync,
-			stat: options.fs.stat || nativeFs.stat,
-			statSync: options.fs.statSync || nativeFs.statSync
-		} : void 0,
+		} : excludePredicate,
+		fs: options.fs,
 		pathSeparator: "/",
-		relativePaths: true,
-		resolveSymlinks: true,
+		relativePaths: !absolute,
+		resolvePaths: absolute,
+		includeBasePath: absolute,
+		resolveSymlinks: followSymbolicLinks,
+		excludeSymlinks: !followSymbolicLinks,
+		excludeFiles: onlyDirectories,
+		includeDirs: onlyDirectories || !options.onlyFiles,
+		maxDepth,
 		signal: options.signal
+	}).crawl(root);
+	if (options.debug) log("internal properties:", {
+		...props,
+		root
+	});
+	return [crawler, cwd !== root && !absolute && buildRelative(cwd, root)];
+}
+function formatPaths(paths, mapper) {
+	if (mapper) for (let i = paths.length - 1; i >= 0; i--) paths[i] = mapper(paths[i]);
+	return paths;
+}
+const defaultOptions = {
+	caseSensitiveMatch: true,
+	cwd: process.cwd(),
+	debug: !!process.env.TINYGLOBBY_DEBUG,
+	expandDirectories: true,
+	followSymbolicLinks: true,
+	onlyFiles: true
+};
+function getOptions(options) {
+	const opts = {
+		...defaultOptions,
+		...options
 	};
-	if (options.deep !== void 0) fdirOptions.maxDepth = Math.round(options.deep - props.depthOffset);
-	if (options.absolute) {
-		fdirOptions.relativePaths = false;
-		fdirOptions.resolvePaths = true;
-		fdirOptions.includeBasePath = true;
-	}
-	if (options.followSymbolicLinks === false) {
-		fdirOptions.resolveSymlinks = false;
-		fdirOptions.excludeSymlinks = true;
-	}
-	if (options.onlyDirectories) {
-		fdirOptions.excludeFiles = true;
-		fdirOptions.includeDirs = true;
-	} else if (options.onlyFiles === false) fdirOptions.includeDirs = true;
-	props.root = props.root.replace(BACKSLASHES, "");
-	const root = props.root;
-	if (options.debug) log("internal properties:", props);
-	const relative = cwd !== root && !options.absolute && buildRelative(cwd, props.root);
-	return [new Builder(fdirOptions).crawl(root), relative];
+	opts.cwd = (opts.cwd instanceof URL ? fileURLToPath(opts.cwd) : resolve(opts.cwd)).replace(BACKSLASHES, "/");
+	opts.ignore = ensureStringArray(opts.ignore);
+	opts.fs && (opts.fs = {
+		readdir: opts.fs.readdir || readdir,
+		readdirSync: opts.fs.readdirSync || readdirSync,
+		realpath: opts.fs.realpath || realpath,
+		realpathSync: opts.fs.realpathSync || realpathSync,
+		stat: opts.fs.stat || stat,
+		statSync: opts.fs.statSync || statSync
+	});
+	if (opts.debug) log("globbing with options:", opts);
+	return opts;
+}
+function getCrawler(globInput, inputOptions = {}) {
+	var _ref;
+	if (globInput && (inputOptions === null || inputOptions === void 0 ? void 0 : inputOptions.patterns)) throw new Error("Cannot pass patterns as both an argument and an option");
+	const isModern = isReadonlyArray(globInput) || typeof globInput === "string";
+	const patterns = ensureStringArray((_ref = isModern ? globInput : globInput.patterns) !== null && _ref !== void 0 ? _ref : "**/*");
+	const options = getOptions(isModern ? inputOptions : globInput);
+	return patterns.length > 0 ? buildCrawler(options, patterns) : [];
 }
-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] = getCrawler(isModern ? patternsOrOptions : patternsOrOptions.patterns, opts);
-	if (!relative) return crawler.withPromise();
-	return formatPaths(await crawler.withPromise(), relative);
+async function glob$1(globInput, options) {
+	const [crawler, relative] = getCrawler(globInput, options);
+	return crawler ? 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] = getCrawler(isModern ? patternsOrOptions : patternsOrOptions.patterns, opts);
-	if (!relative) return crawler.sync();
-	return formatPaths(crawler.sync(), relative);
+function globSync$1(globInput, options) {
+	const [crawler, relative] = getCrawler(globInput, options);
+	return crawler ? formatPaths(crawler.sync(), relative) : [];
 }
-
 //#endregion
 //#region src/fs/glob.ts
 const normalizeArgs = (patternsOrOptions, maybeOptions) => {
@@ -2198,10 +2376,129 @@ function globSync(...args) {
 		...options
 	});
 }
-
 //#endregion
-//#region src/fs/safe.ts
-const pathLikeToPath = (pathLike) => path$1.resolve(pathLike instanceof URL ? pathLike.pathname : pathLike);
+//#region src/fs/vfile.ts
+const nil$1 = nil$2;
+var BaseVFile = class BaseVFile {
+	_cwd = process.cwd();
+	_dirname = "";
+	_filename = "";
+	_extname = "";
+	constructor(filepath, cwd) {
+		if (cwd) this.cwd(cwd);
+		const pathname = isString(filepath) ? filepath : url.fileURLToPath(filepath);
+		if (path.isAbsolute(pathname)) this.pathname(pathname);
+		else this.pathname.relative(pathname);
+	}
+	cwd(cwd) {
+		if (cwd === void 0) return this._cwd;
+		this._cwd = cwd;
+		return this;
+	}
+	get pathname() {
+		const obj = this.absolutePathname.bind(this);
+		obj.relative = this.relativePathname.bind(this);
+		return obj;
+	}
+	get dirname() {
+		const obj = this.relativeDirname.bind(this);
+		obj.absolute = this.absoluteDirname.bind(this);
+		return obj;
+	}
+	filename(filename) {
+		if (filename === void 0) return this._filename;
+		this._filename = filename;
+		return this;
+	}
+	extname(extname) {
+		if (extname === void 0) return this._extname;
+		this._extname = extname;
+		return this;
+	}
+	basename(basename) {
+		if (basename === void 0) {
+			if (!this._extname) return this._filename;
+			return this._filename + "." + this._extname;
+		}
+		const { name, ext } = path.parse(basename);
+		this._filename = name;
+		this._extname = removePrefix(".", ext);
+		return this;
+	}
+	clone() {
+		const vfile = new BaseVFile("");
+		vfile._cwd = this._cwd;
+		vfile._dirname = this._dirname;
+		vfile._filename = this._filename;
+		vfile._extname = this._extname;
+		return vfile;
+	}
+	absolutePathname(pathname) {
+		if (pathname === void 0) {
+			const basename = this._filename + (this._extname ? "." : "") + this._extname;
+			return path.resolve(this._cwd, this._dirname, basename);
+		}
+		const { dir, name, ext } = path.parse(pathname);
+		this._dirname = path.relative(this._cwd, dir);
+		this._filename = name;
+		this._extname = removePrefix(".", ext);
+		return this;
+	}
+	relativePathname(pathname) {
+		if (pathname === void 0) {
+			const basename = this._filename + (this._extname ? "." : "") + this._extname;
+			return path.join(this._dirname, basename);
+		}
+		const { dir, name, ext } = path.parse(pathname);
+		this._dirname = dir;
+		this._filename = name;
+		this._extname = removePrefix(".", ext);
+		return this;
+	}
+	relativeDirname(dirname) {
+		if (dirname === void 0) return this._dirname;
+		this._dirname = dirname;
+		return this;
+	}
+	absoluteDirname(dirname) {
+		if (dirname === void 0) return path.resolve(this._cwd, this._dirname);
+		this._dirname = path.relative(this._cwd, dirname);
+		return this;
+	}
+};
+var ExtendVFile = class ExtendVFile extends BaseVFile {
+	_encoding = "utf-8";
+	_linebreak = "\n";
+	_transformer;
+	_raw = nil$1;
+	_value = nil$1;
+	encoding(encoding) {
+		if (encoding === void 0) return this._encoding;
+		this._encoding = encoding;
+		return this;
+	}
+	linebreak(linebreak) {
+		if (linebreak === void 0) return this._linebreak;
+		this._linebreak = linebreak;
+		return this;
+	}
+	clone() {
+		const vfile = new ExtendVFile("");
+		vfile._cwd = this._cwd;
+		vfile._dirname = this._dirname;
+		vfile._filename = this._filename;
+		vfile._extname = this._extname;
+		vfile._encoding = this._encoding;
+		vfile._linebreak = this._linebreak;
+		vfile._transformer = this._transformer;
+		vfile._raw = this._raw;
+		vfile._value = this._value;
+		return vfile;
+	}
+};
+//#endregion
+//#region src/fs/utils.ts
+const pathLikeToPath = (pathLike) => path.resolve(pathLike instanceof URL ? url.fileURLToPath(pathLike) : pathLike);
 const parseEncodingOptions = (options) => {
 	const encoding = options?.encoding || "utf-8";
 	return encoding === "buffer" ? {} : { encoding };
@@ -2216,86 +2513,88 @@ const parseWriteJsonOptions = (options) => {
 		encoding: parseEncodingOptions(options)
 	};
 };
-const appendFile$1 = async (path, data, options) => Result.gen(async function* () {
-	const newline = options?.newline ?? true;
-	yield* await mkdir$1(dirname$1(pathLikeToPath(path).toString()));
-	const fn = async () => {
-		await promises.appendFile(path, newline ? `\n${data}` : data, parseEncodingOptions(options));
-	};
-	return (await Result.try(fn, Error)).context(`Failed to append file: ${path}`);
-});
-const appendFileSync$1 = (path, data, options) => Result.gen(function* () {
-	const newline = options?.newline ?? true;
-	yield* mkdirSync$1(dirname$1(pathLikeToPath(path).toString()));
-	const fn = () => {
-		fs.appendFileSync(path, newline ? `\n${data}` : data, parseEncodingOptions(options));
-	};
-	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.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.try(fn, Error).context(`Failed to copy path: ${source} to ${destination}`);
-};
-const exists$1 = async (path) => {
-	const fn = async () => {
+//#endregion
+//#region src/fs/safe/exists.ts
+const exists = async (path) => {
+	try {
 		await promises.access(path);
 		return true;
-	};
-	return (await Result.try(fn, Error)).context(`Failed to check exists for path: ${path}`);
+	} catch {
+		return false;
+	}
 };
-const existsSync$1 = (path) => {
-	const fn = () => {
+const existsSync = (path) => {
+	try {
 		fs.accessSync(path);
 		return true;
-	};
-	return Result.try(fn, Error).context(`Failed to check exists for path: ${path}`);
+	} catch {
+		return false;
+	}
 };
+//#endregion
+//#region src/fs/safe/mkdir.ts
+const safeMkdir = Result.wrap(promises.mkdir, Error);
 const mkdir$1 = async (path, options) => {
 	const { recursive = true } = options || {};
-	if ((await exists$1(path)).isOk()) return ok();
-	const fn = async () => {
-		await promises.mkdir(path, { recursive });
-	};
-	return (await Result.try(fn, Error)).context(`Failed to create directory: ${path}`);
+	if (await exists(path)) return ok();
+	return (await safeMkdir(path, { recursive })).and(ok()).context(`Failed to create directory: ${path}`);
 };
+const safeMkdirSync = Result.wrap(fs.mkdirSync, Error);
 const mkdirSync$1 = (path, options) => {
 	const { recursive = true } = options || {};
-	if (existsSync$1(path).isOk()) return ok();
-	const fn = () => {
-		fs.mkdirSync(path, { recursive });
-	};
-	return Result.try(fn, Error).context(`Failed to create directory: ${path}`);
+	if (existsSync(path)) return ok();
+	return safeMkdirSync(path, { recursive }).and(ok()).context(`Failed to create directory: ${path}`);
 };
+//#endregion
+//#region src/fs/safe/append.ts
+const safeAppendFile = Result.wrap(promises.appendFile, Error);
+const appendFile$1 = async (path, data, options) => Result.gen(async function* () {
+	const newline = options?.newline ?? true;
+	yield* await mkdir$1(dirname(pathLikeToPath(path).toString()));
+	return (await safeAppendFile(path, newline ? `\n${data}` : data, parseEncodingOptions(options))).context(`Failed to append file: ${path}`);
+});
+const safeAppendFileSync = Result.wrap(fs.appendFileSync, Error);
+const appendFileSync$1 = (path, data, options) => Result.gen(function* () {
+	const newline = options?.newline ?? true;
+	yield* mkdirSync$1(dirname(pathLikeToPath(path).toString()));
+	return safeAppendFileSync(path, newline ? `\n${data}` : data, parseEncodingOptions(options)).context(`Failed to append file: ${path}`);
+});
+//#endregion
+//#region src/fs/safe/cp.ts
+const safeCp = Result.wrap(promises.cp, Error);
+const cp$1 = async (source, destination, options) => {
+	const { recursive = true } = options || {};
+	return (await safeCp(source, destination, { recursive })).context(`Failed to copy path: ${source} to ${destination}`);
+};
+const safeCpSync = Result.wrap(fs.cpSync, Error);
+const cpSync$1 = (source, destination, options) => {
+	const { recursive = true } = options || {};
+	return safeCpSync(source, destination, { recursive }).context(`Failed to copy path: ${source} to ${destination}`);
+};
+//#endregion
+//#region src/fs/safe/read.ts
+const safeReadFile = Result.wrap(promises.readFile, Error);
 async function readFile$1(path, options) {
-	return Result.gen(async function* () {
-		yield* await exists$1(path);
-		const fn = async () => {
-			return await promises.readFile(path, parseEncodingOptions(options));
-		};
-		return (await Result.try(fn, Error)).context(`Failed to read file: ${path}`);
-	});
+	if (!await exists(path)) return err(new Error(`File does not exist: ${path}`));
+	return (await safeReadFile(path, parseEncodingOptions(options))).context(`Failed to read file: ${path}`);
 }
+const safeReadFileSync = Result.wrap(fs.readFileSync, Error);
 function readFileSync$1(path, options) {
-	return Result.gen(function* () {
-		yield* existsSync$1(path);
-		const fn = () => {
-			return fs.readFileSync(path, parseEncodingOptions(options));
-		};
-		return Result.try(fn, Error).context(`Failed to read file: ${path}`);
-	});
+	if (!existsSync(path)) return err(new Error(`File does not exist: ${path}`));
+	return safeReadFileSync(path, parseEncodingOptions(options)).context(`Failed to read file: ${path}`);
 }
-const readFileByLine$1 = (path, options) => Result.gen(async function* () {
-	yield* await exists$1(path);
+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 parse(content).context(`Failed to parse JSON file: ${path}`);
+});
+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 parse(content).context(`Failed to parse JSON file: ${path}`);
+});
+const readFileByLine$1 = async (path, options) => {
+	if (!await exists(path)) return err(new Error(`File does not exist: ${path}`));
 	const { createInterface } = await import("node:readline");
 	const fn = () => {
 		const stream = fs.createReadStream(path, {
@@ -2311,194 +2610,367 @@ const readFileByLine$1 = (path, options) => Result.gen(async function* () {
 		});
 	};
 	return Result.try(fn, Error).context(`Failed to read file: ${path}`);
-});
-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, 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}`);
-});
+};
+//#endregion
+//#region src/fs/safe/rm.ts
+const safeRm = Result.wrap(promises.rm, Error);
 const rm$1 = async (path, options) => {
 	const { force = true, recursive = true } = options || {};
-	const fn = async () => {
-		await promises.rm(path, {
-			force,
-			recursive
-		});
-	};
-	return (await Result.try(fn, Error)).context(`Failed to remove path: ${path}`);
+	return (await safeRm(path, {
+		force,
+		recursive
+	})).context(`Failed to remove path: ${path}`);
 };
+const safeRmSync = Result.wrap(fs.rmSync, Error);
 const rmSync$1 = (path, options) => {
 	const { force = true, recursive = true } = options || {};
-	const fn = () => {
-		fs.rmSync(path, {
-			force,
-			recursive
-		});
-	};
-	return Result.try(fn, Error).context(`Failed to remove path: ${path}`);
+	return safeRmSync(path, {
+		force,
+		recursive
+	}).context(`Failed to remove path: ${path}`);
 };
+//#endregion
+//#region src/fs/safe/write.ts
+const safeWriteFile = Result.wrap(promises.writeFile, Error);
 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, data, parseEncodingOptions(options));
-	};
-	return (await Result.try(fn, Error)).context(`Failed to write file: ${path}`);
+	yield* await mkdir$1(dirname(pathLikeToPath(path).toString()));
+	return (await safeWriteFile(path, data, parseEncodingOptions(options))).context(`Failed to write file: ${path}`);
 });
-const writeFileSync = (path, data, options) => {
-	const fn = () => {
-		fs.writeFileSync(path, data, parseEncodingOptions(options));
-	};
-	return Result.try(fn, Error).context(`Failed to write file: ${path}`);
-};
-const writeJson = async (path, data, indentOrOptions) => {
+const safeWriteFileSync = Result.wrap(fs.writeFileSync, Error);
+const writeFileSync = (path, data, options) => Result.gen(function* () {
+	yield* mkdirSync$1(dirname(pathLikeToPath(path).toString()));
+	return safeWriteFileSync(path, data, parseEncodingOptions(options)).context(`Failed to write file: ${path}`);
+});
+const writeJson = async (path, data, indentOrOptions) => Result.gen(async function* () {
 	const { indent, encoding } = parseWriteJsonOptions(indentOrOptions);
-	return writeFile(path, stringify(data, null, indent) ?? "", encoding);
-};
-const writeJsonSync = (path, data, indentOrOptions) => {
+	return writeFile(path, yield* stringify(data, null, indent), encoding);
+});
+const writeJsonSync = (path, data, indentOrOptions) => Result.gen(function* () {
 	const { indent, encoding } = parseWriteJsonOptions(indentOrOptions);
-	return writeFileSync(path, stringify(data, null, indent) ?? "", encoding);
+	return writeFileSync(path, yield* stringify(data, null, indent), encoding);
+});
+//#endregion
+//#region src/fs/safe/vfile.ts
+const nil = nil$2;
+var VFile = class extends ExtendVFile {
+	transformer(transformer, indent = 2) {
+		if (transformer === void 0) return this._transformer;
+		if (transformer === "json") this._transformer = {
+			parse,
+			stringify: (value) => stringify(value, null, indent)
+		};
+		else this._transformer = transformer;
+		return this;
+	}
+	raw(raw) {
+		if (raw !== void 0) {
+			this._raw = raw;
+			this._value = nil;
+			return this;
+		}
+		if (!isNil(this._raw)) return ok(this._raw);
+		if (isNil(this._value)) return err(new Error("No content")).context("Failed to get raw content");
+		return this.stringifyValue(this._value).inspect((raw) => {
+			this._raw = raw;
+		});
+	}
+	value(value) {
+		if (value !== void 0) {
+			this._value = value;
+			this._raw = nil;
+			return this;
+		}
+		if (this._value !== nil) return ok(this._value);
+		if (this._raw === nil) return err(new Error("No content")).context("Failed to get value");
+		return this.parseRaw(this._raw).inspect((value) => {
+			this._value = value;
+		});
+	}
+	lines() {
+		return this.raw().map((raw) => raw.split(this._linebreak));
+	}
+	append(value, newline = true) {
+		return Result.gen(function* () {
+			const linebreak = newline ? this._linebreak : "";
+			const append = yield* this.stringifyValue(value);
+			if (isNil(this._raw) || isNil(this._value)) this.raw(append);
+			else this.raw(this._raw + linebreak + append);
+		}, this);
+	}
+	async exists() {
+		return exists(this.pathname());
+	}
+	existsSync() {
+		return existsSync(this.pathname());
+	}
+	async cp(destination, options) {
+		return cp$1(this.pathname(), destination, options);
+	}
+	cpSync(destination, options) {
+		return cpSync$1(this.pathname(), destination, options);
+	}
+	async rm(options) {
+		return rm$1(this.pathname(), options);
+	}
+	rmSync(options) {
+		return rmSync$1(this.pathname(), options);
+	}
+	async read() {
+		return (await readFile$1(this.pathname(), this.encodingOptions)).andThen((raw) => {
+			this.raw(raw);
+			return this.value();
+		});
+	}
+	readSync() {
+		return readFileSync$1(this.pathname(), this.encodingOptions).andThen((raw) => {
+			this.raw(raw);
+			return this.value();
+		});
+	}
+	readByLine() {
+		return readFileByLine$1(this.pathname(), this.encodingOptions);
+	}
+	async write() {
+		const result = this.raw();
+		if (result.isErr()) return result;
+		return writeFile(this.pathname(), result.unwrap(), this.encodingOptions);
+	}
+	writeSync() {
+		const result = this.raw();
+		if (result.isErr()) return result;
+		return writeFileSync(this.pathname(), result.unwrap(), this.encodingOptions);
+	}
+	get encodingOptions() {
+		return { encoding: this._encoding };
+	}
+	parseRaw(raw) {
+		if (!this._transformer?.parse) return ok(raw);
+		return this._transformer.parse(raw).context("Failed to parse raw content");
+	}
+	stringifyValue(value) {
+		if (!this._transformer?.stringify) return ok(value);
+		return this._transformer.stringify(value).context("Failed to stringify value");
+	}
 };
-
 //#endregion
-//#region src/fs/unsafe.ts
+//#region src/fs/unsafe/mkdir.ts
+const mkdir = async (path, options) => {
+	const { recursive = true } = options || {};
+	if (await exists(path)) return;
+	await promises.mkdir(path, { recursive });
+};
+const mkdirSync = (path, options) => {
+	const { recursive = true } = options || {};
+	if (existsSync(path)) return;
+	fs.mkdirSync(path, { recursive });
+};
+//#endregion
+//#region src/fs/unsafe/append.ts
 const appendFile = async (path, data, options) => {
-	await appendFile$1(path, data, options);
+	const newline = options?.newline ?? true;
+	await mkdir(dirname(pathLikeToPath(path).toString()));
+	await promises.appendFile(path, newline ? `\n${data}` : data, parseEncodingOptions(options));
 };
 const appendFileSync = (path, data, options) => {
-	appendFileSync$1(path, data, options);
+	const newline = options?.newline ?? true;
+	mkdirSync(dirname(pathLikeToPath(path).toString()));
+	fs.appendFileSync(path, newline ? `\n${data}` : data, parseEncodingOptions(options));
 };
+//#endregion
+//#region src/fs/unsafe/cp.ts
 const cp = async (source, destination, options) => {
-	await cp$1(source, destination, options);
+	const { recursive = true } = options || {};
+	await promises.cp(source, destination, { recursive });
 };
 const cpSync = (source, destination, options) => {
-	cpSync$1(source, destination, options);
-};
-const exists = async (path) => {
-	return (await exists$1(path)).isOk();
-};
-const existsSync = (path) => {
-	return existsSync$1(path).isOk();
-};
-const mkdir = async (path, options) => {
-	await mkdir$1(path, options);
-};
-const mkdirSync = (path, options) => {
-	mkdirSync$1(path, options);
+	const { recursive = true } = options || {};
+	fs.cpSync(source, destination, { recursive });
 };
+//#endregion
+//#region src/fs/unsafe/read.ts
 async function readFile(path, options) {
-	const result = await readFile$1(path, options);
-	if (result.isErr()) return void 0;
-	return result.unwrap(null);
+	if (!await exists(path)) return nil$2;
+	try {
+		return await promises.readFile(path, parseEncodingOptions(options));
+	} catch {
+		return nil$2;
+	}
 }
 function readFileSync(path, options) {
-	const result = readFileSync$1(path, options);
-	if (result.isErr()) return void 0;
-	return result.unwrap(null);
+	if (!existsSync(path)) return nil$2;
+	try {
+		return fs.readFileSync(path, parseEncodingOptions(options));
+	} catch {
+		return nil$2;
+	}
 }
-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, options) => {
-	const result = await readJson$1(path, options);
-	if (result.isErr()) return void 0;
-	return result.unwrap(null);
+	const content = await readFile(path, options);
+	if (isNil(content)) return nil$2;
+	return parse$1(content);
 };
 const readJsonSync = (path, options) => {
-	const result = readJsonSync$1(path, options);
-	if (result.isErr()) return void 0;
-	return result.unwrap(null);
+	const content = readFileSync(path, options);
+	if (isNil(content)) return nil$2;
+	return parse$1(content);
 };
+const readFileByLine = async (path, options) => {
+	if (!await exists(path)) return null;
+	const { createInterface } = await import("node:readline");
+	try {
+		const stream = fs.createReadStream(path, {
+			...parseEncodingOptions(options),
+			autoClose: true
+		});
+		stream.on("error", (error) => {
+			throw error;
+		});
+		return createInterface({
+			input: stream,
+			crlfDelay: Infinity
+		});
+	} catch {
+		return null;
+	}
+};
+//#endregion
+//#region src/fs/unsafe/rm.ts
 const rm = async (path, options) => {
-	await rm$1(path, options);
+	const { force = true, recursive = true } = options || {};
+	await promises.rm(path, {
+		force,
+		recursive
+	});
 };
 const rmSync = (path, options) => {
-	rmSync$1(path, options);
+	const { force = true, recursive = true } = options || {};
+	fs.rmSync(path, {
+		force,
+		recursive
+	});
 };
+//#endregion
+//#region src/fs/unsafe/write.ts
 const writeFile$1 = async (path, data, options) => {
-	await writeFile(path, data, options);
+	await mkdir(dirname(pathLikeToPath(path).toString()));
+	await promises.writeFile(path, data, parseEncodingOptions(options));
 };
 const writeFileSync$1 = (path, data, options) => {
-	writeFileSync(path, data, options);
+	mkdirSync(dirname(pathLikeToPath(path).toString()));
+	fs.writeFileSync(path, data, parseEncodingOptions(options));
 };
 const writeJson$1 = async (path, data, indentOrOptions) => {
-	await writeJson(path, data, indentOrOptions);
+	const { indent, encoding } = parseWriteJsonOptions(indentOrOptions);
+	const content = stringify$1(data, null, indent);
+	if (isNil(content)) throw new TypeError(`Value cannot be stringified: ${String(data)}`);
+	return writeFile$1(path, content, encoding);
 };
 const writeJsonSync$1 = (path, data, indentOrOptions) => {
-	writeJsonSync(path, data, indentOrOptions);
+	const { indent, encoding } = parseWriteJsonOptions(indentOrOptions);
+	const content = stringify$1(data, null, indent);
+	if (isNil(content)) throw new TypeError(`Value cannot be stringified: ${String(data)}`);
+	return writeFileSync$1(path, content, encoding);
 };
-
 //#endregion
-//#region src/fs/vfile.ts
-var VFile = class VFile {
-	static async fromFilepath(pathname, cwd) {
-		const vfile = new VFile({
-			pathname,
-			cwd
-		});
-		return (await readFile$1(pathname)).map((content) => {
-			vfile.content = content;
-			return vfile;
-		});
+//#region src/fs/unsafe/vfile.ts
+var VFile$1 = class extends ExtendVFile {
+	transformer(transformer, indent = 2) {
+		if (transformer === void 0) return this._transformer;
+		if (transformer === "json") this._transformer = {
+			parse: parse$1,
+			stringify: (value) => stringify$1(value, null, indent)
+		};
+		else this._transformer = transformer;
+		return this;
 	}
-	content = "";
-	cwd = process.cwd();
-	dirname = "";
-	filename = "";
-	extname = "";
-	constructor(options) {
-		const { pathname, content, cwd } = options;
-		if (content) this.content = content;
-		if (cwd) this.cwd = cwd;
-		if (path$1.isAbsolute(pathname)) this.pathname = pathname;
-		else this.relativePathname = pathname;
+	raw(raw) {
+		if (raw !== void 0) {
+			this._raw = raw;
+			this._value = nil$2;
+			return this;
+		}
+		if (!isNil(this._raw)) return this._raw;
+		if (isNil(this._value)) return nil$2;
+		this._raw = this.stringifyValue(this._value);
+		return this._raw;
 	}
-	get pathname() {
-		return path$1.resolve(this.cwd, this.dirname, this.basename);
+	value(value) {
+		if (value !== void 0) {
+			this._value = value;
+			this._raw = nil$2;
+			return this;
+		}
+		if (!isNil(this._value)) return this._value;
+		if (isNil(this._raw)) return nil$2;
+		this._value = this.parseRaw(this._raw);
+		return this._value;
 	}
-	set pathname(value) {
-		this.parse(value);
+	lines() {
+		const raw = this.raw();
+		if (isNil(raw)) return [];
+		return raw.split(this._linebreak);
 	}
-	get basename() {
-		return this.extname ? this.filename + "." + this.extname : this.filename;
+	append(value, newline = true) {
+		const linebreak = newline ? this._linebreak : "";
+		const append = this.stringifyValue(value);
+		if (isNil(append)) throw new TypeError(`Value cannot be stringified: ${String(value)}`);
+		if (isNil(this._raw) || isNil(this._value)) this.raw(append);
+		else this.raw(this._raw + linebreak + append);
 	}
-	set basename(value) {
-		const { name, ext } = path$1.parse(value);
-		this.filename = name;
-		this.extname = removePrefix(".", ext);
+	async exists() {
+		return exists(this.pathname());
 	}
-	get absoluteDirname() {
-		return path$1.resolve(this.cwd, this.dirname);
+	existsSync() {
+		return existsSync(this.pathname());
 	}
-	set absoluteDirname(value) {
-		this.dirname = path$1.relative(this.cwd, value);
+	async cp(destination, options) {
+		return cp(this.pathname(), destination, options);
 	}
-	get relativePathname() {
-		return path$1.relative(this.cwd, this.pathname);
+	cpSync(destination, options) {
+		return cpSync(this.pathname(), destination, options);
 	}
-	set relativePathname(value) {
-		this.parse(path$1.resolve(this.cwd, value));
+	async rm(options) {
+		return rm(this.pathname(), options);
 	}
-	clone() {
-		return new VFile({
-			pathname: this.pathname,
-			content: this.content,
-			cwd: this.cwd
-		});
+	rmSync(options) {
+		return rmSync(this.pathname(), options);
+	}
+	async read() {
+		const raw = await readFile(this.pathname(), this.encodingOptions);
+		if (isNil(raw)) return nil$2;
+		this.raw(raw);
+		return this.value();
+	}
+	readSync() {
+		const raw = readFileSync(this.pathname(), this.encodingOptions);
+		if (isNil(raw)) return nil$2;
+		this.raw(raw);
+		return this.value();
+	}
+	readByLine() {
+		return readFileByLine(this.pathname(), this.encodingOptions);
+	}
+	async write() {
+		const raw = this.raw();
+		if (isNil(raw)) throw new TypeError("VFile has no content to write");
+		return writeFile$1(this.pathname(), raw, this.encodingOptions);
+	}
+	writeSync() {
+		const raw = this.raw();
+		if (isNil(raw)) throw new TypeError("VFile has no content to write");
+		return writeFileSync$1(this.pathname(), raw, this.encodingOptions);
+	}
+	get encodingOptions() {
+		return { encoding: this._encoding };
+	}
+	parseRaw(raw) {
+		if (!this._transformer?.parse) return raw;
+		return this._transformer.parse(raw);
 	}
-	parse(value) {
-		const { name, ext } = path$1.parse(value);
-		this.dirname = path$1.relative(this.cwd, path$1.dirname(value));
-		this.filename = name;
-		this.extname = removePrefix(".", ext);
+	stringifyValue(value) {
+		if (!this._transformer?.stringify) return value;
+		return this._transformer.stringify(value);
 	}
 };
-
 //#endregion
-export { VFile, appendFile, appendFileSync, convertPathToPattern, cp, cpSync, escapePath, exists, existsSync, glob, globSync, isDynamicPattern, mkdir, mkdirSync, readFile, readFileByLine, readFileSync, readJson, readJsonSync, rm, rmSync, appendFile$1 as safeAppendFile, appendFileSync$1 as safeAppendFileSync, cp$1 as safeCp, cpSync$1 as safeCpSync, exists$1 as safeExists, existsSync$1 as safeExistsSync, mkdir$1 as safeMkdir, mkdirSync$1 as safeMkdirSync, readFile$1 as safeReadFile, readFileByLine$1 as safeReadFileByLine, readFileSync$1 as safeReadFileSync, readJson$1 as safeReadJson, readJsonSync$1 as safeReadJsonSync, rm$1 as safeRm, rmSync$1 as safeRmSync, writeFile as safeWriteFile, writeFileSync as safeWriteFileSync, writeJson as safeWriteJson, writeJsonSync as safeWriteJsonSync, writeFile$1 as writeFile, writeFileSync$1 as writeFileSync, writeJson$1 as writeJson, writeJsonSync$1 as writeJsonSync };
+export { BaseVFile, VFile as SafeVFile, VFile$1 as VFile, appendFile, appendFileSync, convertPathToPattern, cp, cpSync, escapePath, exists, exists as safeExists, existsSync, existsSync as safeExistsSync, glob, globSync, isDynamicPattern, mkdir, mkdirSync, readFile, readFileByLine, readFileSync, readJson, readJsonSync, rm, rmSync, appendFile$1 as safeAppendFile, appendFileSync$1 as safeAppendFileSync, cp$1 as safeCp, cpSync$1 as safeCpSync, mkdir$1 as safeMkdir, mkdirSync$1 as safeMkdirSync, readFile$1 as safeReadFile, readFileByLine$1 as safeReadFileByLine, readFileSync$1 as safeReadFileSync, readJson$1 as safeReadJson, readJsonSync$1 as safeReadJsonSync, rm$1 as safeRm, rmSync$1 as safeRmSync, writeFile as safeWriteFile, writeFileSync as safeWriteFileSync, writeJson as safeWriteJson, writeJsonSync as safeWriteJsonSync, writeFile$1 as writeFile, writeFileSync$1 as writeFileSync, writeJson$1 as writeJson, writeJsonSync$1 as writeJsonSync };