@better-t-stack/template-generator 3.27.1 → 3.27.3

package/dist/{template-reader-DOXCnctl.mjs → template-reader-C8MBRmk-.mjs}

@@ -1,32 +1,27 @@
-import { t as isBinaryPath } from "./is-binary-path-BN88l03c.mjs";
+import { t as isBinaryPath } from "./is-binary-path-maAgJE_Q.mjs";
 import { dirname, join } from "pathe";
 import fs from "node:fs";
 import { fileURLToPath } from "node:url";
-import * as nativeFs$1 from "fs";
-import nativeFs from "fs";
-import path, { basename, dirname as dirname$1, normalize as normalize$1, posix, relative, resolve, sep } from "path";
+import * as nativeFs from "fs";
+import { readdir, readdirSync, realpath, realpathSync, stat, statSync } from "fs";
+import { basename, dirname as dirname$1, isAbsolute, normalize as normalize$1, posix, relative, resolve, sep } from "path";
 import { fileURLToPath as fileURLToPath$1 } from "url";
 import { createRequire } from "module";
-
-//#region rolldown:runtime
+//#region \0rolldown/runtime.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
 var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") {
-		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-			key = keys[i];
-			if (!__hasOwnProp.call(to, key) && key !== except) {
-				__defProp(to, key, {
-					get: ((k) => from[k]).bind(null, key),
-					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-				});
-			}
-		}
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
 	}
 	return to;
 };
@@ -34,30 +29,29 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	value: mod,
 	enumerable: true
 }) : target, mod));
-
 //#endregion
