ccusage 16.2.5 → 17.0.1

package/dist/data-loader-ClkEoCfz.js

@@ -0,0 +1,3733 @@
+import { activityDateSchema, array, boolean, createBucket, createDailyDate, createMonthlyDate, createProjectPath, createSessionId, createWeeklyDate, dailyDateSchema, getTotalTokens, isoTimestampSchema, messageIdSchema, modelNameSchema, monthlyDateSchema, number, object, optional, parse as parse$2, projectPathSchema, requestIdSchema, safeParse, sessionIdSchema, string, union, versionSchema, weeklyDateSchema } from "./_types-CV6z8-9_.js";
+import { logger } from "./logger-C_yajNg2.js";
+import { createRequire } from "node:module";
+import a, { readFile, stat } from "node:fs/promises";
+import path, { basename, dirname, normalize, posix, relative, resolve, sep } from "node:path";
+import process$1 from "node:process";
+import * as nativeFs from "node:fs";
+import b from "node:fs";
+import F, { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n$1 = keys.length, key; i < n$1; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k$1) => from[k$1]).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$1 = /* @__PURE__ */ createRequire(import.meta.url);
+function toArray(array$1) {
+	array$1 = array$1 ?? [];
+	return Array.isArray(array$1) ? array$1 : [array$1];
+}
+const isFailure = (result) => "Failure" === result.type;
+const isPromise = (value) => "object" == typeof value && null !== value && "then" in value && "function" == typeof value.then && "catch" in value && "function" == typeof value.catch;
+const andThen = (fn) => (result) => {
+	const apply = (r) => {
+		if (isFailure(r)) return r;
+		return fn(r.value);
+	};
+	return isPromise(result) ? result.then(apply) : apply(result);
+};
+const andThrough = (fn) => (result) => {
+	const apply = (r) => {
+		if (isFailure(r)) return r;
+		const next = fn(r.value);
+		if (isPromise(next)) return next.then((n$1) => {
+			if (isFailure(n$1)) return n$1;
+			return r;
+		});
+		if (isFailure(next)) return next;
+		return r;
+	};
+	return isPromise(result) ? result.then(apply) : apply(result);
+};
+const isSuccess = (result) => "Success" === result.type;
+const succeed = (...args) => {
+	if (args.length <= 0) return { type: "Success" };
+	const value = args[0];
+	if (isPromise(value)) return value.then((value$1) => ({
+		type: "Success",
+		value: value$1
+	}));
+	return {
+		type: "Success",
+		value
+	};
+};
+const fail = (...args) => {
+	if (args.length <= 0) return { type: "Failure" };
+	const error = args[0];
+	if (isPromise(error)) return error.then((error$1) => ({
+		type: "Failure",
+		error: error$1
+	}));
+	return {
+		type: "Failure",
+		error
+	};
+};
+const inspect = (fn) => (result) => {
+	const apply = (r) => {
+		if (isSuccess(r)) fn(r.value);
+		return r;
+	};
+	return isPromise(result) ? result.then(apply) : apply(result);
+};
+const inspectError = (fn) => (result) => {
+	const apply = (r) => {
+		if (isFailure(r)) fn(r.error);
+		return r;
+	};
+	return isPromise(result) ? result.then(apply) : apply(result);
+};
+const isResult = (result) => "object" == typeof result && null !== result && "type" in result && ("Success" === result.type && "value" in result || "Failure" === result.type && "error" in result);
+const map = (fn) => (result) => {
+	const apply = (r) => {
+		if (isFailure(r)) return r;
+		return succeed(fn(r.value));
+	};
+	if (isPromise(result)) return result.then(apply);
+	return apply(result);
+};
+const orElse = (fn) => (result) => {
+	const apply = (r) => {
+		if (isSuccess(r)) return r;
+		return fn(r.error);
+	};
+	return isPromise(result) ? result.then(apply) : apply(result);
+};
+const pipe = (value, ...functions) => {
+	let next = value;
+	for (const func of functions) next = func(next);
+	return next;
+};
+const try_ = (options) => {
+	if (isPromise(options.try)) {
+		if ("safe" in options && options.safe) return succeed(options.try);
+		return options.try.then((value) => succeed(value), (error) => fail(options.catch(error)));
+	}
+	return (...args) => {
+		try {
+			const output = options.try(...args);
+			if (isPromise(output)) {
+				const promise$1 = succeed(output);
+				if ("safe" in options && options.safe) return promise$1;
+				return promise$1.catch((error) => fail(options.catch(error)));
+			}
+			return succeed(output);
+		} catch (error) {
+			if ("safe" in options && options.safe) throw error;
+			return fail(options.catch(error));
+		}
+	};
+};
+const unwrap = (...args) => {
+	const firstArgument = args[0];
+	if (isResult(firstArgument) || isPromise(firstArgument)) {
+		const result = firstArgument;
+		const hasDefault$1 = 2 === args.length;
+		const defaultValue$1 = hasDefault$1 ? args[1] : void 0;
+		const apply = (r) => {
+			if (isFailure(r)) {
+				if (hasDefault$1) return defaultValue$1;
+				throw r.error;
+			}
+			return r.value;
+		};
+		return isPromise(result) ? result.then(apply) : apply(result);
+	}
+	const hasDefault = 1 === args.length;
+	const defaultValue = hasDefault ? args[0] : void 0;
+	return (result) => {
+		const apply = (r) => {
+			if (isFailure(r)) {
+				if (hasDefault) return defaultValue;
+				throw r.error;
+			}
+			return r.value;
+		};
+		return isPromise(result) ? result.then(apply) : apply(result);
+	};
+};
+function groupBy(arr, getKeyFromItem) {
+	const result = {};
+	for (let i = 0; i < arr.length; i++) {
+		const item = arr[i];
+		const key = getKeyFromItem(item);
+		if (!Object.hasOwn(result, key)) result[key] = [];
+		result[key].push(item);
+	}
+	return result;
+}
+function uniq(arr) {
+	return Array.from(new Set(arr));
+}
+var d = Object.defineProperty;
+var n = (s, t) => d(s, "name", {
+	value: t,
+	configurable: !0
+});
+typeof Symbol.asyncDispose != "symbol" && Object.defineProperty(Symbol, "asyncDispose", {
+	configurable: !1,
+	enumerable: !1,
+	writable: !1,
+	value: Symbol.for("asyncDispose")
+});
+var P = class {
+	static {
+		n(this, "FsFixture");
+	}
+	path;
+	constructor(t) {
+		this.path = t;
+	}
+	getPath(...t) {
+		return path.join(this.path, ...t);
+	}
+	exists(t = "") {
+		return a.access(this.getPath(t)).then(() => !0, () => !1);
+	}
+	rm(t = "") {
+		return a.rm(this.getPath(t), {
+			recursive: !0,
+			force: !0
+		});
+	}
+	cp(t, r, i) {
+		return r ? r.endsWith(path.sep) && (r += path.basename(t)) : r = path.basename(t), a.cp(t, this.getPath(r), i);
+	}
+	mkdir(t) {
+		return a.mkdir(this.getPath(t), { recursive: !0 });
+	}
+	writeFile(t, r) {
+		return a.writeFile(this.getPath(t), r);
+	}
+	writeJson(t, r) {
+		return this.writeFile(t, JSON.stringify(r, null, 2));
+	}
+	readFile(t, r) {
+		return a.readFile(this.getPath(t), r);
+	}
+	async [Symbol.asyncDispose]() {
+		await this.rm();
+	}
+};
+const v = b.realpathSync(F.tmpdir()), D = `fs-fixture-${Date.now()}-${process.pid}`;
+let m = 0;
+const j = n(() => (m += 1, m), "getId");
+var u = class {
+	static {
+		n(this, "Path");
+	}
+	path;
+	constructor(t) {
+		this.path = t;
+	}
+};
+var f = class extends u {
+	static {
+		n(this, "Directory");
+	}
+};
+var y = class extends u {
+	static {
+		n(this, "File");
+	}
+	content;
+	constructor(t, r) {
+		super(t), this.content = r;
+	}
+};
+var l = class {
+	static {
+		n(this, "Symlink");
+	}
+	target;
+	type;
+	path;
+	constructor(t, r) {
+		this.target = t, this.type = r;
+	}
+};
+const w = n((s, t, r) => {
+	const i = [];
+	for (const p in s) {
+		if (!Object.hasOwn(s, p)) continue;
+		const e = path.join(t, p);
+		let o = s[p];
+		if (typeof o == "function") {
+			const g = Object.assign(Object.create(r), { filePath: e }), h = o(g);
+			if (h instanceof l) {
+				h.path = e, i.push(h);
+				continue;
+			} else o = h;
+		}
+		typeof o == "string" ? i.push(new y(e, o)) : i.push(new f(e), ...w(o, e, r));
+	}
+	return i;
+}, "flattenFileTree");
+n(async (s, t) => {
+	const r = t?.tempDir ? path.resolve(t.tempDir) : v, i = path.join(r, `${D}-${j()}/`);
+	if (await a.mkdir(i, { recursive: !0 }), s) {
+		if (typeof s == "string") await a.cp(s, i, {
+			recursive: !0,
+			filter: t?.templateFilter
+		});
+		else if (typeof s == "object") {
+			const p = {
+				fixturePath: i,
+				getPath: n((...e) => path.join(i, ...e), "getPath"),
+				symlink: n((e, o) => new l(e, o), "symlink")
+			};
+			await Promise.all(w(s, i, p).map(async (e) => {
+				e instanceof f ? await a.mkdir(e.path, { recursive: !0 }) : e instanceof l ? (await a.mkdir(path.dirname(e.path), { recursive: !0 }), await a.symlink(e.target, e.path, e.type)) : e instanceof y && (await a.mkdir(path.dirname(e.path), { recursive: !0 }), await a.writeFile(e.path, e.content));
+			}));
+		}
+	}
+	return new P(i);
+}, "createFixture");
+async function isType(fsStatType, statsMethodName, filePath) {
+	if (typeof filePath !== "string") throw new TypeError(`Expected a string, got ${typeof filePath}`);
+	try {
+		return (await a[fsStatType](filePath))[statsMethodName]();
+	} catch (error) {
+		if (error.code === "ENOENT") return false;
+		throw error;
+	}
+}
+function isTypeSync(fsStatType, statsMethodName, filePath) {
+	if (typeof filePath !== "string") throw new TypeError(`Expected a string, got ${typeof filePath}`);
+	try {
+		return b[fsStatType](filePath)[statsMethodName]();
+	} catch (error) {
+		if (error.code === "ENOENT") return false;
+		throw error;
+	}
+}
+isType.bind(void 0, "stat", "isFile");
+isType.bind(void 0, "stat", "isDirectory");
+isType.bind(void 0, "lstat", "isSymbolicLink");
+isTypeSync.bind(void 0, "statSync", "isFile");
+const isDirectorySync = isTypeSync.bind(void 0, "statSync", "isDirectory");
+isTypeSync.bind(void 0, "lstatSync", "isSymbolicLink");
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+function cleanPath(path$1) {
+	let normalized = normalize(path$1);
+	if (normalized.length > 1 && normalized[normalized.length - 1] === sep) normalized = normalized.substring(0, normalized.length - 1);
+	return normalized;
+}
+const SLASHES_REGEX = /[\\/]/g;
+function convertSlashes(path$1, separator) {
+	return path$1.replace(SLASHES_REGEX, separator);
+}
+const WINDOWS_ROOT_DIR_REGEX = /^[a-z]:[\\/]$/i;
+function isRootDirectory(path$1) {
+	return path$1 === "/" || WINDOWS_ROOT_DIR_REGEX.test(path$1);
+}
+function normalizePath(path$1, options) {
+	const { resolvePaths, normalizePath: normalizePath$1, pathSeparator } = options;
+	const pathNeedsCleaning = process.platform === "win32" && path$1.includes("/") || path$1.startsWith(".");
+	if (resolvePaths) path$1 = resolve(path$1);
+	if (normalizePath$1 || pathNeedsCleaning) path$1 = cleanPath(path$1);
+	if (path$1 === ".") return "";
+	const needsSeperator = path$1[path$1.length - 1] !== pathSeparator;
+	return convertSlashes(needsSeperator ? path$1 + pathSeparator : path$1, pathSeparator);
+}
+function joinPathWithBasePath(filename, directoryPath) {
+	return directoryPath + filename;
+}
+function joinPathWithRelativePath(root, options) {
+	return function(filename, directoryPath) {
+		if (directoryPath.startsWith(root)) return directoryPath.slice(root.length) + filename;
+		else return convertSlashes(relative(root, directoryPath), options.pathSeparator) + options.pathSeparator + filename;
+	};
+}
+function joinPath(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;
+}
+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 = (directoryPath, paths) => {
+	paths.push(directoryPath || ".");
+};
+const pushDirectoryFilter = (directoryPath, paths, filters) => {
+	const path$1 = directoryPath || ".";
+	if (filters.every((filter) => filter(path$1, true))) paths.push(path$1);
+};
+const 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;
+}
+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 = (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;
+}
+const getArray = (paths) => {
+	return paths;
+};
+const getArrayGroup = () => {
+	return [""].slice(0, 0);
+};
+function build$4(options) {
+	return options.group ? getArrayGroup : getArray;
+}
+const groupFiles = (groups, directory, files) => {
+	groups.push({
+		directory,
+		files,
+		dir: directory
+	});
+};
+const empty = () => {};
+function build$3(options) {
+	return options.group ? groupFiles : empty;
+}
+const resolveSymlinksAsync = function(path$1, state, callback$1) {
+	const { queue, fs, options: { suppressErrors } } = state;
+	queue.enqueue();
+	fs.realpath(path$1, (error, resolvedPath) => {
+		if (error) return queue.dequeue(suppressErrors ? null : error, state);
+		fs.stat(resolvedPath, (error$1, stat$1) => {
+			if (error$1) return queue.dequeue(suppressErrors ? null : error$1, state);
+			if (stat$1.isDirectory() && isRecursive(path$1, resolvedPath, state)) return queue.dequeue(null, state);
+			callback$1(stat$1, resolvedPath);
+			queue.dequeue(null, state);
+		});
+	});
+};
+const resolveSymlinks = function(path$1, state, callback$1) {
+	const { queue, fs, options: { suppressErrors } } = state;
+	queue.enqueue();
+	try {
+		const resolvedPath = fs.realpathSync(path$1);
+		const stat$1 = fs.statSync(resolvedPath);
+		if (stat$1.isDirectory() && isRecursive(path$1, resolvedPath, state)) return;
+		callback$1(stat$1, 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$1, resolved, state) {
+	if (state.options.useRealPaths) return isRecursiveUsingRealPaths(resolved, state);
+	let parent = dirname(path$1);
+	let depth$1 = 1;
+	while (parent !== state.root && depth$1 < 2) {
+		const resolvedPath = state.symlinks.get(parent);
+		if (!!resolvedPath && (resolvedPath === resolved || resolvedPath.startsWith(resolved) || resolved.startsWith(resolvedPath))) depth$1++;
+		else parent = dirname(parent);
+	}
+	state.symlinks.set(path$1, resolved);
+	return depth$1 > 1;
+}
+function isRecursiveUsingRealPaths(resolved, state) {
+	return state.visited.includes(resolved + state.options.pathSeparator);
+}
+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;
+}
+const readdirOpts = { withFileTypes: true };
+const walkAsync = (state, crawlPath, directoryPath, currentDepth, callback$1) => {
+	state.queue.enqueue();
+	if (currentDepth < 0) return state.queue.dequeue(null, state);
+	const { fs } = state;
+	state.visited.push(crawlPath);
+	state.counts.directories++;
+	fs.readdir(crawlPath || ".", readdirOpts, (error, entries = []) => {
+		callback$1(entries, directoryPath, currentDepth);
+		state.queue.dequeue(state.options.suppressErrors ? null : error, state);
+	});
+};
+const walkSync = (state, crawlPath, directoryPath, currentDepth, callback$1) => {
+	const { fs } = state;
+	if (currentDepth < 0) return;
+	state.visited.push(crawlPath);
+	state.counts.directories++;
+	let entries = [];
+	try {
+		entries = fs.readdirSync(crawlPath || ".", readdirOpts);
+	} catch (e) {
+		if (!state.options.suppressErrors) throw e;
+	}
+	callback$1(entries, directoryPath, currentDepth);
+};
+function build(isSynchronous) {
+	return isSynchronous ? walkSync : walkAsync;
+}
+var Queue = class {
+	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;
+			}
+		}
+	}
+};
+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;
+	}
+	/* c8 ignore next 3 */
+	get dirs() {
+		return this._directories;
+	}
+};
+var Aborter = class {
+	aborted = false;
+	abort() {
+		this.aborted = true;
+	}
+};
+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 = build$1(options, this.isSynchronous);
+		this.root = normalizePath(root, options);
+		this.state = {
+			root: isRootDirectory(this.root) ? this.root : this.root.slice(0, -1),
+			paths: [""].slice(0, 0),
+			groups: [],
+			counts: new Counter(),
+			options,
+			queue: new Queue((error, state) => this.callbackInvoker(state, error, callback$1)),
+			symlinks: /* @__PURE__ */ new Map(),
+			visited: [""].slice(0, 0),
+			controller: new Aborter(),
+			fs: options.fs || nativeFs
+		};
+		this.joinPath = build$7(this.root, options);
+		this.pushDirectory = build$6(this.root, options);
+		this.pushFile = build$5(options);
+		this.getArray = build$4(options);
+		this.groupFiles = build$3(options);
+		this.resolveSymlink = build$2(options, this.isSynchronous);
+		this.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.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$1 = joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
+				if (exclude && exclude(entry.name, path$1)) continue;
+				this.pushDirectory(path$1, paths, filters);
+				this.walkDirectory(this.state, path$1, path$1, depth$1 - 1, this.walk);
+			} else if (this.resolveSymlink && entry.isSymbolicLink()) {
+				let path$1 = joinPathWithBasePath(entry.name, directoryPath);
+				this.resolveSymlink(path$1, this.state, (stat$1, resolvedPath) => {
+					if (stat$1.isDirectory()) {
+						resolvedPath = normalizePath(resolvedPath, this.state.options);
+						if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path$1 + pathSeparator)) return;
+						this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path$1 + pathSeparator, depth$1 - 1, this.walk);
+					} else {
+						resolvedPath = useRealPaths ? resolvedPath : path$1;
+						const filename = basename(resolvedPath);
+						const directoryPath$1 = normalizePath(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);
+	};
+};
+function promise(root, options) {
+	return new Promise((resolve$1, reject) => {
+		callback(root, options, (err, output) => {
+			if (err) return reject(err);
+			resolve$1(output);
+		});
+	});
+}
+function callback(root, options, callback$1) {
+	new Walker(root, options, callback$1).start();
+}
+function sync(root, options) {
+	return new Walker(root, options).start();
+}
+var APIBuilder = class {
+	constructor(root, options) {
+		this.root = root;
+		this.options = options;
+	}
+	withPromise() {
+		return promise(this.root, this.options);
+	}
+	withCallback(cb) {
+		callback(this.root, this.options, cb);
+	}
+	sync() {
+		return sync(this.root, this.options);
+	}
+};
+let pm = null;
+/* c8 ignore next 6 */
+try {
+	__require.resolve("picomatch");
+	pm = __require("picomatch");
+} catch {}
+var Builder = class {
+	globCache = {};
+	options = {
+		maxDepth: Infinity,
+		suppressErrors: true,
+		pathSeparator: 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 APIBuilder(root || ".", this.options);
+	}
+	withGlobFunction(fn) {
+		this.globFunction = fn;
+		return this;
+	}
+	/* c8 ignore next 4 */
+	crawlWithOptions(root, options) {
+		this.options = {
+			...this.options,
+			...options
+		};
+		return new 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$1) => isMatch(path$1));
+		return this;
+	}
+};
+var require_constants = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const WIN_SLASH = "\\\\/";
+	const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
+	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 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: "/"
+	};
+	const WINDOWS_CHARS = {
+		...POSIX_CHARS,
+		SLASH_LITERAL: `[${WIN_SLASH}]`,
+		QMARK: WIN_NO_SLASH,
+		STAR: `${WIN_NO_SLASH}*?`,
+		DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,
+		NO_DOT: `(?!${DOT_LITERAL})`,
+		NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+		NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,
+		NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+		QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
+		START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
+		END_ANCHOR: `(?:[${WIN_SLASH}]|$)`,
+		SEP: "\\"
+	};
+	module.exports = {
+		MAX_LENGTH: 1024 * 64,
+		POSIX_REGEX_SOURCE: {
+			alnum: "a-zA-Z0-9",
+			alpha: "a-zA-Z",
+			ascii: "\\x00-\\x7F",
+			blank: " \\t",
+			cntrl: "\\x00-\\x1F\\x7F",
+			digit: "0-9",
+			graph: "\\x21-\\x7E",
+			lower: "a-z",
+			print: "\\x20-\\x7E ",
+			punct: "\\-!\"#$%&'()\\*+,./:;<=>?@[\\]^_`{|}~",
+			space: " \\t\\r\\n\\v\\f",
+			upper: "A-Z",
+			word: "A-Za-z0-9_",
+			xdigit: "A-Fa-f0-9"
+		},
+		REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
+		REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
+		REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
+		REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
+		REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
+		REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
+		REPLACEMENTS: {
+			__proto__: null,
+			"***": "*",
+			"**/**": "**",
+			"**/**/**": "**"
+		},
+		CHAR_0: 48,
+		CHAR_9: 57,
+		CHAR_UPPERCASE_A: 65,
+		CHAR_LOWERCASE_A: 97,
+		CHAR_UPPERCASE_Z: 90,
+		CHAR_LOWERCASE_Z: 122,
+		CHAR_LEFT_PARENTHESES: 40,
+		CHAR_RIGHT_PARENTHESES: 41,
+		CHAR_ASTERISK: 42,
+		CHAR_AMPERSAND: 38,
+		CHAR_AT: 64,
+		CHAR_BACKWARD_SLASH: 92,
+		CHAR_CARRIAGE_RETURN: 13,
+		CHAR_CIRCUMFLEX_ACCENT: 94,
+		CHAR_COLON: 58,
+		CHAR_COMMA: 44,
+		CHAR_DOT: 46,
+		CHAR_DOUBLE_QUOTE: 34,
+		CHAR_EQUAL: 61,
+		CHAR_EXCLAMATION_MARK: 33,
+		CHAR_FORM_FEED: 12,
+		CHAR_FORWARD_SLASH: 47,
+		CHAR_GRAVE_ACCENT: 96,
+		CHAR_HASH: 35,
+		CHAR_HYPHEN_MINUS: 45,
+		CHAR_LEFT_ANGLE_BRACKET: 60,
+		CHAR_LEFT_CURLY_BRACE: 123,
+		CHAR_LEFT_SQUARE_BRACKET: 91,
+		CHAR_LINE_FEED: 10,
+		CHAR_NO_BREAK_SPACE: 160,
+		CHAR_PERCENT: 37,
+		CHAR_PLUS: 43,
+		CHAR_QUESTION_MARK: 63,
+		CHAR_RIGHT_ANGLE_BRACKET: 62,
+		CHAR_RIGHT_CURLY_BRACE: 125,
+		CHAR_RIGHT_SQUARE_BRACKET: 93,
+		CHAR_SEMICOLON: 59,
+		CHAR_SINGLE_QUOTE: 39,
+		CHAR_SPACE: 32,
+		CHAR_TAB: 9,
+		CHAR_UNDERSCORE: 95,
+		CHAR_VERTICAL_LINE: 124,
+		CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
+		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;
+		}
+	};
+}));
+var require_utils = /* @__PURE__ */ __commonJSMin(((exports) => {
+	const { REGEX_BACKSLASH, REGEX_REMOVE_BACKSLASH, REGEX_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_GLOBAL } = require_constants();
+	exports.isObject = (val) => val !== null && typeof val === "object" && !Array.isArray(val);
+	exports.hasRegexChars = (str) => REGEX_SPECIAL_CHARS.test(str);
+	exports.isRegexChar = (str) => str.length === 1 && exports.hasRegexChars(str);
+	exports.escapeRegex = (str) => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, "\\$1");
+	exports.toPosixSlashes = (str) => str.replace(REGEX_BACKSLASH, "/");
+	exports.isWindows = () => {
+		if (typeof navigator !== "undefined" && navigator.platform) {
+			const platform = navigator.platform.toLowerCase();
+			return platform === "win32" || platform === "windows";
+		}
+		if (typeof process !== "undefined" && process.platform) return process.platform === "win32";
+		return false;
+	};
+	exports.removeBackslashes = (str) => {
+		return str.replace(REGEX_REMOVE_BACKSLASH, (match) => {
+			return match === "\\" ? "" : match;
+		});
+	};
+	exports.escapeLast = (input, char, lastIdx) => {
+		const idx = input.lastIndexOf(char, lastIdx);
+		if (idx === -1) return input;
+		if (input[idx - 1] === "\\") return exports.escapeLast(input, char, idx - 1);
+		return `${input.slice(0, idx)}\\${input.slice(idx)}`;
+	};
+	exports.removePrefix = (input, state = {}) => {
+		let output = input;
+		if (output.startsWith("./")) {
+			output = output.slice(2);
+			state.prefix = "./";
+		}
+		return output;
+	};
+	exports.wrapOutput = (input, state = {}, options = {}) => {
+		const prepend = options.contains ? "" : "^";
+		const append = options.contains ? "" : "$";
+		let output = `${prepend}(?:${input})${append}`;
+		if (state.negated === true) output = `(?:^(?!${output}).*$)`;
+		return output;
+	};
+	exports.basename = (path$1, { windows } = {}) => {
+		const segs = path$1.split(windows ? /[\\/]/ : "/");
+		const last = segs[segs.length - 1];
+		if (last === "") return segs[segs.length - 2];
+		return last;
+	};
+}));
+var require_scan = /* @__PURE__ */ __commonJSMin(((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;
+	};
+	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) {
+				if ((code === CHAR_PLUS || code === CHAR_AT || code === CHAR_ASTERISK || code === CHAR_QUESTION_MARK || code === CHAR_EXCLAMATION_MARK) === true && peek() === CHAR_LEFT_PARENTHESES) {
+					isGlob = token.isGlob = true;
+					isExtglob = token.isExtglob = true;
+					finished = true;
+					if (code === CHAR_EXCLAMATION_MARK && index === start) negatedExtglob = true;
+					if (scanToEnd === true) {
+						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$1 = prevIndex ? prevIndex + 1 : start;
+				const i = slashes[idx];
+				const value = input.slice(n$1, 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;
+}));
+var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const constants$1 = require_constants();
+	const utils$2 = require_utils();
+	const { MAX_LENGTH, POSIX_REGEX_SOURCE, REGEX_NON_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_BACKREF, REPLACEMENTS } = constants$1;
+	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$1) => utils$2.escapeRegex(v$1)).join("..");
+		}
+		return value;
+	};
+	const syntaxError = (type, char) => {
+		return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
+	};
+	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;
+		const eos = () => state.index === len - 1;
+		const peek = state.peek = (n$1 = 1) => input[state.index + n$1];
+		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();
+		};
+		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)) output = token.close = `)${parse$1(rest, {
+					...options,
+					fastpaths: false
+				}).output})${extglobStar})`;
+				if (token.prev.type === "bos") state.negatedExtglob = true;
+			}
+			push({
+				type: "paren",
+				extglob: true,
+				value,
+				output
+			});
+			decrement("parens");
+		};
+		if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) {
+			let backslashes = false;
+			let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m$1, esc, chars, first, rest, index) => {
+				if (first === "\\") {
+					backslashes = true;
+					return m$1;
+				}
+				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$1 : `\\${m$1}`;
+			});
+			if (backslashes === true) if (opts.unescape === true) output = output.replace(/\\/g, "");
+			else output = output.replace(/\\+/g, (m$1) => {
+				return m$1.length % 2 === 0 ? "\\\\" : m$1 ? "\\" : "";
+			});
+			if (output === input && opts.contains === true) {
+				state.output = input;
+				return state;
+			}
+			state.output = utils$2.wrapOutput(output, state, options);
+			return state;
+		}
+		while (!eos()) {
+			value = advance();
+			if (value === "\0") continue;
+			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 (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 (state.quotes === 1 && value !== "\"") {
+				value = utils$2.escapeRegex(value);
+				prev.value += value;
+				append({ value });
+				continue;
+			}
+			if (value === "\"") {
+				state.quotes = state.quotes === 1 ? 0 : 1;
+				if (opts.keepQuotes === true) push({
+					type: "text",
+					value
+				});
+				continue;
+			}
+			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;
+			}
+			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;
+			}
+			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;
+			}
+			if (value === "|") {
+				if (extglobs.length > 0) extglobs[extglobs.length - 1].conditions++;
+				push({
+					type: "text",
+					value
+				});
+				continue;
+			}
+			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;
+			}
+			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;
+			}
+			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;
+			}
+			if (value === "?") {
+				if (!(prev && prev.value === "(") && opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+					extglobOpen("qmark", value);
+					continue;
+				}
+				if (prev && prev.type === "paren") {
+					const next = peek();
+					let output = value;
+					if (prev.value === "(" && !/[!=<:]/.test(next) || next === "<" && !/<([!=]|\w+>)/.test(remaining())) output = `\\${value}`;
+					push({
+						type: "text",
+						value,
+						output
+					});
+					continue;
+				}
+				if (opts.dot !== true && (prev.type === "slash" || prev.type === "bos")) {
+					push({
+						type: "qmark",
+						value,
+						output: QMARK_NO_DOT$1
+					});
+					continue;
+				}
+				push({
+					type: "qmark",
+					value,
+					output: QMARK$1
+				});
+				continue;
+			}
+			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;
+				}
+			}
+			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;
+			}
+			if (value === "@") {
+				if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+					push({
+						type: "at",
+						extglob: true,
+						value,
+						output: ""
+					});
+					continue;
+				}
+				push({
+					type: "text",
+					value
+				});
+				continue;
+			}
+			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;
+			}
+			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;
+	};
+	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;
+}));
+var require_picomatch$1 = /* @__PURE__ */ __commonJSMin(((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);
+	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 = isState ? picomatch$2.compileRe(glob$1, options) : picomatch$2.makeRe(glob$1, options, false, true);
+		const state = regex.state;
+		delete regex.state;
+		let isIgnored = () => false;
+		if (opts.ignore) {
+			const ignoreOpts = {
+				...options,
+				ignore: null,
+				onMatch: null,
+				onResult: null
+			};
+			isIgnored = picomatch$2(opts.ignore, ignoreOpts, returnState);
+		}
+		const matcher = (input, returnObject = false) => {
+			const { isMatch, match, output } = picomatch$2.test(input, regex, options, {
+				glob: glob$1,
+				posix: posix$1
+			});
+			const result = {
+				glob: glob$1,
+				state,
+				regex,
+				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;
+	};
+	picomatch$2.test = (input, regex, 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, options, posix$1);
+		else match = regex.exec(output);
+		return {
+			isMatch: Boolean(match),
+			match,
+			output
+		};
+	};
+	picomatch$2.matchBase = (input, glob$1, options) => {
+		return (glob$1 instanceof RegExp ? glob$1 : picomatch$2.makeRe(glob$1, options)).test(utils$1.basename(input));
+	};
+	picomatch$2.isMatch = (str, patterns, options) => picomatch$2(patterns, options)(str);
+	picomatch$2.parse = (pattern, options) => {
+		if (Array.isArray(pattern)) return pattern.map((p) => picomatch$2.parse(p, options));
+		return parse(pattern, {
+			...options,
+			fastpaths: false
+		});
+	};
+	picomatch$2.scan = (input, options) => scan(input, options);
+	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 = picomatch$2.toRegex(source, options);
+		if (returnState === true) regex.state = state;
+		return regex;
+	};
+	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);
+	};
+	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$2.constants = constants;
+	module.exports = picomatch$2;
+}));
+var import_picomatch = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const pico = require_picomatch$1();
+	const utils = require_utils();
+	function picomatch$1(glob$1, options, returnState = false) {
+		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;
+})))(), 1);
+const isReadonlyArray = Array.isArray;
+const isWin = process.platform === "win32";
+const ONLY_PARENT_DIRECTORIES = /^(\/?\.\.)+$/;
+function getPartialMatcher(patterns, options = {}) {
+	const patternsCount = patterns.length;
+	const patternsParts = Array(patternsCount);
+	const matchers = Array(patternsCount);
+	const globstarEnabled = !options.noglobstar;
+	for (let i = 0; i < patternsCount; i++) {
+		const parts = splitPattern(patterns[i]);
+		patternsParts[i] = parts;
+		const partsCount = parts.length;
+		const partMatchers = Array(partsCount);
+		for (let j$1 = 0; j$1 < partsCount; j$1++) partMatchers[j$1] = (0, import_picomatch.default)(parts[j$1], options);
+		matchers[i] = partMatchers;
+	}
+	return (input) => {
+		const inputParts = input.split("/");
+		if (inputParts[0] === ".." && ONLY_PARENT_DIRECTORIES.test(input)) return true;
+		for (let i = 0; i < patterns.length; i++) {
+			const patternParts = patternsParts[i];
+			const matcher = matchers[i];
+			const inputPatternCount = inputParts.length;
+			const minParts = Math.min(inputPatternCount, patternParts.length);
+			let j$1 = 0;
+			while (j$1 < minParts) {
+				const part = patternParts[j$1];
+				if (part.includes("/")) return true;
+				if (!matcher[j$1](inputParts[j$1])) break;
+				if (globstarEnabled && part === "**") return true;
+				j$1++;
+			}
+			if (j$1 === inputPatternCount) return true;
+		}
+		return false;
+	};
+}
+/* node:coverage ignore next 2 */
+const WIN32_ROOT_DIR = /^[A-Z]:\/$/i;
+const isRoot = isWin ? (p) => WIN32_ROOT_DIR.test(p) : (p) => p === "/";
+function buildFormat(cwd, root, absolute) {
+	if (cwd === root || root.startsWith(`${cwd}/`)) {
+		if (absolute) {
+			const start = isRoot(cwd) ? cwd.length : cwd.length + 1;
+			return (p, isDir) => p.slice(start, isDir ? -1 : void 0) || ".";
+		}
+		const prefix = root.slice(cwd.length + 1);
+		if (prefix) return (p, isDir) => {
+			if (p === ".") return prefix;
+			const result = `${prefix}/${p}`;
+			return isDir ? result.slice(0, -1) : result;
+		};
+		return (p, isDir) => isDir && p !== "." ? p.slice(0, -1) : p;
+	}
+	if (absolute) return (p) => posix.relative(cwd, p) || ".";
+	return (p) => posix.relative(cwd, `${root}/${p}`) || ".";
+}
+function buildRelative(cwd, root) {
+	if (root.startsWith(`${cwd}/`)) {
+		const prefix = root.slice(cwd.length + 1);
+		return (p) => `${prefix}/${p}`;
+	}
+	return (p) => {
+		const result = posix.relative(cwd, `${root}/${p}`);
+		if (p.endsWith("/") && result !== "") return `${result}/`;
+		return result || ".";
+	};
+}
+const splitPatternOptions = { parts: true };
+function splitPattern(path$1) {
+	var _result$parts;
+	const result = import_picomatch.default.scan(path$1, splitPatternOptions);
+	return ((_result$parts = result.parts) === null || _result$parts === void 0 ? void 0 : _result$parts.length) ? result.parts : [path$1];
+}
+const POSIX_UNESCAPED_GLOB_SYMBOLS = /(?<!\\)([()[\]{}*?|]|^!|[!+@](?=\()|\\(?![()[\]{}!*+?@|]))/g;
+const WIN32_UNESCAPED_GLOB_SYMBOLS = /(?<!\\)([()[\]{}]|^!|[!+@](?=\())/g;
+const escapePosixPath = (path$1) => path$1.replace(POSIX_UNESCAPED_GLOB_SYMBOLS, "\\$&");
+const escapeWin32Path = (path$1) => path$1.replace(WIN32_UNESCAPED_GLOB_SYMBOLS, "\\$&");
+/* node:coverage ignore next */
+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 ${(/* @__PURE__ */ 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.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$1 = (parentDirectoryMatch[0].length + 1) / 3;
+		let i = 0;
+		const cwdParts = escapedCwd.split("/");
+		while (i < n$1 && parts[i + n$1] === cwdParts[cwdParts.length + i - n$1]) {
+			result = result.slice(0, (n$1 - i - 1) * 3) + result.slice((n$1 - i) * 3 + parts[i + n$1].length + 1) || ".";
+			i++;
+		}
+		const potentialRoot = posix.join(cwd, parentDirectoryMatch[0].slice(i * 3));
+		if (!potentialRoot.startsWith(".") && props.root.length > potentialRoot.length) {
+			props.root = potentialRoot;
+			props.depthOffset = -n$1 + i;
+		}
+	}
+	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 ? posix.join(cwd, ...newCommonPath) : cwd;
+	}
+	return result;
+}
+function processPatterns({ patterns = ["**/*"], ignore = [], expandDirectories = true }, cwd, props) {
+	if (typeof patterns === "string") 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 formatPaths(paths, relative$1) {
+	for (let i = paths.length - 1; i >= 0; i--) {
+		const path$1 = paths[i];
+		paths[i] = relative$1(path$1);
+	}
+	return paths;
+}
+function normalizeCwd(cwd) {
+	if (!cwd) return process.cwd().replace(BACKSLASHES, "/");
+	if (cwd instanceof URL) return fileURLToPath(cwd).replace(BACKSLASHES, "/");
+	return path.resolve(cwd).replace(BACKSLASHES, "/");
+}
+function getCrawler(patterns, inputOptions = {}) {
+	const options = process.env.TINYGLOBBY_DEBUG ? {
+		...inputOptions,
+		debug: true
+	} : inputOptions;
+	const cwd = normalizeCwd(options.cwd);
+	if (options.debug) log("globbing with:", {
+		patterns,
+		options,
+		cwd
+	});
+	if (Array.isArray(patterns) && patterns.length === 0) return [{
+		sync: () => [],
+		withPromise: async () => []
+	}, false];
+	const props = {
+		root: cwd,
+		commonPath: null,
+		depthOffset: 0
+	};
+	const processed = processPatterns({
+		...options,
+		patterns
+	}, cwd, props);
+	if (options.debug) log("internal processing patterns:", processed);
+	const matchOptions = {
+		dot: options.dot,
+		nobrace: options.braceExpansion === false,
+		nocase: options.caseSensitiveMatch === false,
+		noextglob: options.extglob === false,
+		noglobstar: options.globstar === false,
+		posix: true
+	};
+	const matcher = (0, import_picomatch.default)(processed.match, {
+		...matchOptions,
+		ignore: processed.ignore
+	});
+	const ignore = (0, import_picomatch.default)(processed.ignore, matchOptions);
+	const partialMatcher = getPartialMatcher(processed.match, matchOptions);
+	const format = buildFormat(cwd, props.root, options.absolute);
+	const formatExclude = options.absolute ? format : buildFormat(cwd, props.root, true);
+	const fdirOptions = {
+		filters: [options.debug ? (p, isDirectory$1) => {
+			const path$1 = format(p, isDirectory$1);
+			const matches = matcher(path$1);
+			if (matches) log(`matched ${path$1}`);
+			return matches;
+		} : (p, isDirectory$1) => matcher(format(p, isDirectory$1))],
+		exclude: options.debug ? (_, p) => {
+			const relativePath = formatExclude(p, true);
+			const skipped = relativePath !== "." && !partialMatcher(relativePath) || ignore(relativePath);
+			if (skipped) log(`skipped ${p}`);
+			else log(`crawling ${p}`);
+			return skipped;
+		} : (_, p) => {
+			const relativePath = formatExclude(p, true);
+			return relativePath !== "." && !partialMatcher(relativePath) || ignore(relativePath);
+		},
+		fs: options.fs ? {
+			readdir: options.fs.readdir || b.readdir,
+			readdirSync: options.fs.readdirSync || b.readdirSync,
+			realpath: options.fs.realpath || b.realpath,
+			realpathSync: options.fs.realpathSync || b.realpathSync,
+			stat: options.fs.stat || b.stat,
+			statSync: options.fs.statSync || b.statSync
+		} : void 0,
+		pathSeparator: "/",
+		relativePaths: true,
+		resolveSymlinks: true,
+		signal: options.signal
+	};
+	if (options.deep !== void 0) fdirOptions.maxDepth = Math.round(options.deep - props.depthOffset);
+	if (options.absolute) {
+		fdirOptions.relativePaths = false;
+		fdirOptions.resolvePaths = true;
+		fdirOptions.includeBasePath = true;
+	}
+	if (options.followSymbolicLinks === false) {
+		fdirOptions.resolveSymlinks = false;
+		fdirOptions.excludeSymlinks = true;
+	}
+	if (options.onlyDirectories) {
+		fdirOptions.excludeFiles = true;
+		fdirOptions.includeDirs = true;
+	} else if (options.onlyFiles === false) fdirOptions.includeDirs = true;
+	props.root = props.root.replace(BACKSLASHES, "");
+	const root = props.root;
+	if (options.debug) log("internal properties:", props);
+	const relative$1 = cwd !== root && !options.absolute && buildRelative(cwd, props.root);
+	return [new Builder(fdirOptions).crawl(root), relative$1];
+}
+async function glob(patternsOrOptions, options) {
+	if (patternsOrOptions && (options === null || options === void 0 ? void 0 : options.patterns)) throw new Error("Cannot pass patterns as both an argument and an option");
+	const isModern = isReadonlyArray(patternsOrOptions) || typeof patternsOrOptions === "string";
+	const opts = isModern ? options : patternsOrOptions;
+	const patterns = isModern ? patternsOrOptions : patternsOrOptions.patterns;
+	const [crawler, relative$1] = getCrawler(patterns, opts);
+	if (!relative$1) return crawler.withPromise();
+	return formatPaths(await crawler.withPromise(), relative$1);
+}
+const homeDirectory = F.homedir();
+const { env } = process;
+const xdgData = env.XDG_DATA_HOME || (homeDirectory ? path.join(homeDirectory, ".local", "share") : void 0);
+const xdgConfig = env.XDG_CONFIG_HOME || (homeDirectory ? path.join(homeDirectory, ".config") : void 0);
+env.XDG_STATE_HOME || homeDirectory && path.join(homeDirectory, ".local", "state");
+env.XDG_CACHE_HOME || homeDirectory && path.join(homeDirectory, ".cache");
+env.XDG_RUNTIME_DIR;
+const xdgDataDirectories = (env.XDG_DATA_DIRS || "/usr/local/share/:/usr/share/").split(":");
+if (xdgData) xdgDataDirectories.unshift(xdgData);
+const xdgConfigDirectories = (env.XDG_CONFIG_DIRS || "/etc/xdg").split(":");
+if (xdgConfig) xdgConfigDirectories.unshift(xdgConfig);
+const DEFAULT_RECENT_DAYS = 3;
+const BLOCKS_WARNING_THRESHOLD = .8;
+const BLOCKS_COMPACT_WIDTH_THRESHOLD = 120;
+const BLOCKS_DEFAULT_TERMINAL_WIDTH = 120;
+const DEBUG_MATCH_THRESHOLD_PERCENT = .1;
+const USER_HOME_DIR = homedir();
+const XDG_CONFIG_DIR = xdgConfig ?? `${USER_HOME_DIR}/.config`;
+const DEFAULT_CLAUDE_CODE_PATH = ".claude";
+const DEFAULT_CLAUDE_CONFIG_PATH = `${XDG_CONFIG_DIR}/claude`;
+const CLAUDE_CONFIG_DIR_ENV = "CLAUDE_CONFIG_DIR";
+const CLAUDE_PROJECTS_DIR_NAME = "projects";
+const USAGE_DATA_GLOB_PATTERN = "**/*.jsonl";
+const DEFAULT_REFRESH_INTERVAL_SECONDS = 1;
+const MIN_REFRESH_INTERVAL_SECONDS = 1;
+const MAX_REFRESH_INTERVAL_SECONDS = 60;
+const MIN_RENDER_INTERVAL_MS = 16;
+const BURN_RATE_THRESHOLDS = {
+	HIGH: 1e3,
+	MODERATE: 500
+};
+const DEFAULT_CONTEXT_USAGE_THRESHOLDS = {
+	LOW: 50,
+	MEDIUM: 80
+};
+const WEEK_DAYS = [
+	"sunday",
+	"monday",
+	"tuesday",
+	"wednesday",
+	"thursday",
+	"friday",
+	"saturday"
+];
+const CONFIG_FILE_NAME = "ccusage.json";
+const DEFAULT_LOCALE = "en-CA";
+var castComparer = function(comparer) {
+	return function(a$1, b$1, order) {
+		return comparer(a$1, b$1, 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$1, b$1) {
+		var valA;
+		var valB;
+		if (typeof sortBy === "string") {
+			valA = a$1[sortBy];
+			valB = b$1[sortBy];
+		} else if (typeof sortBy === "function") {
+			valA = sortBy(a$1);
+			valB = sortBy(b$1);
+		} else {
+			var objectSorterConfig = unpackObjectSorter(sortBy);
+			return multiPropertySorter(objectSorterConfig.sortBy, sortByArr, depth$1, objectSorterConfig.order, objectSorterConfig.comparer || defaultComparer$1, a$1, b$1);
+		}
+		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$1, b$1);
+		return equality;
+	};
+};
+function getSortStrategy(sortBy, comparer, order) {
+	if (sortBy === void 0 || sortBy === true) return function(a$1, b$1) {
+		return comparer(a$1, b$1, order);
+	};
+	if (typeof sortBy === "string") {
+		throwInvalidConfigErrorIfTrue(sortBy.includes("."), "String syntax not allowed for nested properties.");
+		return function(a$1, b$1) {
+			return comparer(a$1[sortBy], b$1[sortBy], order);
+		};
+	}
+	if (typeof sortBy === "function") return function(a$1, b$1) {
+		return comparer(sortBy(a$1), sortBy(b$1), order);
+	};
+	if (Array.isArray(sortBy)) {
+		var multiPropSorter_1 = multiPropertySorterProvider(comparer);
+		return function(a$1, b$1) {
+			return multiPropSorter_1(sortBy[0], sortBy, 1, order, comparer, a$1, b$1);
+		};
+	}
+	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$1, b$1, order) {
+	if (a$1 == null) return order;
+	if (b$1 == null) return -order;
+	if (typeof a$1 !== typeof b$1) return typeof a$1 < typeof b$1 ? -1 : 1;
+	if (a$1 < b$1) return -1;
+	if (a$1 > b$1) return 1;
+	return 0;
+};
+var sort = createNewSortInstance({ comparer: defaultComparer });
+createNewSortInstance({
+	comparer: defaultComparer,
+	inPlaceSorting: true
+});
+function _usingCtx() {
+	var r = "function" == typeof SuppressedError ? SuppressedError : function(r$1, e$1) {
+		var n$2 = Error();
+		return n$2.name = "SuppressedError", n$2.error = r$1, n$2.suppressed = e$1, n$2;
+	}, e = {}, n$1 = [];
+	function using(r$1, e$1) {
+		if (null != e$1) {
+			if (Object(e$1) !== e$1) throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");
+			if (r$1) var o = e$1[Symbol.asyncDispose || Symbol["for"]("Symbol.asyncDispose")];
+			if (void 0 === o && (o = e$1[Symbol.dispose || Symbol["for"]("Symbol.dispose")], r$1)) var t = o;
+			if ("function" != typeof o) throw new TypeError("Object is not disposable.");
+			t && (o = function o$1() {
+				try {
+					t.call(e$1);
+				} catch (r$2) {
+					return Promise.reject(r$2);
+				}
+			}), n$1.push({
+				v: e$1,
+				d: o,
+				a: r$1
+			});
+		} else r$1 && n$1.push({
+			d: e$1,
+			a: r$1
+		});
+		return e$1;
+	}
+	return {
+		e,
+		u: using.bind(null, !1),
+		a: using.bind(null, !0),
+		d: function d$1() {
+			var o, t = this.e, s = 0;
+			function next() {
+				for (; o = n$1.pop();) try {
+					if (!o.a && 1 === s) return s = 0, n$1.push(o), Promise.resolve().then(next);
+					if (o.d) {
+						var r$1 = o.d.call(o.v);
+						if (o.a) return s |= 2, Promise.resolve(r$1).then(next, err);
+					} else s |= 1;
+				} catch (r$2) {
+					return err(r$2);
+				}
+				if (1 === s) return t !== e ? Promise.reject(t) : Promise.resolve();
+				if (t !== e) throw t;
+			}
+			function err(n$2) {
+				return t = t !== e ? new r(n$2, t) : n$2, next();
+			}
+			return next();
+		}
+	};
+}
+function unreachable(value) {
+	throw new Error(`Unreachable code reached with value: ${value}`);
+}
+async function getFileModifiedTime(filePath) {
+	return pipe(try_({
+		try: stat(filePath),
+		catch: (error) => error
+	}), map((stats) => stats.mtime.getTime()), unwrap(0));
+}
+function createDateFormatter(timezone, locale) {
+	return new Intl.DateTimeFormat(locale, {
+		year: "numeric",
+		month: "2-digit",
+		day: "2-digit",
+		timeZone: timezone
+	});
+}
+function createDatePartsFormatter(timezone, locale) {
+	return new Intl.DateTimeFormat(locale, {
+		year: "numeric",
+		month: "2-digit",
+		day: "2-digit",
+		timeZone: timezone
+	});
+}
+function formatDate(dateStr, timezone, locale) {
+	const date = new Date(dateStr);
+	return createDateFormatter(timezone, locale ?? DEFAULT_LOCALE).format(date);
+}
+function formatDateCompact(dateStr, timezone, locale) {
+	const date = safeParse(dailyDateSchema, dateStr).success ? timezone != null ? /* @__PURE__ */ new Date(`${dateStr}T00:00:00Z`) : /* @__PURE__ */ new Date(`${dateStr}T00:00:00`) : new Date(dateStr);
+	const parts = createDatePartsFormatter(timezone, locale).formatToParts(date);
+	const year = parts.find((p) => p.type === "year")?.value ?? "";
+	const month = parts.find((p) => p.type === "month")?.value ?? "";
+	const day = parts.find((p) => p.type === "day")?.value ?? "";
+	return `${year}\n${month}-${day}`;
+}
+function sortByDate(items, getDate, order = "desc") {
+	const sorted = sort(items);
+	switch (order) {
+		case "desc": return sorted.desc((item) => new Date(getDate(item)).getTime());
+		case "asc": return sorted.asc((item) => new Date(getDate(item)).getTime());
+		default: unreachable(order);
+	}
+}
+function filterByDateRange(items, getDate, since, until) {
+	if (since == null && until == null) return items;
+	return items.filter((item) => {
+		const dateStr = getDate(item).substring(0, 10).replace(/-/g, "");
+		if (since != null && dateStr < since) return false;
+		if (until != null && dateStr > until) return false;
+		return true;
+	});
+}
+function getDateWeek(date, startDay) {
+	const d$1 = new Date(date);
+	const shift = (d$1.getDay() - startDay + 7) % 7;
+	d$1.setDate(d$1.getDate() - shift);
+	return createWeeklyDate(d$1.toISOString().substring(0, 10));
+}
+function getDayNumber(day) {
+	return {
+		sunday: 0,
+		monday: 1,
+		tuesday: 2,
+		wednesday: 3,
+		thursday: 4,
+		friday: 5,
+		saturday: 6
+	}[day];
+}
+const LITELLM_PRICING_URL = "https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json";
+const DEFAULT_TIERED_THRESHOLD = 2e5;
+const liteLLMModelPricingSchema = object({
+	input_cost_per_token: optional(number()),
+	output_cost_per_token: optional(number()),
+	cache_creation_input_token_cost: optional(number()),
+	cache_read_input_token_cost: optional(number()),
+	max_tokens: optional(number()),
+	max_input_tokens: optional(number()),
+	max_output_tokens: optional(number()),
+	input_cost_per_token_above_200k_tokens: optional(number()),
+	output_cost_per_token_above_200k_tokens: optional(number()),
+	cache_creation_input_token_cost_above_200k_tokens: optional(number()),
+	cache_read_input_token_cost_above_200k_tokens: optional(number()),
+	input_cost_per_token_above_128k_tokens: optional(number()),
+	output_cost_per_token_above_128k_tokens: optional(number())
+});
+const DEFAULT_PROVIDER_PREFIXES = [
+	"anthropic/",
+	"claude-3-5-",
+	"claude-3-",
+	"claude-",
+	"openai/",
+	"azure/",
+	"openrouter/openai/"
+];
+function createLogger(logger$1) {
+	if (logger$1 != null) return logger$1;
+	return {
+		debug: () => {},
+		error: () => {},
+		info: () => {},
+		warn: () => {}
+	};
+}
+var LiteLLMPricingFetcher = class {
+	cachedPricing = null;
+	logger;
+	offline;
+	offlineLoader;
+	url;
+	providerPrefixes;
+	constructor(options = {}) {
+		this.logger = createLogger(options.logger);
+		this.offline = Boolean(options.offline);
+		this.offlineLoader = options.offlineLoader;
+		this.url = options.url ?? LITELLM_PRICING_URL;
+		this.providerPrefixes = options.providerPrefixes ?? DEFAULT_PROVIDER_PREFIXES;
+	}
+	[Symbol.dispose]() {
+		this.clearCache();
+	}
+	clearCache() {
+		this.cachedPricing = null;
+	}
+	loadOfflinePricing = try_({
+		try: async () => {
+			if (this.offlineLoader == null) throw new Error("Offline loader was not provided");
+			const pricing = new Map(Object.entries(await this.offlineLoader()));
+			this.cachedPricing = pricing;
+			return pricing;
+		},
+		catch: (error) => new Error("Failed to load offline pricing data", { cause: error })
+	});
+	async handleFallbackToCachedPricing(originalError) {
+		this.logger.warn("Failed to fetch model pricing from LiteLLM, falling back to cached pricing data");
+		this.logger.debug("Fetch error details:", originalError);
+		return pipe(this.loadOfflinePricing(), inspect((pricing) => {
+			this.logger.info(`Using cached pricing data for ${pricing.size} models`);
+		}), inspectError((error) => {
+			this.logger.error("Failed to load cached pricing data as fallback:", error);
+			this.logger.error("Original fetch error:", originalError);
+		}));
+	}
+	async ensurePricingLoaded() {
+		return pipe(this.cachedPricing != null ? succeed(this.cachedPricing) : fail(/* @__PURE__ */ new Error("Cached pricing not available")), orElse(async () => {
+			if (this.offline) return this.loadOfflinePricing();
+			this.logger.warn("Fetching latest model pricing from LiteLLM...");
+			return pipe(try_({
+				try: fetch(this.url),
+				catch: (error) => new Error("Failed to fetch model pricing from LiteLLM", { cause: error })
+			}), andThrough((response) => {
+				if (!response.ok) return fail(/* @__PURE__ */ new Error(`Failed to fetch pricing data: ${response.statusText}`));
+				return succeed();
+			}), andThen(async (response) => try_({
+				try: response.json(),
+				catch: (error) => new Error("Failed to parse pricing data", { cause: error })
+			})), map((data) => {
+				const pricing = /* @__PURE__ */ new Map();
+				for (const [modelName, modelData] of Object.entries(data)) {
+					if (typeof modelData !== "object" || modelData == null) continue;
+					const parsed = safeParse(liteLLMModelPricingSchema, modelData);
+					if (!parsed.success) continue;
+					pricing.set(modelName, parsed.output);
+				}
+				return pricing;
+			}), inspect((pricing) => {
+				this.cachedPricing = pricing;
+				this.logger.info(`Loaded pricing for ${pricing.size} models`);
+			}), orElse(async (error) => this.handleFallbackToCachedPricing(error)));
+		}));
+	}
+	async fetchModelPricing() {
+		return this.ensurePricingLoaded();
+	}
+	createMatchingCandidates(modelName) {
+		const candidates = /* @__PURE__ */ new Set();
+		candidates.add(modelName);
+		for (const prefix of this.providerPrefixes) candidates.add(`${prefix}${modelName}`);
+		return Array.from(candidates);
+	}
+	async getModelPricing(modelName) {
+		return pipe(this.ensurePricingLoaded(), map((pricing) => {
+			for (const candidate of this.createMatchingCandidates(modelName)) {
+				const direct = pricing.get(candidate);
+				if (direct != null) return direct;
+			}
+			const lower = modelName.toLowerCase();
+			for (const [key, value] of pricing) {
+				const comparison = key.toLowerCase();
+				if (comparison.includes(lower) || lower.includes(comparison)) return value;
+			}
+			return null;
+		}));
+	}
+	async getModelContextLimit(modelName) {
+		return pipe(this.getModelPricing(modelName), map((pricing) => pricing?.max_input_tokens ?? null));
+	}
+	calculateCostFromPricing(tokens, pricing) {
+		const calculateTieredCost = (totalTokens, basePrice, tieredPrice, threshold = DEFAULT_TIERED_THRESHOLD) => {
+			if (totalTokens == null || totalTokens <= 0) return 0;
+			if (totalTokens > threshold && tieredPrice != null) {
+				const tokensBelowThreshold = Math.min(totalTokens, threshold);
+				let tieredCost = Math.max(0, totalTokens - threshold) * tieredPrice;
+				if (basePrice != null) tieredCost += tokensBelowThreshold * basePrice;
+				return tieredCost;
+			}
+			if (basePrice != null) return totalTokens * basePrice;
+			return 0;
+		};
+		const inputCost = calculateTieredCost(tokens.input_tokens, pricing.input_cost_per_token, pricing.input_cost_per_token_above_200k_tokens);
+		const outputCost = calculateTieredCost(tokens.output_tokens, pricing.output_cost_per_token, pricing.output_cost_per_token_above_200k_tokens);
+		const cacheCreationCost = calculateTieredCost(tokens.cache_creation_input_tokens, pricing.cache_creation_input_token_cost, pricing.cache_creation_input_token_cost_above_200k_tokens);
+		const cacheReadCost = calculateTieredCost(tokens.cache_read_input_tokens, pricing.cache_read_input_token_cost, pricing.cache_read_input_token_cost_above_200k_tokens);
+		return inputCost + outputCost + cacheCreationCost + cacheReadCost;
+	}
+	async calculateCostFromTokens(tokens, modelName) {
+		if (modelName == null || modelName === "") return succeed(0);
+		return pipe(this.getModelPricing(modelName), andThen((pricing) => {
+			if (pricing == null) return fail(/* @__PURE__ */ new Error(`Model pricing not found for ${modelName}`));
+			return succeed(this.calculateCostFromPricing(tokens, pricing));
+		}));
+	}
+};
+function createPricingDataset() {
+	return Object.create(null);
+}
+async function fetchLiteLLMPricingDataset() {
+	const response = await fetch(LITELLM_PRICING_URL);
+	if (!response.ok) throw new Error(`Failed to fetch pricing data: ${response.status} ${response.statusText}`);
+	const rawDataset = await response.json();
+	const dataset = createPricingDataset();
+	for (const [modelName, modelData] of Object.entries(rawDataset)) {
+		if (modelData == null || typeof modelData !== "object") continue;
+		const parsed = safeParse(liteLLMModelPricingSchema, modelData);
+		if (!parsed.success) continue;
+		dataset[modelName] = parsed.output;
+	}
+	return dataset;
+}
+function filterPricingDataset(dataset, predicate) {
+	const filtered = createPricingDataset();
+	for (const [modelName, pricing] of Object.entries(dataset)) if (predicate(modelName, pricing)) filtered[modelName] = pricing;
+	return filtered;
+}
+function isClaudeModel(modelName, _pricing) {
+	return modelName.startsWith("claude-");
+}
+async function prefetchClaudePricing() {
+	if (process$1.env.OFFLINE === "true") return createPricingDataset();
+	try {
+		const dataset = await fetchLiteLLMPricingDataset();
+		return filterPricingDataset(dataset, isClaudeModel);
+	} catch (error) {
+		console.warn("Failed to prefetch Claude pricing data, proceeding with empty cache.", error);
+		return createPricingDataset();
+	}
+}
+const CLAUDE_PROVIDER_PREFIXES = [
+	"anthropic/",
+	"claude-3-5-",
+	"claude-3-",
+	"claude-",
+	"openrouter/openai/"
+];
+const PREFETCHED_CLAUDE_PRICING = prefetchClaudePricing();
+var PricingFetcher = class extends LiteLLMPricingFetcher {
+	constructor(offline = false) {
+		super({
+			offline,
+			offlineLoader: async () => PREFETCHED_CLAUDE_PRICING,
+			logger,
+			providerPrefixes: CLAUDE_PROVIDER_PREFIXES
+		});
+	}
+};
+const DEFAULT_SESSION_DURATION_HOURS = 5;
+function floorToHour(timestamp) {
+	const floored = new Date(timestamp);
+	floored.setUTCMinutes(0, 0, 0);
+	return floored;
+}
+function identifySessionBlocks(entries, sessionDurationHours = DEFAULT_SESSION_DURATION_HOURS) {
+	if (entries.length === 0) return [];
+	const sessionDurationMs = sessionDurationHours * 60 * 60 * 1e3;
+	const blocks = [];
+	const sortedEntries = [...entries].sort((a$1, b$1) => a$1.timestamp.getTime() - b$1.timestamp.getTime());
+	let currentBlockStart = null;
+	let currentBlockEntries = [];
+	const now = /* @__PURE__ */ new Date();
+	for (const entry of sortedEntries) {
+		const entryTime = entry.timestamp;
+		if (currentBlockStart == null) {
+			currentBlockStart = floorToHour(entryTime);
+			currentBlockEntries = [entry];
+		} else {
+			const timeSinceBlockStart = entryTime.getTime() - currentBlockStart.getTime();
+			const lastEntry = currentBlockEntries.at(-1);
+			if (lastEntry == null) continue;
+			const lastEntryTime = lastEntry.timestamp;
+			const timeSinceLastEntry = entryTime.getTime() - lastEntryTime.getTime();
+			if (timeSinceBlockStart > sessionDurationMs || timeSinceLastEntry > sessionDurationMs) {
+				const block = createBlock(currentBlockStart, currentBlockEntries, now, sessionDurationMs);
+				blocks.push(block);
+				if (timeSinceLastEntry > sessionDurationMs) {
+					const gapBlock = createGapBlock(lastEntryTime, entryTime, sessionDurationMs);
+					if (gapBlock != null) blocks.push(gapBlock);
+				}
+				currentBlockStart = floorToHour(entryTime);
+				currentBlockEntries = [entry];
+			} else currentBlockEntries.push(entry);
+		}
+	}
+	if (currentBlockStart != null && currentBlockEntries.length > 0) {
+		const block = createBlock(currentBlockStart, currentBlockEntries, now, sessionDurationMs);
+		blocks.push(block);
+	}
+	return blocks;
+}
+function createBlock(startTime, entries, now, sessionDurationMs) {
+	const endTime = new Date(startTime.getTime() + sessionDurationMs);
+	const lastEntry = entries[entries.length - 1];
+	const actualEndTime = lastEntry != null ? lastEntry.timestamp : startTime;
+	const isActive = now.getTime() - actualEndTime.getTime() < sessionDurationMs && now < endTime;
+	const tokenCounts = {
+		inputTokens: 0,
+		outputTokens: 0,
+		cacheCreationInputTokens: 0,
+		cacheReadInputTokens: 0
+	};
+	let costUSD = 0;
+	const models = [];
+	let usageLimitResetTime;
+	for (const entry of entries) {
+		tokenCounts.inputTokens += entry.usage.inputTokens;
+		tokenCounts.outputTokens += entry.usage.outputTokens;
+		tokenCounts.cacheCreationInputTokens += entry.usage.cacheCreationInputTokens;
+		tokenCounts.cacheReadInputTokens += entry.usage.cacheReadInputTokens;
+		costUSD += entry.costUSD ?? 0;
+		usageLimitResetTime = entry.usageLimitResetTime ?? usageLimitResetTime;
+		models.push(entry.model);
+	}
+	return {
+		id: startTime.toISOString(),
+		startTime,
+		endTime,
+		actualEndTime,
+		isActive,
+		entries,
+		tokenCounts,
+		costUSD,
+		models: uniq(models),
+		usageLimitResetTime
+	};
+}
+function createGapBlock(lastActivityTime, nextActivityTime, sessionDurationMs) {
+	if (nextActivityTime.getTime() - lastActivityTime.getTime() <= sessionDurationMs) return null;
+	const gapStart = new Date(lastActivityTime.getTime() + sessionDurationMs);
+	const gapEnd = nextActivityTime;
+	return {
+		id: `gap-${gapStart.toISOString()}`,
+		startTime: gapStart,
+		endTime: gapEnd,
+		isActive: false,
+		isGap: true,
+		entries: [],
+		tokenCounts: {
+			inputTokens: 0,
+			outputTokens: 0,
+			cacheCreationInputTokens: 0,
+			cacheReadInputTokens: 0
+		},
+		costUSD: 0,
+		models: []
+	};
+}
+function calculateBurnRate(block) {
+	if (block.entries.length === 0 || (block.isGap ?? false)) return null;
+	const firstEntryData = block.entries[0];
+	const lastEntryData = block.entries[block.entries.length - 1];
+	if (firstEntryData == null || lastEntryData == null) return null;
+	const firstEntry = firstEntryData.timestamp;
+	const durationMinutes = (lastEntryData.timestamp.getTime() - firstEntry.getTime()) / (1e3 * 60);
+	if (durationMinutes <= 0) return null;
+	const tokensPerMinute = getTotalTokens(block.tokenCounts) / durationMinutes;
+	const tokensPerMinuteForIndicator = ((block.tokenCounts.inputTokens ?? 0) + (block.tokenCounts.outputTokens ?? 0)) / durationMinutes;
+	const costPerHour = block.costUSD / durationMinutes * 60;
+	return {
+		tokensPerMinute,
+		tokensPerMinuteForIndicator,
+		costPerHour
+	};
+}
+function projectBlockUsage(block) {
+	if (!block.isActive || (block.isGap ?? false)) return null;
+	const burnRate = calculateBurnRate(block);
+	if (burnRate == null) return null;
+	const now = /* @__PURE__ */ new Date();
+	const remainingTime = block.endTime.getTime() - now.getTime();
+	const remainingMinutes = Math.max(0, remainingTime / (1e3 * 60));
+	const currentTokens = getTotalTokens(block.tokenCounts);
+	const projectedAdditionalTokens = burnRate.tokensPerMinute * remainingMinutes;
+	const totalTokens = currentTokens + projectedAdditionalTokens;
+	const projectedAdditionalCost = burnRate.costPerHour / 60 * remainingMinutes;
+	const totalCost = block.costUSD + projectedAdditionalCost;
+	return {
+		totalTokens: Math.round(totalTokens),
+		totalCost: Math.round(totalCost * 100) / 100,
+		remainingMinutes: Math.round(remainingMinutes)
+	};
+}
+function filterRecentBlocks(blocks, days = DEFAULT_RECENT_DAYS) {
+	const now = /* @__PURE__ */ new Date();
+	const cutoffTime = /* @__PURE__ */ new Date(now.getTime() - days * 24 * 60 * 60 * 1e3);
+	return blocks.filter((block) => {
+		return block.startTime >= cutoffTime || block.isActive;
+	});
+}
+function getClaudePaths() {
+	const paths = [];
+	const normalizedPaths = /* @__PURE__ */ new Set();
+	const envPaths = (process$1.env[CLAUDE_CONFIG_DIR_ENV] ?? "").trim();
+	if (envPaths !== "") {
+		const envPathList = envPaths.split(",").map((p) => p.trim()).filter((p) => p !== "");
+		for (const envPath of envPathList) {
+			const normalizedPath = path.resolve(envPath);
+			if (isDirectorySync(normalizedPath)) {
+				const projectsPath = path.join(normalizedPath, CLAUDE_PROJECTS_DIR_NAME);
+				if (isDirectorySync(projectsPath)) {
+					if (!normalizedPaths.has(normalizedPath)) {
+						normalizedPaths.add(normalizedPath);
+						paths.push(normalizedPath);
+					}
+				}
+			}
+		}
+		if (paths.length > 0) return paths;
+		throw new Error(`No valid Claude data directories found in CLAUDE_CONFIG_DIR. Please ensure the following exists:
+- ${envPaths}/${CLAUDE_PROJECTS_DIR_NAME}`.trim());
+	}
+	const defaultPaths = [DEFAULT_CLAUDE_CONFIG_PATH, path.join(USER_HOME_DIR, DEFAULT_CLAUDE_CODE_PATH)];
+	for (const defaultPath of defaultPaths) {
+		const normalizedPath = path.resolve(defaultPath);
+		if (isDirectorySync(normalizedPath)) {
+			const projectsPath = path.join(normalizedPath, CLAUDE_PROJECTS_DIR_NAME);
+			if (isDirectorySync(projectsPath)) {
+				if (!normalizedPaths.has(normalizedPath)) {
+					normalizedPaths.add(normalizedPath);
+					paths.push(normalizedPath);
+				}
+			}
+		}
+	}
+	if (paths.length === 0) throw new Error(`No valid Claude data directories found. Please ensure at least one of the following exists:
+- ${path.join(DEFAULT_CLAUDE_CONFIG_PATH, CLAUDE_PROJECTS_DIR_NAME)}
+- ${path.join(USER_HOME_DIR, DEFAULT_CLAUDE_CODE_PATH, CLAUDE_PROJECTS_DIR_NAME)}
+- Or set ${CLAUDE_CONFIG_DIR_ENV} environment variable to valid directory path(s) containing a '${CLAUDE_PROJECTS_DIR_NAME}' subdirectory`.trim());
+	return paths;
+}
+function extractProjectFromPath(jsonlPath) {
+	const segments = jsonlPath.replace(/[/\\]/g, path.sep).split(path.sep);
+	const projectsIndex = segments.findIndex((segment) => segment === CLAUDE_PROJECTS_DIR_NAME);
+	if (projectsIndex === -1 || projectsIndex + 1 >= segments.length) return "unknown";
+	const projectName = segments[projectsIndex + 1];
+	return projectName != null && projectName.trim() !== "" ? projectName : "unknown";
+}
+const usageDataSchema = object({
+	cwd: optional(string()),
+	sessionId: optional(sessionIdSchema),
+	timestamp: isoTimestampSchema,
+	version: optional(versionSchema),
+	message: object({
+		usage: object({
+			input_tokens: number(),
+			output_tokens: number(),
+			cache_creation_input_tokens: optional(number()),
+			cache_read_input_tokens: optional(number())
+		}),
+		model: optional(modelNameSchema),
+		id: optional(messageIdSchema),
+		content: optional(array(object({ text: optional(string()) })))
+	}),
+	costUSD: optional(number()),
+	requestId: optional(requestIdSchema),
+	isApiErrorMessage: optional(boolean())
+});
+const transcriptUsageSchema = object({
+	input_tokens: optional(number()),
+	cache_creation_input_tokens: optional(number()),
+	cache_read_input_tokens: optional(number()),
+	output_tokens: optional(number())
+});
+const transcriptMessageSchema = object({
+	type: optional(string()),
+	message: optional(object({ usage: optional(transcriptUsageSchema) }))
+});
+const modelBreakdownSchema = object({
+	modelName: modelNameSchema,
+	inputTokens: number(),
+	outputTokens: number(),
+	cacheCreationTokens: number(),
+	cacheReadTokens: number(),
+	cost: number()
+});
+const dailyUsageSchema = object({
+	date: dailyDateSchema,
+	inputTokens: number(),
+	outputTokens: number(),
+	cacheCreationTokens: number(),
+	cacheReadTokens: number(),
+	totalCost: number(),
+	modelsUsed: array(modelNameSchema),
+	modelBreakdowns: array(modelBreakdownSchema),
+	project: optional(string())
+});
+const sessionUsageSchema = object({
+	sessionId: sessionIdSchema,
+	projectPath: projectPathSchema,
+	inputTokens: number(),
+	outputTokens: number(),
+	cacheCreationTokens: number(),
+	cacheReadTokens: number(),
+	totalCost: number(),
+	lastActivity: activityDateSchema,
+	versions: array(versionSchema),
+	modelsUsed: array(modelNameSchema),
+	modelBreakdowns: array(modelBreakdownSchema)
+});
+const monthlyUsageSchema = object({
+	month: monthlyDateSchema,
+	inputTokens: number(),
+	outputTokens: number(),
+	cacheCreationTokens: number(),
+	cacheReadTokens: number(),
+	totalCost: number(),
+	modelsUsed: array(modelNameSchema),
+	modelBreakdowns: array(modelBreakdownSchema),
+	project: optional(string())
+});
+const weeklyUsageSchema = object({
+	week: weeklyDateSchema,
+	inputTokens: number(),
+	outputTokens: number(),
+	cacheCreationTokens: number(),
+	cacheReadTokens: number(),
+	totalCost: number(),
+	modelsUsed: array(modelNameSchema),
+	modelBreakdowns: array(modelBreakdownSchema),
+	project: optional(string())
+});
+const bucketUsageSchema = object({
+	bucket: union([weeklyDateSchema, monthlyDateSchema]),
+	inputTokens: number(),
+	outputTokens: number(),
+	cacheCreationTokens: number(),
+	cacheReadTokens: number(),
+	totalCost: number(),
+	modelsUsed: array(modelNameSchema),
+	modelBreakdowns: array(modelBreakdownSchema),
+	project: optional(string())
+});
+function aggregateByModel(entries, getModel, getUsage, getCost) {
+	const modelAggregates = /* @__PURE__ */ new Map();
+	const defaultStats = {
+		inputTokens: 0,
+		outputTokens: 0,
+		cacheCreationTokens: 0,
+		cacheReadTokens: 0,
+		cost: 0
+	};
+	for (const entry of entries) {
+		const modelName = getModel(entry) ?? "unknown";
+		if (modelName === "<synthetic>") continue;
+		const usage = getUsage(entry);
+		const cost = getCost(entry);
+		const existing = modelAggregates.get(modelName) ?? defaultStats;
+		modelAggregates.set(modelName, {
+			inputTokens: existing.inputTokens + (usage.input_tokens ?? 0),
+			outputTokens: existing.outputTokens + (usage.output_tokens ?? 0),
+			cacheCreationTokens: existing.cacheCreationTokens + (usage.cache_creation_input_tokens ?? 0),
+			cacheReadTokens: existing.cacheReadTokens + (usage.cache_read_input_tokens ?? 0),
+			cost: existing.cost + cost
+		});
+	}
+	return modelAggregates;
+}
+function aggregateModelBreakdowns(breakdowns) {
+	const modelAggregates = /* @__PURE__ */ new Map();
+	const defaultStats = {
+		inputTokens: 0,
+		outputTokens: 0,
+		cacheCreationTokens: 0,
+		cacheReadTokens: 0,
+		cost: 0
+	};
+	for (const breakdown of breakdowns) {
+		if (breakdown.modelName === "<synthetic>") continue;
+		const existing = modelAggregates.get(breakdown.modelName) ?? defaultStats;
+		modelAggregates.set(breakdown.modelName, {
+			inputTokens: existing.inputTokens + breakdown.inputTokens,
+			outputTokens: existing.outputTokens + breakdown.outputTokens,
+			cacheCreationTokens: existing.cacheCreationTokens + breakdown.cacheCreationTokens,
+			cacheReadTokens: existing.cacheReadTokens + breakdown.cacheReadTokens,
+			cost: existing.cost + breakdown.cost
+		});
+	}
+	return modelAggregates;
+}
+function createModelBreakdowns(modelAggregates) {
+	return Array.from(modelAggregates.entries()).map(([modelName, stats]) => ({
+		modelName,
+		...stats
+	})).sort((a$1, b$1) => b$1.cost - a$1.cost);
+}
+function calculateTotals(entries, getUsage, getCost) {
+	return entries.reduce((acc, entry) => {
+		const usage = getUsage(entry);
+		const cost = getCost(entry);
+		return {
+			inputTokens: acc.inputTokens + (usage.input_tokens ?? 0),
+			outputTokens: acc.outputTokens + (usage.output_tokens ?? 0),
+			cacheCreationTokens: acc.cacheCreationTokens + (usage.cache_creation_input_tokens ?? 0),
+			cacheReadTokens: acc.cacheReadTokens + (usage.cache_read_input_tokens ?? 0),
+			cost: acc.cost + cost,
+			totalCost: acc.totalCost + cost
+		};
+	}, {
+		inputTokens: 0,
+		outputTokens: 0,
+		cacheCreationTokens: 0,
+		cacheReadTokens: 0,
+		cost: 0,
+		totalCost: 0
+	});
+}
+function filterByProject(items, getProject, projectFilter) {
+	if (projectFilter == null) return items;
+	return items.filter((item) => {
+		return getProject(item) === projectFilter;
+	});
+}
+function isDuplicateEntry(uniqueHash, processedHashes) {
+	if (uniqueHash == null) return false;
+	return processedHashes.has(uniqueHash);
+}
+function markAsProcessed(uniqueHash, processedHashes) {
+	if (uniqueHash != null) processedHashes.add(uniqueHash);
+}
+function extractUniqueModels(entries, getModel) {
+	return uniq(entries.map(getModel).filter((m$1) => m$1 != null && m$1 !== "<synthetic>"));
+}
+function createUniqueHash(data) {
+	const messageId = data.message.id;
+	const requestId = data.requestId;
+	if (messageId == null || requestId == null) return null;
+	return `${messageId}:${requestId}`;
+}
+async function getEarliestTimestamp(filePath) {
+	try {
+		const lines = (await readFile(filePath, "utf-8")).trim().split("\n");
+		let earliestDate = null;
+		for (const line of lines) {
+			if (line.trim() === "") continue;
+			try {
+				const json = JSON.parse(line);
+				if (json.timestamp != null && typeof json.timestamp === "string") {
+					const date = new Date(json.timestamp);
+					if (!Number.isNaN(date.getTime())) {
+						if (earliestDate == null || date < earliestDate) earliestDate = date;
+					}
+				}
+			} catch {
+				continue;
+			}
+		}
+		return earliestDate;
+	} catch (error) {
+		logger.debug(`Failed to get earliest timestamp for ${filePath}:`, error);
+		return null;
+	}
+}
+async function sortFilesByTimestamp(files) {
+	return (await Promise.all(files.map(async (file) => ({
+		file,
+		timestamp: await getEarliestTimestamp(file)
+	})))).sort((a$1, b$1) => {
+		if (a$1.timestamp == null && b$1.timestamp == null) return 0;
+		if (a$1.timestamp == null) return 1;
+		if (b$1.timestamp == null) return -1;
+		return a$1.timestamp.getTime() - b$1.timestamp.getTime();
+	}).map((item) => item.file);
+}
+async function calculateCostForEntry(data, mode, fetcher) {
+	if (mode === "display") return data.costUSD ?? 0;
+	if (mode === "calculate") {
+		if (data.message.model != null) return unwrap(fetcher.calculateCostFromTokens(data.message.usage, data.message.model), 0);
+		return 0;
+	}
+	if (mode === "auto") {
+		if (data.costUSD != null) return data.costUSD;
+		if (data.message.model != null) return unwrap(fetcher.calculateCostFromTokens(data.message.usage, data.message.model), 0);
+		return 0;
+	}
+	unreachable(mode);
+}
+function getUsageLimitResetTime(data) {
+	let resetTime = null;
+	if (data.isApiErrorMessage === true) {
+		const timestampMatch = data.message?.content?.find((c) => c.text != null && c.text.includes("Claude AI usage limit reached"))?.text?.match(/\|(\d+)/) ?? null;
+		if (timestampMatch?.[1] != null) {
+			const resetTimestamp = Number.parseInt(timestampMatch[1]);
+			resetTime = resetTimestamp > 0 ? /* @__PURE__ */ new Date(resetTimestamp * 1e3) : null;
+		}
+	}
+	return resetTime;
+}
+async function globUsageFiles(claudePaths) {
+	const filePromises = claudePaths.map(async (claudePath) => {
+		const claudeDir = path.join(claudePath, CLAUDE_PROJECTS_DIR_NAME);
+		return (await glob([USAGE_DATA_GLOB_PATTERN], {
+			cwd: claudeDir,
+			absolute: true
+		}).catch(() => [])).map((file) => ({
+			file,
+			baseDir: claudeDir
+		}));
+	});
+	return (await Promise.all(filePromises)).flat();
+}
+async function loadDailyUsageData(options) {
+	try {
+		var _usingCtx$1 = _usingCtx();
+		const claudePaths = toArray(options?.claudePath ?? getClaudePaths());
+		const fileList = (await globUsageFiles(claudePaths)).map((f$1) => f$1.file);
+		if (fileList.length === 0) return [];
+		const projectFilteredFiles = filterByProject(fileList, (filePath) => extractProjectFromPath(filePath), options?.project);
+		const sortedFiles = await sortFilesByTimestamp(projectFilteredFiles);
+		const mode = options?.mode ?? "auto";
+		const fetcher = _usingCtx$1.u(mode === "display" ? null : new PricingFetcher(options?.offline));
+		const processedHashes = /* @__PURE__ */ new Set();
+		const allEntries = [];
+		for (const file of sortedFiles) {
+			const lines = (await readFile(file, "utf-8")).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 uniqueHash = createUniqueHash(data);
+				if (isDuplicateEntry(uniqueHash, processedHashes)) continue;
+				markAsProcessed(uniqueHash, processedHashes);
+				const date = formatDate(data.timestamp, options?.timezone, DEFAULT_LOCALE);
+				const cost = fetcher != null ? await calculateCostForEntry(data, mode, fetcher) : data.costUSD ?? 0;
+				const project = extractProjectFromPath(file);
+				allEntries.push({
+					data,
+					date,
+					cost,
+					model: data.message.model,
+					project
+				});
+			} catch {}
+		}
+		const groupingKey = options?.groupByProject === true || options?.project != null ? (entry) => `${entry.date}\x00${entry.project}` : (entry) => entry.date;
+		const groupedData = groupBy(allEntries, groupingKey);
+		const results = Object.entries(groupedData).map(([groupKey, entries]) => {
+			if (entries == null) return;
+			const parts = groupKey.split("\0");
+			const date = parts[0] ?? groupKey;
+			const project = parts.length > 1 ? parts[1] : void 0;
+			const modelAggregates = aggregateByModel(entries, (entry) => entry.model, (entry) => entry.data.message.usage, (entry) => entry.cost);
+			const modelBreakdowns = createModelBreakdowns(modelAggregates);
+			const totals = calculateTotals(entries, (entry) => entry.data.message.usage, (entry) => entry.cost);
+			const modelsUsed = extractUniqueModels(entries, (e) => e.model);
+			return {
+				date: createDailyDate(date),
+				...totals,
+				modelsUsed,
+				modelBreakdowns,
+				...project != null && { project }
+			};
+		}).filter((item) => item != null);
+		const dateFiltered = filterByDateRange(results, (item) => item.date, options?.since, options?.until);
+		const finalFiltered = filterByProject(dateFiltered, (item) => item.project, options?.project);
+		return sortByDate(finalFiltered, (item) => item.date, options?.order);
+	} catch (_) {
+		_usingCtx$1.e = _;
+	} finally {
+		_usingCtx$1.d();
+	}
+}
+async function loadSessionData(options) {
+	try {
+		var _usingCtx3 = _usingCtx();
+		const claudePaths = toArray(options?.claudePath ?? getClaudePaths());
+		const filesWithBase = await globUsageFiles(claudePaths);
+		if (filesWithBase.length === 0) return [];
+		const projectFilteredWithBase = filterByProject(filesWithBase, (item) => extractProjectFromPath(item.file), options?.project);
+		const fileToBaseMap = new Map(projectFilteredWithBase.map((f$1) => [f$1.file, f$1.baseDir]));
+		const sortedFilesWithBase = await sortFilesByTimestamp(projectFilteredWithBase.map((f$1) => f$1.file)).then((sortedFiles) => sortedFiles.map((file) => ({
+			file,
+			baseDir: fileToBaseMap.get(file) ?? ""
+		})));
+		const mode = options?.mode ?? "auto";
+		const fetcher = _usingCtx3.u(mode === "display" ? null : new PricingFetcher(options?.offline));
+		const processedHashes = /* @__PURE__ */ new Set();
+		const allEntries = [];
+		for (const { file, baseDir } of sortedFilesWithBase) {
+			const parts = path.relative(baseDir, file).split(path.sep);
+			const sessionId = parts[parts.length - 2] ?? "unknown";
+			const joinedPath = parts.slice(0, -2).join(path.sep);
+			const projectPath = joinedPath.length > 0 ? joinedPath : "Unknown Project";
+			const lines = (await readFile(file, "utf-8")).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 uniqueHash = createUniqueHash(data);
+				if (isDuplicateEntry(uniqueHash, processedHashes)) continue;
+				markAsProcessed(uniqueHash, processedHashes);
+				const sessionKey = `${projectPath}/${sessionId}`;
+				const cost = fetcher != null ? await calculateCostForEntry(data, mode, fetcher) : data.costUSD ?? 0;
+				allEntries.push({
+					data,
+					sessionKey,
+					sessionId,
+					projectPath,
+					cost,
+					timestamp: data.timestamp,
+					model: data.message.model
+				});
+			} catch {}
+		}
+		const groupedBySessions = groupBy(allEntries, (entry) => entry.sessionKey);
+		const results = Object.entries(groupedBySessions).map(([_, entries]) => {
+			if (entries == null) return;
+			const latestEntry = entries.reduce((latest, current) => current.timestamp > latest.timestamp ? current : latest);
+			const versions = [];
+			for (const entry of entries) if (entry.data.version != null) versions.push(entry.data.version);
+			const modelAggregates = aggregateByModel(entries, (entry) => entry.model, (entry) => entry.data.message.usage, (entry) => entry.cost);
+			const modelBreakdowns = createModelBreakdowns(modelAggregates);
+			const totals = calculateTotals(entries, (entry) => entry.data.message.usage, (entry) => entry.cost);
+			const modelsUsed = extractUniqueModels(entries, (e) => e.model);
+			return {
+				sessionId: createSessionId(latestEntry.sessionId),
+				projectPath: createProjectPath(latestEntry.projectPath),
+				...totals,
+				lastActivity: formatDate(latestEntry.timestamp, options?.timezone, DEFAULT_LOCALE),
+				versions: uniq(versions).sort(),
+				modelsUsed,
+				modelBreakdowns
+			};
+		}).filter((item) => item != null);
+		const dateFiltered = filterByDateRange(results, (item) => item.lastActivity, options?.since, options?.until);
+		const sessionFiltered = filterByProject(dateFiltered, (item) => item.projectPath, options?.project);
+		return sortByDate(sessionFiltered, (item) => item.lastActivity, options?.order);
+	} catch (_) {
+		_usingCtx3.e = _;
+	} finally {
+		_usingCtx3.d();
+	}
+}
+async function loadMonthlyUsageData(options) {
+	return loadBucketUsageData((data) => createMonthlyDate(data.date.slice(0, 7)), options).then((usages) => usages.map(({ bucket,...rest }) => ({
+		month: parse$2(monthlyDateSchema, bucket),
+		...rest
+	})));
+}
+async function loadWeeklyUsageData(options) {
+	const startDay = options?.startOfWeek != null ? getDayNumber(options.startOfWeek) : getDayNumber("sunday");
+	return loadBucketUsageData((data) => getDateWeek(new Date(data.date), startDay), options).then((usages) => usages.map(({ bucket,...rest }) => ({
+		week: parse$2(weeklyDateSchema, bucket),
+		...rest
+	})));
+}
+async function loadSessionUsageById(sessionId, options) {
+	try {
+		var _usingCtx4 = _usingCtx();
+		const patterns = getClaudePaths().map((p) => path.join(p, "projects", "**", `${sessionId}.jsonl`).replace(/\\/g, "/"));
+		const jsonlFiles = await glob(patterns);
+		if (jsonlFiles.length === 0) return null;
+		const file = jsonlFiles[0];
+		if (file == null) return null;
+		const lines = (await readFile(file, "utf-8")).trim().split("\n").filter((line) => line.length > 0);
+		const mode = options?.mode ?? "auto";
+		const fetcher = _usingCtx4.u(mode === "display" ? null : new PricingFetcher(options?.offline));
+		const entries = [];
+		let totalCost = 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 cost = fetcher != null ? await calculateCostForEntry(data, mode, fetcher) : data.costUSD ?? 0;
+			totalCost += cost;
+			entries.push(data);
+		} catch {}
+		return {
+			totalCost,
+			entries
+		};
+	} catch (_) {
+		_usingCtx4.e = _;
+	} finally {
+		_usingCtx4.d();
+	}
+}
+async function loadBucketUsageData(groupingFn, options) {
+	const dailyData = await loadDailyUsageData(options);
+	const groupingKey = options?.groupByProject === true || options?.project != null ? (data) => {
+		const bucketValue = groupingFn(data);
+		const projectSegment = data.project ?? "unknown";
+		return `${bucketValue}\x00${projectSegment}`;
+	} : (data) => `${groupingFn(data)}`;
+	const grouped = groupBy(dailyData, groupingKey);
+	const buckets = [];
+	for (const [groupKey, dailyEntries] of Object.entries(grouped)) {
+		if (dailyEntries == null) continue;
+		const parts = groupKey.split("\0");
+		const bucket = createBucket(parts[0] ?? groupKey);
+		const project = parts.length > 1 ? parts[1] : void 0;
+		const allBreakdowns = dailyEntries.flatMap((daily) => daily.modelBreakdowns);
+		const modelAggregates = aggregateModelBreakdowns(allBreakdowns);
+		const modelBreakdowns = createModelBreakdowns(modelAggregates);
+		const models = [];
+		for (const data of dailyEntries) for (const model of data.modelsUsed) if (model !== "<synthetic>") models.push(model);
+		let totalInputTokens = 0;
+		let totalOutputTokens = 0;
+		let totalCacheCreationTokens = 0;
+		let totalCacheReadTokens = 0;
+		let totalCost = 0;
+		for (const daily of dailyEntries) {
+			totalInputTokens += daily.inputTokens;
+			totalOutputTokens += daily.outputTokens;
+			totalCacheCreationTokens += daily.cacheCreationTokens;
+			totalCacheReadTokens += daily.cacheReadTokens;
+			totalCost += daily.totalCost;
+		}
+		const bucketUsage = {
+			bucket,
+			inputTokens: totalInputTokens,
+			outputTokens: totalOutputTokens,
+			cacheCreationTokens: totalCacheCreationTokens,
+			cacheReadTokens: totalCacheReadTokens,
+			totalCost,
+			modelsUsed: uniq(models),
+			modelBreakdowns,
+			...project != null && { project }
+		};
+		buckets.push(bucketUsage);
+	}
+	return sortByDate(buckets, (item) => item.bucket, options?.order);
+}
+async function calculateContextTokens(transcriptPath, modelId, offline = false) {
+	let content;
+	try {
+		content = await readFile(transcriptPath, "utf-8");
+	} catch (error) {
+		logger.debug(`Failed to read transcript file: ${String(error)}`);
+		return null;
+	}
+	const lines = content.split("\n").reverse();
+	for (const line of lines) {
+		const trimmedLine = line.trim();
+		if (trimmedLine === "") continue;
+		try {
+			const parsed = JSON.parse(trimmedLine);
+			const result = safeParse(transcriptMessageSchema, parsed);
+			if (!result.success) continue;
+			const obj = result.output;
+			if (obj.type === "assistant" && obj.message != null && obj.message.usage != null && obj.message.usage.input_tokens != null) {
+				const usage = obj.message.usage;
+				const inputTokens = usage.input_tokens + (usage.cache_creation_input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0);
+				let contextLimit = 2e5;
+				if (modelId != null && modelId !== "") try {
+					var _usingCtx5 = _usingCtx();
+					const contextLimitResult = await _usingCtx5.u(new PricingFetcher(offline)).getModelContextLimit(modelId);
+					if (isSuccess(contextLimitResult) && contextLimitResult.value != null) contextLimit = contextLimitResult.value;
+					else if (isSuccess(contextLimitResult)) logger.debug(`No context limit data available for model ${modelId} in LiteLLM`);
+					else logger.debug(`Failed to get context limit for model ${modelId}: ${contextLimitResult.error.message}`);
+				} catch (_) {
+					_usingCtx5.e = _;
+				} finally {
+					_usingCtx5.d();
+				}
+				const percentage = Math.min(100, Math.max(0, Math.round(inputTokens / contextLimit * 100)));
+				return {
+					inputTokens,
+					percentage,
+					contextLimit
+				};
+			}
+		} catch {
+			continue;
+		}
+	}
+	logger.debug("No usage information found in transcript");
+	return null;
+}
+async function loadSessionBlockData(options) {
+	try {
+		var _usingCtx6 = _usingCtx();
+		const claudePaths = toArray(options?.claudePath ?? getClaudePaths());
+		const allFiles = [];
+		for (const claudePath of claudePaths) {
+			const claudeDir = path.join(claudePath, CLAUDE_PROJECTS_DIR_NAME);
+			const files = await glob([USAGE_DATA_GLOB_PATTERN], {
+				cwd: claudeDir,
+				absolute: true
+			});
+			allFiles.push(...files);
+		}
+		if (allFiles.length === 0) return [];
+		const blocksFilteredFiles = filterByProject(allFiles, (filePath) => extractProjectFromPath(filePath), options?.project);
+		const sortedFiles = await sortFilesByTimestamp(blocksFilteredFiles);
+		const mode = options?.mode ?? "auto";
+		const fetcher = _usingCtx6.u(mode === "display" ? null : new PricingFetcher(options?.offline));
+		const processedHashes = /* @__PURE__ */ new Set();
+		const allEntries = [];
+		for (const file of sortedFiles) {
+			const lines = (await readFile(file, "utf-8")).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 uniqueHash = createUniqueHash(data);
+				if (isDuplicateEntry(uniqueHash, processedHashes)) continue;
+				markAsProcessed(uniqueHash, processedHashes);
+				const cost = fetcher != null ? await calculateCostForEntry(data, mode, fetcher) : data.costUSD ?? 0;
+				const usageLimitResetTime = getUsageLimitResetTime(data);
+				allEntries.push({
+					timestamp: new Date(data.timestamp),
+					usage: {
+						inputTokens: data.message.usage.input_tokens,
+						outputTokens: data.message.usage.output_tokens,
+						cacheCreationInputTokens: data.message.usage.cache_creation_input_tokens ?? 0,
+						cacheReadInputTokens: data.message.usage.cache_read_input_tokens ?? 0
+					},
+					costUSD: cost,
+					model: data.message.model ?? "unknown",
+					version: data.version,
+					usageLimitResetTime: usageLimitResetTime ?? void 0
+				});
+			} catch (error) {
+				logger.debug(`Skipping invalid JSON line in 5-hour blocks: ${error instanceof Error ? error.message : String(error)}`);
+			}
+		}
+		const blocks = identifySessionBlocks(allEntries, options?.sessionDurationHours);
+		const dateFiltered = options?.since != null && options.since !== "" || options?.until != null && options.until !== "" ? blocks.filter((block) => {
+			const blockDateStr = formatDate(block.startTime.toISOString(), options?.timezone, DEFAULT_LOCALE).replace(/-/g, "");
+			if (options.since != null && options.since !== "" && blockDateStr < options.since) return false;
+			if (options.until != null && options.until !== "" && blockDateStr > options.until) return false;
+			return true;
+		}) : blocks;
+		return sortByDate(dateFiltered, (block) => block.startTime, options?.order);
+	} catch (_) {
+		_usingCtx6.e = _;
+	} finally {
+		_usingCtx6.d();
+	}
+}
+export { BLOCKS_COMPACT_WIDTH_THRESHOLD, BLOCKS_DEFAULT_TERMINAL_WIDTH, BLOCKS_WARNING_THRESHOLD, BURN_RATE_THRESHOLDS, CLAUDE_PROJECTS_DIR_NAME, CONFIG_FILE_NAME, DEBUG_MATCH_THRESHOLD_PERCENT, DEFAULT_CONTEXT_USAGE_THRESHOLDS, DEFAULT_LOCALE, DEFAULT_RECENT_DAYS, DEFAULT_REFRESH_INTERVAL_SECONDS, DEFAULT_SESSION_DURATION_HOURS, MAX_REFRESH_INTERVAL_SECONDS, MIN_REFRESH_INTERVAL_SECONDS, MIN_RENDER_INTERVAL_MS, PricingFetcher, USAGE_DATA_GLOB_PATTERN, WEEK_DAYS, __commonJSMin, __require$1 as __require, __toESM, _usingCtx, andThen, bucketUsageSchema, calculateBurnRate, calculateContextTokens, calculateCostForEntry, createUniqueHash, dailyUsageSchema, extractProjectFromPath, fail, filterRecentBlocks, formatDateCompact, getClaudePaths, getEarliestTimestamp, getFileModifiedTime, getUsageLimitResetTime, glob, globUsageFiles, identifySessionBlocks, inspect, inspectError, isFailure, isSuccess, loadBucketUsageData, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, loadSessionUsageById, loadWeeklyUsageData, map, modelBreakdownSchema, monthlyUsageSchema, pipe, projectBlockUsage, sessionUsageSchema, sortFilesByTimestamp, succeed, toArray, transcriptMessageSchema, transcriptUsageSchema, try_, uniq, unreachable, unwrap, usageDataSchema, weeklyUsageSchema };