ccusage 0.2.2 → 0.3.0

package/dist/data-loader-D64xoJ7s.js

@@ -0,0 +1,3302 @@
+import { createRequire } from "node:module";
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+import path$1, { posix } from "path";
+
+//#region rolldown:runtime
+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 __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), 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
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+//#region node_modules/fast-sort/dist/sort.mjs
+var castComparer = function(comparer) {
+	return function(a, b, order) {
+		return comparer(a, b, order) * order;
+	};
+};
+var throwInvalidConfigErrorIfTrue = function(condition, context) {
+	if (condition) throw Error("Invalid sort config: " + context);
+};
+var unpackObjectSorter = function(sortByObj) {
+	var _a = sortByObj || {}, asc = _a.asc, desc = _a.desc;
+	var order = asc ? 1 : -1;
+	var sortBy = asc || desc;
+	throwInvalidConfigErrorIfTrue(!sortBy, "Expected `asc` or `desc` property");
+	throwInvalidConfigErrorIfTrue(asc && desc, "Ambiguous object with `asc` and `desc` config properties");
+	var comparer = sortByObj.comparer && castComparer(sortByObj.comparer);
+	return {
+		order,
+		sortBy,
+		comparer
+	};
+};
+var multiPropertySorterProvider = function(defaultComparer$1) {
+	return function multiPropertySorter(sortBy, sortByArr, depth$1, order, comparer, a, b) {
+		var valA;
+		var valB;
+		if (typeof sortBy === "string") {
+			valA = a[sortBy];
+			valB = b[sortBy];
+		} else if (typeof sortBy === "function") {
+			valA = sortBy(a);
+			valB = sortBy(b);
+		} else {
+			var objectSorterConfig = unpackObjectSorter(sortBy);
+			return multiPropertySorter(objectSorterConfig.sortBy, sortByArr, depth$1, objectSorterConfig.order, objectSorterConfig.comparer || defaultComparer$1, a, b);
+		}
+		var equality = comparer(valA, valB, order);
+		if ((equality === 0 || valA == null && valB == null) && sortByArr.length > depth$1) return multiPropertySorter(sortByArr[depth$1], sortByArr, depth$1 + 1, order, comparer, a, b);
+		return equality;
+	};
+};
+function getSortStrategy(sortBy, comparer, order) {
+	if (sortBy === void 0 || sortBy === true) return function(a, b) {
+		return comparer(a, b, order);
+	};
+	if (typeof sortBy === "string") {
+		throwInvalidConfigErrorIfTrue(sortBy.includes("."), "String syntax not allowed for nested properties.");
+		return function(a, b) {
+			return comparer(a[sortBy], b[sortBy], order);
+		};
+	}
+	if (typeof sortBy === "function") return function(a, b) {
+		return comparer(sortBy(a), sortBy(b), order);
+	};
+	if (Array.isArray(sortBy)) {
+		var multiPropSorter_1 = multiPropertySorterProvider(comparer);
+		return function(a, b) {
+			return multiPropSorter_1(sortBy[0], sortBy, 1, order, comparer, a, b);
+		};
+	}
+	var objectSorterConfig = unpackObjectSorter(sortBy);
+	return getSortStrategy(objectSorterConfig.sortBy, objectSorterConfig.comparer || comparer, objectSorterConfig.order);
+}
+var sortArray = function(order, ctx, sortBy, comparer) {
+	var _a;
+	if (!Array.isArray(ctx)) return ctx;
+	if (Array.isArray(sortBy) && sortBy.length < 2) _a = sortBy, sortBy = _a[0];
+	return ctx.sort(getSortStrategy(sortBy, comparer, order));
+};
+function createNewSortInstance(opts) {
+	var comparer = castComparer(opts.comparer);
+	return function(arrayToSort) {
+		var ctx = Array.isArray(arrayToSort) && !opts.inPlaceSorting ? arrayToSort.slice() : arrayToSort;
+		return {
+			asc: function(sortBy) {
+				return sortArray(1, ctx, sortBy, comparer);
+			},
+			desc: function(sortBy) {
+				return sortArray(-1, ctx, sortBy, comparer);
+			},
+			by: function(sortBy) {
+				return sortArray(1, ctx, sortBy, comparer);
+			}
+		};
+	};
+}
+var defaultComparer = function(a, b, order) {
+	if (a == null) return order;
+	if (b == null) return -order;
+	if (typeof a !== typeof b) return typeof a < typeof b ? -1 : 1;
+	if (a < b) return -1;
+	if (a > b) return 1;
+	return 0;
+};
+var sort = createNewSortInstance({ comparer: defaultComparer });
+var inPlaceSort = createNewSortInstance({
+	comparer: defaultComparer,
+	inPlaceSorting: true
+});
+
+//#endregion
+//#region node_modules/fdir/dist/utils.js
+var require_utils$1 = __commonJS({ "node_modules/fdir/dist/utils.js"(exports) {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.cleanPath = cleanPath;
+	exports.convertSlashes = convertSlashes;
+	exports.isRootDirectory = isRootDirectory;
+	exports.normalizePath = normalizePath;
+	const path_1$4 = __require("path");
+	function cleanPath(path$2) {
+		let normalized = (0, path_1$4.normalize)(path$2);
+		if (normalized.length > 1 && normalized[normalized.length - 1] === path_1$4.sep) normalized = normalized.substring(0, normalized.length - 1);
+		return normalized;
+	}
+	const SLASHES_REGEX = /[\\/]/g;
+	function convertSlashes(path$2, separator) {
+		return path$2.replace(SLASHES_REGEX, separator);
+	}
+	const WINDOWS_ROOT_DIR_REGEX = /^[a-z]:[\\/]$/i;
+	function isRootDirectory(path$2) {
+		return path$2 === "/" || WINDOWS_ROOT_DIR_REGEX.test(path$2);
+	}
+	function normalizePath(path$2, options) {
+		const { resolvePaths, normalizePath: normalizePath$1, pathSeparator } = options;
+		const pathNeedsCleaning = process.platform === "win32" && path$2.includes("/") || path$2.startsWith(".");
+		if (resolvePaths) path$2 = (0, path_1$4.resolve)(path$2);
+		if (normalizePath$1 || pathNeedsCleaning) path$2 = cleanPath(path$2);
+		if (path$2 === ".") return "";
+		const needsSeperator = path$2[path$2.length - 1] !== pathSeparator;
+		return convertSlashes(needsSeperator ? path$2 + pathSeparator : path$2, pathSeparator);
+	}
+} });
+
+//#endregion
+//#region node_modules/fdir/dist/api/functions/join-path.js
+var require_join_path = __commonJS({ "node_modules/fdir/dist/api/functions/join-path.js"(exports) {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.joinPathWithBasePath = joinPathWithBasePath;
+	exports.joinDirectoryPath = joinDirectoryPath;
+	exports.build = build$7;
+	const path_1$3 = __require("path");
+	const utils_1$1 = require_utils$1();
+	function joinPathWithBasePath(filename, directoryPath) {
+		return directoryPath + filename;
+	}
+	function joinPathWithRelativePath(root, options) {
+		return function(filename, directoryPath) {
+			const sameRoot = directoryPath.startsWith(root);
+			if (sameRoot) return directoryPath.replace(root, "") + filename;
+			else return (0, utils_1$1.convertSlashes)((0, path_1$3.relative)(root, directoryPath), options.pathSeparator) + options.pathSeparator + filename;
+		};
+	}
+	function joinPath$1(filename) {
+		return filename;
+	}
+	function joinDirectoryPath(filename, directoryPath, separator) {
+		return directoryPath + filename + separator;
+	}
+	function build$7(root, options) {
+		const { relativePaths, includeBasePath } = options;
+		return relativePaths && root ? joinPathWithRelativePath(root, options) : includeBasePath ? joinPathWithBasePath : joinPath$1;
+	}
+} });
+
+//#endregion
+//#region node_modules/fdir/dist/api/functions/push-directory.js
+var require_push_directory = __commonJS({ "node_modules/fdir/dist/api/functions/push-directory.js"(exports) {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.build = build$6;
+	function pushDirectoryWithRelativePath(root) {
+		return function(directoryPath, paths) {
+			paths.push(directoryPath.substring(root.length) || ".");
+		};
+	}
+	function pushDirectoryFilterWithRelativePath(root) {
+		return function(directoryPath, paths, filters) {
+			const relativePath = directoryPath.substring(root.length) || ".";
+			if (filters.every((filter) => filter(relativePath, true))) paths.push(relativePath);
+		};
+	}
+	const pushDirectory$1 = (directoryPath, paths) => {
+		paths.push(directoryPath || ".");
+	};
+	const pushDirectoryFilter = (directoryPath, paths, filters) => {
+		const path$2 = directoryPath || ".";
+		if (filters.every((filter) => filter(path$2, true))) paths.push(path$2);
+	};
+	const empty$2 = () => {};
+	function build$6(root, options) {
+		const { includeDirs, filters, relativePaths } = options;
+		if (!includeDirs) return empty$2;
+		if (relativePaths) return filters && filters.length ? pushDirectoryFilterWithRelativePath(root) : pushDirectoryWithRelativePath(root);
+		return filters && filters.length ? pushDirectoryFilter : pushDirectory$1;
+	}
+} });
+
+//#endregion
+//#region node_modules/fdir/dist/api/functions/push-file.js
+var require_push_file = __commonJS({ "node_modules/fdir/dist/api/functions/push-file.js"(exports) {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.build = build$5;
+	const pushFileFilterAndCount = (filename, _paths, counts, filters) => {
+		if (filters.every((filter) => filter(filename, false))) counts.files++;
+	};
+	const pushFileFilter = (filename, paths, _counts, filters) => {
+		if (filters.every((filter) => filter(filename, false))) paths.push(filename);
+	};
+	const pushFileCount = (_filename, _paths, counts, _filters) => {
+		counts.files++;
+	};
+	const pushFile$1 = (filename, paths) => {
+		paths.push(filename);
+	};
+	const empty$1 = () => {};
+	function build$5(options) {
+		const { excludeFiles, filters, onlyCounts } = options;
+		if (excludeFiles) return empty$1;
+		if (filters && filters.length) return onlyCounts ? pushFileFilterAndCount : pushFileFilter;
+		else if (onlyCounts) return pushFileCount;
+		else return pushFile$1;
+	}
+} });
+
+//#endregion
+//#region node_modules/fdir/dist/api/functions/get-array.js
+var require_get_array = __commonJS({ "node_modules/fdir/dist/api/functions/get-array.js"(exports) {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.build = build$4;
+	const getArray$1 = (paths) => {
+		return paths;
+	};
+	const getArrayGroup = () => {
+		return [""].slice(0, 0);
+	};
+	function build$4(options) {
+		return options.group ? getArrayGroup : getArray$1;
+	}
+} });
+
+//#endregion
+//#region node_modules/fdir/dist/api/functions/group-files.js
+var require_group_files = __commonJS({ "node_modules/fdir/dist/api/functions/group-files.js"(exports) {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.build = build$3;
+	const groupFiles$1 = (groups, directory, files) => {
+		groups.push({
+			directory,
+			files,
+			dir: directory
+		});
+	};
+	const empty = () => {};
+	function build$3(options) {
+		return options.group ? groupFiles$1 : empty;
+	}
+} });
+
+//#endregion
+//#region node_modules/fdir/dist/api/functions/resolve-symlink.js
+var require_resolve_symlink = __commonJS({ "node_modules/fdir/dist/api/functions/resolve-symlink.js"(exports) {
+	var __importDefault$1 = void 0 && (void 0).__importDefault || function(mod) {
+		return mod && mod.__esModule ? mod : { "default": mod };
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.build = build$2;
+	const fs_1$1 = __importDefault$1(__require("fs"));
+	const path_1$2 = __require("path");
+	const resolveSymlinksAsync = function(path$2, state, callback$1) {
+		const { queue, options: { suppressErrors } } = state;
+		queue.enqueue();
+		fs_1$1.default.realpath(path$2, (error, resolvedPath) => {
+			if (error) return queue.dequeue(suppressErrors ? null : error, state);
+			fs_1$1.default.stat(resolvedPath, (error$1, stat) => {
+				if (error$1) return queue.dequeue(suppressErrors ? null : error$1, state);
+				if (stat.isDirectory() && isRecursive(path$2, resolvedPath, state)) return queue.dequeue(null, state);
+				callback$1(stat, resolvedPath);
+				queue.dequeue(null, state);
+			});
+		});
+	};
+	const resolveSymlinks = function(path$2, state, callback$1) {
+		const { queue, options: { suppressErrors } } = state;
+		queue.enqueue();
+		try {
+			const resolvedPath = fs_1$1.default.realpathSync(path$2);
+			const stat = fs_1$1.default.statSync(resolvedPath);
+			if (stat.isDirectory() && isRecursive(path$2, resolvedPath, state)) return;
+			callback$1(stat, resolvedPath);
+		} catch (e) {
+			if (!suppressErrors) throw e;
+		}
+	};
+	function build$2(options, isSynchronous) {
+		if (!options.resolveSymlinks || options.excludeSymlinks) return null;
+		return isSynchronous ? resolveSymlinks : resolveSymlinksAsync;
+	}
+	function isRecursive(path$2, resolved, state) {
+		if (state.options.useRealPaths) return isRecursiveUsingRealPaths(resolved, state);
+		let parent = (0, path_1$2.dirname)(path$2);
+		let depth$1 = 1;
+		while (parent !== state.root && depth$1 < 2) {
+			const resolvedPath = state.symlinks.get(parent);
+			const isSameRoot = !!resolvedPath && (resolvedPath === resolved || resolvedPath.startsWith(resolved) || resolved.startsWith(resolvedPath));
+			if (isSameRoot) depth$1++;
+			else parent = (0, path_1$2.dirname)(parent);
+		}
+		state.symlinks.set(path$2, resolved);
+		return depth$1 > 1;
+	}
+	function isRecursiveUsingRealPaths(resolved, state) {
+		return state.visited.includes(resolved + state.options.pathSeparator);
+	}
+} });
+
+//#endregion
+//#region node_modules/fdir/dist/api/functions/invoke-callback.js
+var require_invoke_callback = __commonJS({ "node_modules/fdir/dist/api/functions/invoke-callback.js"(exports) {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.build = build$1;
+	const onlyCountsSync = (state) => {
+		return state.counts;
+	};
+	const groupsSync = (state) => {
+		return state.groups;
+	};
+	const defaultSync = (state) => {
+		return state.paths;
+	};
+	const limitFilesSync = (state) => {
+		return state.paths.slice(0, state.options.maxFiles);
+	};
+	const onlyCountsAsync = (state, error, callback$1) => {
+		report(error, callback$1, state.counts, state.options.suppressErrors);
+		return null;
+	};
+	const defaultAsync = (state, error, callback$1) => {
+		report(error, callback$1, state.paths, state.options.suppressErrors);
+		return null;
+	};
+	const limitFilesAsync = (state, error, callback$1) => {
+		report(error, callback$1, state.paths.slice(0, state.options.maxFiles), state.options.suppressErrors);
+		return null;
+	};
+	const groupsAsync = (state, error, callback$1) => {
+		report(error, callback$1, state.groups, state.options.suppressErrors);
+		return null;
+	};
+	function report(error, callback$1, output, suppressErrors) {
+		if (error && !suppressErrors) callback$1(error, output);
+		else callback$1(null, output);
+	}
+	function build$1(options, isSynchronous) {
+		const { onlyCounts, group, maxFiles } = options;
+		if (onlyCounts) return isSynchronous ? onlyCountsSync : onlyCountsAsync;
+		else if (group) return isSynchronous ? groupsSync : groupsAsync;
+		else if (maxFiles) return isSynchronous ? limitFilesSync : limitFilesAsync;
+		else return isSynchronous ? defaultSync : defaultAsync;
+	}
+} });
+
+//#endregion
+//#region node_modules/fdir/dist/api/functions/walk-directory.js
+var require_walk_directory = __commonJS({ "node_modules/fdir/dist/api/functions/walk-directory.js"(exports) {
+	var __importDefault = void 0 && (void 0).__importDefault || function(mod) {
+		return mod && mod.__esModule ? mod : { "default": mod };
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.build = build;
+	const fs_1 = __importDefault(__require("fs"));
+	const readdirOpts = { withFileTypes: true };
+	const walkAsync = (state, crawlPath, directoryPath, currentDepth, callback$1) => {
+		state.queue.enqueue();
+		if (currentDepth <= 0) return state.queue.dequeue(null, state);
+		state.visited.push(crawlPath);
+		state.counts.directories++;
+		fs_1.default.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) => {
+		if (currentDepth <= 0) return;
+		state.visited.push(crawlPath);
+		state.counts.directories++;
+		let entries = [];
+		try {
+			entries = fs_1.default.readdirSync(crawlPath || ".", readdirOpts);
+		} catch (e) {
+			if (!state.options.suppressErrors) throw e;
+		}
+		callback$1(entries, directoryPath, currentDepth);
+	};
+	function build(isSynchronous) {
+		return isSynchronous ? walkSync : walkAsync;
+	}
+} });
+
+//#endregion
+//#region node_modules/fdir/dist/api/queue.js
+var require_queue = __commonJS({ "node_modules/fdir/dist/api/queue.js"(exports) {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.Queue = void 0;
+	/**
+	* This is a custom stateless queue to track concurrent async fs calls.
+	* It increments a counter whenever a call is queued and decrements it
+	* as soon as it completes. When the counter hits 0, it calls onQueueEmpty.
+	*/
+	var Queue = class {
+		onQueueEmpty;
+		count = 0;
+		constructor(onQueueEmpty) {
+			this.onQueueEmpty = onQueueEmpty;
+		}
+		enqueue() {
+			this.count++;
+			return this.count;
+		}
+		dequeue(error, output) {
+			if (this.onQueueEmpty && (--this.count <= 0 || error)) {
+				this.onQueueEmpty(error, output);
+				if (error) {
+					output.controller.abort();
+					this.onQueueEmpty = void 0;
+				}
+			}
+		}
+	};
+	exports.Queue = Queue;
+} });
+
+//#endregion
+//#region node_modules/fdir/dist/api/counter.js
+var require_counter = __commonJS({ "node_modules/fdir/dist/api/counter.js"(exports) {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.Counter = void 0;
+	var Counter = class {
+		_files = 0;
+		_directories = 0;
+		set files(num) {
+			this._files = num;
+		}
+		get files() {
+			return this._files;
+		}
+		set directories(num) {
+			this._directories = num;
+		}
+		get directories() {
+			return this._directories;
+		}
+		/**
+		* @deprecated use `directories` instead
+		*/
+		/* c8 ignore next 3 */
+		get dirs() {
+			return this._directories;
+		}
+	};
+	exports.Counter = Counter;
+} });
+
+//#endregion
+//#region node_modules/fdir/dist/api/walker.js
+var require_walker = __commonJS({ "node_modules/fdir/dist/api/walker.js"(exports) {
+	var __createBinding$1 = void 0 && (void 0).__createBinding || (Object.create ? function(o, m, k, k2) {
+		if (k2 === void 0) k2 = k;
+		var desc = Object.getOwnPropertyDescriptor(m, k);
+		if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) desc = {
+			enumerable: true,
+			get: function() {
+				return m[k];
+			}
+		};
+		Object.defineProperty(o, k2, desc);
+	} : function(o, m, k, k2) {
+		if (k2 === void 0) k2 = k;
+		o[k2] = m[k];
+	});
+	var __setModuleDefault = void 0 && (void 0).__setModuleDefault || (Object.create ? function(o, v) {
+		Object.defineProperty(o, "default", {
+			enumerable: true,
+			value: v
+		});
+	} : function(o, v) {
+		o["default"] = v;
+	});
+	var __importStar = void 0 && (void 0).__importStar || function() {
+		var ownKeys = function(o) {
+			ownKeys = Object.getOwnPropertyNames || function(o$1) {
+				var ar = [];
+				for (var k in o$1) if (Object.prototype.hasOwnProperty.call(o$1, k)) ar[ar.length] = k;
+				return ar;
+			};
+			return ownKeys(o);
+		};
+		return function(mod) {
+			if (mod && mod.__esModule) return mod;
+			var result = {};
+			if (mod != null) {
+				for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding$1(result, mod, k[i]);
+			}
+			__setModuleDefault(result, mod);
+			return result;
+		};
+	}();
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.Walker = void 0;
+	const path_1$1 = __require("path");
+	const utils_1 = require_utils$1();
+	const joinPath = __importStar(require_join_path());
+	const pushDirectory = __importStar(require_push_directory());
+	const pushFile = __importStar(require_push_file());
+	const getArray = __importStar(require_get_array());
+	const groupFiles = __importStar(require_group_files());
+	const resolveSymlink = __importStar(require_resolve_symlink());
+	const invokeCallback = __importStar(require_invoke_callback());
+	const walkDirectory = __importStar(require_walk_directory());
+	const queue_1 = require_queue();
+	const counter_1 = require_counter();
+	var Walker = class {
+		root;
+		isSynchronous;
+		state;
+		joinPath;
+		pushDirectory;
+		pushFile;
+		getArray;
+		groupFiles;
+		resolveSymlink;
+		walkDirectory;
+		callbackInvoker;
+		constructor(root, options, callback$1) {
+			this.isSynchronous = !callback$1;
+			this.callbackInvoker = invokeCallback.build(options, this.isSynchronous);
+			this.root = (0, utils_1.normalizePath)(root, options);
+			this.state = {
+				root: (0, utils_1.isRootDirectory)(this.root) ? this.root : this.root.slice(0, -1),
+				paths: [""].slice(0, 0),
+				groups: [],
+				counts: new counter_1.Counter(),
+				options,
+				queue: new queue_1.Queue((error, state) => this.callbackInvoker(state, error, callback$1)),
+				symlinks: new Map(),
+				visited: [""].slice(0, 0),
+				controller: new AbortController()
+			};
+			this.joinPath = joinPath.build(this.root, options);
+			this.pushDirectory = pushDirectory.build(this.root, options);
+			this.pushFile = pushFile.build(options);
+			this.getArray = getArray.build(options);
+			this.groupFiles = groupFiles.build(options);
+			this.resolveSymlink = resolveSymlink.build(options, this.isSynchronous);
+			this.walkDirectory = walkDirectory.build(this.isSynchronous);
+		}
+		start() {
+			this.pushDirectory(this.root, this.state.paths, this.state.options.filters);
+			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) => {
+			const { paths, options: { filters, resolveSymlinks: resolveSymlinks$1, excludeSymlinks, exclude, maxFiles, signal, useRealPaths, pathSeparator }, controller } = this.state;
+			if (controller.signal.aborted || signal && signal.aborted || maxFiles && paths.length > maxFiles) return;
+			const files = this.getArray(this.state.paths);
+			for (let i = 0; i < entries.length; ++i) {
+				const entry = entries[i];
+				if (entry.isFile() || entry.isSymbolicLink() && !resolveSymlinks$1 && !excludeSymlinks) {
+					const filename = this.joinPath(entry.name, directoryPath);
+					this.pushFile(filename, files, this.state.counts, filters);
+				} else if (entry.isDirectory()) {
+					let path$2 = joinPath.joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
+					if (exclude && exclude(entry.name, path$2)) continue;
+					this.pushDirectory(path$2, paths, filters);
+					this.walkDirectory(this.state, path$2, path$2, depth$1 - 1, this.walk);
+				} else if (this.resolveSymlink && entry.isSymbolicLink()) {
+					let path$2 = joinPath.joinPathWithBasePath(entry.name, directoryPath);
+					this.resolveSymlink(path$2, this.state, (stat, resolvedPath) => {
+						if (stat.isDirectory()) {
+							resolvedPath = (0, utils_1.normalizePath)(resolvedPath, this.state.options);
+							if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path$2 + pathSeparator)) return;
+							this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path$2 + pathSeparator, depth$1 - 1, this.walk);
+						} else {
+							resolvedPath = useRealPaths ? resolvedPath : path$2;
+							const filename = (0, path_1$1.basename)(resolvedPath);
+							const directoryPath$1 = (0, utils_1.normalizePath)((0, path_1$1.dirname)(resolvedPath), this.state.options);
+							resolvedPath = this.joinPath(filename, directoryPath$1);
+							this.pushFile(resolvedPath, files, this.state.counts, filters);
+						}
+					});
+				}
+			}
+			this.groupFiles(this.state.groups, directoryPath, files);
+		};
+	};
+	exports.Walker = Walker;
+} });
+
+//#endregion
+//#region node_modules/fdir/dist/api/async.js
+var require_async = __commonJS({ "node_modules/fdir/dist/api/async.js"(exports) {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.promise = promise;
+	exports.callback = callback;
+	const walker_1$1 = require_walker();
+	function promise(root, options) {
+		return new Promise((resolve, reject) => {
+			callback(root, options, (err, output) => {
+				if (err) return reject(err);
+				resolve(output);
+			});
+		});
+	}
+	function callback(root, options, callback$1) {
+		let walker = new walker_1$1.Walker(root, options, callback$1);
+		walker.start();
+	}
+} });
+
+//#endregion
+//#region node_modules/fdir/dist/api/sync.js
+var require_sync = __commonJS({ "node_modules/fdir/dist/api/sync.js"(exports) {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.sync = sync;
+	const walker_1 = require_walker();
+	function sync(root, options) {
+		const walker = new walker_1.Walker(root, options);
+		return walker.start();
+	}
+} });
+
+//#endregion
+//#region node_modules/fdir/dist/builder/api-builder.js
+var require_api_builder = __commonJS({ "node_modules/fdir/dist/builder/api-builder.js"(exports) {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.APIBuilder = void 0;
+	const async_1 = require_async();
+	const sync_1 = require_sync();
+	var APIBuilder = class {
+		root;
+		options;
+		constructor(root, options) {
+			this.root = root;
+			this.options = options;
+		}
+		withPromise() {
+			return (0, async_1.promise)(this.root, this.options);
+		}
+		withCallback(cb) {
+			(0, async_1.callback)(this.root, this.options, cb);
+		}
+		sync() {
+			return (0, sync_1.sync)(this.root, this.options);
+		}
+	};
+	exports.APIBuilder = APIBuilder;
+} });
+
+//#endregion
+//#region node_modules/picomatch/lib/constants.js
+var require_constants = __commonJS({ "node_modules/picomatch/lib/constants.js"(exports, module) {
+	const WIN_SLASH = "\\\\/";
+	const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
+	/**
+	* Posix glob regex
+	*/
+	const DOT_LITERAL = "\\.";
+	const PLUS_LITERAL = "\\+";
+	const QMARK_LITERAL = "\\?";
+	const SLASH_LITERAL = "\\/";
+	const ONE_CHAR = "(?=.)";
+	const QMARK = "[^/]";
+	const END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
+	const START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
+	const DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
+	const NO_DOT = `(?!${DOT_LITERAL})`;
+	const NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;
+	const NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;
+	const NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;
+	const QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;
+	const STAR = `${QMARK}*?`;
+	const SEP = "/";
+	const POSIX_CHARS = {
+		DOT_LITERAL,
+		PLUS_LITERAL,
+		QMARK_LITERAL,
+		SLASH_LITERAL,
+		ONE_CHAR,
+		QMARK,
+		END_ANCHOR,
+		DOTS_SLASH,
+		NO_DOT,
+		NO_DOTS,
+		NO_DOT_SLASH,
+		NO_DOTS_SLASH,
+		QMARK_NO_DOT,
+		STAR,
+		START_ANCHOR,
+		SEP
+	};
+	/**
+	* Windows glob regex
+	*/
+	const WINDOWS_CHARS = {
+		...POSIX_CHARS,
+		SLASH_LITERAL: `[${WIN_SLASH}]`,
+		QMARK: WIN_NO_SLASH,
+		STAR: `${WIN_NO_SLASH}*?`,
+		DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,
+		NO_DOT: `(?!${DOT_LITERAL})`,
+		NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+		NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,
+		NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+		QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
+		START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
+		END_ANCHOR: `(?:[${WIN_SLASH}]|$)`,
+		SEP: "\\"
+	};
+	/**
+	* 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 = {
+		MAX_LENGTH: 1024 * 64,
+		POSIX_REGEX_SOURCE: POSIX_REGEX_SOURCE$1,
+		REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
+		REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
+		REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
+		REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
+		REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
+		REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
+		REPLACEMENTS: {
+			"***": "*",
+			"**/**": "**",
+			"**/**/**": "**"
+		},
+		CHAR_0: 48,
+		CHAR_9: 57,
+		CHAR_UPPERCASE_A: 65,
+		CHAR_LOWERCASE_A: 97,
+		CHAR_UPPERCASE_Z: 90,
+		CHAR_LOWERCASE_Z: 122,
+		CHAR_LEFT_PARENTHESES: 40,
+		CHAR_RIGHT_PARENTHESES: 41,
+		CHAR_ASTERISK: 42,
+		CHAR_AMPERSAND: 38,
+		CHAR_AT: 64,
+		CHAR_BACKWARD_SLASH: 92,
+		CHAR_CARRIAGE_RETURN: 13,
+		CHAR_CIRCUMFLEX_ACCENT: 94,
+		CHAR_COLON: 58,
+		CHAR_COMMA: 44,
+		CHAR_DOT: 46,
+		CHAR_DOUBLE_QUOTE: 34,
+		CHAR_EQUAL: 61,
+		CHAR_EXCLAMATION_MARK: 33,
+		CHAR_FORM_FEED: 12,
+		CHAR_FORWARD_SLASH: 47,
+		CHAR_GRAVE_ACCENT: 96,
+		CHAR_HASH: 35,
+		CHAR_HYPHEN_MINUS: 45,
+		CHAR_LEFT_ANGLE_BRACKET: 60,
+		CHAR_LEFT_CURLY_BRACE: 123,
+		CHAR_LEFT_SQUARE_BRACKET: 91,
+		CHAR_LINE_FEED: 10,
+		CHAR_NO_BREAK_SPACE: 160,
+		CHAR_PERCENT: 37,
+		CHAR_PLUS: 43,
+		CHAR_QUESTION_MARK: 63,
+		CHAR_RIGHT_ANGLE_BRACKET: 62,
+		CHAR_RIGHT_CURLY_BRACE: 125,
+		CHAR_RIGHT_SQUARE_BRACKET: 93,
+		CHAR_SEMICOLON: 59,
+		CHAR_SINGLE_QUOTE: 39,
+		CHAR_SPACE: 32,
+		CHAR_TAB: 9,
+		CHAR_UNDERSCORE: 95,
+		CHAR_VERTICAL_LINE: 124,
+		CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
+		extglobChars(chars) {
+			return {
+				"!": {
+					type: "negate",
+					open: "(?:(?!(?:",
+					close: `))${chars.STAR})`
+				},
+				"?": {
+					type: "qmark",
+					open: "(?:",
+					close: ")?"
+				},
+				"+": {
+					type: "plus",
+					open: "(?:",
+					close: ")+"
+				},
+				"*": {
+					type: "star",
+					open: "(?:",
+					close: ")*"
+				},
+				"@": {
+					type: "at",
+					open: "(?:",
+					close: ")"
+				}
+			};
+		},
+		globChars(win32) {
+			return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;
+		}
+	};
+} });
+
+//#endregion
+//#region node_modules/picomatch/lib/utils.js
+var require_utils = __commonJS({ "node_modules/picomatch/lib/utils.js"(exports) {
+	const { REGEX_BACKSLASH, REGEX_REMOVE_BACKSLASH, REGEX_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_GLOBAL } = require_constants();
+	exports.isObject = (val) => val !== null && typeof val === "object" && !Array.isArray(val);
+	exports.hasRegexChars = (str) => REGEX_SPECIAL_CHARS.test(str);
+	exports.isRegexChar = (str) => str.length === 1 && exports.hasRegexChars(str);
+	exports.escapeRegex = (str) => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, "\\$1");
+	exports.toPosixSlashes = (str) => str.replace(REGEX_BACKSLASH, "/");
+	exports.isWindows = () => {
+		if (typeof navigator !== "undefined" && navigator.platform) {
+			const platform = navigator.platform.toLowerCase();
+			return platform === "win32" || platform === "windows";
+		}
+		if (typeof process !== "undefined" && process.platform) return process.platform === "win32";
+		return false;
+	};
+	exports.removeBackslashes = (str) => {
+		return str.replace(REGEX_REMOVE_BACKSLASH, (match) => {
+			return match === "\\" ? "" : match;
+		});
+	};
+	exports.escapeLast = (input, char, lastIdx) => {
+		const idx = input.lastIndexOf(char, lastIdx);
+		if (idx === -1) return input;
+		if (input[idx - 1] === "\\") return exports.escapeLast(input, char, idx - 1);
+		return `${input.slice(0, idx)}\\${input.slice(idx)}`;
+	};
+	exports.removePrefix = (input, state = {}) => {
+		let output = input;
+		if (output.startsWith("./")) {
+			output = output.slice(2);
+			state.prefix = "./";
+		}
+		return output;
+	};
+	exports.wrapOutput = (input, state = {}, options = {}) => {
+		const prepend = options.contains ? "" : "^";
+		const append = options.contains ? "" : "$";
+		let output = `${prepend}(?:${input})${append}`;
+		if (state.negated === true) output = `(?:^(?!${output}).*$)`;
+		return output;
+	};
+	exports.basename = (path$2, { windows } = {}) => {
+		const segs = path$2.split(windows ? /[\\/]/ : "/");
+		const last = segs[segs.length - 1];
+		if (last === "") return segs[segs.length - 2];
+		return last;
+	};
+} });
+
+//#endregion
+//#region node_modules/picomatch/lib/scan.js
+var require_scan = __commonJS({ "node_modules/picomatch/lib/scan.js"(exports, module) {
+	const utils$3 = require_utils();
+	const { CHAR_ASTERISK, CHAR_AT, CHAR_BACKWARD_SLASH, CHAR_COMMA, CHAR_DOT, CHAR_EXCLAMATION_MARK, CHAR_FORWARD_SLASH, CHAR_LEFT_CURLY_BRACE, CHAR_LEFT_PARENTHESES, CHAR_LEFT_SQUARE_BRACKET, CHAR_PLUS, CHAR_QUESTION_MARK, CHAR_RIGHT_CURLY_BRACE, CHAR_RIGHT_PARENTHESES, CHAR_RIGHT_SQUARE_BRACKET } = require_constants();
+	const isPathSeparator = (code) => {
+		return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
+	};
+	const depth = (token) => {
+		if (token.isPrefix !== true) token.depth = token.isGlobstar ? Infinity : 1;
+	};
+	/**
+	* Quickly scans a glob pattern and returns an object with a handful of
+	* useful properties, like `isGlob`, `path` (the leading non-glob, if it exists),
+	* `glob` (the actual pattern), `negated` (true if the path starts with `!` but not
+	* with `!(`) and `negatedExtglob` (true if the path starts with `!(`).
+	*
+	* ```js
+	* const pm = require('picomatch');
+	* console.log(pm.scan('foo/bar/*.js'));
+	* { isGlob: true, input: 'foo/bar/*.js', base: 'foo/bar', glob: '*.js' }
+	* ```
+	* @param {String} `str`
+	* @param {Object} `options`
+	* @return {Object} Returns an object with tokens and regex source string.
+	* @api public
+	*/
+	const scan$1 = (input, options) => {
+		const opts = options || {};
+		const length = input.length - 1;
+		const scanToEnd = opts.parts === true || opts.scanToEnd === true;
+		const slashes = [];
+		const tokens = [];
+		const parts = [];
+		let str = input;
+		let index = -1;
+		let start = 0;
+		let lastIndex = 0;
+		let isBrace = false;
+		let isBracket = false;
+		let isGlob = false;
+		let isExtglob = false;
+		let isGlobstar = false;
+		let braceEscaped = false;
+		let backslashes = false;
+		let negated = false;
+		let negatedExtglob = false;
+		let finished = false;
+		let braces = 0;
+		let prev;
+		let code;
+		let token = {
+			value: "",
+			depth: 0,
+			isGlob: false
+		};
+		const eos = () => index >= length;
+		const peek = () => str.charCodeAt(index + 1);
+		const advance = () => {
+			prev = code;
+			return str.charCodeAt(++index);
+		};
+		while (index < length) {
+			code = advance();
+			let next;
+			if (code === CHAR_BACKWARD_SLASH) {
+				backslashes = token.backslashes = true;
+				code = advance();
+				if (code === CHAR_LEFT_CURLY_BRACE) braceEscaped = true;
+				continue;
+			}
+			if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE) {
+				braces++;
+				while (eos() !== true && (code = advance())) {
+					if (code === CHAR_BACKWARD_SLASH) {
+						backslashes = token.backslashes = true;
+						advance();
+						continue;
+					}
+					if (code === CHAR_LEFT_CURLY_BRACE) {
+						braces++;
+						continue;
+					}
+					if (braceEscaped !== true && code === CHAR_DOT && (code = advance()) === CHAR_DOT) {
+						isBrace = token.isBrace = true;
+						isGlob = token.isGlob = true;
+						finished = true;
+						if (scanToEnd === true) continue;
+						break;
+					}
+					if (braceEscaped !== true && code === CHAR_COMMA) {
+						isBrace = token.isBrace = true;
+						isGlob = token.isGlob = true;
+						finished = true;
+						if (scanToEnd === true) continue;
+						break;
+					}
+					if (code === CHAR_RIGHT_CURLY_BRACE) {
+						braces--;
+						if (braces === 0) {
+							braceEscaped = false;
+							isBrace = token.isBrace = true;
+							finished = true;
+							break;
+						}
+					}
+				}
+				if (scanToEnd === true) continue;
+				break;
+			}
+			if (code === CHAR_FORWARD_SLASH) {
+				slashes.push(index);
+				tokens.push(token);
+				token = {
+					value: "",
+					depth: 0,
+					isGlob: false
+				};
+				if (finished === true) continue;
+				if (prev === CHAR_DOT && index === start + 1) {
+					start += 2;
+					continue;
+				}
+				lastIndex = index + 1;
+				continue;
+			}
+			if (opts.noext !== true) {
+				const isExtglobChar = code === CHAR_PLUS || code === CHAR_AT || code === CHAR_ASTERISK || code === CHAR_QUESTION_MARK || code === CHAR_EXCLAMATION_MARK;
+				if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES) {
+					isGlob = token.isGlob = true;
+					isExtglob = token.isExtglob = true;
+					finished = true;
+					if (code === CHAR_EXCLAMATION_MARK && index === start) negatedExtglob = true;
+					if (scanToEnd === true) {
+						while (eos() !== true && (code = advance())) {
+							if (code === CHAR_BACKWARD_SLASH) {
+								backslashes = token.backslashes = true;
+								code = advance();
+								continue;
+							}
+							if (code === CHAR_RIGHT_PARENTHESES) {
+								isGlob = token.isGlob = true;
+								finished = true;
+								break;
+							}
+						}
+						continue;
+					}
+					break;
+				}
+			}
+			if (code === CHAR_ASTERISK) {
+				if (prev === CHAR_ASTERISK) isGlobstar = token.isGlobstar = true;
+				isGlob = token.isGlob = true;
+				finished = true;
+				if (scanToEnd === true) continue;
+				break;
+			}
+			if (code === CHAR_QUESTION_MARK) {
+				isGlob = token.isGlob = true;
+				finished = true;
+				if (scanToEnd === true) continue;
+				break;
+			}
+			if (code === CHAR_LEFT_SQUARE_BRACKET) {
+				while (eos() !== true && (next = advance())) {
+					if (next === CHAR_BACKWARD_SLASH) {
+						backslashes = token.backslashes = true;
+						advance();
+						continue;
+					}
+					if (next === CHAR_RIGHT_SQUARE_BRACKET) {
+						isBracket = token.isBracket = true;
+						isGlob = token.isGlob = true;
+						finished = true;
+						break;
+					}
+				}
+				if (scanToEnd === true) continue;
+				break;
+			}
+			if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) {
+				negated = token.negated = true;
+				start++;
+				continue;
+			}
+			if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) {
+				isGlob = token.isGlob = true;
+				if (scanToEnd === true) {
+					while (eos() !== true && (code = advance())) {
+						if (code === CHAR_LEFT_PARENTHESES) {
+							backslashes = token.backslashes = true;
+							code = advance();
+							continue;
+						}
+						if (code === CHAR_RIGHT_PARENTHESES) {
+							finished = true;
+							break;
+						}
+					}
+					continue;
+				}
+				break;
+			}
+			if (isGlob === true) {
+				finished = true;
+				if (scanToEnd === true) continue;
+				break;
+			}
+		}
+		if (opts.noext === true) {
+			isExtglob = false;
+			isGlob = false;
+		}
+		let base = str;
+		let prefix = "";
+		let glob$1 = "";
+		if (start > 0) {
+			prefix = str.slice(0, start);
+			str = str.slice(start);
+			lastIndex -= start;
+		}
+		if (base && isGlob === true && lastIndex > 0) {
+			base = str.slice(0, lastIndex);
+			glob$1 = str.slice(lastIndex);
+		} else if (isGlob === true) {
+			base = "";
+			glob$1 = 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);
+		}
+		const state = {
+			prefix,
+			input,
+			start,
+			base,
+			glob: glob$1,
+			isBrace,
+			isBracket,
+			isGlob,
+			isExtglob,
+			isGlobstar,
+			negated,
+			negatedExtglob
+		};
+		if (opts.tokens === true) {
+			state.maxDepth = 0;
+			if (!isPathSeparator(code)) tokens.push(token);
+			state.tokens = tokens;
+		}
+		if (opts.parts === true || opts.tokens === true) {
+			let prevIndex;
+			for (let idx = 0; idx < slashes.length; idx++) {
+				const n = prevIndex ? prevIndex + 1 : start;
+				const i = slashes[idx];
+				const value = input.slice(n, i);
+				if (opts.tokens) {
+					if (idx === 0 && start !== 0) {
+						tokens[idx].isPrefix = true;
+						tokens[idx].value = prefix;
+					} else tokens[idx].value = value;
+					depth(tokens[idx]);
+					state.maxDepth += tokens[idx].depth;
+				}
+				if (idx !== 0 || value !== "") parts.push(value);
+				prevIndex = i;
+			}
+			if (prevIndex && prevIndex + 1 < input.length) {
+				const value = input.slice(prevIndex + 1);
+				parts.push(value);
+				if (opts.tokens) {
+					tokens[tokens.length - 1].value = value;
+					depth(tokens[tokens.length - 1]);
+					state.maxDepth += tokens[tokens.length - 1].depth;
+				}
+			}
+			state.slashes = slashes;
+			state.parts = parts;
+		}
+		return state;
+	};
+	module.exports = scan$1;
+} });
+
+//#endregion
+//#region node_modules/picomatch/lib/parse.js
+var require_parse = __commonJS({ "node_modules/picomatch/lib/parse.js"(exports, module) {
+	const constants$1 = require_constants();
+	const utils$2 = require_utils();
+	/**
+	* Constants
+	*/
+	const { MAX_LENGTH, POSIX_REGEX_SOURCE, REGEX_NON_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_BACKREF, REPLACEMENTS } = constants$1;
+	/**
+	* Helpers
+	*/
+	const expandRange = (args, options) => {
+		if (typeof options.expandRange === "function") return options.expandRange(...args, options);
+		args.sort();
+		const value = `[${args.join("-")}]`;
+		try {
+			new RegExp(value);
+		} catch (ex) {
+			return args.map((v) => utils$2.escapeRegex(v)).join("..");
+		}
+		return value;
+	};
+	/**
+	* Create the message for a syntax error
+	*/
+	const syntaxError = (type, char) => {
+		return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
+	};
+	/**
+	* Parse the given input string.
+	* @param {String} input
+	* @param {Object} options
+	* @return {Object}
+	*/
+	const parse$1 = (input, options) => {
+		if (typeof input !== "string") throw new TypeError("Expected a string");
+		input = REPLACEMENTS[input] || input;
+		const opts = { ...options };
+		const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+		let len = input.length;
+		if (len > max) throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+		const bos = {
+			type: "bos",
+			value: "",
+			output: opts.prepend || ""
+		};
+		const tokens = [bos];
+		const capture = opts.capture ? "" : "?:";
+		const PLATFORM_CHARS = constants$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$1, NO_DOT_SLASH: NO_DOT_SLASH$1, NO_DOTS_SLASH: NO_DOTS_SLASH$1, QMARK: QMARK$1, QMARK_NO_DOT: QMARK_NO_DOT$1, STAR: STAR$1, 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 nodot = opts.dot ? "" : NO_DOT$1;
+		const qmarkNoDot = opts.dot ? QMARK$1 : QMARK_NO_DOT$1;
+		let star = opts.bash === true ? globstar(opts) : STAR$1;
+		if (opts.capture) star = `(${star})`;
+		if (typeof opts.noext === "boolean") opts.noextglob = opts.noext;
+		const state = {
+			input,
+			index: -1,
+			start: 0,
+			dot: opts.dot === true,
+			consumed: "",
+			output: "",
+			prefix: "",
+			backtrack: false,
+			negated: false,
+			brackets: 0,
+			braces: 0,
+			parens: 0,
+			quotes: 0,
+			globstar: false,
+			tokens
+		};
+		input = utils$2.removePrefix(input, state);
+		len = input.length;
+		const extglobs = [];
+		const braces = [];
+		const stack = [];
+		let prev = bos;
+		let value;
+		/**
+		* Tokenizing helpers
+		*/
+		const eos = () => state.index === len - 1;
+		const peek = state.peek = (n = 1) => input[state.index + n];
+		const advance = state.advance = () => input[++state.index] || "";
+		const remaining = () => input.slice(state.index + 1);
+		const consume = (value$1 = "", num = 0) => {
+			state.consumed += value$1;
+			state.index += num;
+		};
+		const append = (token) => {
+			state.output += token.output != null ? token.output : token.value;
+			consume(token.value);
+		};
+		const negate = () => {
+			let count = 1;
+			while (peek() === "!" && (peek(2) !== "(" || peek(3) === "?")) {
+				advance();
+				state.start++;
+				count++;
+			}
+			if (count % 2 === 0) return false;
+			state.negated = true;
+			state.start++;
+			return true;
+		};
+		const increment = (type) => {
+			state[type]++;
+			stack.push(type);
+		};
+		const decrement = (type) => {
+			state[type]--;
+			stack.pop();
+		};
+		/**
+		* Push tokens onto the tokens array. This helper speeds up
+		* tokenizing by 1) helping us avoid backtracking as much as possible,
+		* and 2) helping us avoid creating extra tokens when consecutive
+		* characters are plain text. This improves performance and simplifies
+		* lookbehinds.
+		*/
+		const push = (tok) => {
+			if (prev.type === "globstar") {
+				const isBrace = state.braces > 0 && (tok.type === "comma" || tok.type === "brace");
+				const isExtglob = tok.extglob === true || extglobs.length && (tok.type === "pipe" || tok.type === "paren");
+				if (tok.type !== "slash" && tok.type !== "paren" && !isBrace && !isExtglob) {
+					state.output = state.output.slice(0, -prev.output.length);
+					prev.type = "star";
+					prev.value = "*";
+					prev.output = star;
+					state.output += prev.output;
+				}
+			}
+			if (extglobs.length && tok.type !== "paren") extglobs[extglobs.length - 1].inner += tok.value;
+			if (tok.value || tok.output) append(tok);
+			if (prev && prev.type === "text" && tok.type === "text") {
+				prev.output = (prev.output || prev.value) + tok.value;
+				prev.value += tok.value;
+				return;
+			}
+			tok.prev = prev;
+			tokens.push(tok);
+			prev = tok;
+		};
+		const extglobOpen = (type, value$1) => {
+			const token = {
+				...EXTGLOB_CHARS[value$1],
+				conditions: 1,
+				inner: ""
+			};
+			token.prev = prev;
+			token.parens = state.parens;
+			token.output = state.output;
+			const output = (opts.capture ? "(" : "") + token.open;
+			increment("parens");
+			push({
+				type,
+				value: value$1,
+				output: state.output ? "" : ONE_CHAR$1
+			});
+			push({
+				type: "paren",
+				extglob: true,
+				value: advance(),
+				output
+			});
+			extglobs.push(token);
+		};
+		const extglobClose = (token) => {
+			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)) {
+					const expression = parse$1(rest, {
+						...options,
+						fastpaths: false
+					}).output;
+					output = token.close = `)${expression})${extglobStar})`;
+				}
+				if (token.prev.type === "bos") state.negatedExtglob = true;
+			}
+			push({
+				type: "paren",
+				extglob: true,
+				value,
+				output
+			});
+			decrement("parens");
+		};
+		/**
+		* Fast paths
+		*/
+		if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) {
+			let backslashes = false;
+			let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => {
+				if (first === "\\") {
+					backslashes = true;
+					return m;
+				}
+				if (first === "?") {
+					if (esc) return esc + first + (rest ? QMARK$1.repeat(rest.length) : "");
+					if (index === 0) return qmarkNoDot + (rest ? QMARK$1.repeat(rest.length) : "");
+					return QMARK$1.repeat(chars.length);
+				}
+				if (first === ".") return DOT_LITERAL$1.repeat(chars.length);
+				if (first === "*") {
+					if (esc) return esc + first + (rest ? star : "");
+					return star;
+				}
+				return esc ? m : `\\${m}`;
+			});
+			if (backslashes === true) if (opts.unescape === true) output = output.replace(/\\/g, "");
+			else output = output.replace(/\\+/g, (m) => {
+				return m.length % 2 === 0 ? "\\\\" : m ? "\\" : "";
+			});
+			if (output === input && opts.contains === true) {
+				state.output = input;
+				return state;
+			}
+			state.output = utils$2.wrapOutput(output, state, options);
+			return state;
+		}
+		/**
+		* Tokenize input until we reach end-of-string
+		*/
+		while (!eos()) {
+			value = advance();
+			if (value === "\0") continue;
+			/**
+			* Escaped characters
+			*/
+			if (value === "\\") {
+				const next = peek();
+				if (next === "/" && opts.bash !== true) continue;
+				if (next === "." || next === ";") continue;
+				if (!next) {
+					value += "\\";
+					push({
+						type: "text",
+						value
+					});
+					continue;
+				}
+				const match = /^\\+/.exec(remaining());
+				let slashes = 0;
+				if (match && match[0].length > 2) {
+					slashes = match[0].length;
+					state.index += slashes;
+					if (slashes % 2 !== 0) value += "\\";
+				}
+				if (opts.unescape === true) value = advance();
+				else value += advance();
+				if (state.brackets === 0) {
+					push({
+						type: "text",
+						value
+					});
+					continue;
+				}
+			}
+			/**
+			* If we're inside a regex character class, continue
+			* until we reach the closing bracket.
+			*/
+			if (state.brackets > 0 && (value !== "]" || prev.value === "[" || prev.value === "[^")) {
+				if (opts.posix !== false && value === ":") {
+					const inner = prev.value.slice(1);
+					if (inner.includes("[")) {
+						prev.posix = true;
+						if (inner.includes(":")) {
+							const idx = prev.value.lastIndexOf("[");
+							const pre = prev.value.slice(0, idx);
+							const rest$1 = prev.value.slice(idx + 2);
+							const posix$1 = POSIX_REGEX_SOURCE[rest$1];
+							if (posix$1) {
+								prev.value = pre + posix$1;
+								state.backtrack = true;
+								advance();
+								if (!bos.output && tokens.indexOf(prev) === 1) bos.output = ONE_CHAR$1;
+								continue;
+							}
+						}
+					}
+				}
+				if (value === "[" && peek() !== ":" || value === "-" && peek() === "]") value = `\\${value}`;
+				if (value === "]" && (prev.value === "[" || prev.value === "[^")) value = `\\${value}`;
+				if (opts.posix === true && value === "!" && prev.value === "[") value = "^";
+				prev.value += value;
+				append({ value });
+				continue;
+			}
+			/**
+			* If we're inside a quoted string, continue
+			* until we reach the closing double quote.
+			*/
+			if (state.quotes === 1 && value !== "\"") {
+				value = utils$2.escapeRegex(value);
+				prev.value += value;
+				append({ value });
+				continue;
+			}
+			/**
+			* Double quotes
+			*/
+			if (value === "\"") {
+				state.quotes = state.quotes === 1 ? 0 : 1;
+				if (opts.keepQuotes === true) push({
+					type: "text",
+					value
+				});
+				continue;
+			}
+			/**
+			* Parentheses
+			*/
+			if (value === "(") {
+				increment("parens");
+				push({
+					type: "paren",
+					value
+				});
+				continue;
+			}
+			if (value === ")") {
+				if (state.parens === 0 && opts.strictBrackets === true) throw new SyntaxError(syntaxError("opening", "("));
+				const extglob = extglobs[extglobs.length - 1];
+				if (extglob && state.parens === extglob.parens + 1) {
+					extglobClose(extglobs.pop());
+					continue;
+				}
+				push({
+					type: "paren",
+					value,
+					output: state.parens ? ")" : "\\)"
+				});
+				decrement("parens");
+				continue;
+			}
+			/**
+			* Square brackets
+			*/
+			if (value === "[") {
+				if (opts.nobracket === true || !remaining().includes("]")) {
+					if (opts.nobracket !== true && opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "]"));
+					value = `\\${value}`;
+				} else increment("brackets");
+				push({
+					type: "bracket",
+					value
+				});
+				continue;
+			}
+			if (value === "]") {
+				if (opts.nobracket === true || prev && prev.type === "bracket" && prev.value.length === 1) {
+					push({
+						type: "text",
+						value,
+						output: `\\${value}`
+					});
+					continue;
+				}
+				if (state.brackets === 0) {
+					if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("opening", "["));
+					push({
+						type: "text",
+						value,
+						output: `\\${value}`
+					});
+					continue;
+				}
+				decrement("brackets");
+				const prevValue = prev.value.slice(1);
+				if (prev.posix !== true && prevValue[0] === "^" && !prevValue.includes("/")) value = `/${value}`;
+				prev.value += value;
+				append({ value });
+				if (opts.literalBrackets === false || utils$2.hasRegexChars(prevValue)) continue;
+				const escaped = utils$2.escapeRegex(prev.value);
+				state.output = state.output.slice(0, -prev.value.length);
+				if (opts.literalBrackets === true) {
+					state.output += escaped;
+					prev.value = escaped;
+					continue;
+				}
+				prev.value = `(${capture}${escaped}|${prev.value})`;
+				state.output += prev.value;
+				continue;
+			}
+			/**
+			* Braces
+			*/
+			if (value === "{" && opts.nobrace !== true) {
+				increment("braces");
+				const open = {
+					type: "brace",
+					value,
+					output: "(",
+					outputIndex: state.output.length,
+					tokensIndex: state.tokens.length
+				};
+				braces.push(open);
+				push(open);
+				continue;
+			}
+			if (value === "}") {
+				const brace = braces[braces.length - 1];
+				if (opts.nobrace === true || !brace) {
+					push({
+						type: "text",
+						value,
+						output: value
+					});
+					continue;
+				}
+				let output = ")";
+				if (brace.dots === true) {
+					const arr = tokens.slice();
+					const range = [];
+					for (let i = arr.length - 1; i >= 0; i--) {
+						tokens.pop();
+						if (arr[i].type === "brace") break;
+						if (arr[i].type !== "dots") range.unshift(arr[i].value);
+					}
+					output = expandRange(range, opts);
+					state.backtrack = true;
+				}
+				if (brace.comma !== true && brace.dots !== true) {
+					const out = state.output.slice(0, brace.outputIndex);
+					const toks = state.tokens.slice(brace.tokensIndex);
+					brace.value = brace.output = "\\{";
+					value = output = "\\}";
+					state.output = out;
+					for (const t of toks) state.output += t.output || t.value;
+				}
+				push({
+					type: "brace",
+					value,
+					output
+				});
+				decrement("braces");
+				braces.pop();
+				continue;
+			}
+			/**
+			* Pipes
+			*/
+			if (value === "|") {
+				if (extglobs.length > 0) extglobs[extglobs.length - 1].conditions++;
+				push({
+					type: "text",
+					value
+				});
+				continue;
+			}
+			/**
+			* Commas
+			*/
+			if (value === ",") {
+				let output = value;
+				const brace = braces[braces.length - 1];
+				if (brace && stack[stack.length - 1] === "braces") {
+					brace.comma = true;
+					output = "|";
+				}
+				push({
+					type: "comma",
+					value,
+					output
+				});
+				continue;
+			}
+			/**
+			* Slashes
+			*/
+			if (value === "/") {
+				if (prev.type === "dot" && state.index === state.start + 1) {
+					state.start = state.index + 1;
+					state.consumed = "";
+					state.output = "";
+					tokens.pop();
+					prev = bos;
+					continue;
+				}
+				push({
+					type: "slash",
+					value,
+					output: SLASH_LITERAL$1
+				});
+				continue;
+			}
+			/**
+			* Dots
+			*/
+			if (value === ".") {
+				if (state.braces > 0 && prev.type === "dot") {
+					if (prev.value === ".") prev.output = DOT_LITERAL$1;
+					const brace = braces[braces.length - 1];
+					prev.type = "dots";
+					prev.output += value;
+					prev.value += value;
+					brace.dots = true;
+					continue;
+				}
+				if (state.braces + state.parens === 0 && prev.type !== "bos" && prev.type !== "slash") {
+					push({
+						type: "text",
+						value,
+						output: DOT_LITERAL$1
+					});
+					continue;
+				}
+				push({
+					type: "dot",
+					value,
+					output: DOT_LITERAL$1
+				});
+				continue;
+			}
+			/**
+			* Question marks
+			*/
+			if (value === "?") {
+				const isGroup = prev && prev.value === "(";
+				if (!isGroup && opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+					extglobOpen("qmark", value);
+					continue;
+				}
+				if (prev && prev.type === "paren") {
+					const next = peek();
+					let output = value;
+					if (prev.value === "(" && !/[!=<:]/.test(next) || next === "<" && !/<([!=]|\w+>)/.test(remaining())) output = `\\${value}`;
+					push({
+						type: "text",
+						value,
+						output
+					});
+					continue;
+				}
+				if (opts.dot !== true && (prev.type === "slash" || prev.type === "bos")) {
+					push({
+						type: "qmark",
+						value,
+						output: QMARK_NO_DOT$1
+					});
+					continue;
+				}
+				push({
+					type: "qmark",
+					value,
+					output: QMARK$1
+				});
+				continue;
+			}
+			/**
+			* Exclamation
+			*/
+			if (value === "!") {
+				if (opts.noextglob !== true && peek() === "(") {
+					if (peek(2) !== "?" || !/[!=<:]/.test(peek(3))) {
+						extglobOpen("negate", value);
+						continue;
+					}
+				}
+				if (opts.nonegate !== true && state.index === 0) {
+					negate();
+					continue;
+				}
+			}
+			/**
+			* Plus
+			*/
+			if (value === "+") {
+				if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+					extglobOpen("plus", value);
+					continue;
+				}
+				if (prev && prev.value === "(" || opts.regex === false) {
+					push({
+						type: "plus",
+						value,
+						output: PLUS_LITERAL$1
+					});
+					continue;
+				}
+				if (prev && (prev.type === "bracket" || prev.type === "paren" || prev.type === "brace") || state.parens > 0) {
+					push({
+						type: "plus",
+						value
+					});
+					continue;
+				}
+				push({
+					type: "plus",
+					value: PLUS_LITERAL$1
+				});
+				continue;
+			}
+			/**
+			* Plain text
+			*/
+			if (value === "@") {
+				if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+					push({
+						type: "at",
+						extglob: true,
+						value,
+						output: ""
+					});
+					continue;
+				}
+				push({
+					type: "text",
+					value
+				});
+				continue;
+			}
+			/**
+			* Plain text
+			*/
+			if (value !== "*") {
+				if (value === "$" || value === "^") value = `\\${value}`;
+				const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
+				if (match) {
+					value += match[0];
+					state.index += match[0].length;
+				}
+				push({
+					type: "text",
+					value
+				});
+				continue;
+			}
+			/**
+			* Stars
+			*/
+			if (prev && (prev.type === "globstar" || prev.star === true)) {
+				prev.type = "star";
+				prev.star = true;
+				prev.value += value;
+				prev.output = star;
+				state.backtrack = true;
+				state.globstar = true;
+				consume(value);
+				continue;
+			}
+			let rest = remaining();
+			if (opts.noextglob !== true && /^\([^?]/.test(rest)) {
+				extglobOpen("star", value);
+				continue;
+			}
+			if (prev.type === "star") {
+				if (opts.noglobstar === true) {
+					consume(value);
+					continue;
+				}
+				const prior = prev.prev;
+				const before = prior.prev;
+				const isStart = prior.type === "slash" || prior.type === "bos";
+				const afterStar = before && (before.type === "star" || before.type === "globstar");
+				if (opts.bash === true && (!isStart || rest[0] && rest[0] !== "/")) {
+					push({
+						type: "star",
+						value,
+						output: ""
+					});
+					continue;
+				}
+				const isBrace = state.braces > 0 && (prior.type === "comma" || prior.type === "brace");
+				const isExtglob = extglobs.length && (prior.type === "pipe" || prior.type === "paren");
+				if (!isStart && prior.type !== "paren" && !isBrace && !isExtglob) {
+					push({
+						type: "star",
+						value,
+						output: ""
+					});
+					continue;
+				}
+				while (rest.slice(0, 3) === "/**") {
+					const after = input[state.index + 4];
+					if (after && after !== "/") break;
+					rest = rest.slice(3);
+					consume("/**", 3);
+				}
+				if (prior.type === "bos" && eos()) {
+					prev.type = "globstar";
+					prev.value += value;
+					prev.output = globstar(opts);
+					state.output = prev.output;
+					state.globstar = true;
+					consume(value);
+					continue;
+				}
+				if (prior.type === "slash" && prior.prev.type !== "bos" && !afterStar && eos()) {
+					state.output = state.output.slice(0, -(prior.output + prev.output).length);
+					prior.output = `(?:${prior.output}`;
+					prev.type = "globstar";
+					prev.output = globstar(opts) + (opts.strictSlashes ? ")" : "|$)");
+					prev.value += value;
+					state.globstar = true;
+					state.output += prior.output + prev.output;
+					consume(value);
+					continue;
+				}
+				if (prior.type === "slash" && prior.prev.type !== "bos" && rest[0] === "/") {
+					const end = rest[1] !== void 0 ? "|$" : "";
+					state.output = state.output.slice(0, -(prior.output + prev.output).length);
+					prior.output = `(?:${prior.output}`;
+					prev.type = "globstar";
+					prev.output = `${globstar(opts)}${SLASH_LITERAL$1}|${SLASH_LITERAL$1}${end})`;
+					prev.value += value;
+					state.output += prior.output + prev.output;
+					state.globstar = true;
+					consume(value + advance());
+					push({
+						type: "slash",
+						value: "/",
+						output: ""
+					});
+					continue;
+				}
+				if (prior.type === "bos" && rest[0] === "/") {
+					prev.type = "globstar";
+					prev.value += value;
+					prev.output = `(?:^|${SLASH_LITERAL$1}|${globstar(opts)}${SLASH_LITERAL$1})`;
+					state.output = prev.output;
+					state.globstar = true;
+					consume(value + advance());
+					push({
+						type: "slash",
+						value: "/",
+						output: ""
+					});
+					continue;
+				}
+				state.output = state.output.slice(0, -prev.output.length);
+				prev.type = "globstar";
+				prev.output = globstar(opts);
+				prev.value += value;
+				state.output += prev.output;
+				state.globstar = true;
+				consume(value);
+				continue;
+			}
+			const token = {
+				type: "star",
+				value,
+				output: star
+			};
+			if (opts.bash === true) {
+				token.output = ".*?";
+				if (prev.type === "bos" || prev.type === "slash") token.output = nodot + token.output;
+				push(token);
+				continue;
+			}
+			if (prev && (prev.type === "bracket" || prev.type === "paren") && opts.regex === true) {
+				token.output = value;
+				push(token);
+				continue;
+			}
+			if (state.index === state.start || prev.type === "slash" || prev.type === "dot") {
+				if (prev.type === "dot") {
+					state.output += NO_DOT_SLASH$1;
+					prev.output += NO_DOT_SLASH$1;
+				} else if (opts.dot === true) {
+					state.output += NO_DOTS_SLASH$1;
+					prev.output += NO_DOTS_SLASH$1;
+				} else {
+					state.output += nodot;
+					prev.output += nodot;
+				}
+				if (peek() !== "*") {
+					state.output += ONE_CHAR$1;
+					prev.output += ONE_CHAR$1;
+				}
+			}
+			push(token);
+		}
+		while (state.brackets > 0) {
+			if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "]"));
+			state.output = utils$2.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, "(");
+			decrement("parens");
+		}
+		while (state.braces > 0) {
+			if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "}"));
+			state.output = utils$2.escapeLast(state.output, "{");
+			decrement("braces");
+		}
+		if (opts.strictSlashes !== true && (prev.type === "star" || prev.type === "bracket")) push({
+			type: "maybe_slash",
+			value: "",
+			output: `${SLASH_LITERAL$1}?`
+		});
+		if (state.backtrack === true) {
+			state.output = "";
+			for (const token of state.tokens) {
+				state.output += token.output != null ? token.output : token.value;
+				if (token.suffix) state.output += token.suffix;
+			}
+		}
+		return state;
+	};
+	/**
+	* Fast paths for creating regular expressions for common glob patterns.
+	* This can significantly speed up processing and has very little downside
+	* impact when none of the fast paths match.
+	*/
+	parse$1.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_DOT$1, NO_DOTS: NO_DOTS$1, NO_DOTS_SLASH: NO_DOTS_SLASH$1, STAR: STAR$1, START_ANCHOR: START_ANCHOR$1 } = constants$1.globChars(opts.windows);
+		const nodot = opts.dot ? NO_DOTS$1 : NO_DOT$1;
+		const slashDot = opts.dot ? NO_DOTS_SLASH$1 : NO_DOT$1;
+		const capture = opts.capture ? "" : "?:";
+		const state = {
+			negated: false,
+			prefix: ""
+		};
+		let star = opts.bash === true ? ".*?" : STAR$1;
+		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 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 + 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}`;
+				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 output = utils$2.removePrefix(input, state);
+		let source = create(output);
+		if (source && opts.strictSlashes !== true) source += `${SLASH_LITERAL$1}?`;
+		return source;
+	};
+	module.exports = parse$1;
+} });
+
+//#endregion
+//#region node_modules/picomatch/lib/picomatch.js
+var require_picomatch$1 = __commonJS({ "node_modules/picomatch/lib/picomatch.js"(exports, module) {
+	const scan = require_scan();
+	const parse = require_parse();
+	const utils$1 = require_utils();
+	const constants = require_constants();
+	const isObject = (val) => val && typeof val === "object" && !Array.isArray(val);
+	/**
+	* Creates a matcher function from one or more glob patterns. The
+	* returned function takes a string to match as its first argument,
+	* and returns true if the string is a match. The returned matcher
+	* function also takes a boolean as the second argument that, when true,
+	* returns an object with additional information.
+	*
+	* ```js
+	* const picomatch = require('picomatch');
+	* // picomatch(glob[, options]);
+	*
+	* const isMatch = picomatch('*.!(*a)');
+	* console.log(isMatch('a.a')); //=> false
+	* console.log(isMatch('a.b')); //=> true
+	* ```
+	* @name picomatch
+	* @param {String|Array} `globs` One or more glob patterns.
+	* @param {Object=} `options`
+	* @return {Function=} Returns a matcher function.
+	* @api public
+	*/
+	const picomatch$2 = (glob$1, options, returnState = false) => {
+		if (Array.isArray(glob$1)) {
+			const fns = glob$1.map((input) => picomatch$2(input, options, returnState));
+			const arrayMatcher = (str) => {
+				for (const isMatch of fns) {
+					const state$1 = isMatch(str);
+					if (state$1) return state$1;
+				}
+				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 opts = options || {};
+		const posix$1 = opts.windows;
+		const regex$1 = isState ? picomatch$2.compileRe(glob$1, options) : picomatch$2.makeRe(glob$1, options, false, true);
+		const state = regex$1.state;
+		delete regex$1.state;
+		let isIgnored = () => false;
+		if (opts.ignore) {
+			const ignoreOpts = {
+				...options,
+				ignore: null,
+				onMatch: null,
+				onResult: null
+			};
+			isIgnored = picomatch$2(opts.ignore, ignoreOpts, returnState);
+		}
+		const matcher = (input, returnObject = false) => {
+			const { isMatch, match, output } = picomatch$2.test(input, regex$1, options, {
+				glob: glob$1,
+				posix: posix$1
+			});
+			const result = {
+				glob: glob$1,
+				state,
+				regex: regex$1,
+				posix: posix$1,
+				input,
+				output,
+				match,
+				isMatch
+			};
+			if (typeof opts.onResult === "function") opts.onResult(result);
+			if (isMatch === false) {
+				result.isMatch = false;
+				return returnObject ? result : false;
+			}
+			if (isIgnored(input)) {
+				if (typeof opts.onIgnore === "function") opts.onIgnore(result);
+				result.isMatch = false;
+				return returnObject ? result : false;
+			}
+			if (typeof opts.onMatch === "function") opts.onMatch(result);
+			return returnObject ? result : true;
+		};
+		if (returnState) matcher.state = state;
+		return matcher;
+	};
+	/**
+	* Test `input` with the given `regex`. This is used by the main
+	* `picomatch()` function to test the input string.
+	*
+	* ```js
+	* const picomatch = require('picomatch');
+	* // picomatch.test(input, regex[, options]);
+	*
+	* console.log(picomatch.test('foo/bar', /^(?:([^/]*?)\/([^/]*?))$/));
+	* // { isMatch: true, match: [ 'foo/', 'foo', 'bar' ], output: 'foo/bar' }
+	* ```
+	* @param {String} `input` String to test.
+	* @param {RegExp} `regex`
+	* @return {Object} Returns an object with matching info.
+	* @api public
+	*/
+	picomatch$2.test = (input, regex$1, options, { glob: glob$1, posix: posix$1 } = {}) => {
+		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;
+		let output = match && format ? format(input) : input;
+		if (match === false) {
+			output = format ? format(input) : input;
+			match = output === glob$1;
+		}
+		if (match === false || opts.capture === true) if (opts.matchBase === true || opts.basename === true) match = picomatch$2.matchBase(input, regex$1, options, posix$1);
+		else match = regex$1.exec(output);
+		return {
+			isMatch: Boolean(match),
+			match,
+			output
+		};
+	};
+	/**
+	* Match the basename of a filepath.
+	*
+	* ```js
+	* const picomatch = require('picomatch');
+	* // picomatch.matchBase(input, glob[, options]);
+	* console.log(picomatch.matchBase('foo/bar.js', '*.js'); // true
+	* ```
+	* @param {String} `input` String to test.
+	* @param {RegExp|String} `glob` Glob pattern or regex created by [.makeRe](#makeRe).
+	* @return {Boolean}
+	* @api public
+	*/
+	picomatch$2.matchBase = (input, glob$1, options) => {
+		const regex$1 = glob$1 instanceof RegExp ? glob$1 : picomatch$2.makeRe(glob$1, options);
+		return regex$1.test(utils$1.basename(input));
+	};
+	/**
+	* Returns true if **any** of the given glob `patterns` match the specified `string`.
+	*
+	* ```js
+	* const picomatch = require('picomatch');
+	* // picomatch.isMatch(string, patterns[, options]);
+	*
+	* console.log(picomatch.isMatch('a.a', ['b.*', '*.a'])); //=> true
+	* console.log(picomatch.isMatch('a.a', 'b.*')); //=> false
+	* ```
+	* @param {String|Array} str The string to test.
+	* @param {String|Array} patterns One or more glob patterns to use for matching.
+	* @param {Object} [options] See available [options](#options).
+	* @return {Boolean} Returns true if any patterns match `str`
+	* @api public
+	*/
+	picomatch$2.isMatch = (str, patterns, options) => picomatch$2(patterns, options)(str);
+	/**
+	* Parse a glob pattern to create the source string for a regular
+	* expression.
+	*
+	* ```js
+	* const picomatch = require('picomatch');
+	* const result = picomatch.parse(pattern[, options]);
+	* ```
+	* @param {String} `pattern`
+	* @param {Object} `options`
+	* @return {Object} Returns an object with useful properties and output to be used as a regex source string.
+	* @api public
+	*/
+	picomatch$2.parse = (pattern, options) => {
+		if (Array.isArray(pattern)) return pattern.map((p) => picomatch$2.parse(p, options));
+		return parse(pattern, {
+			...options,
+			fastpaths: false
+		});
+	};
+	/**
+	* Scan a glob pattern to separate the pattern into segments.
+	*
+	* ```js
+	* const picomatch = require('picomatch');
+	* // picomatch.scan(input[, options]);
+	*
+	* const result = picomatch.scan('!./foo/*.js');
+	* console.log(result);
+	* { prefix: '!./',
+	*   input: '!./foo/*.js',
+	*   start: 3,
+	*   base: 'foo',
+	*   glob: '*.js',
+	*   isBrace: false,
+	*   isBracket: false,
+	*   isGlob: true,
+	*   isExtglob: false,
+	*   isGlobstar: false,
+	*   negated: true }
+	* ```
+	* @param {String} `input` Glob pattern to scan.
+	* @param {Object} `options`
+	* @return {Object} Returns an object with
+	* @api public
+	*/
+	picomatch$2.scan = (input, options) => scan(input, options);
+	/**
+	* Compile a regular expression from the `state` object returned by the
+	* [parse()](#parse) method.
+	*
+	* @param {Object} `state`
+	* @param {Object} `options`
+	* @param {Boolean} `returnOutput` Intended for implementors, this argument allows you to return the raw output from the parser.
+	* @param {Boolean} `returnState` Adds the state to a `state` property on the returned regex. Useful for implementors and debugging.
+	* @return {RegExp}
+	* @api public
+	*/
+	picomatch$2.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$1 = picomatch$2.toRegex(source, options);
+		if (returnState === true) regex$1.state = state;
+		return regex$1;
+	};
+	/**
+	* Create a regular expression from a parsed glob pattern.
+	*
+	* ```js
+	* const picomatch = require('picomatch');
+	* const state = picomatch.parse('*.js');
+	* // picomatch.compileRe(state[, options]);
+	*
+	* console.log(picomatch.compileRe(state));
+	* //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+	* ```
+	* @param {String} `state` The object returned from the `.parse` method.
+	* @param {Object} `options`
+	* @param {Boolean} `returnOutput` Implementors may use this argument to return the compiled output, instead of a regular expression. This is not exposed on the options to prevent end-users from mutating the result.
+	* @param {Boolean} `returnState` Implementors may use this argument to return the state from the parsed glob with the returned regular expression.
+	* @return {RegExp} Returns a regex created from the given pattern.
+	* @api public
+	*/
+	picomatch$2.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
+		if (!input || typeof input !== "string") throw new TypeError("Expected a non-empty string");
+		let parsed = {
+			negated: false,
+			fastpaths: true
+		};
+		if (options.fastpaths !== false && (input[0] === "." || input[0] === "*")) parsed.output = parse.fastpaths(input, options);
+		if (!parsed.output) parsed = parse(input, options);
+		return picomatch$2.compileRe(parsed, options, returnOutput, returnState);
+	};
+	/**
+	* Create a regular expression from the given regex source string.
+	*
+	* ```js
+	* const picomatch = require('picomatch');
+	* // picomatch.toRegex(source[, options]);
+	*
+	* const { output } = picomatch.parse('*.js');
+	* console.log(picomatch.toRegex(output));
+	* //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+	* ```
+	* @param {String} `source` Regular expression source string.
+	* @param {Object} `options`
+	* @return {RegExp}
+	* @api public
+	*/
+	picomatch$2.toRegex = (source, options) => {
+		try {
+			const opts = options || {};
+			return new RegExp(source, opts.flags || (opts.nocase ? "i" : ""));
+		} catch (err) {
+			if (options && options.debug === true) throw err;
+			return /$^/;
+		}
+	};
+	/**
+	* Picomatch constants.
+	* @return {Object}
+	*/
+	picomatch$2.constants = constants;
+	/**
+	* Expose "picomatch"
+	*/
+	module.exports = picomatch$2;
+} });
+
+//#endregion
+//#region node_modules/picomatch/index.js
+var require_picomatch = __commonJS({ "node_modules/picomatch/index.js"(exports, module) {
+	const pico = require_picomatch$1();
+	const utils = require_utils();
+	function picomatch$1(glob$1, options, returnState = false) {
+		if (options && (options.windows === null || options.windows === void 0)) options = {
+			...options,
+			windows: utils.isWindows()
+		};
+		return pico(glob$1, options, returnState);
+	}
+	Object.assign(picomatch$1, pico);
+	module.exports = picomatch$1;
+} });
+
+//#endregion
+//#region node_modules/fdir/dist/builder/index.js
+var require_builder = __commonJS({ "node_modules/fdir/dist/builder/index.js"(exports) {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.Builder = void 0;
+	const path_1 = __require("path");
+	const api_builder_1 = require_api_builder();
+	var pm = null;
+	/* c8 ignore next 6 */
+	try {
+		__require.resolve("picomatch");
+		pm = require_picomatch();
+	} catch (_e) {}
+	var Builder = class {
+		globCache = {};
+		options = {
+			maxDepth: Infinity,
+			suppressErrors: true,
+			pathSeparator: path_1.sep,
+			filters: []
+		};
+		globFunction;
+		constructor(options) {
+			this.options = {
+				...this.options,
+				...options
+			};
+			this.globFunction = this.options.globFunction;
+		}
+		group() {
+			this.options.group = true;
+			return this;
+		}
+		withPathSeparator(separator) {
+			this.options.pathSeparator = separator;
+			return this;
+		}
+		withBasePath() {
+			this.options.includeBasePath = true;
+			return this;
+		}
+		withRelativePaths() {
+			this.options.relativePaths = true;
+			return this;
+		}
+		withDirs() {
+			this.options.includeDirs = true;
+			return this;
+		}
+		withMaxDepth(depth$1) {
+			this.options.maxDepth = depth$1;
+			return this;
+		}
+		withMaxFiles(limit) {
+			this.options.maxFiles = limit;
+			return this;
+		}
+		withFullPaths() {
+			this.options.resolvePaths = true;
+			this.options.includeBasePath = true;
+			return this;
+		}
+		withErrors() {
+			this.options.suppressErrors = false;
+			return this;
+		}
+		withSymlinks({ resolvePaths = true } = {}) {
+			this.options.resolveSymlinks = true;
+			this.options.useRealPaths = resolvePaths;
+			return this.withFullPaths();
+		}
+		withAbortSignal(signal) {
+			this.options.signal = signal;
+			return this;
+		}
+		normalize() {
+			this.options.normalizePath = true;
+			return this;
+		}
+		filter(predicate) {
+			this.options.filters.push(predicate);
+			return this;
+		}
+		onlyDirs() {
+			this.options.excludeFiles = true;
+			this.options.includeDirs = true;
+			return this;
+		}
+		exclude(predicate) {
+			this.options.exclude = predicate;
+			return this;
+		}
+		onlyCounts() {
+			this.options.onlyCounts = true;
+			return this;
+		}
+		crawl(root) {
+			return new api_builder_1.APIBuilder(root || ".", this.options);
+		}
+		withGlobFunction(fn) {
+			this.globFunction = fn;
+			return this;
+		}
+		/**
+		* @deprecated Pass options using the constructor instead:
+		* ```ts
+		* new fdir(options).crawl("/path/to/root");
+		* ```
+		* This method will be removed in v7.0
+		*/
+		/* c8 ignore next 4 */
+		crawlWithOptions(root, options) {
+			this.options = {
+				...this.options,
+				...options
+			};
+			return new api_builder_1.APIBuilder(root || ".", this.options);
+		}
+		glob(...patterns) {
+			if (this.globFunction) return this.globWithOptions(patterns);
+			return this.globWithOptions(patterns, ...[{ dot: true }]);
+		}
+		globWithOptions(patterns, ...options) {
+			const globFn = this.globFunction || pm;
+			/* c8 ignore next 5 */
+			if (!globFn) throw new Error("Please specify a glob function to use glob matching.");
+			var isMatch = this.globCache[patterns.join("\0")];
+			if (!isMatch) {
+				isMatch = globFn(patterns, ...options);
+				this.globCache[patterns.join("\0")] = isMatch;
+			}
+			this.options.filters.push((path$2) => isMatch(path$2));
+			return this;
+		}
+	};
+	exports.Builder = Builder;
+} });
+
+//#endregion
+//#region node_modules/fdir/dist/types.js
+var require_types = __commonJS({ "node_modules/fdir/dist/types.js"(exports) {
+	Object.defineProperty(exports, "__esModule", { value: true });
+} });
+
+//#endregion
+//#region node_modules/fdir/dist/index.js
+var require_dist = __commonJS({ "node_modules/fdir/dist/index.js"(exports) {
+	var __createBinding = void 0 && (void 0).__createBinding || (Object.create ? function(o, m, k, k2) {
+		if (k2 === void 0) k2 = k;
+		var desc = Object.getOwnPropertyDescriptor(m, k);
+		if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) desc = {
+			enumerable: true,
+			get: function() {
+				return m[k];
+			}
+		};
+		Object.defineProperty(o, k2, desc);
+	} : function(o, m, k, k2) {
+		if (k2 === void 0) k2 = k;
+		o[k2] = m[k];
+	});
+	var __exportStar = void 0 && (void 0).__exportStar || function(m, exports$1) {
+		for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports$1, p)) __createBinding(exports$1, m, p);
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.fdir = void 0;
+	const builder_1 = require_builder();
+	Object.defineProperty(exports, "fdir", {
+		enumerable: true,
+		get: function() {
+			return builder_1.Builder;
+		}
+	});
+	__exportStar(require_types(), exports);
+} });
+
+//#endregion
+//#region node_modules/tinyglobby/dist/index.mjs
+var import_dist = __toESM(require_dist(), 1);
+var import_picomatch = __toESM(require_picomatch(), 1);
+const ONLY_PARENT_DIRECTORIES = /^(\/?\.\.)+$/;
+function getPartialMatcher(patterns, options) {
+	const patternsCount = patterns.length;
+	const patternsParts = Array(patternsCount);
+	const regexes = Array(patternsCount);
+	for (let i = 0; i < patternsCount; i++) {
+		const parts = splitPattern(patterns[i]);
+		patternsParts[i] = parts;
+		const partsCount = parts.length;
+		const partRegexes = Array(partsCount);
+		for (let j = 0; j < partsCount; j++) partRegexes[j] = import_picomatch.default.makeRe(parts[j], options);
+		regexes[i] = partRegexes;
+	}
+	return (input) => {
+		const inputParts = input.split("/");
+		if (inputParts[0] === ".." && ONLY_PARENT_DIRECTORIES.test(input)) return true;
+		for (let i = 0; i < patterns.length; i++) {
+			const patternParts = patternsParts[i];
+			const regex$1 = regexes[i];
+			const inputPatternCount = inputParts.length;
+			const minParts = Math.min(inputPatternCount, patternParts.length);
+			let j = 0;
+			while (j < minParts) {
+				const part = patternParts[j];
+				if (part.includes("/")) return true;
+				const match = regex$1[j].test(inputParts[j]);
+				if (!match) break;
+				if (part === "**") return true;
+				j++;
+			}
+			if (j === inputPatternCount) return true;
+		}
+		return false;
+	};
+}
+const splitPatternOptions = { parts: true };
+function splitPattern(path$1$1) {
+	var _result$parts;
+	const result = import_picomatch.default.scan(path$1$1, splitPatternOptions);
+	return ((_result$parts = result.parts) === null || _result$parts === void 0 ? void 0 : _result$parts.length) ? result.parts : [path$1$1];
+}
+const isWin = process.platform === "win32";
+const POSIX_UNESCAPED_GLOB_SYMBOLS = /(?<!\\)([()[\]{}*?|]|^!|[!+@](?=\()|\\(?![()[\]{}!*+?@|]))/g;
+const WIN32_UNESCAPED_GLOB_SYMBOLS = /(?<!\\)([()[\]{}]|^!|[!+@](?=\())/g;
+const escapePosixPath = (path$1$1) => path$1$1.replace(POSIX_UNESCAPED_GLOB_SYMBOLS, "\\$&");
+const escapeWin32Path = (path$1$1) => path$1$1.replace(WIN32_UNESCAPED_GLOB_SYMBOLS, "\\$&");
+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;
+}
+function log(...tasks) {
+	console.log(`[tinyglobby ${new Date().toLocaleTimeString("es")}]`, ...tasks);
+}
+const PARENT_DIRECTORY = /^(\/?\.\.)+/;
+const ESCAPING_BACKSLASHES = /\\(?=[()[\]{}!*+?@|])/g;
+const BACKSLASHES = /\\/g;
+function normalizePattern(pattern, expandDirectories, cwd, props, isIgnore) {
+	let result = pattern;
+	if (pattern.endsWith("/")) result = pattern.slice(0, -1);
+	if (!result.endsWith("*") && expandDirectories) result += "/**";
+	const escapedCwd = escapePath(cwd);
+	if (path$1.isAbsolute(result.replace(ESCAPING_BACKSLASHES, ""))) result = posix.relative(escapedCwd, result);
+	else result = posix.normalize(result);
+	const parentDirectoryMatch = PARENT_DIRECTORY.exec(result);
+	const parts = splitPattern(result);
+	if (parentDirectoryMatch === null || parentDirectoryMatch === void 0 ? void 0 : parentDirectoryMatch[0]) {
+		const n = (parentDirectoryMatch[0].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) {
+			props.root = potentialRoot;
+			props.depthOffset = -n + i;
+		}
+	}
+	if (!isIgnore && props.depthOffset >= 0) {
+		var _props$commonPath;
+		(_props$commonPath = props.commonPath) !== null && _props$commonPath !== void 0 || (props.commonPath = parts);
+		const newCommonPath = [];
+		const length = Math.min(props.commonPath.length, parts.length);
+		for (let i = 0; i < length; i++) {
+			const part = parts[i];
+			if (part === "**" && !parts[i + 1]) {
+				newCommonPath.pop();
+				break;
+			}
+			if (part !== props.commonPath[i] || isDynamicPattern(part) || i === parts.length - 1) break;
+			newCommonPath.push(part);
+		}
+		props.depthOffset = newCommonPath.length;
+		props.commonPath = newCommonPath;
+		props.root = newCommonPath.length > 0 ? path$1.posix.join(cwd, ...newCommonPath) : cwd;
+	}
+	return result;
+}
+function processPatterns({ patterns, ignore = [], expandDirectories = true }, cwd, props) {
+	if (typeof patterns === "string") patterns = [patterns];
+	else if (!patterns) patterns = ["**/*"];
+	if (typeof ignore === "string") ignore = [ignore];
+	const matchPatterns = [];
+	const ignorePatterns = [];
+	for (const pattern of ignore) {
+		if (!pattern) continue;
+		if (pattern[0] !== "!" || pattern[1] === "(") ignorePatterns.push(normalizePattern(pattern, expandDirectories, cwd, 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));
+	}
+	return {
+		match: matchPatterns,
+		ignore: ignorePatterns
+	};
+}
+function getRelativePath(path$1$1, cwd, root) {
+	return posix.relative(cwd, `${root}/${path$1$1}`) || ".";
+}
+function processPath(path$1$1, cwd, root, isDirectory, absolute) {
+	const relativePath = absolute ? path$1$1.slice(root === "/" ? 1 : root.length + 1) || "." : path$1$1;
+	if (root === cwd) return isDirectory && relativePath !== "." ? relativePath.slice(0, -1) : relativePath;
+	return getRelativePath(relativePath, cwd, root);
+}
+function formatPaths(paths, cwd, root) {
+	for (let i = paths.length - 1; i >= 0; i--) {
+		const path$1$1 = paths[i];
+		paths[i] = getRelativePath(path$1$1, cwd, root) + (!path$1$1 || path$1$1.endsWith("/") ? "/" : "");
+	}
+	return paths;
+}
+function crawl(options, cwd, sync$1) {
+	if (process.env.TINYGLOBBY_DEBUG) options.debug = true;
+	if (options.debug) log("globbing with options:", options, "cwd:", cwd);
+	if (Array.isArray(options.patterns) && options.patterns.length === 0) return sync$1 ? [] : Promise.resolve([]);
+	const props = {
+		root: cwd,
+		commonPath: null,
+		depthOffset: 0
+	};
+	const processed = processPatterns(options, cwd, props);
+	const nocase = options.caseSensitiveMatch === false;
+	if (options.debug) log("internal processing patterns:", processed);
+	const matcher = (0, import_picomatch.default)(processed.match, {
+		dot: options.dot,
+		nocase,
+		ignore: processed.ignore
+	});
+	const ignore = (0, import_picomatch.default)(processed.ignore, {
+		dot: options.dot,
+		nocase
+	});
+	const partialMatcher = getPartialMatcher(processed.match, {
+		dot: options.dot,
+		nocase
+	});
+	const fdirOptions = {
+		filters: [options.debug ? (p, isDirectory) => {
+			const path$1$1 = processPath(p, cwd, props.root, isDirectory, options.absolute);
+			const matches = matcher(path$1$1);
+			if (matches) log(`matched ${path$1$1}`);
+			return matches;
+		} : (p, isDirectory) => matcher(processPath(p, cwd, props.root, isDirectory, options.absolute))],
+		exclude: options.debug ? (_, p) => {
+			const relativePath = processPath(p, cwd, props.root, true, true);
+			const skipped = relativePath !== "." && !partialMatcher(relativePath) || ignore(relativePath);
+			if (skipped) log(`skipped ${p}`);
+			else log(`crawling ${p}`);
+			return skipped;
+		} : (_, p) => {
+			const relativePath = processPath(p, cwd, props.root, true, true);
+			return relativePath !== "." && !partialMatcher(relativePath) || ignore(relativePath);
+		},
+		pathSeparator: "/",
+		relativePaths: true,
+		resolveSymlinks: true
+	};
+	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 api = new import_dist.fdir(fdirOptions).crawl(root);
+	if (cwd === root || options.absolute) return sync$1 ? api.sync() : api.withPromise();
+	return sync$1 ? formatPaths(api.sync(), cwd, root) : api.withPromise().then((paths) => formatPaths(paths, cwd, root));
+}
+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 opts = Array.isArray(patternsOrOptions) || typeof patternsOrOptions === "string" ? {
+		...options,
+		patterns: patternsOrOptions
+	} : patternsOrOptions;
+	const cwd = opts.cwd ? path$1.resolve(opts.cwd).replace(BACKSLASHES, "/") : process.cwd().replace(BACKSLASHES, "/");
+	return crawl(opts, cwd, false);
+}
+
+//#endregion
+//#region node_modules/valibot/dist/index.js
+var store;
+/* @__NO_SIDE_EFFECTS__ */
+function getGlobalConfig(config2) {
+	return {
+		lang: config2?.lang ?? store?.lang,
+		message: config2?.message,
+		abortEarly: config2?.abortEarly ?? store?.abortEarly,
+		abortPipeEarly: config2?.abortPipeEarly ?? store?.abortPipeEarly
+	};
+}
+var store2;
+/* @__NO_SIDE_EFFECTS__ */
+function getGlobalMessage(lang) {
+	return store2?.get(lang);
+}
+var store3;
+/* @__NO_SIDE_EFFECTS__ */
+function getSchemaMessage(lang) {
+	return store3?.get(lang);
+}
+var store4;
+/* @__NO_SIDE_EFFECTS__ */
+function getSpecificMessage(reference, lang) {
+	return store4?.get(reference)?.get(lang);
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _stringify(input) {
+	const type = typeof input;
+	if (type === "string") return `"${input}"`;
+	if (type === "number" || type === "bigint" || type === "boolean") return `${input}`;
+	if (type === "object" || type === "function") return (input && Object.getPrototypeOf(input)?.constructor?.name) ?? "null";
+	return type;
+}
+function _addIssue(context, label, dataset, config2, other) {
+	const input = other && "input" in other ? other.input : dataset.value;
+	const expected = other?.expected ?? context.expects ?? null;
+	const received = other?.received ?? /* @__PURE__ */ _stringify(input);
+	const issue = {
+		kind: context.kind,
+		type: context.type,
+		input,
+		expected,
+		received,
+		message: `Invalid ${label}: ${expected ? `Expected ${expected} but r` : "R"}eceived ${received}`,
+		requirement: context.requirement,
+		path: other?.path,
+		issues: other?.issues,
+		lang: config2.lang,
+		abortEarly: config2.abortEarly,
+		abortPipeEarly: config2.abortPipeEarly
+	};
+	const isSchema = context.kind === "schema";
+	const message2 = other?.message ?? context.message ?? /* @__PURE__ */ getSpecificMessage(context.reference, issue.lang) ?? (isSchema ? /* @__PURE__ */ getSchemaMessage(issue.lang) : null) ?? config2.message ?? /* @__PURE__ */ getGlobalMessage(issue.lang);
+	if (message2 !== void 0) issue.message = typeof message2 === "function" ? message2(issue) : message2;
+	if (isSchema) dataset.typed = false;
+	if (dataset.issues) dataset.issues.push(issue);
+	else dataset.issues = [issue];
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _getStandardProps(context) {
+	return {
+		version: 1,
+		vendor: "valibot",
+		validate(value2) {
+			return context["~run"]({ value: value2 }, /* @__PURE__ */ getGlobalConfig());
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _isValidObjectKey(object2, key) {
+	return Object.hasOwn(object2, key) && key !== "__proto__" && key !== "prototype" && key !== "constructor";
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _joinExpects(values2, separator) {
+	const list = [...new Set(values2)];
+	if (list.length > 1) return `(${list.join(` ${separator} `)})`;
+	return list[0] ?? "never";
+}
+/* @__NO_SIDE_EFFECTS__ */
+function regex(requirement, message2) {
+	return {
+		kind: "validation",
+		type: "regex",
+		reference: regex,
+		async: false,
+		expects: `${requirement}`,
+		requirement,
+		message: message2,
+		"~run"(dataset, config2) {
+			if (dataset.typed && !this.requirement.test(dataset.value)) _addIssue(this, "format", dataset, config2);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function getFallback(schema, dataset, config2) {
+	return typeof schema.fallback === "function" ? schema.fallback(dataset, config2) : schema.fallback;
+}
+/* @__NO_SIDE_EFFECTS__ */
+function getDefault(schema, dataset, config2) {
+	return typeof schema.default === "function" ? schema.default(dataset, config2) : schema.default;
+}
+/* @__NO_SIDE_EFFECTS__ */
+function boolean(message2) {
+	return {
+		kind: "schema",
+		type: "boolean",
+		reference: boolean,
+		expects: "boolean",
+		async: false,
+		message: message2,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config2) {
+			if (typeof dataset.value === "boolean") dataset.typed = true;
+			else _addIssue(this, "type", dataset, config2);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function number(message2) {
+	return {
+		kind: "schema",
+		type: "number",
+		reference: number,
+		expects: "number",
+		async: false,
+		message: message2,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config2) {
+			if (typeof dataset.value === "number" && !isNaN(dataset.value)) dataset.typed = true;
+			else _addIssue(this, "type", dataset, config2);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function object(entries2, message2) {
+	return {
+		kind: "schema",
+		type: "object",
+		reference: object,
+		expects: "Object",
+		async: false,
+		entries: entries2,
+		message: message2,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config2) {
+			const input = dataset.value;
+			if (input && typeof input === "object") {
+				dataset.typed = true;
+				dataset.value = {};
+				for (const key in this.entries) {
+					const valueSchema = this.entries[key];
+					if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && valueSchema.default !== void 0) {
+						const value2 = key in input ? input[key] : /* @__PURE__ */ getDefault(valueSchema);
+						const valueDataset = valueSchema["~run"]({ value: value2 }, config2);
+						if (valueDataset.issues) {
+							const pathItem = {
+								type: "object",
+								origin: "value",
+								input,
+								key,
+								value: value2
+							};
+							for (const issue of valueDataset.issues) {
+								if (issue.path) issue.path.unshift(pathItem);
+								else issue.path = [pathItem];
+								dataset.issues?.push(issue);
+							}
+							if (!dataset.issues) dataset.issues = valueDataset.issues;
+							if (config2.abortEarly) {
+								dataset.typed = false;
+								break;
+							}
+						}
+						if (!valueDataset.typed) dataset.typed = false;
+						dataset.value[key] = valueDataset.value;
+					} else if (valueSchema.fallback !== void 0) dataset.value[key] = /* @__PURE__ */ getFallback(valueSchema);
+					else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
+						_addIssue(this, "key", dataset, config2, {
+							input: void 0,
+							expected: `"${key}"`,
+							path: [{
+								type: "object",
+								origin: "key",
+								input,
+								key,
+								value: input[key]
+							}]
+						});
+						if (config2.abortEarly) break;
+					}
+				}
+			} else _addIssue(this, "type", dataset, config2);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function optional(wrapped, default_) {
+	return {
+		kind: "schema",
+		type: "optional",
+		reference: optional,
+		expects: `(${wrapped.expects} | undefined)`,
+		async: false,
+		wrapped,
+		default: default_,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config2) {
+			if (dataset.value === void 0) {
+				if (this.default !== void 0) dataset.value = /* @__PURE__ */ getDefault(this, dataset, config2);
+				if (dataset.value === void 0) {
+					dataset.typed = true;
+					return dataset;
+				}
+			}
+			return this.wrapped["~run"](dataset, config2);
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function record(key, value2, message2) {
+	return {
+		kind: "schema",
+		type: "record",
+		reference: record,
+		expects: "Object",
+		async: false,
+		key,
+		value: value2,
+		message: message2,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config2) {
+			const input = dataset.value;
+			if (input && typeof input === "object") {
+				dataset.typed = true;
+				dataset.value = {};
+				for (const entryKey in input) if (/* @__PURE__ */ _isValidObjectKey(input, entryKey)) {
+					const entryValue = input[entryKey];
+					const keyDataset = this.key["~run"]({ value: entryKey }, config2);
+					if (keyDataset.issues) {
+						const pathItem = {
+							type: "object",
+							origin: "key",
+							input,
+							key: entryKey,
+							value: entryValue
+						};
+						for (const issue of keyDataset.issues) {
+							issue.path = [pathItem];
+							dataset.issues?.push(issue);
+						}
+						if (!dataset.issues) dataset.issues = keyDataset.issues;
+						if (config2.abortEarly) {
+							dataset.typed = false;
+							break;
+						}
+					}
+					const valueDataset = this.value["~run"]({ value: entryValue }, config2);
+					if (valueDataset.issues) {
+						const pathItem = {
+							type: "object",
+							origin: "value",
+							input,
+							key: entryKey,
+							value: entryValue
+						};
+						for (const issue of valueDataset.issues) {
+							if (issue.path) issue.path.unshift(pathItem);
+							else issue.path = [pathItem];
+							dataset.issues?.push(issue);
+						}
+						if (!dataset.issues) dataset.issues = valueDataset.issues;
+						if (config2.abortEarly) {
+							dataset.typed = false;
+							break;
+						}
+					}
+					if (!keyDataset.typed || !valueDataset.typed) dataset.typed = false;
+					if (keyDataset.typed) dataset.value[keyDataset.value] = valueDataset.value;
+				}
+			} else _addIssue(this, "type", dataset, config2);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function string(message2) {
+	return {
+		kind: "schema",
+		type: "string",
+		reference: string,
+		expects: "string",
+		async: false,
+		message: message2,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config2) {
+			if (typeof dataset.value === "string") dataset.typed = true;
+			else _addIssue(this, "type", dataset, config2);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _subIssues(datasets) {
+	let issues;
+	if (datasets) for (const dataset of datasets) if (issues) issues.push(...dataset.issues);
+	else issues = dataset.issues;
+	return issues;
+}
+/* @__NO_SIDE_EFFECTS__ */
+function union(options, message2) {
+	return {
+		kind: "schema",
+		type: "union",
+		reference: union,
+		expects: /* @__PURE__ */ _joinExpects(options.map((option) => option.expects), "|"),
+		async: false,
+		options,
+		message: message2,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config2) {
+			let validDataset;
+			let typedDatasets;
+			let untypedDatasets;
+			for (const schema of this.options) {
+				const optionDataset = schema["~run"]({ value: dataset.value }, config2);
+				if (optionDataset.typed) if (optionDataset.issues) if (typedDatasets) typedDatasets.push(optionDataset);
+				else typedDatasets = [optionDataset];
+				else {
+					validDataset = optionDataset;
+					break;
+				}
+				else if (untypedDatasets) untypedDatasets.push(optionDataset);
+				else untypedDatasets = [optionDataset];
+			}
+			if (validDataset) return validDataset;
+			if (typedDatasets) {
+				if (typedDatasets.length === 1) return typedDatasets[0];
+				_addIssue(this, "type", dataset, config2, { issues: /* @__PURE__ */ _subIssues(typedDatasets) });
+				dataset.typed = true;
+			} else if (untypedDatasets?.length === 1) return untypedDatasets[0];
+			else _addIssue(this, "type", dataset, config2, { issues: /* @__PURE__ */ _subIssues(untypedDatasets) });
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function pipe(...pipe2) {
+	return {
+		...pipe2[0],
+		pipe: pipe2,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config2) {
+			for (const item of pipe2) if (item.kind !== "metadata") {
+				if (dataset.issues && (item.kind === "schema" || item.kind === "transformation")) {
+					dataset.typed = false;
+					break;
+				}
+				if (!dataset.issues || !config2.abortEarly && !config2.abortPipeEarly) dataset = item["~run"](dataset, config2);
+			}
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function safeParse(schema, input, config2) {
+	const dataset = schema["~run"]({ value: input }, /* @__PURE__ */ getGlobalConfig(config2));
+	return {
+		typed: dataset.typed,
+		success: !dataset.issues,
+		output: dataset.value,
+		issues: dataset.issues
+	};
+}
+
+//#endregion
+//#region data-loader.ts
+const getDefaultClaudePath = () => path.join(homedir(), ".claude");
+const UsageDataSchema = object({
+	timestamp: string(),
+	message: object({ usage: object({
+		input_tokens: number(),
+		output_tokens: number(),
+		cache_creation_input_tokens: optional(number()),
+		cache_read_input_tokens: optional(number())
+	}) }),
+	costUSD: number()
+});
+const DailyUsageSchema = object({
+	date: string(),
+	inputTokens: number(),
+	outputTokens: number(),
+	cacheCreationTokens: number(),
+	cacheReadTokens: number(),
+	totalCost: number()
+});
+const SessionUsageSchema = object({
+	sessionId: string(),
+	projectPath: string(),
+	inputTokens: number(),
+	outputTokens: number(),
+	cacheCreationTokens: number(),
+	cacheReadTokens: number(),
+	totalCost: number(),
+	lastActivity: string()
+});
+const formatDate = (dateStr) => {
+	const date = new Date(dateStr);
+	const year = date.getFullYear();
+	const month = String(date.getMonth() + 1).padStart(2, "0");
+	const day = String(date.getDate()).padStart(2, "0");
+	return `${year}-${month}-${day}`;
+};
+async function loadUsageData(options) {
+	const claudePath = options?.claudePath ?? getDefaultClaudePath();
+	const claudeDir = path.join(claudePath, "projects");
+	const files = await glob(["**/*.jsonl"], {
+		cwd: claudeDir,
+		absolute: true
+	});
+	if (files.length === 0) return [];
+	const dailyMap = new Map();
+	for (const file of files) {
+		const content = await readFile(file, "utf-8");
+		const lines = content.trim().split("\n").filter((line) => line.length > 0);
+		for (const line of lines) try {
+			const parsed = JSON.parse(line);
+			const result = safeParse(UsageDataSchema, parsed);
+			if (!result.success) continue;
+			const data = result.output;
+			const date = formatDate(data.timestamp);
+			const existing = dailyMap.get(date) || {
+				date,
+				inputTokens: 0,
+				outputTokens: 0,
+				cacheCreationTokens: 0,
+				cacheReadTokens: 0,
+				totalCost: 0
+			};
+			existing.inputTokens += data.message.usage.input_tokens || 0;
+			existing.outputTokens += data.message.usage.output_tokens || 0;
+			existing.cacheCreationTokens += data.message.usage.cache_creation_input_tokens || 0;
+			existing.cacheReadTokens += data.message.usage.cache_read_input_tokens || 0;
+			existing.totalCost += data.costUSD || 0;
+			dailyMap.set(date, existing);
+		} catch (e) {}
+	}
+	let results = Array.from(dailyMap.values());
+	if (options?.since || options?.until) results = results.filter((data) => {
+		const dateStr = data.date.replace(/-/g, "");
+		if (options.since && dateStr < options.since) return false;
+		if (options.until && dateStr > options.until) return false;
+		return true;
+	});
+	return sort(results).desc((item) => new Date(item.date).getTime());
+}
+async function loadSessionData(options) {
+	const claudePath = options?.claudePath ?? getDefaultClaudePath();
+	const claudeDir = path.join(claudePath, "projects");
+	const files = await glob(["**/*.jsonl"], {
+		cwd: claudeDir,
+		absolute: true
+	});
+	if (files.length === 0) return [];
+	const sessionMap = new Map();
+	for (const file of files) {
+		const relativePath = path.relative(claudeDir, file);
+		const parts = relativePath.split(path.sep);
+		const sessionId = parts[parts.length - 2];
+		const projectPath = parts.slice(0, -2).join(path.sep);
+		const content = await readFile(file, "utf-8");
+		const lines = content.trim().split("\n").filter((line) => line.length > 0);
+		let lastTimestamp = "";
+		for (const line of lines) try {
+			const parsed = JSON.parse(line);
+			const result = safeParse(UsageDataSchema, parsed);
+			if (!result.success) continue;
+			const data = result.output;
+			const key = `${projectPath}/${sessionId}`;
+			const existing = sessionMap.get(key) || {
+				sessionId: sessionId || "unknown",
+				projectPath: projectPath || "Unknown Project",
+				inputTokens: 0,
+				outputTokens: 0,
+				cacheCreationTokens: 0,
+				cacheReadTokens: 0,
+				totalCost: 0,
+				lastActivity: ""
+			};
+			existing.inputTokens += data.message.usage.input_tokens || 0;
+			existing.outputTokens += data.message.usage.output_tokens || 0;
+			existing.cacheCreationTokens += data.message.usage.cache_creation_input_tokens || 0;
+			existing.cacheReadTokens += data.message.usage.cache_read_input_tokens || 0;
+			existing.totalCost += data.costUSD || 0;
+			if (data.timestamp > lastTimestamp) {
+				lastTimestamp = data.timestamp;
+				existing.lastActivity = formatDate(data.timestamp);
+			}
+			sessionMap.set(key, existing);
+		} catch (e) {}
+	}
+	let results = Array.from(sessionMap.values());
+	if (options?.since || options?.until) results = results.filter((session) => {
+		const dateStr = session.lastActivity.replace(/-/g, "");
+		if (options.since && dateStr < options.since) return false;
+		if (options.until && dateStr > options.until) return false;
+		return true;
+	});
+	return sort(results).desc((item) => item.totalCost);
+}
+
+//#endregion
+export { DailyUsageSchema, SessionUsageSchema, UsageDataSchema, __commonJS, __require, __toESM, boolean, formatDate, getDefaultClaudePath, loadSessionData, loadUsageData, number, object, optional, pipe, record, regex, safeParse, string, union };