-//#region ../../node_modules/.bun/fdir@6.5.0+a185e370e160e74e/node_modules/fdir/dist/index.mjs
+//#region ../../node_modules/.bun/fdir@6.5.0+5b2c60377f53a28e/node_modules/fdir/dist/index.mjs
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
-function cleanPath(path$1) {
-	let normalized = normalize$1(path$1);
+function cleanPath(path) {
+	let normalized = normalize$1(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$1, separator) {
-	return path$1.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$1) {
-	return path$1 === "/" || WINDOWS_ROOT_DIR_REGEX.test(path$1);
+function isRootDirectory(path) {
+	return path === "/" || WINDOWS_ROOT_DIR_REGEX.test(path);
 }
-function normalizePath(path$1, options) {
+function normalizePath(path, options) {
 	const { resolvePaths, normalizePath: normalizePath$1, pathSeparator } = options;
-	const pathNeedsCleaning = process.platform === "win32" && path$1.includes("/") || path$1.startsWith(".");
-	if (resolvePaths) path$1 = resolve(path$1);
-	if (normalizePath$1 || pathNeedsCleaning) path$1 = cleanPath(path$1);
-	if (path$1 === ".") return "";
-	return convertSlashes(path$1[path$1.length - 1] !== pathSeparator ? path$1 + pathSeparator : path$1, 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;
@@ -93,8 +87,8 @@ const pushDirectory = (directoryPath, paths) => {
 	paths.push(directoryPath || ".");
 };
 const pushDirectoryFilter = (directoryPath, paths, filters) => {
-	const path$1 = directoryPath || ".";
-	if (filters.every((filter) => filter(path$1, true))) paths.push(path$1);
+	const path = directoryPath || ".";
+	if (filters.every((filter) => filter(path, true))) paths.push(path);
 };
 const empty$2 = () => {};
 function build$6(root, options) {
@@ -143,26 +137,26 @@ const empty = () => {};
 function build$3(options) {
 	return options.group ? groupFiles : empty;
 }
-const resolveSymlinksAsync = function(path$1, 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$1, (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$1, 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$1, 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$1);
-		const stat = fs$1.statSync(resolvedPath);
-		if (stat.isDirectory() && isRecursive(path$1, 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) {
 		if (!suppressErrors) throw e;
@@ -172,17 +166,17 @@ function build$2(options, isSynchronous) {
 	if (!options.resolveSymlinks || options.excludeSymlinks) return null;
 	return isSynchronous ? resolveSymlinks : resolveSymlinksAsync;
 }
-function isRecursive(path$1, resolved, state) {
+function isRecursive(path, resolved, state) {
 	if (state.options.useRealPaths) return isRecursiveUsingRealPaths(resolved, state);
-	let parent = dirname$1(path$1);
-	let depth$1 = 1;
-	while (parent !== state.root && depth$1 < 2) {
+	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$1++;
+		if (!!resolvedPath && (resolvedPath === resolved || resolvedPath.startsWith(resolved) || resolved.startsWith(resolvedPath))) depth++;
 		else parent = dirname$1(parent);
 	}
-	state.symlinks.set(path$1, resolved);
-	return depth$1 > 1;
+	state.symlinks.set(path, resolved);
+	return depth > 1;
 }
 function isRecursiveUsingRealPaths(resolved, state) {
 	return state.visited.includes(resolved + state.options.pathSeparator);
@@ -230,22 +224,22 @@ 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);
+		entries = fs.readdirSync(crawlPath || ".", readdirOpts);
 	} catch (e) {
 		if (!state.options.suppressErrors) throw e;
 	}
@@ -337,7 +331,7 @@ var Walker = class {
 			symlinks: /* @__PURE__ */ 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);
@@ -352,7 +346,7 @@ var Walker = class {
 		this.walkDirectory(this.state, this.root, this.root, this.state.options.maxDepth, this.walk);
 		return this.isSynchronous ? this.callbackInvoker(this.state, null) : null;
 	}
-	walk = (entries, directoryPath, depth$1) => {
+	walk = (entries, directoryPath, depth) => {
 		const { paths, options: { filters, resolveSymlinks: resolveSymlinks$1, excludeSymlinks, exclude, maxFiles, signal, useRealPaths, pathSeparator }, controller } = this.state;
 		if (controller.aborted || signal && signal.aborted || maxFiles && paths.length > maxFiles) return;
 		const files = this.getArray(this.state.paths);
@@ -362,19 +356,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$1 = joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
-				if (exclude && exclude(entry.name, path$1)) continue;
-				this.pushDirectory(path$1, paths, filters);
-				this.walkDirectory(this.state, path$1, path$1, depth$1 - 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$1 = joinPathWithBasePath(entry.name, directoryPath);
-				this.resolveSymlink(path$1, 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$1 + pathSeparator)) return;
-						this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path$1 + pathSeparator, depth$1 - 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$1;
+						resolvedPath = useRealPaths ? resolvedPath : path;
 						const filename = basename(resolvedPath);
 						const directoryPath$1 = normalizePath(dirname$1(resolvedPath), this.state.options);
 						resolvedPath = this.joinPath(filename, directoryPath$1);
@@ -457,8 +451,8 @@ var Builder = class {
 		this.options.includeDirs = true;
 		return this;
 	}
-	withMaxDepth(depth$1) {
-		this.options.maxDepth = depth$1;
+	withMaxDepth(depth) {
+		this.options.maxDepth = depth;
 		return this;
 	}
 	withMaxFiles(limit) {
@@ -539,16 +533,16 @@ var Builder = class {
 			isMatch = globFn(patterns, ...options);
 			this.globCache[patterns.join("\0")] = isMatch;
 		}
-		this.options.filters.push((path$1) => isMatch(path$1));
+		this.options.filters.push((path) => isMatch(path));
 		return this;
 	}
 };
-
 //#endregion
-//#region ../../node_modules/.bun/picomatch@4.0.3/node_modules/picomatch/lib/constants.js
+//#region ../../node_modules/.bun/picomatch@4.0.4/node_modules/picomatch/lib/constants.js
 var require_constants = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const WIN_SLASH = "\\\\/";
 	const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
+	const DEFAULT_MAX_EXTGLOB_RECURSION = 0;
 	/**
 	* Posix glob regex
 	*/
@@ -597,28 +591,26 @@ var require_constants = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		END_ANCHOR: `(?:[${WIN_SLASH}]|$)`,
 		SEP: "\\"
 	};
-	/**
-	* POSIX Bracket Regex
-	*/
-	const POSIX_REGEX_SOURCE$1 = {
-		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$1,
+		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: /[-*+?.^${}(|)[\]]/,
@@ -708,9 +700,8 @@ var require_constants = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		}
 	};
 }));
-
 //#endregion
-//#region ../../node_modules/.bun/picomatch@4.0.3/node_modules/picomatch/lib/utils.js
+//#region ../../node_modules/.bun/picomatch@4.0.4/node_modules/picomatch/lib/utils.js
 var require_utils = /* @__PURE__ */ __commonJSMin(((exports) => {
 	const { REGEX_BACKSLASH, REGEX_REMOVE_BACKSLASH, REGEX_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_GLOBAL } = require_constants();
 	exports.isObject = (val) => val !== null && typeof val === "object" && !Array.isArray(val);
@@ -750,18 +741,17 @@ var require_utils = /* @__PURE__ */ __commonJSMin(((exports) => {
 		if (state.negated === true) output = `(?:^(?!${output}).*$)`;
 		return output;
 	};
-	exports.basename = (path$1, { windows } = {}) => {
-		const segs = path$1.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;
 	};
 }));
-
 //#endregion
-//#region ../../node_modules/.bun/picomatch@4.0.3/node_modules/picomatch/lib/scan.js
+//#region ../../node_modules/.bun/picomatch@4.0.4/node_modules/picomatch/lib/scan.js
 var require_scan = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	const utils$3 = require_utils();
+	const utils = require_utils();
 	const { CHAR_ASTERISK, CHAR_AT, CHAR_BACKWARD_SLASH, CHAR_COMMA, CHAR_DOT, CHAR_EXCLAMATION_MARK, CHAR_FORWARD_SLASH, CHAR_LEFT_CURLY_BRACE, CHAR_LEFT_PARENTHESES, CHAR_LEFT_SQUARE_BRACKET, CHAR_PLUS, CHAR_QUESTION_MARK, CHAR_RIGHT_CURLY_BRACE, CHAR_RIGHT_PARENTHESES, CHAR_RIGHT_SQUARE_BRACKET } = require_constants();
 	const isPathSeparator = (code) => {
 		return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
@@ -785,7 +775,7 @@ var require_scan = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	* @return {Object} Returns an object with tokens and regex source string.
 	* @api public
 	*/
-	const scan$1 = (input, options) => {
+	const scan = (input, options) => {
 		const opts = options || {};
 		const length = input.length - 1;
 		const scanToEnd = opts.parts === true || opts.scanToEnd === true;
@@ -973,7 +963,7 @@ var require_scan = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		}
 		let base = str;
 		let prefix = "";
-		let glob$1 = "";
+		let glob = "";
 		if (start > 0) {
 			prefix = str.slice(0, start);
 			str = str.slice(start);
@@ -981,24 +971,24 @@ var require_scan = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		}
 		if (base && isGlob === true && lastIndex > 0) {
 			base = str.slice(0, lastIndex);
-			glob$1 = str.slice(lastIndex);
+			glob = str.slice(lastIndex);
 		} else if (isGlob === true) {
 			base = "";
-			glob$1 = 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$1) glob$1 = utils$3.removeBackslashes(glob$1);
-			if (base && backslashes === true) base = utils$3.removeBackslashes(base);
+			if (glob) glob = utils.removeBackslashes(glob);
+			if (base && backslashes === true) base = utils.removeBackslashes(base);
 		}
 		const state = {
 			prefix,
 			input,
 			start,
 			base,
-			glob: glob$1,
+			glob,
 			isBrace,
 			isBracket,
 			isGlob,
@@ -1043,18 +1033,17 @@ var require_scan = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		}
 		return state;
 	};
-	module.exports = scan$1;
+	module.exports = scan;
 }));
-
 //#endregion
-//#region ../../node_modules/.bun/picomatch@4.0.3/node_modules/picomatch/lib/parse.js
+//#region ../../node_modules/.bun/picomatch@4.0.4/node_modules/picomatch/lib/parse.js
 var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	const constants$1 = require_constants();
-	const utils$2 = require_utils();
+	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$1;
+	const { MAX_LENGTH, POSIX_REGEX_SOURCE, REGEX_NON_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_BACKREF, REPLACEMENTS } = constants;
 	/**
 	* Helpers
 	*/
@@ -1065,7 +1054,7 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		try {
 			new RegExp(value);
 		} catch (ex) {
-			return args.map((v) => utils$2.escapeRegex(v)).join("..");
+			return args.map((v) => utils.escapeRegex(v)).join("..");
 		}
 		return value;
 	};
@@ -1075,13 +1064,184 @@ var require_parse = /* @__PURE__ */ __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 };
+	};
 	/**
 	* Parse the given input string.
 	* @param {String} input
 	* @param {Object} options
 	* @return {Object}
 	*/
-	const parse$1 = (input, options) => {
+	const parse = (input, options) => {
 		if (typeof input !== "string") throw new TypeError("Expected a string");
 		input = REPLACEMENTS[input] || input;
 		const opts = { ...options };
@@ -1095,14 +1255,14 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		};
 		const tokens = [bos];
 		const capture = opts.capture ? "" : "?:";
-		const PLATFORM_CHARS = constants$1.globChars(opts.windows);
-		const EXTGLOB_CHARS = constants$1.extglobChars(PLATFORM_CHARS);
-		const { DOT_LITERAL: DOT_LITERAL$1, PLUS_LITERAL: PLUS_LITERAL$1, SLASH_LITERAL: SLASH_LITERAL$1, ONE_CHAR: ONE_CHAR$1, DOTS_SLASH: DOTS_SLASH$1, NO_DOT, NO_DOT_SLASH, NO_DOTS_SLASH, QMARK: QMARK$1, QMARK_NO_DOT, STAR, START_ANCHOR: START_ANCHOR$1 } = PLATFORM_CHARS;
-		const globstar = (opts$1) => {
-			return `(${capture}(?:(?!${START_ANCHOR$1}${opts$1.dot ? DOTS_SLASH$1 : DOT_LITERAL$1}).)*?)`;
+		const PLATFORM_CHARS = constants.globChars(opts.windows);
+		const EXTGLOB_CHARS = constants.extglobChars(PLATFORM_CHARS);
+		const { DOT_LITERAL, PLUS_LITERAL, SLASH_LITERAL, ONE_CHAR, DOTS_SLASH, NO_DOT, NO_DOT_SLASH, NO_DOTS_SLASH, QMARK, QMARK_NO_DOT, STAR, START_ANCHOR } = PLATFORM_CHARS;
+		const globstar = (opts) => {
+			return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
 		};
 		const nodot = opts.dot ? "" : NO_DOT;
-		const qmarkNoDot = opts.dot ? QMARK$1 : QMARK_NO_DOT;
+		const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT;
 		let star = opts.bash === true ? globstar(opts) : STAR;
 		if (opts.capture) star = `(${star})`;
 		if (typeof opts.noext === "boolean") opts.noextglob = opts.noext;
@@ -1123,7 +1283,7 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			globstar: false,
 			tokens
 		};
-		input = utils$2.removePrefix(input, state);
+		input = utils.removePrefix(input, state);
 		len = input.length;
 		const extglobs = [];
 		const braces = [];
@@ -1137,8 +1297,8 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		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) => {
@@ -1195,21 +1355,23 @@ 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: ""
 			};
 			token.prev = prev;
 			token.parens = state.parens;
 			token.output = state.output;
+			token.startIndex = state.index;
+			token.tokensIndex = tokens.length;
 			const output = (opts.capture ? "(" : "") + token.open;
 			increment("parens");
 			push({
 				type,
-				value: value$1,
-				output: state.output ? "" : ONE_CHAR$1
+				value,
+				output: state.output ? "" : ONE_CHAR
 			});
 			push({
 				type: "paren",
@@ -1220,13 +1382,37 @@ var require_parse = /* @__PURE__ */ __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") {
 				let extglobStar = star;
 				if (token.inner && token.inner.length > 1 && token.inner.includes("/")) extglobStar = globstar(opts);
 				if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) output = token.close = `)$))${extglobStar}`;
-				if (token.inner.includes("*") && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) output = token.close = `)${parse$1(rest, {
+				if (token.inner.includes("*") && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) output = token.close = `)${parse(rest, {
 					...options,
 					fastpaths: false
 				}).output})${extglobStar})`;
@@ -1251,11 +1437,11 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 					return m;
 				}
 				if (first === "?") {
-					if (esc) return esc + first + (rest ? QMARK$1.repeat(rest.length) : "");
-					if (index === 0) return qmarkNoDot + (rest ? QMARK$1.repeat(rest.length) : "");
-					return QMARK$1.repeat(chars.length);
+					if (esc) return esc + first + (rest ? QMARK.repeat(rest.length) : "");
+					if (index === 0) return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : "");
+					return QMARK.repeat(chars.length);
 				}
-				if (first === ".") return DOT_LITERAL$1.repeat(chars.length);
+				if (first === ".") return DOT_LITERAL.repeat(chars.length);
 				if (first === "*") {
 					if (esc) return esc + first + (rest ? star : "");
 					return star;
@@ -1270,7 +1456,7 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				state.output = input;
 				return state;
 			}
-			state.output = utils$2.wrapOutput(output, state, options);
+			state.output = utils.wrapOutput(output, state, options);
 			return state;
 		}
 		/**
@@ -1323,12 +1509,12 @@ 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$1;
+								if (!bos.output && tokens.indexOf(prev) === 1) bos.output = ONE_CHAR;
 								continue;
 							}
 						}
@@ -1346,7 +1532,7 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			* until we reach the closing double quote.
 			*/
 			if (state.quotes === 1 && value !== "\"") {
-				value = utils$2.escapeRegex(value);
+				value = utils.escapeRegex(value);
 				prev.value += value;
 				append({ value });
 				continue;
@@ -1425,8 +1611,8 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				if (prev.posix !== true && prevValue[0] === "^" && !prevValue.includes("/")) value = `/${value}`;
 				prev.value += value;
 				append({ value });
-				if (opts.literalBrackets === false || utils$2.hasRegexChars(prevValue)) continue;
-				const escaped = utils$2.escapeRegex(prev.value);
+				if (opts.literalBrackets === false || utils.hasRegexChars(prevValue)) continue;
+				const escaped = utils.escapeRegex(prev.value);
 				state.output = state.output.slice(0, -prev.value.length);
 				if (opts.literalBrackets === true) {
 					state.output += escaped;
@@ -1535,7 +1721,7 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				push({
 					type: "slash",
 					value,
-					output: SLASH_LITERAL$1
+					output: SLASH_LITERAL
 				});
 				continue;
 			}
@@ -1544,7 +1730,7 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			*/
 			if (value === ".") {
 				if (state.braces > 0 && prev.type === "dot") {
-					if (prev.value === ".") prev.output = DOT_LITERAL$1;
+					if (prev.value === ".") prev.output = DOT_LITERAL;
 					const brace = braces[braces.length - 1];
 					prev.type = "dots";
 					prev.output += value;
@@ -1556,14 +1742,14 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 					push({
 						type: "text",
 						value,
-						output: DOT_LITERAL$1
+						output: DOT_LITERAL
 					});
 					continue;
 				}
 				push({
 					type: "dot",
 					value,
-					output: DOT_LITERAL$1
+					output: DOT_LITERAL
 				});
 				continue;
 			}
@@ -1597,7 +1783,7 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				push({
 					type: "qmark",
 					value,
-					output: QMARK$1
+					output: QMARK
 				});
 				continue;
 			}
@@ -1628,7 +1814,7 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 					push({
 						type: "plus",
 						value,
-						output: PLUS_LITERAL$1
+						output: PLUS_LITERAL
 					});
 					continue;
 				}
@@ -1641,7 +1827,7 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				}
 				push({
 					type: "plus",
-					value: PLUS_LITERAL$1
+					value: PLUS_LITERAL
 				});
 				continue;
 			}
@@ -1756,7 +1942,7 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 					state.output = state.output.slice(0, -(prior.output + prev.output).length);
 					prior.output = `(?:${prior.output}`;
 					prev.type = "globstar";
-					prev.output = `${globstar(opts)}${SLASH_LITERAL$1}|${SLASH_LITERAL$1}${end})`;
+					prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;
 					prev.value += value;
 					state.output += prior.output + prev.output;
 					state.globstar = true;
@@ -1771,7 +1957,7 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				if (prior.type === "bos" && rest[0] === "/") {
 					prev.type = "globstar";
 					prev.value += value;
-					prev.output = `(?:^|${SLASH_LITERAL$1}|${globstar(opts)}${SLASH_LITERAL$1})`;
+					prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;
 					state.output = prev.output;
 					state.globstar = true;
 					consume(value + advance());
@@ -1819,31 +2005,31 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 					prev.output += nodot;
 				}
 				if (peek() !== "*") {
-					state.output += ONE_CHAR$1;
-					prev.output += ONE_CHAR$1;
+					state.output += ONE_CHAR;
+					prev.output += ONE_CHAR;
 				}
 			}
 			push(token);
 		}
 		while (state.brackets > 0) {
 			if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "]"));
-			state.output = utils$2.escapeLast(state.output, "[");
+			state.output = utils.escapeLast(state.output, "[");
 			decrement("brackets");
 		}
 		while (state.parens > 0) {
 			if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", ")"));
-			state.output = utils$2.escapeLast(state.output, "(");
+			state.output = utils.escapeLast(state.output, "(");
 			decrement("parens");
 		}
 		while (state.braces > 0) {
 			if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "}"));
-			state.output = utils$2.escapeLast(state.output, "{");
+			state.output = utils.escapeLast(state.output, "{");
 			decrement("braces");
 		}
 		if (opts.strictSlashes !== true && (prev.type === "star" || prev.type === "bracket")) push({
 			type: "maybe_slash",
 			value: "",
-			output: `${SLASH_LITERAL$1}?`
+			output: `${SLASH_LITERAL}?`
 		});
 		if (state.backtrack === true) {
 			state.output = "";
@@ -1859,13 +2045,13 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	* This can significantly speed up processing and has very little downside
 	* impact when none of the fast paths match.
 	*/
-	parse$1.fastpaths = (input, options) => {
+	parse.fastpaths = (input, options) => {
 		const opts = { ...options };
 		const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
 		const len = input.length;
 		if (len > max) throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
 		input = REPLACEMENTS[input] || input;
-		const { DOT_LITERAL: DOT_LITERAL$1, SLASH_LITERAL: SLASH_LITERAL$1, ONE_CHAR: ONE_CHAR$1, DOTS_SLASH: DOTS_SLASH$1, NO_DOT, NO_DOTS, NO_DOTS_SLASH, STAR, START_ANCHOR: START_ANCHOR$1 } = constants$1.globChars(opts.windows);
+		const { DOT_LITERAL, SLASH_LITERAL, ONE_CHAR, DOTS_SLASH, NO_DOT, NO_DOTS, NO_DOTS_SLASH, STAR, START_ANCHOR } = constants.globChars(opts.windows);
 		const nodot = opts.dot ? NO_DOTS : NO_DOT;
 		const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
 		const capture = opts.capture ? "" : "?:";
@@ -1875,42 +2061,41 @@ 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$1}${opts$1.dot ? DOTS_SLASH$1 : DOT_LITERAL$1}).)*?)`;
+		const globstar = (opts) => {
+			if (opts.noglobstar === true) return star;
+			return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
 		};
 		const create = (str) => {
 			switch (str) {
-				case "*": return `${nodot}${ONE_CHAR$1}${star}`;
-				case ".*": return `${DOT_LITERAL$1}${ONE_CHAR$1}${star}`;
-				case "*.*": return `${nodot}${star}${DOT_LITERAL$1}${ONE_CHAR$1}${star}`;
-				case "*/*": return `${nodot}${star}${SLASH_LITERAL$1}${ONE_CHAR$1}${slashDot}${star}`;
+				case "*": return `${nodot}${ONE_CHAR}${star}`;
+				case ".*": return `${DOT_LITERAL}${ONE_CHAR}${star}`;
+				case "*.*": return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+				case "*/*": return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;
 				case "**": return nodot + globstar(opts);
-				case "**/*": return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL$1})?${slashDot}${ONE_CHAR$1}${star}`;
-				case "**/*.*": return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL$1})?${slashDot}${star}${DOT_LITERAL$1}${ONE_CHAR$1}${star}`;
-				case "**/.*": return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL$1})?${DOT_LITERAL$1}${ONE_CHAR$1}${star}`;
+				case "**/*": return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;
+				case "**/*.*": return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+				case "**/.*": return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;
 				default: {
 					const match = /^(.*?)\.(\w+)$/.exec(str);
 					if (!match) return;
-					const source$1 = create(match[1]);
-					if (!source$1) return;
-					return source$1 + DOT_LITERAL$1 + match[2];
+					const source = create(match[1]);
+					if (!source) return;
+					return source + DOT_LITERAL + match[2];
 				}
 			}
 		};
-		let source = create(utils$2.removePrefix(input, state));
-		if (source && opts.strictSlashes !== true) source += `${SLASH_LITERAL$1}?`;
+		let source = create(utils.removePrefix(input, state));
+		if (source && opts.strictSlashes !== true) source += `${SLASH_LITERAL}?`;
 		return source;
 	};
-	module.exports = parse$1;
+	module.exports = parse;
 }));
-
 //#endregion
-//#region ../../node_modules/.bun/picomatch@4.0.3/node_modules/picomatch/lib/picomatch.js
+//#region ../../node_modules/.bun/picomatch@4.0.4/node_modules/picomatch/lib/picomatch.js
 var require_picomatch$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const scan = require_scan();
 	const parse = require_parse();
-	const utils$1 = require_utils();
+	const utils = require_utils();
 	const constants = require_constants();
 	const isObject = (val) => val && typeof val === "object" && !Array.isArray(val);
 	/**
@@ -1934,23 +2119,23 @@ var require_picomatch$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	* @return {Function=} Returns a matcher function.
 	* @api public
 	*/
-	const picomatch$2 = (glob$1, options, returnState = false) => {
-		if (Array.isArray(glob$1)) {
-			const fns = glob$1.map((input) => picomatch$2(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$1) && glob$1.tokens && glob$1.input;
-		if (glob$1 === "" || typeof glob$1 !== "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$2.compileRe(glob$1, options) : picomatch$2.makeRe(glob$1, 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;
@@ -1961,18 +2146,18 @@ var require_picomatch$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				onMatch: null,
 				onResult: null
 			};
-			isIgnored = picomatch$2(opts.ignore, ignoreOpts, returnState);
+			isIgnored = picomatch(opts.ignore, ignoreOpts, returnState);
 		}
 		const matcher = (input, returnObject = false) => {
-			const { isMatch, match, output } = picomatch$2.test(input, regex, options, {
-				glob: glob$1,
-				posix: posix$1
+			const { isMatch, match, output } = picomatch.test(input, regex, options, {
+				glob,
+				posix
 			});
 			const result = {
-				glob: glob$1,
+				glob,
 				state,
 				regex,
-				posix: posix$1,
+				posix,
 				input,
 				output,
 				match,
@@ -2010,21 +2195,21 @@ var require_picomatch$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	* @return {Object} Returns an object with matching info.
 	* @api public
 	*/
-	picomatch$2.test = (input, regex, options, { glob: glob$1, 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$1.toPosixSlashes : null);
-		let match = input === glob$1;
+		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$1;
+			match = output === glob;
 		}
-		if (match === false || opts.capture === true) if (opts.matchBase === true || opts.basename === true) match = picomatch$2.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),
@@ -2045,8 +2230,8 @@ var require_picomatch$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	* @return {Boolean}
 	* @api public
 	*/
-	picomatch$2.matchBase = (input, glob$1, options) => {
-		return (glob$1 instanceof RegExp ? glob$1 : picomatch$2.makeRe(glob$1, options)).test(utils$1.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`.
@@ -2064,7 +2249,7 @@ var require_picomatch$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	* @return {Boolean} Returns true if any patterns match `str`
 	* @api public
 	*/
-	picomatch$2.isMatch = (str, patterns, options) => picomatch$2(patterns, options)(str);
+	picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
 	/**
 	* Parse a glob pattern to create the source string for a regular
 	* expression.
@@ -2078,8 +2263,8 @@ var require_picomatch$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	* @return {Object} Returns an object with useful properties and output to be used as a regex source string.
 	* @api public
 	*/
-	picomatch$2.parse = (pattern, options) => {
-		if (Array.isArray(pattern)) return pattern.map((p) => picomatch$2.parse(p, options));
+	picomatch.parse = (pattern, options) => {
+		if (Array.isArray(pattern)) return pattern.map((p) => picomatch.parse(p, options));
 		return parse(pattern, {
 			...options,
 			fastpaths: false
@@ -2111,11 +2296,19 @@ var require_picomatch$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	* @return {Object} Returns an object with
 	* @api public
 	*/
-	picomatch$2.scan = (input, options) => scan(input, options);
+	picomatch.scan = (input, options) => scan(input, options);
 	/**
 	* Compile a regular expression from the `state` object returned by the
 	* [parse()](#parse) method.
 	*
+	* ```js
+	* const picomatch = require('picomatch');
+	* const state = picomatch.parse('*.js');
+	* // picomatch.compileRe(state[, options]);
+	*
+	* console.log(picomatch.compileRe(state));
+	* //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+	* ```
 	* @param {Object} `state`
 	* @param {Object} `options`
 	* @param {Boolean} `returnOutput` Intended for implementors, this argument allows you to return the raw output from the parser.
@@ -2123,14 +2316,14 @@ var require_picomatch$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	* @return {RegExp}
 	* @api public
 	*/
-	picomatch$2.compileRe = (state, options, returnOutput = false, returnState = false) => {
+	picomatch.compileRe = (state, options, returnOutput = false, returnState = false) => {
 		if (returnOutput === true) return state.output;
 		const opts = options || {};
 		const prepend = opts.contains ? "" : "^";
 		const append = opts.contains ? "" : "$";
 		let source = `${prepend}(?:${state.output})${append}`;
 		if (state && state.negated === true) source = `^(?!${source}).*$`;
-		const regex = picomatch$2.toRegex(source, options);
+		const regex = picomatch.toRegex(source, options);
 		if (returnState === true) regex.state = state;
 		return regex;
 	};
@@ -2139,10 +2332,10 @@ var require_picomatch$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	*
 	* ```js
 	* const picomatch = require('picomatch');
-	* const state = picomatch.parse('*.js');
-	* // picomatch.compileRe(state[, options]);
+	* // picomatch.makeRe(state[, options]);
 	*
-	* console.log(picomatch.compileRe(state));
+	* const result = picomatch.makeRe('*.js');
+	* console.log(result);
 	* //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
 	* ```
 	* @param {String} `state` The object returned from the `.parse` method.
@@ -2152,7 +2345,7 @@ var require_picomatch$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	* @return {RegExp} Returns a regex created from the given pattern.
 	* @api public
 	*/
-	picomatch$2.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
+	picomatch.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
 		if (!input || typeof input !== "string") throw new TypeError("Expected a non-empty string");
 		let parsed = {
 			negated: false,
@@ -2160,7 +2353,7 @@ var require_picomatch$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		};
 		if (options.fastpaths !== false && (input[0] === "." || input[0] === "*")) parsed.output = parse.fastpaths(input, options);
 		if (!parsed.output) parsed = parse(input, options);
-		return picomatch$2.compileRe(parsed, options, returnOutput, returnState);
+		return picomatch.compileRe(parsed, options, returnOutput, returnState);
 	};
 	/**
 	* Create a regular expression from the given regex source string.
@@ -2178,7 +2371,7 @@ var require_picomatch$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	* @return {RegExp}
 	* @api public
 	*/
-	picomatch$2.toRegex = (source, options) => {
+	picomatch.toRegex = (source, options) => {
 		try {
 			const opts = options || {};
 			return new RegExp(source, opts.flags || (opts.nocase ? "i" : ""));
@@ -2191,62 +2384,58 @@ var require_picomatch$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	* Picomatch constants.
 	* @return {Object}
 	*/
-	picomatch$2.constants = constants;
+	picomatch.constants = constants;
 	/**
 	* Expose "picomatch"
 	*/
-	module.exports = picomatch$2;
+	module.exports = picomatch;
 }));
-
 //#endregion
-//#region ../../node_modules/.bun/picomatch@4.0.3/node_modules/picomatch/index.js
-var require_picomatch = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+//#region ../../node_modules/.bun/tinyglobby@0.2.16/node_modules/tinyglobby/dist/index.mjs
+var import_picomatch = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const pico = require_picomatch$1();
 	const utils = require_utils();
-	function picomatch$1(glob$1, 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$1, options, returnState);
+		return pico(glob, options, returnState);
 	}
-	Object.assign(picomatch$1, pico);
-	module.exports = picomatch$1;
-}));
-
-//#endregion
-//#region ../../node_modules/.bun/tinyglobby@0.2.15/node_modules/tinyglobby/dist/index.mjs
-var import_picomatch = /* @__PURE__ */ __toESM(require_picomatch(), 1);
+	Object.assign(picomatch, pico);
+	module.exports = picomatch;
+})))(), 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;
@@ -2260,7 +2449,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);
@@ -2281,20 +2470,19 @@ 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 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, "\\$&");
 /**
 * Escapes a path's special characters depending on the platform.
 * @see {@link https://superchupu.dev/tinyglobby/documentation#escapePath}
@@ -2315,34 +2503,37 @@ const escapePath = isWin ? escapeWin32Path : escapePosixPath;
 */
 function isDynamicPattern(pattern, options) {
 	if ((options === null || options === void 0 ? void 0 : options.caseSensitiveMatch) === false) return true;
-	const scan$2 = import_picomatch.default.scan(pattern);
-	return scan$2.isGlob || scan$2.negated;
+	const scan = import_picomatch.default.scan(pattern);
+	return scan.isGlob || scan.negated;
 }
 function log(...tasks) {
 	console.log(`[tinyglobby ${(/* @__PURE__ */ 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;
 		}
@@ -2358,7 +2549,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;
@@ -2367,137 +2558,127 @@ 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$1) {
-	for (let i = paths.length - 1; i >= 0; i--) {
-		const path$1 = paths[i];
-		paths[i] = relative$1(path$1);
-	}
-	return paths;
-}
-function normalizeCwd(cwd) {
-	if (!cwd) return process.cwd().replace(BACKSLASHES, "/");
-	if (cwd instanceof URL) return fileURLToPath$1(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$1 = cwd !== root && !options.absolute && buildRelative(cwd, props.root);
-	return [new Builder(fdirOptions).crawl(root), relative$1];
+	opts.cwd = (opts.cwd instanceof URL ? fileURLToPath$1(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;
 }
-async function glob(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);
+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(globInput, options) {
+	const [crawler, relative] = getCrawler(globInput, options);
+	return crawler ? formatPaths(await crawler.withPromise(), relative) : [];
 }
-
 //#endregion
 //#region src/core/template-reader.ts
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -2558,7 +2739,7 @@ async function listTemplates(prefix) {
 	});
 	return prefix ? files.map((f) => `${prefix}/${f}`) : files;
 }
-
 //#endregion
 export { loadTemplates as a, loadTemplate as i, getTemplatesRoot as n, listTemplates as r, getBinaryTemplatesRoot as t };
-//# sourceMappingURL=template-reader-DOXCnctl.mjs.map
+
+//# sourceMappingURL=template-reader-C8MBRmk-.mjs.map