@voidzero-dev/vite-plus-core 0.0.0-0bfcc90f.20260209-0731

package/dist/tsdown/build-l5WhXg4M-BBPqZr0m.js

@@ -0,0 +1,4933 @@
+import { n as __exportAll, r as __toESM, t as __commonJSMin } from "./chunk-CdeBBKNj.js";
+import { C as green, S as dim, T as yellow, _ as resolveRegex, a as __exportAll$1, b as blue, c as getNameLabel, d as matchPattern, f as noop, g as resolveComma, h as promiseWithResolvers, i as LogLevels, l as globalLogger, m as prettyFormat, n as q, o as createLogger, p as pkgExists, r as version, s as generateColor, u as importWithError, v as slash, w as underline, x as bold, y as toArray } from "./main-d9yZSQqW.js";
+import { t as createDebug } from "./node-Cb5OsnKg.js";
+import { i as RE_JS, n as RE_DTS, o as RE_NODE_MODULES$1, t as RE_CSS } from "./filename-7rlgePeo.js";
+import module$1, { builtinModules, createRequire, isBuiltin } from "node:module";
+import process$1, { env } from "node:process";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import readline from "node:readline";
+import { formatWithOptions, inspect, promisify } from "node:util";
+import { VERSION, build, watch } from "@voidzero-dev/vite-plus-core/rolldown";
+import { createRequire as createRequire$1 } from "module";
+import path, { dirname, isAbsolute, join, parse, resolve } from "node:path";
+import { access, chmod, cp, mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
+import * as nativeFs$1 from "fs";
+import nativeFs from "fs";
+import path$1, { basename, dirname as dirname$1, normalize as normalize$1, posix, relative, resolve as resolve$1, sep } from "path";
+import { fileURLToPath as fileURLToPath$1 } from "url";
+import fs$1, { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { and, id, importerId, include } from "@voidzero-dev/vite-plus-core/rolldown/filter";
+import { Buffer } from "node:buffer";
+import { brotliCompress, gzip } from "node:zlib";
+import { tmpdir } from "node:os";
+import { importGlobPlugin } from "@voidzero-dev/vite-plus-core/rolldown/experimental";
+
+//#region ../../node_modules/.pnpm/tsdown@0.20.2_@arethetypeswrong+core@0.18.2_@typescript+native-preview@7.0.0-dev.202601_11c6934cad7d4cedf7999249d5905a1c/node_modules/tsdown/dist/format-BD2e_4xO.mjs
+function fsExists(path) {
+	return access(path).then(() => true, () => false);
+}
+function fsStat(path) {
+	return stat(path).catch(() => null);
+}
+function fsRemove(path) {
+	return rm(path, {
+		force: true,
+		recursive: true
+	}).catch(() => {});
+}
+function fsCopy(from, to) {
+	return cp(from, to, {
+		recursive: true,
+		force: true
+	});
+}
+function lowestCommonAncestor(...filepaths) {
+	if (filepaths.length === 0) return "";
+	if (filepaths.length === 1) return path.dirname(filepaths[0]);
+	filepaths = filepaths.map(path.normalize);
+	const [first, ...rest] = filepaths;
+	let ancestor = first.split(path.sep);
+	for (const filepath of rest) {
+		const directories = filepath.split(path.sep, ancestor.length);
+		let index = 0;
+		for (const directory of directories) if (directory === ancestor[index]) index += 1;
+		else {
+			ancestor = ancestor.slice(0, index);
+			break;
+		}
+		ancestor = ancestor.slice(0, index);
+	}
+	return ancestor.length <= 1 && ancestor[0] === "" ? path.sep + ancestor[0] : ancestor.join(path.sep);
+}
+function stripExtname(filePath) {
+	const ext = path.extname(filePath);
+	if (!ext.length) return filePath;
+	return filePath.slice(0, -ext.length);
+}
+function formatBytes(bytes) {
+	if (bytes === Infinity) return void 0;
+	return `${(bytes / 1e3).toFixed(2)} kB`;
+}
+function detectIndentation(jsonText) {
+	const lines = jsonText.split(/\r?\n/);
+	for (const line of lines) {
+		const match = line.match(/^(\s+)\S/);
+		if (!match) continue;
+		if (match[1].includes("	")) return "	";
+		return match[1].length;
+	}
+	return 2;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/defu@6.1.4/node_modules/defu/dist/defu.mjs
+function isPlainObject(value) {
+	if (value === null || typeof value !== "object") return false;
+	const prototype = Object.getPrototypeOf(value);
+	if (prototype !== null && prototype !== Object.prototype && Object.getPrototypeOf(prototype) !== null) return false;
+	if (Symbol.iterator in value) return false;
+	if (Symbol.toStringTag in value) return Object.prototype.toString.call(value) === "[object Module]";
+	return true;
+}
+function _defu(baseObject, defaults, namespace = ".", merger) {
+	if (!isPlainObject(defaults)) return _defu(baseObject, {}, namespace, merger);
+	const object = Object.assign({}, defaults);
+	for (const key in baseObject) {
+		if (key === "__proto__" || key === "constructor") continue;
+		const value = baseObject[key];
+		if (value === null || value === void 0) continue;
+		if (merger && merger(object, key, value, namespace)) continue;
+		if (Array.isArray(value) && Array.isArray(object[key])) object[key] = [...value, ...object[key]];
+		else if (isPlainObject(value) && isPlainObject(object[key])) object[key] = _defu(value, object[key], (namespace ? `${namespace}.` : "") + key.toString(), merger);
+		else object[key] = value;
+	}
+	return object;
+}
+function createDefu(merger) {
+	return (...arguments_) => arguments_.reduce((p, c) => _defu(p, c, "", merger), {});
+}
+const defu$1 = createDefu();
+const defuFn = createDefu((object, key, currentValue) => {
+	if (object[key] !== void 0 && typeof currentValue === "function") {
+		object[key] = currentValue(object[key]);
+		return true;
+	}
+});
+const defuArrayFn = createDefu((object, key, currentValue) => {
+	if (Array.isArray(object[key]) && typeof currentValue === "function") {
+		object[key] = currentValue(object[key]);
+		return true;
+	}
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/fdir@6.5.0_picomatch@4.0.3/node_modules/fdir/dist/index.mjs
+var __require$1 = /* @__PURE__ */ createRequire$1(import.meta.url);
+function cleanPath(path) {
+	let normalized = normalize$1(path);
+	if (normalized.length > 1 && normalized[normalized.length - 1] === sep) normalized = normalized.substring(0, normalized.length - 1);
+	return normalized;
+}
+const SLASHES_REGEX = /[\\/]/g;
+function convertSlashes(path, separator) {
+	return path.replace(SLASHES_REGEX, separator);
+}
+const WINDOWS_ROOT_DIR_REGEX = /^[a-z]:[\\/]$/i;
+function isRootDirectory(path) {
+	return path === "/" || WINDOWS_ROOT_DIR_REGEX.test(path);
+}
+function normalizePath(path, options) {
+	const { resolvePaths, normalizePath: normalizePath$1, pathSeparator } = options;
+	const pathNeedsCleaning = process.platform === "win32" && path.includes("/") || path.startsWith(".");
+	if (resolvePaths) path = resolve$1(path);
+	if (normalizePath$1 || pathNeedsCleaning) path = cleanPath(path);
+	if (path === ".") return "";
+	return convertSlashes(path[path.length - 1] !== pathSeparator ? path + pathSeparator : path, pathSeparator);
+}
+function joinPathWithBasePath(filename, directoryPath) {
+	return directoryPath + filename;
+}
+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 = directoryPath || ".";
+	if (filters.every((filter) => filter(path, true))) paths.push(path);
+};
+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, state, callback$1) {
+	const { queue, fs, options: { suppressErrors } } = state;
+	queue.enqueue();
+	fs.realpath(path, (error, resolvedPath) => {
+		if (error) return queue.dequeue(suppressErrors ? null : error, state);
+		fs.stat(resolvedPath, (error$1, stat) => {
+			if (error$1) return queue.dequeue(suppressErrors ? null : error$1, state);
+			if (stat.isDirectory() && isRecursive(path, resolvedPath, state)) return queue.dequeue(null, state);
+			callback$1(stat, resolvedPath);
+			queue.dequeue(null, state);
+		});
+	});
+};
+const resolveSymlinks = function(path, state, callback$1) {
+	const { queue, fs, options: { suppressErrors } } = state;
+	queue.enqueue();
+	try {
+		const resolvedPath = fs.realpathSync(path);
+		const stat = fs.statSync(resolvedPath);
+		if (stat.isDirectory() && isRecursive(path, resolvedPath, state)) return;
+		callback$1(stat, resolvedPath);
+	} catch (e) {
+		if (!suppressErrors) throw e;
+	}
+};
+function build$2(options, isSynchronous) {
+	if (!options.resolveSymlinks || options.excludeSymlinks) return null;
+	return isSynchronous ? resolveSymlinks : resolveSymlinksAsync;
+}
+function isRecursive(path, resolved, state) {
+	if (state.options.useRealPaths) return isRecursiveUsingRealPaths(resolved, state);
+	let parent = dirname$1(path);
+	let depth = 1;
+	while (parent !== state.root && depth < 2) {
+		const resolvedPath = state.symlinks.get(parent);
+		if (!!resolvedPath && (resolvedPath === resolved || resolvedPath.startsWith(resolved) || resolved.startsWith(resolvedPath))) depth++;
+		else parent = dirname$1(parent);
+	}
+	state.symlinks.set(path, resolved);
+	return depth > 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$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$8(isSynchronous) {
+	return isSynchronous ? walkSync : walkAsync;
+}
+/**
+* This is a custom stateless queue to track concurrent async fs calls.
+* It increments a counter whenever a call is queued and decrements it
+* as soon as it completes. When the counter hits 0, it calls onQueueEmpty.
+*/
+var Queue = class {
+	count = 0;
+	constructor(onQueueEmpty) {
+		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;
+	}
+	/**
+	* @deprecated use `directories` instead
+	*/
+	/* c8 ignore next 3 */
+	get dirs() {
+		return this._directories;
+	}
+};
+/**
+* AbortController is not supported on Node 14 so we use this until we can drop
+* support for Node 14.
+*/
+var Aborter = class {
+	aborted = false;
+	abort() {
+		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$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$1
+		};
+		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$8(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) => {
+		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 = joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
+				if (exclude && exclude(entry.name, path)) continue;
+				this.pushDirectory(path, paths, filters);
+				this.walkDirectory(this.state, path, path, depth - 1, this.walk);
+			} else if (this.resolveSymlink && entry.isSymbolicLink()) {
+				let path = joinPathWithBasePath(entry.name, directoryPath);
+				this.resolveSymlink(path, this.state, (stat, resolvedPath) => {
+					if (stat.isDirectory()) {
+						resolvedPath = normalizePath(resolvedPath, this.state.options);
+						if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path + pathSeparator)) return;
+						this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path + pathSeparator, depth - 1, this.walk);
+					} else {
+						resolvedPath = useRealPaths ? resolvedPath : path;
+						const filename = basename(resolvedPath);
+						const directoryPath$1 = normalizePath(dirname$1(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$1.resolve("picomatch");
+	pm = __require$1("./npm_entry_picomatch.cjs");
+} 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) {
+		this.options.maxDepth = depth;
+		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;
+	}
+	/**
+	* @deprecated Pass options using the constructor instead:
+	* ```ts
+	* new fdir(options).crawl("/path/to/root");
+	* ```
+	* This method will be removed in v7.0
+	*/
+	/* c8 ignore next 4 */
+	crawlWithOptions(root, options) {
+		this.options = {
+			...this.options,
+			...options
+		};
+		return new 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) => isMatch(path));
+		return this;
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/constants.js
+var require_constants = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const WIN_SLASH = "\\\\/";
+	const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
+	/**
+	* Posix glob regex
+	*/
+	const DOT_LITERAL = "\\.";
+	const PLUS_LITERAL = "\\+";
+	const QMARK_LITERAL = "\\?";
+	const SLASH_LITERAL = "\\/";
+	const ONE_CHAR = "(?=.)";
+	const QMARK = "[^/]";
+	const END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
+	const START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
+	const DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
+	const POSIX_CHARS = {
+		DOT_LITERAL,
+		PLUS_LITERAL,
+		QMARK_LITERAL,
+		SLASH_LITERAL,
+		ONE_CHAR,
+		QMARK,
+		END_ANCHOR,
+		DOTS_SLASH,
+		NO_DOT: `(?!${DOT_LITERAL})`,
+		NO_DOTS: `(?!${START_ANCHOR}${DOTS_SLASH})`,
+		NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`,
+		NO_DOTS_SLASH: `(?!${DOTS_SLASH})`,
+		QMARK_NO_DOT: `[^.${SLASH_LITERAL}]`,
+		STAR: `${QMARK}*?`,
+		START_ANCHOR,
+		SEP: "/"
+	};
+	/**
+	* Windows glob regex
+	*/
+	const WINDOWS_CHARS = {
+		...POSIX_CHARS,
+		SLASH_LITERAL: `[${WIN_SLASH}]`,
+		QMARK: WIN_NO_SLASH,
+		STAR: `${WIN_NO_SLASH}*?`,
+		DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,
+		NO_DOT: `(?!${DOT_LITERAL})`,
+		NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+		NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,
+		NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+		QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
+		START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
+		END_ANCHOR: `(?:[${WIN_SLASH}]|$)`,
+		SEP: "\\"
+	};
+	/**
+	* POSIX Bracket Regex
+	*/
+	const POSIX_REGEX_SOURCE = {
+		alnum: "a-zA-Z0-9",
+		alpha: "a-zA-Z",
+		ascii: "\\x00-\\x7F",
+		blank: " \\t",
+		cntrl: "\\x00-\\x1F\\x7F",
+		digit: "0-9",
+		graph: "\\x21-\\x7E",
+		lower: "a-z",
+		print: "\\x20-\\x7E ",
+		punct: "\\-!\"#$%&'()\\*+,./:;<=>?@[\\]^_`{|}~",
+		space: " \\t\\r\\n\\v\\f",
+		upper: "A-Z",
+		word: "A-Za-z0-9_",
+		xdigit: "A-Fa-f0-9"
+	};
+	module.exports = {
+		MAX_LENGTH: 1024 * 64,
+		POSIX_REGEX_SOURCE,
+		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;
+		}
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/utils.js
+var require_utils = /* @__PURE__ */ __commonJSMin(((exports) => {
+	const { REGEX_BACKSLASH, REGEX_REMOVE_BACKSLASH, REGEX_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_GLOBAL } = require_constants();
+	exports.isObject = (val) => val !== null && typeof val === "object" && !Array.isArray(val);
+	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 = {}) => {
+		let output = `${options.contains ? "" : "^"}(?:${input})${options.contains ? "" : "$"}`;
+		if (state.negated === true) output = `(?:^(?!${output}).*$)`;
+		return output;
+	};
+	exports.basename = (path, { windows } = {}) => {
+		const segs = path.split(windows ? /[\\/]/ : "/");
+		const last = segs[segs.length - 1];
+		if (last === "") return segs[segs.length - 2];
+		return last;
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/scan.js
+var require_scan = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const utils = require_utils();
+	const { CHAR_ASTERISK, CHAR_AT, CHAR_BACKWARD_SLASH, CHAR_COMMA, CHAR_DOT, CHAR_EXCLAMATION_MARK, CHAR_FORWARD_SLASH, CHAR_LEFT_CURLY_BRACE, CHAR_LEFT_PARENTHESES, CHAR_LEFT_SQUARE_BRACKET, CHAR_PLUS, CHAR_QUESTION_MARK, CHAR_RIGHT_CURLY_BRACE, CHAR_RIGHT_PARENTHESES, CHAR_RIGHT_SQUARE_BRACKET } = require_constants();
+	const isPathSeparator = (code) => {
+		return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
+	};
+	const depth = (token) => {
+		if (token.isPrefix !== true) token.depth = token.isGlobstar ? Infinity : 1;
+	};
+	/**
+	* Quickly scans a glob pattern and returns an object with a handful of
+	* useful properties, like `isGlob`, `path` (the leading non-glob, if it exists),
+	* `glob` (the actual pattern), `negated` (true if the path starts with `!` but not
+	* with `!(`) and `negatedExtglob` (true if the path starts with `!(`).
+	*
+	* ```js
+	* const pm = require('picomatch');
+	* console.log(pm.scan('foo/bar/*.js'));
+	* { isGlob: true, input: 'foo/bar/*.js', base: 'foo/bar', glob: '*.js' }
+	* ```
+	* @param {String} `str`
+	* @param {Object} `options`
+	* @return {Object} Returns an object with tokens and regex source string.
+	* @api public
+	*/
+	const scan = (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 = "";
+		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 = str.slice(lastIndex);
+		} else if (isGlob === true) {
+			base = "";
+			glob = str;
+		} else base = str;
+		if (base && base !== "" && base !== "/" && base !== str) {
+			if (isPathSeparator(base.charCodeAt(base.length - 1))) base = base.slice(0, -1);
+		}
+		if (opts.unescape === true) {
+			if (glob) glob = utils.removeBackslashes(glob);
+			if (base && backslashes === true) base = utils.removeBackslashes(base);
+		}
+		const state = {
+			prefix,
+			input,
+			start,
+			base,
+			glob,
+			isBrace,
+			isBracket,
+			isGlob,
+			isExtglob,
+			isGlobstar,
+			negated,
+			negatedExtglob
+		};
+		if (opts.tokens === true) {
+			state.maxDepth = 0;
+			if (!isPathSeparator(code)) tokens.push(token);
+			state.tokens = tokens;
+		}
+		if (opts.parts === true || opts.tokens === true) {
+			let prevIndex;
+			for (let idx = 0; idx < slashes.length; idx++) {
+				const n = prevIndex ? prevIndex + 1 : start;
+				const i = slashes[idx];
+				const value = input.slice(n, i);
+				if (opts.tokens) {
+					if (idx === 0 && start !== 0) {
+						tokens[idx].isPrefix = true;
+						tokens[idx].value = prefix;
+					} else tokens[idx].value = value;
+					depth(tokens[idx]);
+					state.maxDepth += tokens[idx].depth;
+				}
+				if (idx !== 0 || value !== "") parts.push(value);
+				prevIndex = i;
+			}
+			if (prevIndex && prevIndex + 1 < input.length) {
+				const value = input.slice(prevIndex + 1);
+				parts.push(value);
+				if (opts.tokens) {
+					tokens[tokens.length - 1].value = value;
+					depth(tokens[tokens.length - 1]);
+					state.maxDepth += tokens[tokens.length - 1].depth;
+				}
+			}
+			state.slashes = slashes;
+			state.parts = parts;
+		}
+		return state;
+	};
+	module.exports = scan;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/parse.js
+var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const constants = require_constants();
+	const utils = require_utils();
+	/**
+	* Constants
+	*/
+	const { MAX_LENGTH, POSIX_REGEX_SOURCE, REGEX_NON_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_BACKREF, REPLACEMENTS } = constants;
+	/**
+	* Helpers
+	*/
+	const expandRange = (args, options) => {
+		if (typeof options.expandRange === "function") return options.expandRange(...args, options);
+		args.sort();
+		const value = `[${args.join("-")}]`;
+		try {
+			new RegExp(value);
+		} catch (ex) {
+			return args.map((v) => utils.escapeRegex(v)).join("..");
+		}
+		return value;
+	};
+	/**
+	* Create the message for a syntax error
+	*/
+	const syntaxError = (type, char) => {
+		return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
+	};
+	/**
+	* Parse the given input string.
+	* @param {String} input
+	* @param {Object} options
+	* @return {Object}
+	*/
+	const parse = (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.globChars(opts.windows);
+		const EXTGLOB_CHARS = constants.extglobChars(PLATFORM_CHARS);
+		const { DOT_LITERAL, PLUS_LITERAL, SLASH_LITERAL, ONE_CHAR, DOTS_SLASH, NO_DOT, NO_DOT_SLASH, NO_DOTS_SLASH, QMARK, QMARK_NO_DOT, STAR, START_ANCHOR } = PLATFORM_CHARS;
+		const globstar = (opts) => {
+			return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+		};
+		const nodot = opts.dot ? "" : NO_DOT;
+		const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT;
+		let star = opts.bash === true ? globstar(opts) : STAR;
+		if (opts.capture) star = `(${star})`;
+		if (typeof opts.noext === "boolean") opts.noextglob = opts.noext;
+		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.removePrefix(input, state);
+		len = input.length;
+		const extglobs = [];
+		const braces = [];
+		const stack = [];
+		let prev = bos;
+		let value;
+		/**
+		* Tokenizing helpers
+		*/
+		const eos = () => state.index === len - 1;
+		const peek = state.peek = (n = 1) => input[state.index + n];
+		const advance = state.advance = () => input[++state.index] || "";
+		const remaining = () => input.slice(state.index + 1);
+		const consume = (value = "", num = 0) => {
+			state.consumed += value;
+			state.index += num;
+		};
+		const append = (token) => {
+			state.output += token.output != null ? token.output : token.value;
+			consume(token.value);
+		};
+		const negate = () => {
+			let count = 1;
+			while (peek() === "!" && (peek(2) !== "(" || peek(3) === "?")) {
+				advance();
+				state.start++;
+				count++;
+			}
+			if (count % 2 === 0) return false;
+			state.negated = true;
+			state.start++;
+			return true;
+		};
+		const increment = (type) => {
+			state[type]++;
+			stack.push(type);
+		};
+		const decrement = (type) => {
+			state[type]--;
+			stack.pop();
+		};
+		/**
+		* Push tokens onto the tokens array. This helper speeds up
+		* tokenizing by 1) helping us avoid backtracking as much as possible,
+		* and 2) helping us avoid creating extra tokens when consecutive
+		* characters are plain text. This improves performance and simplifies
+		* lookbehinds.
+		*/
+		const push = (tok) => {
+			if (prev.type === "globstar") {
+				const isBrace = state.braces > 0 && (tok.type === "comma" || tok.type === "brace");
+				const isExtglob = tok.extglob === true || extglobs.length && (tok.type === "pipe" || tok.type === "paren");
+				if (tok.type !== "slash" && tok.type !== "paren" && !isBrace && !isExtglob) {
+					state.output = state.output.slice(0, -prev.output.length);
+					prev.type = "star";
+					prev.value = "*";
+					prev.output = star;
+					state.output += prev.output;
+				}
+			}
+			if (extglobs.length && tok.type !== "paren") extglobs[extglobs.length - 1].inner += tok.value;
+			if (tok.value || tok.output) append(tok);
+			if (prev && prev.type === "text" && tok.type === "text") {
+				prev.output = (prev.output || prev.value) + tok.value;
+				prev.value += tok.value;
+				return;
+			}
+			tok.prev = prev;
+			tokens.push(tok);
+			prev = tok;
+		};
+		const extglobOpen = (type, value) => {
+			const token = {
+				...EXTGLOB_CHARS[value],
+				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,
+				output: state.output ? "" : ONE_CHAR
+			});
+			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(rest, {
+					...options,
+					fastpaths: false
+				}).output})${extglobStar})`;
+				if (token.prev.type === "bos") state.negatedExtglob = true;
+			}
+			push({
+				type: "paren",
+				extglob: true,
+				value,
+				output
+			});
+			decrement("parens");
+		};
+		/**
+		* Fast paths
+		*/
+		if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) {
+			let backslashes = false;
+			let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => {
+				if (first === "\\") {
+					backslashes = true;
+					return m;
+				}
+				if (first === "?") {
+					if (esc) return esc + first + (rest ? QMARK.repeat(rest.length) : "");
+					if (index === 0) return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : "");
+					return QMARK.repeat(chars.length);
+				}
+				if (first === ".") return DOT_LITERAL.repeat(chars.length);
+				if (first === "*") {
+					if (esc) return esc + first + (rest ? star : "");
+					return star;
+				}
+				return esc ? m : `\\${m}`;
+			});
+			if (backslashes === true) if (opts.unescape === true) output = output.replace(/\\/g, "");
+			else output = output.replace(/\\+/g, (m) => {
+				return m.length % 2 === 0 ? "\\\\" : m ? "\\" : "";
+			});
+			if (output === input && opts.contains === true) {
+				state.output = input;
+				return state;
+			}
+			state.output = utils.wrapOutput(output, state, options);
+			return state;
+		}
+		/**
+		* Tokenize input until we reach end-of-string
+		*/
+		while (!eos()) {
+			value = advance();
+			if (value === "\0") continue;
+			/**
+			* Escaped characters
+			*/
+			if (value === "\\") {
+				const next = peek();
+				if (next === "/" && opts.bash !== true) continue;
+				if (next === "." || next === ";") continue;
+				if (!next) {
+					value += "\\";
+					push({
+						type: "text",
+						value
+					});
+					continue;
+				}
+				const match = /^\\+/.exec(remaining());
+				let slashes = 0;
+				if (match && match[0].length > 2) {
+					slashes = match[0].length;
+					state.index += slashes;
+					if (slashes % 2 !== 0) value += "\\";
+				}
+				if (opts.unescape === true) value = advance();
+				else value += advance();
+				if (state.brackets === 0) {
+					push({
+						type: "text",
+						value
+					});
+					continue;
+				}
+			}
+			/**
+			* If we're inside a regex character class, continue
+			* until we reach the closing bracket.
+			*/
+			if (state.brackets > 0 && (value !== "]" || prev.value === "[" || prev.value === "[^")) {
+				if (opts.posix !== false && value === ":") {
+					const inner = prev.value.slice(1);
+					if (inner.includes("[")) {
+						prev.posix = true;
+						if (inner.includes(":")) {
+							const idx = prev.value.lastIndexOf("[");
+							const pre = prev.value.slice(0, idx);
+							const posix = POSIX_REGEX_SOURCE[prev.value.slice(idx + 2)];
+							if (posix) {
+								prev.value = pre + posix;
+								state.backtrack = true;
+								advance();
+								if (!bos.output && tokens.indexOf(prev) === 1) bos.output = ONE_CHAR;
+								continue;
+							}
+						}
+					}
+				}
+				if (value === "[" && peek() !== ":" || value === "-" && peek() === "]") value = `\\${value}`;
+				if (value === "]" && (prev.value === "[" || prev.value === "[^")) value = `\\${value}`;
+				if (opts.posix === true && value === "!" && prev.value === "[") value = "^";
+				prev.value += value;
+				append({ value });
+				continue;
+			}
+			/**
+			* If we're inside a quoted string, continue
+			* until we reach the closing double quote.
+			*/
+			if (state.quotes === 1 && value !== "\"") {
+				value = utils.escapeRegex(value);
+				prev.value += value;
+				append({ value });
+				continue;
+			}
+			/**
+			* Double quotes
+			*/
+			if (value === "\"") {
+				state.quotes = state.quotes === 1 ? 0 : 1;
+				if (opts.keepQuotes === true) push({
+					type: "text",
+					value
+				});
+				continue;
+			}
+			/**
+			* Parentheses
+			*/
+			if (value === "(") {
+				increment("parens");
+				push({
+					type: "paren",
+					value
+				});
+				continue;
+			}
+			if (value === ")") {
+				if (state.parens === 0 && opts.strictBrackets === true) throw new SyntaxError(syntaxError("opening", "("));
+				const extglob = extglobs[extglobs.length - 1];
+				if (extglob && state.parens === extglob.parens + 1) {
+					extglobClose(extglobs.pop());
+					continue;
+				}
+				push({
+					type: "paren",
+					value,
+					output: state.parens ? ")" : "\\)"
+				});
+				decrement("parens");
+				continue;
+			}
+			/**
+			* Square brackets
+			*/
+			if (value === "[") {
+				if (opts.nobracket === true || !remaining().includes("]")) {
+					if (opts.nobracket !== true && opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "]"));
+					value = `\\${value}`;
+				} else increment("brackets");
+				push({
+					type: "bracket",
+					value
+				});
+				continue;
+			}
+			if (value === "]") {
+				if (opts.nobracket === true || prev && prev.type === "bracket" && prev.value.length === 1) {
+					push({
+						type: "text",
+						value,
+						output: `\\${value}`
+					});
+					continue;
+				}
+				if (state.brackets === 0) {
+					if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("opening", "["));
+					push({
+						type: "text",
+						value,
+						output: `\\${value}`
+					});
+					continue;
+				}
+				decrement("brackets");
+				const prevValue = prev.value.slice(1);
+				if (prev.posix !== true && prevValue[0] === "^" && !prevValue.includes("/")) value = `/${value}`;
+				prev.value += value;
+				append({ value });
+				if (opts.literalBrackets === false || utils.hasRegexChars(prevValue)) continue;
+				const escaped = utils.escapeRegex(prev.value);
+				state.output = state.output.slice(0, -prev.value.length);
+				if (opts.literalBrackets === true) {
+					state.output += escaped;
+					prev.value = escaped;
+					continue;
+				}
+				prev.value = `(${capture}${escaped}|${prev.value})`;
+				state.output += prev.value;
+				continue;
+			}
+			/**
+			* Braces
+			*/
+			if (value === "{" && opts.nobrace !== true) {
+				increment("braces");
+				const open = {
+					type: "brace",
+					value,
+					output: "(",
+					outputIndex: state.output.length,
+					tokensIndex: state.tokens.length
+				};
+				braces.push(open);
+				push(open);
+				continue;
+			}
+			if (value === "}") {
+				const brace = braces[braces.length - 1];
+				if (opts.nobrace === true || !brace) {
+					push({
+						type: "text",
+						value,
+						output: value
+					});
+					continue;
+				}
+				let output = ")";
+				if (brace.dots === true) {
+					const arr = tokens.slice();
+					const range = [];
+					for (let i = arr.length - 1; i >= 0; i--) {
+						tokens.pop();
+						if (arr[i].type === "brace") break;
+						if (arr[i].type !== "dots") range.unshift(arr[i].value);
+					}
+					output = expandRange(range, opts);
+					state.backtrack = true;
+				}
+				if (brace.comma !== true && brace.dots !== true) {
+					const out = state.output.slice(0, brace.outputIndex);
+					const toks = state.tokens.slice(brace.tokensIndex);
+					brace.value = brace.output = "\\{";
+					value = output = "\\}";
+					state.output = out;
+					for (const t of toks) state.output += t.output || t.value;
+				}
+				push({
+					type: "brace",
+					value,
+					output
+				});
+				decrement("braces");
+				braces.pop();
+				continue;
+			}
+			/**
+			* Pipes
+			*/
+			if (value === "|") {
+				if (extglobs.length > 0) extglobs[extglobs.length - 1].conditions++;
+				push({
+					type: "text",
+					value
+				});
+				continue;
+			}
+			/**
+			* Commas
+			*/
+			if (value === ",") {
+				let output = value;
+				const brace = braces[braces.length - 1];
+				if (brace && stack[stack.length - 1] === "braces") {
+					brace.comma = true;
+					output = "|";
+				}
+				push({
+					type: "comma",
+					value,
+					output
+				});
+				continue;
+			}
+			/**
+			* Slashes
+			*/
+			if (value === "/") {
+				if (prev.type === "dot" && state.index === state.start + 1) {
+					state.start = state.index + 1;
+					state.consumed = "";
+					state.output = "";
+					tokens.pop();
+					prev = bos;
+					continue;
+				}
+				push({
+					type: "slash",
+					value,
+					output: SLASH_LITERAL
+				});
+				continue;
+			}
+			/**
+			* Dots
+			*/
+			if (value === ".") {
+				if (state.braces > 0 && prev.type === "dot") {
+					if (prev.value === ".") prev.output = DOT_LITERAL;
+					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
+					});
+					continue;
+				}
+				push({
+					type: "dot",
+					value,
+					output: DOT_LITERAL
+				});
+				continue;
+			}
+			/**
+			* Question marks
+			*/
+			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
+					});
+					continue;
+				}
+				push({
+					type: "qmark",
+					value,
+					output: QMARK
+				});
+				continue;
+			}
+			/**
+			* Exclamation
+			*/
+			if (value === "!") {
+				if (opts.noextglob !== true && peek() === "(") {
+					if (peek(2) !== "?" || !/[!=<:]/.test(peek(3))) {
+						extglobOpen("negate", value);
+						continue;
+					}
+				}
+				if (opts.nonegate !== true && state.index === 0) {
+					negate();
+					continue;
+				}
+			}
+			/**
+			* Plus
+			*/
+			if (value === "+") {
+				if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+					extglobOpen("plus", value);
+					continue;
+				}
+				if (prev && prev.value === "(" || opts.regex === false) {
+					push({
+						type: "plus",
+						value,
+						output: PLUS_LITERAL
+					});
+					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
+				});
+				continue;
+			}
+			/**
+			* Plain text
+			*/
+			if (value === "@") {
+				if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+					push({
+						type: "at",
+						extglob: true,
+						value,
+						output: ""
+					});
+					continue;
+				}
+				push({
+					type: "text",
+					value
+				});
+				continue;
+			}
+			/**
+			* Plain text
+			*/
+			if (value !== "*") {
+				if (value === "$" || value === "^") value = `\\${value}`;
+				const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
+				if (match) {
+					value += match[0];
+					state.index += match[0].length;
+				}
+				push({
+					type: "text",
+					value
+				});
+				continue;
+			}
+			/**
+			* Stars
+			*/
+			if (prev && (prev.type === "globstar" || prev.star === true)) {
+				prev.type = "star";
+				prev.star = true;
+				prev.value += value;
+				prev.output = star;
+				state.backtrack = true;
+				state.globstar = true;
+				consume(value);
+				continue;
+			}
+			let rest = remaining();
+			if (opts.noextglob !== true && /^\([^?]/.test(rest)) {
+				extglobOpen("star", value);
+				continue;
+			}
+			if (prev.type === "star") {
+				if (opts.noglobstar === true) {
+					consume(value);
+					continue;
+				}
+				const prior = prev.prev;
+				const before = prior.prev;
+				const isStart = prior.type === "slash" || prior.type === "bos";
+				const afterStar = before && (before.type === "star" || before.type === "globstar");
+				if (opts.bash === true && (!isStart || rest[0] && rest[0] !== "/")) {
+					push({
+						type: "star",
+						value,
+						output: ""
+					});
+					continue;
+				}
+				const isBrace = state.braces > 0 && (prior.type === "comma" || prior.type === "brace");
+				const isExtglob = extglobs.length && (prior.type === "pipe" || prior.type === "paren");
+				if (!isStart && prior.type !== "paren" && !isBrace && !isExtglob) {
+					push({
+						type: "star",
+						value,
+						output: ""
+					});
+					continue;
+				}
+				while (rest.slice(0, 3) === "/**") {
+					const after = input[state.index + 4];
+					if (after && after !== "/") break;
+					rest = rest.slice(3);
+					consume("/**", 3);
+				}
+				if (prior.type === "bos" && eos()) {
+					prev.type = "globstar";
+					prev.value += value;
+					prev.output = globstar(opts);
+					state.output = prev.output;
+					state.globstar = true;
+					consume(value);
+					continue;
+				}
+				if (prior.type === "slash" && prior.prev.type !== "bos" && !afterStar && eos()) {
+					state.output = state.output.slice(0, -(prior.output + prev.output).length);
+					prior.output = `(?:${prior.output}`;
+					prev.type = "globstar";
+					prev.output = globstar(opts) + (opts.strictSlashes ? ")" : "|$)");
+					prev.value += value;
+					state.globstar = true;
+					state.output += prior.output + prev.output;
+					consume(value);
+					continue;
+				}
+				if (prior.type === "slash" && prior.prev.type !== "bos" && rest[0] === "/") {
+					const end = rest[1] !== void 0 ? "|$" : "";
+					state.output = state.output.slice(0, -(prior.output + prev.output).length);
+					prior.output = `(?:${prior.output}`;
+					prev.type = "globstar";
+					prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${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}|${globstar(opts)}${SLASH_LITERAL})`;
+					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;
+					prev.output += NO_DOT_SLASH;
+				} else if (opts.dot === true) {
+					state.output += NO_DOTS_SLASH;
+					prev.output += NO_DOTS_SLASH;
+				} else {
+					state.output += nodot;
+					prev.output += nodot;
+				}
+				if (peek() !== "*") {
+					state.output += ONE_CHAR;
+					prev.output += ONE_CHAR;
+				}
+			}
+			push(token);
+		}
+		while (state.brackets > 0) {
+			if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "]"));
+			state.output = utils.escapeLast(state.output, "[");
+			decrement("brackets");
+		}
+		while (state.parens > 0) {
+			if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", ")"));
+			state.output = utils.escapeLast(state.output, "(");
+			decrement("parens");
+		}
+		while (state.braces > 0) {
+			if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "}"));
+			state.output = utils.escapeLast(state.output, "{");
+			decrement("braces");
+		}
+		if (opts.strictSlashes !== true && (prev.type === "star" || prev.type === "bracket")) push({
+			type: "maybe_slash",
+			value: "",
+			output: `${SLASH_LITERAL}?`
+		});
+		if (state.backtrack === true) {
+			state.output = "";
+			for (const token of state.tokens) {
+				state.output += token.output != null ? token.output : token.value;
+				if (token.suffix) state.output += token.suffix;
+			}
+		}
+		return state;
+	};
+	/**
+	* Fast paths for creating regular expressions for common glob patterns.
+	* This can significantly speed up processing and has very little downside
+	* impact when none of the fast paths match.
+	*/
+	parse.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, SLASH_LITERAL, ONE_CHAR, DOTS_SLASH, NO_DOT, NO_DOTS, NO_DOTS_SLASH, STAR, START_ANCHOR } = constants.globChars(opts.windows);
+		const nodot = opts.dot ? NO_DOTS : NO_DOT;
+		const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
+		const capture = opts.capture ? "" : "?:";
+		const state = {
+			negated: false,
+			prefix: ""
+		};
+		let star = opts.bash === true ? ".*?" : STAR;
+		if (opts.capture) star = `(${star})`;
+		const globstar = (opts) => {
+			if (opts.noglobstar === true) return star;
+			return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+		};
+		const create = (str) => {
+			switch (str) {
+				case "*": return `${nodot}${ONE_CHAR}${star}`;
+				case ".*": return `${DOT_LITERAL}${ONE_CHAR}${star}`;
+				case "*.*": return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+				case "*/*": return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;
+				case "**": return nodot + globstar(opts);
+				case "**/*": return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;
+				case "**/*.*": return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+				case "**/.*": return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;
+				default: {
+					const match = /^(.*?)\.(\w+)$/.exec(str);
+					if (!match) return;
+					const source = create(match[1]);
+					if (!source) return;
+					return source + DOT_LITERAL + match[2];
+				}
+			}
+		};
+		let source = create(utils.removePrefix(input, state));
+		if (source && opts.strictSlashes !== true) source += `${SLASH_LITERAL}?`;
+		return source;
+	};
+	module.exports = parse;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/picomatch.js
+var require_picomatch$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const scan = require_scan();
+	const parse = require_parse();
+	const utils = require_utils();
+	const constants = require_constants();
+	const isObject = (val) => val && typeof val === "object" && !Array.isArray(val);
+	/**
+	* Creates a matcher function from one or more glob patterns. The
+	* returned function takes a string to match as its first argument,
+	* and returns true if the string is a match. The returned matcher
+	* function also takes a boolean as the second argument that, when true,
+	* returns an object with additional information.
+	*
+	* ```js
+	* const picomatch = require('picomatch');
+	* // picomatch(glob[, options]);
+	*
+	* const isMatch = picomatch('*.!(*a)');
+	* console.log(isMatch('a.a')); //=> false
+	* console.log(isMatch('a.b')); //=> true
+	* ```
+	* @name picomatch
+	* @param {String|Array} `globs` One or more glob patterns.
+	* @param {Object=} `options`
+	* @return {Function=} Returns a matcher function.
+	* @api public
+	*/
+	const picomatch = (glob, options, returnState = false) => {
+		if (Array.isArray(glob)) {
+			const fns = glob.map((input) => picomatch(input, options, returnState));
+			const arrayMatcher = (str) => {
+				for (const isMatch of fns) {
+					const state = isMatch(str);
+					if (state) return state;
+				}
+				return false;
+			};
+			return arrayMatcher;
+		}
+		const isState = isObject(glob) && glob.tokens && glob.input;
+		if (glob === "" || typeof glob !== "string" && !isState) throw new TypeError("Expected pattern to be a non-empty string");
+		const opts = options || {};
+		const posix = opts.windows;
+		const regex = isState ? picomatch.compileRe(glob, options) : picomatch.makeRe(glob, options, false, true);
+		const state = regex.state;
+		delete regex.state;
+		let isIgnored = () => false;
+		if (opts.ignore) {
+			const ignoreOpts = {
+				...options,
+				ignore: null,
+				onMatch: null,
+				onResult: null
+			};
+			isIgnored = picomatch(opts.ignore, ignoreOpts, returnState);
+		}
+		const matcher = (input, returnObject = false) => {
+			const { isMatch, match, output } = picomatch.test(input, regex, options, {
+				glob,
+				posix
+			});
+			const result = {
+				glob,
+				state,
+				regex,
+				posix,
+				input,
+				output,
+				match,
+				isMatch
+			};
+			if (typeof opts.onResult === "function") opts.onResult(result);
+			if (isMatch === false) {
+				result.isMatch = false;
+				return returnObject ? result : false;
+			}
+			if (isIgnored(input)) {
+				if (typeof opts.onIgnore === "function") opts.onIgnore(result);
+				result.isMatch = false;
+				return returnObject ? result : false;
+			}
+			if (typeof opts.onMatch === "function") opts.onMatch(result);
+			return returnObject ? result : true;
+		};
+		if (returnState) matcher.state = state;
+		return matcher;
+	};
+	/**
+	* Test `input` with the given `regex`. This is used by the main
+	* `picomatch()` function to test the input string.
+	*
+	* ```js
+	* const picomatch = require('picomatch');
+	* // picomatch.test(input, regex[, options]);
+	*
+	* console.log(picomatch.test('foo/bar', /^(?:([^/]*?)\/([^/]*?))$/));
+	* // { isMatch: true, match: [ 'foo/', 'foo', 'bar' ], output: 'foo/bar' }
+	* ```
+	* @param {String} `input` String to test.
+	* @param {RegExp} `regex`
+	* @return {Object} Returns an object with matching info.
+	* @api public
+	*/
+	picomatch.test = (input, regex, options, { glob, posix } = {}) => {
+		if (typeof input !== "string") throw new TypeError("Expected input to be a string");
+		if (input === "") return {
+			isMatch: false,
+			output: ""
+		};
+		const opts = options || {};
+		const format = opts.format || (posix ? utils.toPosixSlashes : null);
+		let match = input === glob;
+		let output = match && format ? format(input) : input;
+		if (match === false) {
+			output = format ? format(input) : input;
+			match = output === glob;
+		}
+		if (match === false || opts.capture === true) if (opts.matchBase === true || opts.basename === true) match = picomatch.matchBase(input, regex, options, posix);
+		else match = regex.exec(output);
+		return {
+			isMatch: Boolean(match),
+			match,
+			output
+		};
+	};
+	/**
+	* Match the basename of a filepath.
+	*
+	* ```js
+	* const picomatch = require('picomatch');
+	* // picomatch.matchBase(input, glob[, options]);
+	* console.log(picomatch.matchBase('foo/bar.js', '*.js'); // true
+	* ```
+	* @param {String} `input` String to test.
+	* @param {RegExp|String} `glob` Glob pattern or regex created by [.makeRe](#makeRe).
+	* @return {Boolean}
+	* @api public
+	*/
+	picomatch.matchBase = (input, glob, options) => {
+		return (glob instanceof RegExp ? glob : picomatch.makeRe(glob, options)).test(utils.basename(input));
+	};
+	/**
+	* Returns true if **any** of the given glob `patterns` match the specified `string`.
+	*
+	* ```js
+	* const picomatch = require('picomatch');
+	* // picomatch.isMatch(string, patterns[, options]);
+	*
+	* console.log(picomatch.isMatch('a.a', ['b.*', '*.a'])); //=> true
+	* console.log(picomatch.isMatch('a.a', 'b.*')); //=> false
+	* ```
+	* @param {String|Array} str The string to test.
+	* @param {String|Array} patterns One or more glob patterns to use for matching.
+	* @param {Object} [options] See available [options](#options).
+	* @return {Boolean} Returns true if any patterns match `str`
+	* @api public
+	*/
+	picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
+	/**
+	* Parse a glob pattern to create the source string for a regular
+	* expression.
+	*
+	* ```js
+	* const picomatch = require('picomatch');
+	* const result = picomatch.parse(pattern[, options]);
+	* ```
+	* @param {String} `pattern`
+	* @param {Object} `options`
+	* @return {Object} Returns an object with useful properties and output to be used as a regex source string.
+	* @api public
+	*/
+	picomatch.parse = (pattern, options) => {
+		if (Array.isArray(pattern)) return pattern.map((p) => picomatch.parse(p, options));
+		return parse(pattern, {
+			...options,
+			fastpaths: false
+		});
+	};
+	/**
+	* Scan a glob pattern to separate the pattern into segments.
+	*
+	* ```js
+	* const picomatch = require('picomatch');
+	* // picomatch.scan(input[, options]);
+	*
+	* const result = picomatch.scan('!./foo/*.js');
+	* console.log(result);
+	* { prefix: '!./',
+	*   input: '!./foo/*.js',
+	*   start: 3,
+	*   base: 'foo',
+	*   glob: '*.js',
+	*   isBrace: false,
+	*   isBracket: false,
+	*   isGlob: true,
+	*   isExtglob: false,
+	*   isGlobstar: false,
+	*   negated: true }
+	* ```
+	* @param {String} `input` Glob pattern to scan.
+	* @param {Object} `options`
+	* @return {Object} Returns an object with
+	* @api public
+	*/
+	picomatch.scan = (input, options) => scan(input, options);
+	/**
+	* Compile a regular expression from the `state` object returned by the
+	* [parse()](#parse) method.
+	*
+	* @param {Object} `state`
+	* @param {Object} `options`
+	* @param {Boolean} `returnOutput` Intended for implementors, this argument allows you to return the raw output from the parser.
+	* @param {Boolean} `returnState` Adds the state to a `state` property on the returned regex. Useful for implementors and debugging.
+	* @return {RegExp}
+	* @api public
+	*/
+	picomatch.compileRe = (state, options, returnOutput = false, returnState = false) => {
+		if (returnOutput === true) return state.output;
+		const opts = options || {};
+		const prepend = opts.contains ? "" : "^";
+		const append = opts.contains ? "" : "$";
+		let source = `${prepend}(?:${state.output})${append}`;
+		if (state && state.negated === true) source = `^(?!${source}).*$`;
+		const regex = picomatch.toRegex(source, options);
+		if (returnState === true) regex.state = state;
+		return regex;
+	};
+	/**
+	* Create a regular expression from a parsed glob pattern.
+	*
+	* ```js
+	* const picomatch = require('picomatch');
+	* const state = picomatch.parse('*.js');
+	* // picomatch.compileRe(state[, options]);
+	*
+	* console.log(picomatch.compileRe(state));
+	* //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+	* ```
+	* @param {String} `state` The object returned from the `.parse` method.
+	* @param {Object} `options`
+	* @param {Boolean} `returnOutput` Implementors may use this argument to return the compiled output, instead of a regular expression. This is not exposed on the options to prevent end-users from mutating the result.
+	* @param {Boolean} `returnState` Implementors may use this argument to return the state from the parsed glob with the returned regular expression.
+	* @return {RegExp} Returns a regex created from the given pattern.
+	* @api public
+	*/
+	picomatch.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
+		if (!input || typeof input !== "string") throw new TypeError("Expected a non-empty string");
+		let parsed = {
+			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.compileRe(parsed, options, returnOutput, returnState);
+	};
+	/**
+	* Create a regular expression from the given regex source string.
+	*
+	* ```js
+	* const picomatch = require('picomatch');
+	* // picomatch.toRegex(source[, options]);
+	*
+	* const { output } = picomatch.parse('*.js');
+	* console.log(picomatch.toRegex(output));
+	* //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+	* ```
+	* @param {String} `source` Regular expression source string.
+	* @param {Object} `options`
+	* @return {RegExp}
+	* @api public
+	*/
+	picomatch.toRegex = (source, options) => {
+		try {
+			const opts = options || {};
+			return new RegExp(source, opts.flags || (opts.nocase ? "i" : ""));
+		} catch (err) {
+			if (options && options.debug === true) throw err;
+			return /$^/;
+		}
+	};
+	/**
+	* Picomatch constants.
+	* @return {Object}
+	*/
+	picomatch.constants = constants;
+	/**
+	* Expose "picomatch"
+	*/
+	module.exports = picomatch;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/index.js
+var require_picomatch = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const pico = require_picomatch$1();
+	const utils = require_utils();
+	function picomatch(glob, options, returnState = false) {
+		if (options && (options.windows === null || options.windows === void 0)) options = {
+			...options,
+			windows: utils.isWindows()
+		};
+		return pico(glob, options, returnState);
+	}
+	Object.assign(picomatch, pico);
+	module.exports = picomatch;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/tinyglobby@0.2.15/node_modules/tinyglobby/dist/index.mjs
+var import_picomatch = /* @__PURE__ */ __toESM(require_picomatch(), 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 = 0; j < partsCount; j++) partMatchers[j] = (0, import_picomatch.default)(parts[j], options);
+		matchers[i] = partMatchers;
+	}
+	return (input) => {
+		const inputParts = input.split("/");
+		if (inputParts[0] === ".." && ONLY_PARENT_DIRECTORIES.test(input)) return true;
+		for (let i = 0; i < patterns.length; i++) {
+			const patternParts = patternsParts[i];
+			const matcher = matchers[i];
+			const inputPatternCount = inputParts.length;
+			const minParts = Math.min(inputPatternCount, patternParts.length);
+			let j = 0;
+			while (j < minParts) {
+				const part = patternParts[j];
+				if (part.includes("/")) return true;
+				if (!matcher[j](inputParts[j])) break;
+				if (globstarEnabled && part === "**") return true;
+				j++;
+			}
+			if (j === 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, "\\$&");
+/**
+* Escapes a path's special characters depending on the platform.
+* @see {@link https://superchupu.dev/tinyglobby/documentation#escapePath}
+*/
+/* node:coverage ignore next */
+const escapePath = isWin ? escapeWin32Path : escapePosixPath;
+/**
+* Checks if a pattern has dynamic parts.
+*
+* Has a few minor differences with [`fast-glob`](https://github.com/mrmlnc/fast-glob) for better accuracy:
+*
+* - Doesn't necessarily return `false` on patterns that include `\`.
+* - Returns `true` if the pattern includes parentheses, regardless of them representing one single pattern or not.
+* - Returns `true` for unfinished glob extensions i.e. `(h`, `+(h`.
+* - Returns `true` for unfinished brace expansions as long as they include `,` or `..`.
+*
+* @see {@link https://superchupu.dev/tinyglobby/documentation#isDynamicPattern}
+*/
+function isDynamicPattern(pattern, options) {
+	if ((options === null || options === void 0 ? void 0 : options.caseSensitiveMatch) === false) return true;
+	const scan = import_picomatch.default.scan(pattern);
+	return scan.isGlob || scan.negated;
+}
+function log(...tasks) {
+	console.log(`[tinyglobby ${(/* @__PURE__ */ new Date()).toLocaleTimeString("es")}]`, ...tasks);
+}
+const PARENT_DIRECTORY = /^(\/?\.\.)+/;
+const ESCAPING_BACKSLASHES = /\\(?=[()[\]{}!*+?@|])/g;
+const BACKSLASHES = /\\/g;
+function normalizePattern(pattern, expandDirectories, cwd, props, isIgnore) {
+	let result = pattern;
+	if (pattern.endsWith("/")) result = pattern.slice(0, -1);
+	if (!result.endsWith("*") && expandDirectories) result += "/**";
+	const escapedCwd = escapePath(cwd);
+	if (path$1.isAbsolute(result.replace(ESCAPING_BACKSLASHES, ""))) result = posix.relative(escapedCwd, result);
+	else result = posix.normalize(result);
+	const parentDirectoryMatch = PARENT_DIRECTORY.exec(result);
+	const parts = splitPattern(result);
+	if (parentDirectoryMatch === null || parentDirectoryMatch === void 0 ? void 0 : parentDirectoryMatch[0]) {
+		const n = (parentDirectoryMatch[0].length + 1) / 3;
+		let i = 0;
+		const cwdParts = escapedCwd.split("/");
+		while (i < n && parts[i + n] === cwdParts[cwdParts.length + i - n]) {
+			result = result.slice(0, (n - i - 1) * 3) + result.slice((n - i) * 3 + parts[i + n].length + 1) || ".";
+			i++;
+		}
+		const potentialRoot = posix.join(cwd, parentDirectoryMatch[0].slice(i * 3));
+		if (!potentialRoot.startsWith(".") && props.root.length > potentialRoot.length) {
+			props.root = potentialRoot;
+			props.depthOffset = -n + i;
+		}
+	}
+	if (!isIgnore && props.depthOffset >= 0) {
+		var _props$commonPath;
+		(_props$commonPath = props.commonPath) !== null && _props$commonPath !== void 0 || (props.commonPath = parts);
+		const newCommonPath = [];
+		const length = Math.min(props.commonPath.length, parts.length);
+		for (let i = 0; i < length; i++) {
+			const part = parts[i];
+			if (part === "**" && !parts[i + 1]) {
+				newCommonPath.pop();
+				break;
+			}
+			if (part !== props.commonPath[i] || isDynamicPattern(part) || i === parts.length - 1) break;
+			newCommonPath.push(part);
+		}
+		props.depthOffset = newCommonPath.length;
+		props.commonPath = newCommonPath;
+		props.root = newCommonPath.length > 0 ? 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) {
+	for (let i = paths.length - 1; i >= 0; i--) {
+		const path$1 = paths[i];
+		paths[i] = relative(path$1);
+	}
+	return paths;
+}
+function normalizeCwd(cwd) {
+	if (!cwd) return process.cwd().replace(BACKSLASHES, "/");
+	if (cwd instanceof URL) return fileURLToPath$1(cwd).replace(BACKSLASHES, "/");
+	return path$1.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) => {
+			const path$1 = format(p, isDirectory);
+			const matches = matcher(path$1);
+			if (matches) log(`matched ${path$1}`);
+			return matches;
+		} : (p, isDirectory) => matcher(format(p, isDirectory))],
+		exclude: options.debug ? (_, p) => {
+			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 || nativeFs.readdir,
+			readdirSync: options.fs.readdirSync || nativeFs.readdirSync,
+			realpath: options.fs.realpath || nativeFs.realpath,
+			realpathSync: options.fs.realpathSync || nativeFs.realpathSync,
+			stat: options.fs.stat || nativeFs.stat,
+			statSync: options.fs.statSync || nativeFs.statSync
+		} : void 0,
+		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 = cwd !== root && !options.absolute && buildRelative(cwd, props.root);
+	return [new Builder(fdirOptions).crawl(root), relative];
+}
+async function glob(patternsOrOptions, options) {
+	if (patternsOrOptions && (options === null || options === void 0 ? void 0 : options.patterns)) throw new Error("Cannot pass patterns as both an argument and an option");
+	const isModern = isReadonlyArray(patternsOrOptions) || typeof patternsOrOptions === "string";
+	const opts = isModern ? options : patternsOrOptions;
+	const [crawler, relative] = getCrawler(isModern ? patternsOrOptions : patternsOrOptions.patterns, opts);
+	if (!relative) return crawler.withPromise();
+	return formatPaths(await crawler.withPromise(), relative);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/empathic@2.0.0/node_modules/empathic/resolve.mjs
+/**
+* Resolve an absolute path from {@link root}, but only
+* if {@link input} isn't already absolute.
+*
+* @param input The path to resolve.
+* @param root The base path; default = process.cwd()
+* @returns The resolved absolute path.
+*/
+function absolute(input, root) {
+	return isAbsolute(input) ? input : resolve(root || ".", input);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/empathic@2.0.0/node_modules/empathic/walk.mjs
+/**
+* Get all parent directories of {@link base}.
+* Stops after {@link Options['last']} is processed.
+*
+* @returns An array of absolute paths of all parent directories.
+*/
+function up$2(base, options) {
+	let { last, cwd } = options || {};
+	let tmp = absolute(base, cwd);
+	let root = absolute(last || "/", cwd);
+	let prev, arr = [];
+	while (prev !== root) {
+		arr.push(tmp);
+		tmp = dirname(prev = tmp);
+		if (tmp === prev) break;
+	}
+	return arr;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/empathic@2.0.0/node_modules/empathic/find.mjs
+/**
+* Find an item by name, walking parent directories until found.
+*
+* @param name The item name to find.
+* @returns The absolute path to the item, if found.
+*/
+function up$1(name, options) {
+	let dir, tmp;
+	let start = options && options.cwd || "";
+	for (dir of up$2(start, options)) {
+		tmp = join(dir, name);
+		if (existsSync(tmp)) return tmp;
+	}
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/empathic@2.0.0/node_modules/empathic/package.mjs
+/**
+* Find the closest "package.json" file while walking parent directories.
+* @returns The absolute path to a "package.json", if found.
+*/
+function up(options) {
+	return up$1("package.json", options);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/import-without-cache@0.2.5/node_modules/import-without-cache/dist/index.mjs
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+const namespace = "no-cache://";
+const namespaceLength = 11;
+const isSupported = !!module$1.registerHooks;
+const RE_NODE_MODULES = /[/\\]node_modules[/\\]/;
+let deregister;
+function init({ skipNodeModules } = {}) {
+	if (process$1.versions.bun) throw new Error("init is unnecessary in Bun, use clearRequireCache() instead.");
+	if (!isSupported) throw new Error("import-without-cache requires Node.js v22.15.0 or higher.");
+	if (deregister) return deregister;
+	const hooks = module$1.registerHooks({
+		resolve(specifier, context, nextResolve) {
+			let noCache = context.importAttributes?.cache === "no";
+			if (specifier.startsWith(namespace)) {
+				specifier = specifier.slice(namespaceLength);
+				noCache = true;
+			}
+			const resolved = nextResolve(specifier, context);
+			if (skipNodeModules && RE_NODE_MODULES.test(resolved.url)) return resolved;
+			if (!resolved.url.startsWith("file://")) return resolved;
+			const parentUUID = getParentUUID(context.parentURL);
+			if (!noCache && !parentUUID) return resolved;
+			resolved.url = appendUUID(resolved.url, parentUUID || crypto.randomUUID());
+			return resolved;
+		},
+		load(url, context, nextLoad) {
+			cleanupImportAttributes(context);
+			return nextLoad(url, context);
+		}
+	});
+	return deregister = () => {
+		hooks.deregister();
+		deregister = void 0;
+	};
+}
+function clearRequireCache() {
+	for (const key of Object.keys(__require.cache)) delete __require.cache[key];
+}
+function getParentUUID(parentURL) {
+	if (!parentURL) return;
+	return new URL(parentURL).searchParams.get("no-cache") ?? void 0;
+}
+function appendUUID(url, uuid) {
+	const parsed = new URL(url);
+	parsed.searchParams.set("no-cache", uuid);
+	return parsed.toString();
+}
+function cleanupImportAttributes(context) {
+	if (!context.importAttributes?.cache) return;
+	const attrs = Object.assign(Object.create(null), context.importAttributes);
+	delete attrs.cache;
+	context.importAttributes = attrs;
+	Object.freeze(context.importAttributes);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/quansync@1.0.0/node_modules/quansync/dist/src-C2Pm6gXo.js
+const GET_IS_ASYNC = Symbol.for("quansync.getIsAsync");
+var QuansyncError = class extends Error {
+	constructor(message = "Unexpected promise in sync context") {
+		super(message);
+		this.name = "QuansyncError";
+	}
+};
+function isThenable(value) {
+	return value && typeof value === "object" && typeof value.then === "function";
+}
+function isQuansyncGenerator(value) {
+	return value && typeof value === "object" && typeof value[Symbol.iterator] === "function" && "__quansync" in value;
+}
+function fromObject(options) {
+	const generator = function* (...args) {
+		if (yield GET_IS_ASYNC) return yield options.async.apply(this, args);
+		return options.sync.apply(this, args);
+	};
+	function fn(...args) {
+		const iter = generator.apply(this, args);
+		iter.then = (...thenArgs) => options.async.apply(this, args).then(...thenArgs);
+		iter.__quansync = true;
+		return iter;
+	}
+	fn.sync = options.sync;
+	fn.async = options.async;
+	return fn;
+}
+function fromPromise(promise) {
+	return fromObject({
+		async: () => Promise.resolve(promise),
+		sync: () => {
+			if (isThenable(promise)) throw new QuansyncError();
+			return promise;
+		}
+	});
+}
+function unwrapYield(value, isAsync) {
+	if (value === GET_IS_ASYNC) return isAsync;
+	if (isQuansyncGenerator(value)) return isAsync ? iterateAsync(value) : iterateSync(value);
+	if (!isAsync && isThenable(value)) throw new QuansyncError();
+	return value;
+}
+const DEFAULT_ON_YIELD = (value) => value;
+function iterateSync(generator, onYield = DEFAULT_ON_YIELD) {
+	let current = generator.next();
+	while (!current.done) try {
+		current = generator.next(unwrapYield(onYield(current.value, false)));
+	} catch (err) {
+		current = generator.throw(err);
+	}
+	return unwrapYield(current.value);
+}
+async function iterateAsync(generator, onYield = DEFAULT_ON_YIELD) {
+	let current = generator.next();
+	while (!current.done) try {
+		current = generator.next(await unwrapYield(onYield(current.value, true), true));
+	} catch (err) {
+		current = generator.throw(err);
+	}
+	return current.value;
+}
+function fromGeneratorFn(generatorFn, options) {
+	return fromObject({
+		name: generatorFn.name,
+		async(...args) {
+			return iterateAsync(generatorFn.apply(this, args), options?.onYield);
+		},
+		sync(...args) {
+			return iterateSync(generatorFn.apply(this, args), options?.onYield);
+		}
+	});
+}
+function quansync$1(input, options) {
+	if (isThenable(input)) return fromPromise(input);
+	if (typeof input === "function") return fromGeneratorFn(input, options);
+	else return fromObject(input);
+}
+/**
+* @returns `true` if the current context is async, `false` otherwise.
+*/
+const getIsAsync = quansync$1({
+	async: () => Promise.resolve(true),
+	sync: () => false
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/quansync@1.0.0/node_modules/quansync/dist/macro.js
+/**
+* This function is equivalent to `quansync` from main entry
+* but accepts a fake argument type of async functions.
+*
+* This requires to be used with the macro transformer `unplugin-quansync`.
+* Do NOT use it directly.
+*
+* @internal
+*/
+const quansync = quansync$1;
+
+//#endregion
+//#region ../../node_modules/.pnpm/@quansync+fs@1.0.0/node_modules/@quansync/fs/dist/index.mjs
+/**
+* @link https://nodejs.org/api/fs.html#fspromisesreadfilepath-options
+*/
+const readFile$1 = quansync$1({
+	sync: fs$1.readFileSync,
+	async: fs$1.promises.readFile
+});
+/**
+* @link https://nodejs.org/api/fs.html#fspromiseswritefilefile-data-options
+*/
+const writeFile$1 = quansync$1({
+	sync: fs$1.writeFileSync,
+	async: fs$1.promises.writeFile
+});
+/**
+* @link https://nodejs.org/api/fs.html#fspromisesunlinkpath
+*/
+const unlink = quansync$1({
+	sync: fs$1.unlinkSync,
+	async: fs$1.promises.unlink
+});
+/**
+* @link https://nodejs.org/api/fs.html#fspromisesaccesspath-mode
+*/
+const access$1 = quansync$1({
+	sync: fs$1.accessSync,
+	async: fs$1.promises.access
+});
+/**
+* @link https://nodejs.org/api/fs.html#fspromisesstatpath-options
+*/
+const stat$1 = quansync$1({
+	sync: fs$1.statSync,
+	async: fs$1.promises.stat
+});
+const lstat = quansync$1({
+	sync: fs$1.lstatSync,
+	async: fs$1.promises.lstat
+});
+/**
+* @link https://nodejs.org/api/fs.html#fspromisescpsrc-dest-options
+*/
+const cp$1 = quansync$1({
+	sync: fs$1.copyFileSync,
+	async: fs$1.promises.copyFile
+});
+/**
+* @link https://nodejs.org/api/fs.html#fspromisesrmpath-options
+*/
+const rm$1 = quansync$1({
+	sync: fs$1.rmSync,
+	async: fs$1.promises.rm
+});
+/**
+* @link https://nodejs.org/api/fs.html#fspromisesmkdirpath-options
+*/
+const mkdir = quansync$1({
+	sync: fs$1.mkdirSync,
+	async: fs$1.promises.mkdir
+});
+/**
+* @link https://nodejs.org/api/fs.html#fspromisesrenameoldpath-newpath
+*/
+const rename = quansync$1({
+	sync: fs$1.renameSync,
+	async: fs$1.promises.rename
+});
+/**
+* @link https://nodejs.org/api/fs.html#fspromisesreaddirpath-options
+*/
+const readdir = quansync$1({
+	sync: fs$1.readdirSync,
+	async: fs$1.promises.readdir
+});
+/**
+* @link https://nodejs.org/api/fs.html#fspromisesrealpathpath-options
+*/
+const realpath = quansync$1({
+	sync: fs$1.realpathSync,
+	async: fs$1.promises.realpath
+});
+/**
+* @link https://nodejs.org/api/fs.html#fspromisesreadlinkpath-options
+*/
+const readlink = quansync$1({
+	sync: fs$1.readlinkSync,
+	async: fs$1.promises.readlink
+});
+/**
+* @link https://nodejs.org/api/fs.html#fspromisessymlinktarget-path-type
+*/
+const symlink = quansync$1({
+	sync: fs$1.symlinkSync,
+	async: fs$1.promises.symlink
+});
+/**
+* @link https://nodejs.org/api/fs.html#fspromiseschownpath-uid-gid
+*/
+const chown = quansync$1({
+	sync: fs$1.chownSync,
+	async: fs$1.promises.chown
+});
+/**
+* @link https://nodejs.org/api/fs.html#fspromiseslchownpath-uid-gid
+*/
+const lchown = quansync$1({
+	sync: fs$1.lchownSync,
+	async: fs$1.promises.lchown
+});
+/**
+* @link https://nodejs.org/api/fs.html#fspromiseschmodpath-mode
+*/
+const chmod$1 = quansync$1({
+	sync: fs$1.chmodSync,
+	async: fs$1.promises.chmod
+});
+/**
+* @link https://nodejs.org/api/fs.html#fspromisesutimespath-atime-mtime
+*/
+const utimes = quansync$1({
+	sync: fs$1.utimesSync,
+	async: fs$1.promises.utimes
+});
+/**
+* @link https://nodejs.org/api/fs.html#fspromiseslutimespath-atime-mtime
+*/
+const lutimes = quansync$1({
+	sync: fs$1.lutimesSync,
+	async: fs$1.promises.lutimes
+});
+/**
+* @link https://nodejs.org/api/fs.html#fspromisesmkdtempprefix-options
+*/
+const mkdtemp$1 = quansync$1({
+	sync: fs$1.mkdtempSync,
+	async: fs$1.promises.mkdtemp
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/unconfig-core@7.4.2/node_modules/unconfig-core/dist/index.mjs
+const isFile = quansync(function* (path, allowSymlinks) {
+	try {
+		return (yield (allowSymlinks ? stat$1 : lstat)(path)).isFile();
+	} catch {
+		return false;
+	}
+});
+const findUp = quansync(function* (paths, options = {}) {
+	const { cwd = process$1.cwd(), stopAt = parse(cwd).root, multiple = false, allowSymlinks = true } = options;
+	let current = cwd;
+	const files = [];
+	while (current && current !== stopAt) {
+		for (const path of paths) {
+			const filepath = resolve(current, path);
+			if (yield isFile(filepath, allowSymlinks)) {
+				files.push(filepath);
+				if (!multiple) return files;
+			}
+		}
+		const parent = dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	return files;
+});
+const loadConfigFile$1 = quansync(function* (filepath, source) {
+	try {
+		const config = yield source.parser(filepath);
+		if (!config) return;
+		return {
+			config,
+			source: filepath
+		};
+	} catch (e) {
+		if (source.skipOnError) return;
+		throw e;
+	}
+});
+function createConfigCoreLoader(options) {
+	const { cwd = process$1.cwd(), multiple, sources } = options;
+	const results = [];
+	let matchedFiles;
+	const findConfigs = quansync(function* () {
+		if (matchedFiles == null) matchedFiles = [];
+		matchedFiles.length = 0;
+		for (const source of sources) {
+			const { extensions } = source;
+			const files = yield findUp(source.files.flatMap((file) => !extensions?.length ? [file] : extensions.map((ext) => ext ? `${file}.${ext}` : file)), {
+				cwd,
+				stopAt: options.stopAt,
+				multiple
+			});
+			matchedFiles.push([source, files]);
+		}
+		return matchedFiles.flatMap((i) => i[1]);
+	});
+	return {
+		load: quansync(function* (force = false) {
+			if (matchedFiles == null || force) yield findConfigs();
+			for (const [source, files] of matchedFiles) {
+				if (!files.length) continue;
+				if (!multiple) {
+					const result = yield loadConfigFile$1(files[0], source);
+					if (result) return [result];
+				} else for (const file of files) {
+					const result = yield loadConfigFile$1(file, source);
+					if (result) results.push(result);
+				}
+			}
+			return results;
+		}),
+		findConfigs
+	};
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/tsdown@0.20.2_@arethetypeswrong+core@0.18.2_@typescript+native-preview@7.0.0-dev.202601_11c6934cad7d4cedf7999249d5905a1c/node_modules/tsdown/dist/options-DfwuH01N.mjs
+const __cjs_require$1 = createRequire(import.meta.url);
+const picomatch = __cjs_require$1("./npm_entry_picomatch.cjs");
+const minVersion = __cjs_require$1("./npm_entry_semver_ranges_min-version.cjs");
+const check = (key) => key in env && env[key] !== "0" && env[key] !== "false";
+const isInCi = check("CI") || check("CONTINUOUS_INTEGRATION");
+const debug$3$2 = createDebug("tsdown:clean");
+const RE_LAST_SLASH = /[/\\]$/;
+async function cleanOutDir(configs) {
+	const removes = /* @__PURE__ */ new Set();
+	for (const config of configs) {
+		if (config.devtools && (config.devtools.clean ?? true)) config.clean.push("node_modules/.rolldown");
+		if (!config.clean.length) continue;
+		const files = await glob(config.clean, {
+			cwd: config.cwd,
+			absolute: true,
+			onlyFiles: false,
+			dot: true
+		});
+		const normalizedOutDir = config.outDir.replace(RE_LAST_SLASH, "");
+		for (const file of files) if (file.replace(RE_LAST_SLASH, "") !== normalizedOutDir) removes.add(file);
+	}
+	if (!removes.size) return;
+	globalLogger.info(`Cleaning ${removes.size} files`);
+	await Promise.all([...removes].map(async (file) => {
+		debug$3$2("Removing", file);
+		await fsRemove(file);
+	}));
+	debug$3$2("Removed %d files", removes.size);
+}
+function resolveClean(clean, outDir, cwd) {
+	if (clean === true) clean = [slash(outDir)];
+	else if (!clean) clean = [];
+	if (clean.some((item) => path.resolve(item) === cwd)) throw new Error("Cannot clean the current working directory. Please specify a different path to clean option.");
+	return clean;
+}
+async function cleanChunks(outDir, chunks) {
+	await Promise.all(chunks.map(async (chunk) => {
+		const filePath = path.resolve(outDir, chunk.fileName);
+		debug$3$2("Removing chunk file", filePath);
+		await fsRemove(filePath);
+	}));
+}
+const defaultCssBundleName = "style.css";
+function resolveCssOptions(options = {}) {
+	return {
+		splitting: options.splitting ?? true,
+		fileName: options.fileName ?? defaultCssBundleName
+	};
+}
+async function resolveEntry(logger, entry, cwd, color, nameLabel) {
+	if (!entry || Object.keys(entry).length === 0) {
+		const defaultEntry = path.resolve(cwd, "src/index.ts");
+		if (await fsExists(defaultEntry)) entry = { index: defaultEntry };
+		else throw new Error(`${nameLabel} No input files, try "tsdown <your-file>" or create src/index.ts`);
+	}
+	const entryMap = await toObjectEntry(entry, cwd);
+	const entries = Object.values(entryMap);
+	if (entries.length === 0) throw new Error(`${nameLabel} Cannot find entry: ${JSON.stringify(entry)}`);
+	logger.info(nameLabel, `entry: ${color(entries.map((entry) => path.relative(cwd, entry)).join(", "))}`);
+	return entryMap;
+}
+function toObjectEntry(entry, cwd) {
+	if (typeof entry === "string") entry = [entry];
+	if (!Array.isArray(entry)) return resolveObjectEntry(entry, cwd);
+	return resolveArrayEntry(entry, cwd);
+}
+async function resolveObjectEntry(entries, cwd) {
+	return Object.fromEntries((await Promise.all(Object.entries(entries).map(async ([key, value]) => {
+		if (!key.includes("*")) {
+			if (Array.isArray(value)) throw new TypeError(`Object entry "${key}" cannot have an array value when the key is not a glob pattern.`);
+			return [[key, value]];
+		}
+		const patterns = toArray(value);
+		const files = await glob(patterns, {
+			cwd,
+			expandDirectories: false
+		});
+		if (!files.length) throw new Error(`Cannot find files for entry key "${key}" with patterns: ${JSON.stringify(patterns)}`);
+		let valueGlobBase;
+		for (const pattern of patterns) {
+			if (pattern.startsWith("!")) continue;
+			const base = picomatch.scan(pattern).base;
+			if (valueGlobBase === void 0) valueGlobBase = base;
+			else if (valueGlobBase !== base) throw new Error(`When using object entry with glob pattern key "${key}", all value glob patterns must have the same base directory.`);
+		}
+		if (valueGlobBase === void 0) throw new Error(`Cannot determine base directory for value glob patterns of key "${key}".`);
+		return files.map((file) => [slash(key.replaceAll("*", stripExtname(path.relative(valueGlobBase, file)))), path.resolve(cwd, file)]);
+	}))).flat());
+}
+async function resolveArrayEntry(entries, cwd) {
+	const stringEntries = [];
+	const objectEntries = [];
+	for (const e of entries) if (typeof e === "string") stringEntries.push(e);
+	else objectEntries.push(e);
+	const isGlob = stringEntries.some((e) => isDynamicPattern(e));
+	let resolvedEntries;
+	if (isGlob) resolvedEntries = (await glob(stringEntries, {
+		cwd,
+		expandDirectories: false,
+		absolute: true
+	})).map((file) => path.resolve(file));
+	else resolvedEntries = stringEntries;
+	const base = lowestCommonAncestor(...resolvedEntries);
+	const arrayEntryMap = Object.fromEntries(resolvedEntries.map((file) => {
+		return [slash(stripExtname(path.relative(base, file))), file];
+	}));
+	return Object.assign({}, arrayEntryMap, ...await Promise.all(objectEntries.map((entry) => resolveObjectEntry(entry, cwd))));
+}
+async function writeExports(options, chunks) {
+	const { pkg } = options;
+	const { publishExports, ...generated } = await generateExports(pkg, chunks, options);
+	const updatedPkg = {
+		...pkg,
+		...generated,
+		packageJsonPath: void 0
+	};
+	if (publishExports) {
+		updatedPkg.publishConfig ||= {};
+		updatedPkg.publishConfig.exports = publishExports;
+	}
+	const original = readFileSync(pkg.packageJsonPath, "utf8");
+	let contents = JSON.stringify(updatedPkg, null, detectIndentation(original));
+	if (original.endsWith("\n")) contents += "\n";
+	if (contents !== original) writeFileSync(pkg.packageJsonPath, contents, "utf8");
+}
+function shouldExclude(fileName, exclude) {
+	if (!exclude?.length) return false;
+	return matchPattern(fileName, exclude);
+}
+async function generateExports(pkg, chunks, options) {
+	let { exports: { devExports, all, packageJson = true, exclude, customExports, legacy }, css, logger } = options;
+	const pkgRoot = path.dirname(pkg.packageJsonPath);
+	let main, module, cjsTypes, esmTypes;
+	const exportsMap = /* @__PURE__ */ new Map();
+	const formats = Object.keys(chunks);
+	if (!formats.includes("cjs") && !formats.includes("es")) logger.warn(`No CJS or ESM formats found in chunks for package ${pkg.name}`);
+	const isPureESM = formats.length === 1 && formats[0] === "es";
+	legacy ??= !isPureESM;
+	for (const [format, chunksByFormat] of Object.entries(chunks)) {
+		if (format !== "es" && format !== "cjs") continue;
+		const filteredChunks = chunksByFormat.filter((chunk) => {
+			if (chunk.type !== "chunk" || !chunk.isEntry) return false;
+			const [name] = getExportName(chunk);
+			return !shouldExclude(name, exclude);
+		});
+		const onlyOneEntry = filteredChunks.filter((chunk) => !RE_DTS.test(chunk.fileName)).length === 1;
+		for (const chunk of filteredChunks) {
+			let [name, normalizedName, isDts] = getExportName(chunk);
+			const isIndex = onlyOneEntry || name === "index";
+			const distFile = join$1(pkgRoot, chunk.outDir, normalizedName);
+			if (isIndex) {
+				name = ".";
+				if (format === "cjs") if (isDts) cjsTypes = distFile;
+				else main = distFile;
+				else if (format === "es") if (isDts) esmTypes = distFile;
+				else module = distFile;
+			} else if (name.endsWith("/index")) name = `./${name.slice(0, -6)}`;
+			else name = `./${name}`;
+			let subExport = exportsMap.get(name);
+			if (!subExport) {
+				subExport = {};
+				exportsMap.set(name, subExport);
+			}
+			if (!isDts) {
+				subExport[format] = distFile;
+				if (chunk.facadeModuleId && !subExport.src) subExport.src = `./${slash(path.relative(pkgRoot, chunk.facadeModuleId))}`;
+			}
+		}
+	}
+	const sortedExportsMap = Array.from(exportsMap.entries()).toSorted(([a], [b]) => {
+		if (a === "index") return -1;
+		return a.localeCompare(b);
+	});
+	let exports = Object.fromEntries(sortedExportsMap.map(([name, subExport]) => [name, genSubExport(devExports, subExport)]));
+	exportMeta(exports, all, packageJson);
+	exportCss(exports, chunks, css, pkgRoot);
+	if (customExports) exports = await customExports(exports, {
+		pkg,
+		chunks,
+		isPublish: false
+	});
+	let publishExports;
+	if (devExports) {
+		publishExports = Object.fromEntries(sortedExportsMap.map(([name, subExport]) => [name, genSubExport(false, subExport)]));
+		exportMeta(publishExports, all, packageJson);
+		exportCss(publishExports, chunks, css, pkgRoot);
+		if (customExports) publishExports = await customExports(publishExports, {
+			pkg,
+			chunks,
+			isPublish: true
+		});
+	}
+	return {
+		main: legacy ? main || module || pkg.main : void 0,
+		module: legacy ? module || pkg.module : void 0,
+		types: legacy ? cjsTypes || esmTypes || pkg.types : pkg.types,
+		exports,
+		publishExports
+	};
+}
+function genSubExport(devExports, { src, es, cjs }) {
+	if (devExports === true) return src;
+	let value;
+	const dualFormat = es && cjs;
+	if (!dualFormat && !devExports) value = cjs || es;
+	else {
+		value = {};
+		if (typeof devExports === "string") value[devExports] = src;
+		if (es) value[dualFormat ? "import" : "default"] = es;
+		if (cjs) value[dualFormat ? "require" : "default"] = cjs;
+	}
+	return value;
+}
+function exportMeta(exports, all, packageJson) {
+	if (all) exports["./*"] = "./*";
+	else if (packageJson) exports["./package.json"] = "./package.json";
+}
+function exportCss(exports, chunks, { splitting }, pkgRoot) {
+	if (splitting) return;
+	for (const chunksByFormat of Object.values(chunks)) for (const chunk of chunksByFormat) if (chunk.type === "asset" && RE_CSS.test(chunk.fileName)) {
+		const filename = slash(chunk.fileName);
+		exports[`./${filename}`] = join$1(pkgRoot, chunk.outDir, filename);
+		return;
+	}
+}
+function hasExportsTypes(pkg) {
+	const exports = pkg?.exports;
+	if (!exports) return false;
+	if (typeof exports === "object" && exports !== null && !Array.isArray(exports)) {
+		if ("types" in exports) return true;
+		if ("." in exports) {
+			const mainExport = exports["."];
+			if (typeof mainExport === "object" && mainExport !== null && "types" in mainExport) return true;
+		}
+	}
+	return false;
+}
+function getExportName(chunk) {
+	const normalizedName = slash(chunk.fileName);
+	let name = stripExtname(normalizedName);
+	const isDts = name.endsWith(".d");
+	if (isDts) name = name.slice(0, -2);
+	return [
+		name,
+		normalizedName,
+		isDts
+	];
+}
+function join$1(pkgRoot, outDir, fileName) {
+	const outDirRelative = slash(path.relative(pkgRoot, outDir));
+	return `${outDirRelative ? `./${outDirRelative}` : "."}/${fileName}`;
+}
+function resolveTarget(logger, target, color, pkg, nameLabel) {
+	if (target === false) return;
+	if (target == null) {
+		const pkgTarget = resolvePackageTarget(pkg);
+		if (pkgTarget) target = pkgTarget;
+		else return;
+	}
+	if (typeof target === "number") throw new TypeError(`Invalid target: ${target}`);
+	const targets = resolveComma(toArray(target));
+	if (targets.length) logger.info(nameLabel, `target${targets.length > 1 ? "s" : ""}: ${color(targets.join(", "))}`);
+	return targets;
+}
+function resolvePackageTarget(pkg) {
+	const nodeVersion = pkg?.engines?.node;
+	if (!nodeVersion) return;
+	const nodeMinVersion = minVersion(nodeVersion);
+	if (!nodeMinVersion) return;
+	if (nodeMinVersion.version === "0.0.0") return;
+	return `node${nodeMinVersion.version}`;
+}
+function findTsconfig(cwd, name = "tsconfig.json") {
+	return up$1(name, { cwd }) || false;
+}
+async function resolveTsconfig(logger, tsconfig, cwd, color, nameLabel) {
+	const original = tsconfig;
+	if (tsconfig !== false) {
+		if (tsconfig === true || tsconfig == null) {
+			tsconfig = findTsconfig(cwd);
+			if (original && !tsconfig) logger.warn(`No tsconfig found in ${blue(cwd)}`);
+		} else {
+			const tsconfigPath = path.resolve(cwd, tsconfig);
+			const stat = await fsStat(tsconfigPath);
+			if (stat?.isFile()) tsconfig = tsconfigPath;
+			else if (stat?.isDirectory()) {
+				tsconfig = findTsconfig(tsconfigPath);
+				if (!tsconfig) logger.warn(`No tsconfig found in ${blue(tsconfigPath)}`);
+			} else {
+				tsconfig = findTsconfig(cwd, tsconfig);
+				if (!tsconfig) logger.warn(`tsconfig ${blue(original)} doesn't exist`);
+			}
+		}
+		if (tsconfig) logger.info(nameLabel, `tsconfig: ${color(path.relative(cwd, tsconfig))}`);
+	}
+	return tsconfig;
+}
+const debug$2$2 = createDebug("tsdown:package");
+async function readPackageJson(dir) {
+	const packageJsonPath = up({ cwd: dir });
+	if (!packageJsonPath) return;
+	debug$2$2("Reading package.json:", packageJsonPath);
+	const contents = await readFile(packageJsonPath, "utf8");
+	return {
+		...JSON.parse(contents),
+		packageJsonPath
+	};
+}
+function getPackageType(pkg) {
+	if (pkg?.type) {
+		if (!["module", "commonjs"].includes(pkg.type)) throw new Error(`Invalid package.json type: ${pkg.type}`);
+		return pkg.type;
+	}
+}
+function normalizeFormat(format) {
+	switch (format) {
+		case "es":
+		case "esm":
+		case "module": return "es";
+		case "cjs":
+		case "commonjs": return "cjs";
+		default: return format;
+	}
+}
+const debug$1$6 = createDebug("tsdown:config:file");
+async function loadViteConfig(prefix, cwd, configLoader) {
+	const loader = resolveConfigLoader(configLoader);
+	debug$1$6("Loading Vite config via loader: ", loader);
+	const parser = createParser(loader);
+	const [result] = await createConfigCoreLoader({
+		sources: [{
+			files: [`${prefix}.config`],
+			extensions: [
+				"js",
+				"mjs",
+				"ts",
+				"cjs",
+				"mts",
+				"cts"
+			],
+			parser
+		}],
+		cwd
+	}).load(true);
+	if (!result) return;
+	const { config, source } = result;
+	globalLogger.info(`Using Vite config: ${underline(source)}`);
+	const resolved = await config;
+	if (typeof resolved === "function") return resolved({
+		command: "build",
+		mode: "production"
+	});
+	return resolved;
+}
+const configPrefix = "tsdown.config";
+async function loadConfigFile(inlineConfig, workspace) {
+	let cwd = inlineConfig.cwd || process$1.cwd();
+	let overrideConfig = false;
+	let { config: filePath } = inlineConfig;
+	if (filePath === false) return { configs: [{}] };
+	if (typeof filePath === "string") {
+		const stats = await fsStat(filePath);
+		if (stats) {
+			const resolved = path.resolve(filePath);
+			if (stats.isFile()) {
+				overrideConfig = true;
+				filePath = resolved;
+				cwd = path.dirname(filePath);
+			} else if (stats.isDirectory()) cwd = resolved;
+		}
+	}
+	const loader = resolveConfigLoader(inlineConfig.configLoader);
+	debug$1$6("Using config loader:", loader);
+	const parser = createParser(loader);
+	const [result] = await createConfigCoreLoader({
+		sources: overrideConfig ? [{
+			files: [filePath],
+			extensions: [],
+			parser
+		}] : [{
+			files: [configPrefix],
+			extensions: [
+				"ts",
+				"mts",
+				"cts",
+				"js",
+				"mjs",
+				"cjs",
+				"json"
+			],
+			parser
+		}, {
+			files: ["package.json"],
+			parser
+		}],
+		cwd,
+		stopAt: workspace && path.dirname(workspace)
+	}).load(true);
+	let exported = [];
+	let file;
+	if (result) {
+		({config: exported, source: file} = result);
+		globalLogger.info(`config file: ${underline(file)}`, loader === "native" ? "" : `(${loader})`);
+		exported = await exported;
+		if (typeof exported === "function") exported = await exported(inlineConfig, { ci: isInCi });
+	}
+	exported = toArray(exported);
+	if (exported.length === 0) exported.push({});
+	if (exported.some((config) => typeof config === "function")) throw new Error("Function should not be nested within multiple tsdown configurations. It must be at the top level.\nExample: export default defineConfig(() => [...])");
+	return {
+		configs: exported.map((config) => ({
+			...config,
+			cwd: config.cwd ? path.resolve(cwd, config.cwd) : cwd
+		})),
+		file
+	};
+}
+const isBun = !!process$1.versions.bun;
+const nativeTS = process$1.features.typescript || process$1.versions.deno;
+const autoLoader = isBun || nativeTS && isSupported ? "native" : "unrun";
+function resolveConfigLoader(configLoader = "auto") {
+	if (configLoader === "auto") return autoLoader;
+	else return configLoader === "native" ? "native" : "unrun";
+}
+function createParser(loader) {
+	return async (filepath) => {
+		const basename = path.basename(filepath);
+		const isPkgJson = basename === "package.json";
+		if (basename === configPrefix || isPkgJson || basename.endsWith(".json")) {
+			const contents = await readFile(filepath, "utf8");
+			const parsed = JSON.parse(contents);
+			if (isPkgJson) return parsed?.tsdown;
+			return parsed;
+		}
+		if (loader === "native") return nativeImport(filepath);
+		return unrunImport(filepath);
+	};
+}
+async function nativeImport(id) {
+	const url = pathToFileURL(id);
+	const importAttributes = Object.create(null);
+	if (isSupported) {
+		importAttributes.cache = "no";
+		init({ skipNodeModules: true });
+	} else if (!isBun) url.searchParams.set("no-cache", crypto.randomUUID());
+	const mod = await import(url.href, { with: importAttributes }).catch((error) => {
+		if (error?.message?.includes?.("Cannot find module")) throw new Error(`Failed to load the config file. Try setting the --config-loader CLI flag to \`unrun\`.\n\n${error.message}`, { cause: error });
+		else throw error;
+	});
+	return mod.default || mod;
+}
+async function unrunImport(id) {
+	const { unrun } = await import("./dist-dc0X0G6b.js");
+	const { module } = await unrun({ path: pathToFileURL(id).href });
+	return module;
+}
+const debug$7 = createDebug("tsdown:config:options");
+const parseEnv = process$1.getBuiltinModule("node:util").parseEnv;
+/**
+* Resolve user config into resolved configs
+*
+* **Internal API, not for public use**
+* @private
+*/
+async function resolveUserConfig(userConfig, inlineConfig) {
+	let { entry, format = ["es"], plugins = [], clean = true, logLevel = "info", failOnWarn = "ci-only", customLogger, treeshake = true, platform = "node", outDir = "dist", sourcemap = false, dts, unused = false, watch = false, ignoreWatch, shims = false, skipNodeModulesBundle = false, publint = false, attw = false, fromVite, alias, tsconfig, report = true, target, env = {}, envFile, envPrefix = "TSDOWN_", copy, publicDir, hash = true, cwd = process$1.cwd(), name, workspace, external, noExternal, exports = false, bundle, unbundle = typeof bundle === "boolean" ? !bundle : false, removeNodeProtocol, nodeProtocol, cjsDefault = true, globImport = true, inlineOnly, css, fixedExtension = platform === "node", devtools = false, write = true } = userConfig;
+	const pkg = await readPackageJson(cwd);
+	if (workspace) name ||= pkg?.name;
+	const color = generateColor(name);
+	const nameLabel = getNameLabel(color, name);
+	if (!filterConfig(inlineConfig.filter, cwd, name)) {
+		debug$7("[filter] skipping config %s", cwd);
+		return [];
+	}
+	const logger = createLogger(logLevel, {
+		customLogger,
+		failOnWarn: resolveFeatureOption(failOnWarn, true)
+	});
+	if (typeof bundle === "boolean") logger.warn("`bundle` option is deprecated. Use `unbundle` instead.");
+	if (removeNodeProtocol) {
+		if (nodeProtocol) throw new TypeError("`removeNodeProtocol` is deprecated. Please only use `nodeProtocol` instead.");
+		logger.warn("`removeNodeProtocol` is deprecated. Use `nodeProtocol: \"strip\"` instead.");
+	}
+	nodeProtocol = nodeProtocol ?? (removeNodeProtocol ? "strip" : false);
+	outDir = path.resolve(cwd, outDir);
+	clean = resolveClean(clean, outDir, cwd);
+	const resolvedEntry = await resolveEntry(logger, entry, cwd, color, nameLabel);
+	if (dts == null) dts = !!(pkg?.types || pkg?.typings || hasExportsTypes(pkg));
+	target = resolveTarget(logger, target, color, pkg, nameLabel);
+	tsconfig = await resolveTsconfig(logger, tsconfig, cwd, color, nameLabel);
+	if (typeof external === "string") external = resolveRegex(external);
+	if (typeof noExternal === "string") noExternal = resolveRegex(noExternal);
+	publint = resolveFeatureOption(publint, {});
+	attw = resolveFeatureOption(attw, {});
+	exports = resolveFeatureOption(exports, {});
+	unused = resolveFeatureOption(unused, {});
+	report = resolveFeatureOption(report, {});
+	dts = resolveFeatureOption(dts, {});
+	if (!pkg) {
+		if (exports) throw new Error("`package.json` not found, cannot write exports");
+		if (publint) logger.warn(nameLabel, "publint is enabled but package.json is not found");
+		if (attw) logger.warn(nameLabel, "attw is enabled but package.json is not found");
+	}
+	if (publicDir) if (copy) throw new TypeError("`publicDir` is deprecated. Cannot be used with `copy`");
+	else logger.warn(`${blue`publicDir`} is deprecated. Use ${blue`copy`} instead.`);
+	envPrefix = toArray(envPrefix);
+	if (envPrefix.includes("")) logger.warn("`envPrefix` includes an empty string; filtering is disabled. All environment variables from the env file and process.env will be injected into the build. Ensure this is intended to avoid accidental leakage of sensitive information.");
+	const envFromProcess = filterEnv(process$1.env, envPrefix);
+	if (envFile) {
+		if (!parseEnv) throw new Error(`Your runtime does not support 'util.parseEnv()'. Please upgrade to Node.js v20.12.0 or later.`);
+		const resolvedPath = path.resolve(cwd, envFile);
+		logger.info(nameLabel, `env file: ${color(resolvedPath)}`);
+		env = {
+			...filterEnv(parseEnv(await readFile(resolvedPath, "utf8")), envPrefix),
+			...envFromProcess,
+			...env
+		};
+	} else env = {
+		...envFromProcess,
+		...env
+	};
+	debug$7(`Environment variables: %O`, env);
+	if (fromVite) {
+		const viteUserConfig = await loadViteConfig(fromVite === true ? "vite" : fromVite, cwd, inlineConfig.configLoader);
+		if (viteUserConfig) {
+			const viteAlias = viteUserConfig.resolve?.alias;
+			if (Array.isArray(viteAlias)) throw new TypeError("Unsupported resolve.alias in Vite config. Use object instead of array");
+			if (viteAlias) alias = {
+				...alias,
+				...viteAlias
+			};
+			if (viteUserConfig.plugins) plugins = [viteUserConfig.plugins, plugins];
+		}
+	}
+	ignoreWatch = toArray(ignoreWatch).map((ignore) => {
+		ignore = resolveRegex(ignore);
+		if (typeof ignore === "string") return path.resolve(cwd, ignore);
+		return ignore;
+	});
+	if (noExternal != null && typeof noExternal !== "function") {
+		const noExternalPatterns = toArray(noExternal);
+		noExternal = (id) => matchPattern(id, noExternalPatterns);
+	}
+	if (skipNodeModulesBundle && noExternal != null) throw new TypeError("`skipNodeModulesBundle` and `noExternal` are mutually exclusive options and cannot be used together.");
+	if (inlineOnly != null && inlineOnly !== false) inlineOnly = toArray(inlineOnly);
+	devtools = resolveFeatureOption(devtools, {});
+	if (devtools) if (watch) {
+		if (devtools.ui) logger.warn("Devtools UI is not supported in watch mode, disabling it.");
+		devtools.ui = false;
+	} else devtools.ui ??= !!pkgExists("@vitejs/devtools/cli");
+	const config = {
+		...userConfig,
+		alias,
+		attw,
+		cjsDefault,
+		clean,
+		copy: publicDir || copy,
+		css: resolveCssOptions(css),
+		cwd,
+		devtools,
+		dts,
+		entry: resolvedEntry,
+		env,
+		exports,
+		external,
+		fixedExtension,
+		globImport,
+		hash,
+		ignoreWatch,
+		inlineOnly,
+		logger,
+		name,
+		nameLabel,
+		nodeProtocol,
+		noExternal,
+		outDir,
+		pkg,
+		platform,
+		plugins,
+		publint,
+		report,
+		shims,
+		skipNodeModulesBundle,
+		sourcemap,
+		target,
+		treeshake,
+		tsconfig,
+		unbundle,
+		unused,
+		watch,
+		write
+	};
+	const objectFormat = typeof format === "object" && !Array.isArray(format);
+	return (objectFormat ? Object.keys(format) : resolveComma(toArray(format, "es"))).map((fmt, idx) => {
+		const once = idx === 0;
+		const overrides = objectFormat ? format[fmt] : void 0;
+		return {
+			...config,
+			copy: once ? config.copy : void 0,
+			onSuccess: once ? config.onSuccess : void 0,
+			format: normalizeFormat(fmt),
+			...overrides
+		};
+	});
+}
+/** filter env variables by prefixes */
+function filterEnv(envDict, envPrefixes) {
+	const env = {};
+	for (const [key, value] of Object.entries(envDict)) if (value != null && envPrefixes.some((prefix) => key.startsWith(prefix))) env[key] = value;
+	return env;
+}
+const defu = createDefu((obj, key, value) => {
+	if (Array.isArray(obj[key]) && Array.isArray(value)) {
+		obj[key] = value;
+		return true;
+	}
+});
+function mergeConfig(defaults, overrides) {
+	return defu(overrides, defaults);
+}
+async function mergeUserOptions(defaults, user, args) {
+	const userOutputOptions = typeof user === "function" ? await user(defaults, ...args) : user;
+	if (!userOutputOptions) return defaults;
+	return defu(userOutputOptions, defaults);
+}
+function resolveFeatureOption(value, defaults) {
+	if (typeof value === "object" && value !== null) return resolveCIOption(value.enabled ?? true) ? value : false;
+	return resolveCIOption(value) ? defaults : false;
+}
+function resolveCIOption(value) {
+	if (value === "ci-only") return isInCi ? true : false;
+	if (value === "local-only") return isInCi ? false : true;
+	return value;
+}
+function filterConfig(filter, configCwd, name) {
+	if (!filter) return true;
+	let cwd = path.relative(process$1.cwd(), configCwd);
+	if (cwd === "") cwd = ".";
+	if (filter instanceof RegExp) return name && filter.test(name) || filter.test(cwd);
+	return toArray(filter).some((value) => name && name === value || cwd === value);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/tsdown@0.20.2_@arethetypeswrong+core@0.18.2_@typescript+native-preview@7.0.0-dev.202601_11c6934cad7d4cedf7999249d5905a1c/node_modules/tsdown/dist/watch-y9OGYH2L.mjs
+const shimFile = path.resolve(import.meta.dirname, "..", "esm-shims.js");
+function getShimsInject(format, platform) {
+	if (format === "es" && platform === "node") return {
+		__dirname: [shimFile, "__dirname"],
+		__filename: [shimFile, "__filename"]
+	};
+}
+const debug$1$1 = createDebug("tsdown:dep");
+function DepPlugin({ pkg, noExternal, inlineOnly, skipNodeModulesBundle, logger, nameLabel }) {
+	const deps = pkg && Array.from(getProductionDeps(pkg));
+	return {
+		name: "tsdown:external",
+		resolveId: {
+			filter: [include(and(id(/^[^.]/), importerId(/./)))],
+			async handler(id, importer, extraOptions) {
+				if (extraOptions.isEntry) return;
+				const shouldExternal = await externalStrategy(this, id, importer, extraOptions);
+				const nodeBuiltinModule = isBuiltin(id);
+				debug$1$1("shouldExternal: %o = %o", id, shouldExternal);
+				if (shouldExternal === true || shouldExternal === "absolute") return {
+					id,
+					external: shouldExternal,
+					moduleSideEffects: nodeBuiltinModule ? false : void 0
+				};
+			}
+		},
+		generateBundle: inlineOnly === false ? void 0 : {
+			order: "post",
+			handler(options, bundle) {
+				const deps = /* @__PURE__ */ new Set();
+				const importers = /* @__PURE__ */ new Map();
+				for (const chunk of Object.values(bundle)) {
+					if (chunk.type === "asset") continue;
+					for (const id of chunk.moduleIds) {
+						if (!RE_NODE_MODULES$1.test(id)) continue;
+						const parts = slash(id).split("/node_modules/").at(-1)?.split("/");
+						if (!parts) continue;
+						let dep;
+						if (parts[0][0] === "@") dep = `${parts[0]}/${parts[1]}`;
+						else dep = parts[0];
+						deps.add(dep);
+						const module = this.getModuleInfo(id);
+						if (module) importers.set(dep, new Set([...module.importers, ...importers.get(dep) || []]));
+					}
+				}
+				debug$1$1("found deps in bundle: %o", deps);
+				if (inlineOnly) {
+					const errors = Array.from(deps).filter((dep) => !matchPattern(dep, inlineOnly)).map((dep) => `${yellow(dep)} is located in ${blue`node_modules`} but is not included in ${blue`inlineOnly`} option.\nTo fix this, either add it to ${blue`inlineOnly`}, declare it as a production or peer dependency in your package.json, or externalize it manually.\nImported by\n${[...importers.get(dep) || []].map((s) => `- ${underline(s)}`).join("\n")}`);
+					if (errors.length) this.error(errors.join("\n\n"));
+					const unusedPatterns = inlineOnly.filter((pattern) => !Array.from(deps).some((dep) => matchPattern(dep, [pattern])));
+					if (unusedPatterns.length) logger.info(nameLabel, `The following entries in ${blue`inlineOnly`} are not used in the bundle:\n${unusedPatterns.map((pattern) => `- ${yellow(pattern)}`).join("\n")}\nConsider removing them to keep your configuration clean.`);
+				} else if (deps.size) logger.warn(nameLabel, `Consider adding ${blue`inlineOnly`} option to avoid unintended bundling of dependencies, or set ${blue`inlineOnly: false`} to disable this warning.\nDetected dependencies in bundle:\n${Array.from(deps).map((dep) => `- ${yellow(dep)}`).join("\n")}`);
+			}
+		}
+	};
+	/**
+	* - `true`: always external
+	* - `false`: skip, let other plugins handle it
+	* - `'absolute'`: external as absolute path
+	* - `'no-external'`: skip, but mark as non-external for inlineOnly check
+	*/
+	async function externalStrategy(context, id, importer, extraOptions) {
+		if (id === shimFile) return false;
+		if (noExternal?.(id, importer)) return "no-external";
+		if (skipNodeModulesBundle) {
+			const resolved = await context.resolve(id, importer, extraOptions);
+			if (resolved && (resolved.external || RE_NODE_MODULES$1.test(resolved.id))) return true;
+		}
+		if (deps) {
+			if (deps.includes(id) || deps.some((dep) => id.startsWith(`${dep}/`))) return true;
+			if (importer && RE_DTS.test(importer) && !id.startsWith("@types/")) {
+				const typesName = `@types/${id.replace(/^@/, "").replaceAll("/", "__")}`;
+				if (deps.includes(typesName)) return true;
+			}
+		}
+		return false;
+	}
+}
+function getProductionDeps(pkg) {
+	return new Set([...Object.keys(pkg.dependencies || {}), ...Object.keys(pkg.peerDependencies || {})]);
+}
+/**
+* The `node:` protocol was added in Node.js v14.18.0.
+* @see https://nodejs.org/api/esm.html#node-imports
+*/
+function NodeProtocolPlugin(nodeProtocolOption) {
+	const modulesWithoutProtocol = builtinModules.filter((mod) => !mod.startsWith("node:"));
+	return {
+		name: `tsdown:node-protocol`,
+		resolveId: {
+			order: "pre",
+			filter: { id: nodeProtocolOption === "strip" ? new RegExp(`^node:(${modulesWithoutProtocol.join("|")})$`) : new RegExp(`^(${modulesWithoutProtocol.join("|")})$`) },
+			handler: nodeProtocolOption === "strip" ? (id) => {
+				return {
+					id: id.slice(5),
+					external: true,
+					moduleSideEffects: false
+				};
+			} : (id) => {
+				return {
+					id: `node:${id}`,
+					external: true,
+					moduleSideEffects: false
+				};
+			}
+		}
+	};
+}
+const debug$5 = createDebug("tsdown:report");
+const brotliCompressAsync = promisify(brotliCompress);
+const gzipAsync = promisify(gzip);
+const defaultOptions = {
+	gzip: true,
+	brotli: false,
+	maxCompressSize: 1e6
+};
+function ReportPlugin(userOptions, logger, cwd, cjsDts, nameLabel, isDualFormat) {
+	const options = {
+		...defaultOptions,
+		...userOptions
+	};
+	return {
+		name: "tsdown:report",
+		async writeBundle(outputOptions, bundle) {
+			const outDir = path.relative(cwd, outputOptions.file ? path.resolve(cwd, outputOptions.file, "..") : path.resolve(cwd, outputOptions.dir));
+			const sizes = [];
+			for (const chunk of Object.values(bundle)) {
+				const size = await calcSize(options, chunk);
+				sizes.push(size);
+			}
+			const filenameLength = Math.max(...sizes.map((size) => size.filename.length));
+			const rawTextLength = Math.max(...sizes.map((size) => size.rawText.length));
+			const gzipTextLength = Math.max(...sizes.map((size) => size.gzipText == null ? 0 : size.gzipText.length));
+			const brotliTextLength = Math.max(...sizes.map((size) => size.brotliText == null ? 0 : size.brotliText.length));
+			let totalRaw = 0;
+			for (const size of sizes) {
+				size.rawText = size.rawText.padStart(rawTextLength);
+				size.gzipText = size.gzipText?.padStart(gzipTextLength);
+				size.brotliText = size.brotliText?.padStart(brotliTextLength);
+				totalRaw += size.raw;
+			}
+			sizes.sort((a, b) => {
+				if (a.dts !== b.dts) return a.dts ? 1 : -1;
+				if (a.isEntry !== b.isEntry) return a.isEntry ? -1 : 1;
+				return b.raw - a.raw;
+			});
+			const formatLabel = isDualFormat && prettyFormat(cjsDts ? "cjs" : outputOptions.format);
+			for (const size of sizes) {
+				const filenameColor = size.dts ? green : noop;
+				const filename = path.normalize(size.filename);
+				logger.info(nameLabel, formatLabel, dim(outDir + path.sep) + filenameColor((size.isEntry ? bold : noop)(filename)), ` `.repeat(filenameLength - size.filename.length), dim(size.rawText), options.gzip && size.gzipText && dim`│ gzip: ${size.gzipText}`, options.brotli && size.brotliText && dim`│ brotli: ${size.brotliText}`);
+			}
+			const totalSizeText = formatBytes(totalRaw);
+			logger.info(nameLabel, formatLabel, `${sizes.length} files, total: ${totalSizeText}`);
+		}
+	};
+}
+async function calcSize(options, chunk) {
+	debug$5(`Calculating size for`, chunk.fileName);
+	const content = chunk.type === "chunk" ? chunk.code : chunk.source;
+	const raw = Buffer.byteLength(content, "utf8");
+	debug$5("[size]", chunk.fileName, raw);
+	let gzip = Infinity;
+	let brotli = Infinity;
+	if (raw > options.maxCompressSize) debug$5(chunk.fileName, "file size exceeds limit, skip gzip/brotli");
+	else {
+		if (options.gzip) {
+			gzip = (await gzipAsync(content)).length;
+			debug$5("[gzip]", chunk.fileName, gzip);
+		}
+		if (options.brotli) {
+			brotli = (await brotliCompressAsync(content)).length;
+			debug$5("[brotli]", chunk.fileName, brotli);
+		}
+	}
+	return {
+		filename: chunk.fileName,
+		dts: RE_DTS.test(chunk.fileName),
+		isEntry: chunk.type === "chunk" && chunk.isEntry,
+		raw,
+		rawText: formatBytes(raw),
+		gzip,
+		gzipText: formatBytes(gzip),
+		brotli,
+		brotliText: formatBytes(brotli)
+	};
+}
+const RE_SHEBANG = /^#!.*/;
+function ShebangPlugin(logger, cwd, nameLabel, isDualFormat) {
+	return {
+		name: "tsdown:shebang",
+		async writeBundle(options, bundle) {
+			for (const chunk of Object.values(bundle)) {
+				if (chunk.type !== "chunk" || !chunk.isEntry) continue;
+				if (!RE_SHEBANG.test(chunk.code)) continue;
+				const filepath = path.resolve(cwd, options.file || path.join(options.dir, chunk.fileName));
+				if (await fsExists(filepath)) {
+					logger.info(nameLabel, isDualFormat && prettyFormat(options.format), `Granting execute permission to ${underline(path.relative(cwd, filepath))}`);
+					await chmod(filepath, 493);
+				}
+			}
+		}
+	};
+}
+function addOutDirToChunks(chunks, outDir) {
+	return chunks.map((chunk) => {
+		chunk.outDir = outDir;
+		return chunk;
+	});
+}
+const endsWithConfig = /[\\/](?:tsdown\.config.*|package\.json|tsconfig\.json)$/;
+function WatchPlugin(configFiles, { config, chunks }) {
+	return {
+		name: "tsdown:watch",
+		options: config.ignoreWatch.length ? (inputOptions) => {
+			inputOptions.watch ||= {};
+			inputOptions.watch.exclude = toArray(inputOptions.watch.exclude);
+			inputOptions.watch.exclude.push(...config.ignoreWatch);
+		} : void 0,
+		buildStart() {
+			config.tsconfig && this.addWatchFile(config.tsconfig);
+			for (const file of configFiles) this.addWatchFile(file);
+			if (typeof config.watch !== "boolean") for (const file of resolveComma(toArray(config.watch))) this.addWatchFile(file);
+			if (config.pkg) this.addWatchFile(config.pkg.packageJsonPath);
+		},
+		generateBundle: {
+			order: "post",
+			handler(outputOptions, bundle) {
+				chunks.push(...addOutDirToChunks(Object.values(bundle), config.outDir));
+			}
+		}
+	};
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/hookable@6.0.1/node_modules/hookable/dist/index.mjs
+function flatHooks(configHooks, hooks = {}, parentName) {
+	for (const key in configHooks) {
+		const subHook = configHooks[key];
+		const name = parentName ? `${parentName}:${key}` : key;
+		if (typeof subHook === "object" && subHook !== null) flatHooks(subHook, hooks, name);
+		else if (typeof subHook === "function") hooks[name] = subHook;
+	}
+	return hooks;
+}
+const createTask = /* @__PURE__ */ (() => {
+	if (console.createTask) return console.createTask;
+	const defaultTask = { run: (fn) => fn() };
+	return () => defaultTask;
+})();
+function callHooks(hooks, args, startIndex, task) {
+	for (let i = startIndex; i < hooks.length; i += 1) try {
+		const result = task ? task.run(() => hooks[i](...args)) : hooks[i](...args);
+		if (result instanceof Promise) return result.then(() => callHooks(hooks, args, i + 1, task));
+	} catch (error) {
+		return Promise.reject(error);
+	}
+}
+function serialTaskCaller(hooks, args, name) {
+	if (hooks.length > 0) return callHooks(hooks, args, 0, createTask(name));
+}
+function parallelTaskCaller(hooks, args, name) {
+	if (hooks.length > 0) {
+		const task = createTask(name);
+		return Promise.all(hooks.map((hook) => task.run(() => hook(...args))));
+	}
+}
+function callEachWith(callbacks, arg0) {
+	for (const callback of [...callbacks]) callback(arg0);
+}
+var Hookable = class {
+	_hooks;
+	_before;
+	_after;
+	_deprecatedHooks;
+	_deprecatedMessages;
+	constructor() {
+		this._hooks = {};
+		this._before = void 0;
+		this._after = void 0;
+		this._deprecatedMessages = void 0;
+		this._deprecatedHooks = {};
+		this.hook = this.hook.bind(this);
+		this.callHook = this.callHook.bind(this);
+		this.callHookWith = this.callHookWith.bind(this);
+	}
+	hook(name, function_, options = {}) {
+		if (!name || typeof function_ !== "function") return () => {};
+		const originalName = name;
+		let dep;
+		while (this._deprecatedHooks[name]) {
+			dep = this._deprecatedHooks[name];
+			name = dep.to;
+		}
+		if (dep && !options.allowDeprecated) {
+			let message = dep.message;
+			if (!message) message = `${originalName} hook has been deprecated` + (dep.to ? `, please use ${dep.to}` : "");
+			if (!this._deprecatedMessages) this._deprecatedMessages = /* @__PURE__ */ new Set();
+			if (!this._deprecatedMessages.has(message)) {
+				console.warn(message);
+				this._deprecatedMessages.add(message);
+			}
+		}
+		if (!function_.name) try {
+			Object.defineProperty(function_, "name", {
+				get: () => "_" + name.replace(/\W+/g, "_") + "_hook_cb",
+				configurable: true
+			});
+		} catch {}
+		this._hooks[name] = this._hooks[name] || [];
+		this._hooks[name].push(function_);
+		return () => {
+			if (function_) {
+				this.removeHook(name, function_);
+				function_ = void 0;
+			}
+		};
+	}
+	hookOnce(name, function_) {
+		let _unreg;
+		let _function = (...arguments_) => {
+			if (typeof _unreg === "function") _unreg();
+			_unreg = void 0;
+			_function = void 0;
+			return function_(...arguments_);
+		};
+		_unreg = this.hook(name, _function);
+		return _unreg;
+	}
+	removeHook(name, function_) {
+		const hooks = this._hooks[name];
+		if (hooks) {
+			const index = hooks.indexOf(function_);
+			if (index !== -1) hooks.splice(index, 1);
+			if (hooks.length === 0) this._hooks[name] = void 0;
+		}
+	}
+	deprecateHook(name, deprecated) {
+		this._deprecatedHooks[name] = typeof deprecated === "string" ? { to: deprecated } : deprecated;
+		const _hooks = this._hooks[name] || [];
+		this._hooks[name] = void 0;
+		for (const hook of _hooks) this.hook(name, hook);
+	}
+	deprecateHooks(deprecatedHooks) {
+		for (const name in deprecatedHooks) this.deprecateHook(name, deprecatedHooks[name]);
+	}
+	addHooks(configHooks) {
+		const hooks = flatHooks(configHooks);
+		const removeFns = Object.keys(hooks).map((key) => this.hook(key, hooks[key]));
+		return () => {
+			for (const unreg of removeFns) unreg();
+			removeFns.length = 0;
+		};
+	}
+	removeHooks(configHooks) {
+		const hooks = flatHooks(configHooks);
+		for (const key in hooks) this.removeHook(key, hooks[key]);
+	}
+	removeAllHooks() {
+		this._hooks = {};
+	}
+	callHook(name, ...args) {
+		return this.callHookWith(serialTaskCaller, name, args);
+	}
+	callHookParallel(name, ...args) {
+		return this.callHookWith(parallelTaskCaller, name, args);
+	}
+	callHookWith(caller, name, args) {
+		const event = this._before || this._after ? {
+			name,
+			args,
+			context: {}
+		} : void 0;
+		if (this._before) callEachWith(this._before, event);
+		const result = caller(this._hooks[name] ? [...this._hooks[name]] : [], args, name);
+		if (result instanceof Promise) return result.finally(() => {
+			if (this._after && event) callEachWith(this._after, event);
+		});
+		if (this._after && event) callEachWith(this._after, event);
+		return result;
+	}
+	beforeEach(function_) {
+		this._before = this._before || [];
+		this._before.push(function_);
+		return () => {
+			if (this._before !== void 0) {
+				const index = this._before.indexOf(function_);
+				if (index !== -1) this._before.splice(index, 1);
+			}
+		};
+	}
+	afterEach(function_) {
+		this._after = this._after || [];
+		this._after.push(function_);
+		return () => {
+			if (this._after !== void 0) {
+				const index = this._after.indexOf(function_);
+				if (index !== -1) this._after.splice(index, 1);
+			}
+		};
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/tsdown@0.20.2_@arethetypeswrong+core@0.18.2_@typescript+native-preview@7.0.0-dev.202601_11c6934cad7d4cedf7999249d5905a1c/node_modules/tsdown/dist/build-l5WhXg4M.mjs
+var build_l5WhXg4M_exports = /* @__PURE__ */ __exportAll({
+	n: () => buildWithConfigs,
+	r: () => build_exports,
+	t: () => build$1
+});
+const __cjs_require = createRequire(import.meta.url);
+const coerce = __cjs_require("./npm_entry_semver_functions_coerce.cjs");
+const satisfies = __cjs_require("./npm_entry_semver_functions_satisfies.cjs");
+const treeKill = __cjs_require("./npm_entry_tree-kill.cjs");
+const debug$4 = createDebug("tsdown:config:workspace");
+const DEFAULT_EXCLUDE_WORKSPACE = [
+	"**/node_modules/**",
+	"**/dist/**",
+	"**/test?(s)/**",
+	"**/t?(e)mp/**"
+];
+async function resolveWorkspace(config, inlineConfig) {
+	const normalized = {
+		...config,
+		...inlineConfig
+	};
+	const rootCwd = normalized.cwd || process$1.cwd();
+	let { workspace } = normalized;
+	if (!workspace) return {
+		configs: [normalized],
+		files: []
+	};
+	if (workspace === true) workspace = {};
+	else if (typeof workspace === "string" || Array.isArray(workspace)) workspace = { include: workspace };
+	let { include: packages = "auto", exclude = DEFAULT_EXCLUDE_WORKSPACE, config: workspaceConfig } = workspace;
+	if (packages === "auto") packages = (await glob("**/package.json", {
+		ignore: exclude,
+		cwd: rootCwd,
+		expandDirectories: false
+	})).filter((file) => file !== "package.json").map((file) => slash(path.resolve(rootCwd, file, "..")));
+	else packages = (await glob(packages, {
+		ignore: exclude,
+		cwd: rootCwd,
+		onlyDirectories: true,
+		absolute: true,
+		expandDirectories: false
+	})).map((file) => slash(path.resolve(file)));
+	if (packages.length === 0) throw new Error("No workspace packages found, please check your config");
+	const files = [];
+	return {
+		configs: (await Promise.all(packages.map(async (cwd) => {
+			debug$4("loading workspace config %s", cwd);
+			const { configs, file } = await loadConfigFile({
+				...inlineConfig,
+				config: workspaceConfig,
+				cwd
+			}, cwd);
+			if (file) {
+				debug$4("loaded workspace config file %s", file);
+				files.push(file);
+			} else debug$4("no workspace config file found in %s", cwd);
+			return configs.map((config) => ({
+				...normalized,
+				...config
+			}));
+		}))).flat(),
+		files
+	};
+}
+const debug$3 = createDebug("tsdown:config");
+async function resolveConfig(inlineConfig) {
+	debug$3("inline config %O", inlineConfig);
+	if (inlineConfig.cwd) inlineConfig.cwd = path.resolve(inlineConfig.cwd);
+	const { configs: rootConfigs, file } = await loadConfigFile(inlineConfig);
+	const files = [];
+	if (file) {
+		files.push(file);
+		debug$3("loaded root user config file %s", file);
+		debug$3("root user configs %O", rootConfigs);
+	} else debug$3("no root user config file found");
+	const configs = (await Promise.all(rootConfigs.map(async (rootConfig) => {
+		const { configs: workspaceConfigs, files: workspaceFiles } = await resolveWorkspace(rootConfig, inlineConfig);
+		debug$3("workspace configs %O", workspaceConfigs);
+		if (workspaceFiles) files.push(...workspaceFiles);
+		return (await Promise.all(workspaceConfigs.filter((config) => !config.workspace || config.entry).map((config) => resolveUserConfig(config, inlineConfig)))).flat().filter((config) => !!config);
+	}))).flat();
+	debug$3("resolved configs %O", configs);
+	if (configs.length === 0) throw new Error("No valid configuration found.");
+	return {
+		configs,
+		files
+	};
+}
+function warnLegacyCJS(config) {
+	if (!config.target || !(config.checks?.legacyCjs ?? true) || !config.format.includes("cjs")) return;
+	if (config.target.some((t) => {
+		const version = coerce(t.split("node")[1]);
+		return version && satisfies(version, "^20.19.0 || >=22.12.0");
+	})) config.logger.warnOnce("We recommend using the ESM format instead of CommonJS.\nThe ESM format is compatible with modern platforms and runtimes, and most new libraries are now distributed only in ESM format.\nLearn more at https://nodejs.org/en/learn/modules/publishing-a-package#how-did-we-get-here");
+}
+async function copy(options) {
+	if (!options.copy) return;
+	const copy = typeof options.copy === "function" ? await options.copy(options) : options.copy;
+	const resolved = (await Promise.all(toArray(copy).map(async (entry) => {
+		if (typeof entry === "string") entry = { from: [entry] };
+		let from = toArray(entry.from);
+		if (from.some((f) => isDynamicPattern(f))) from = await glob(from, {
+			cwd: options.cwd,
+			onlyFiles: true,
+			expandDirectories: false
+		});
+		return from.map((file) => resolveCopyEntry({
+			...entry,
+			from: file
+		}));
+	}))).flat();
+	if (!resolved.length) {
+		options.logger.warn(options.nameLabel, `No files matched for copying.`);
+		return;
+	}
+	await Promise.all(resolved.map(({ from, to, verbose }) => {
+		if (verbose) options.logger.info(options.nameLabel, `Copying files from ${path.relative(options.cwd, from)} to ${path.relative(options.cwd, to)}`);
+		return fsCopy(from, to);
+	}));
+	function resolveCopyEntry(entry) {
+		const { flatten = true, rename } = entry;
+		const from = path.resolve(options.cwd, entry.from);
+		const to = entry.to ? path.resolve(options.cwd, entry.to) : options.outDir;
+		const { base, dir } = path.parse(path.relative(options.cwd, from));
+		const destFolder = flatten || !flatten && !dir ? to : dir.replace(dir.split(path.sep)[0], to);
+		const dest = path.join(destFolder, rename ? renameTarget(base, rename, from) : base);
+		return {
+			...entry,
+			from,
+			to: dest
+		};
+	}
+}
+function renameTarget(target, rename, src) {
+	const parsedPath = path.parse(target);
+	return typeof rename === "string" ? rename : rename(parsedPath.name, parsedPath.ext.replace(".", ""), src);
+}
+async function startDevtoolsUI(config) {
+	const { start } = await importWithError("@vitejs/devtools/cli-commands");
+	await start({
+		host: "127.0.0.1",
+		open: true,
+		...typeof config.ui === "object" ? config.ui : {}
+	});
+}
+async function createHooks(options) {
+	const hooks = new Hookable();
+	if (typeof options.hooks === "object") hooks.addHooks(options.hooks);
+	else if (typeof options.hooks === "function") await options.hooks(hooks);
+	return {
+		hooks,
+		context: {
+			options,
+			hooks
+		}
+	};
+}
+function executeOnSuccess(config) {
+	if (!config.onSuccess) return;
+	const ab = new AbortController();
+	if (typeof config.onSuccess === "string") {
+		const p = q(config.onSuccess, [], { nodeOptions: {
+			shell: true,
+			stdio: "inherit"
+		} });
+		p.then(({ exitCode }) => {
+			if (exitCode) process$1.exitCode = exitCode;
+		});
+		ab.signal.addEventListener("abort", () => {
+			if (typeof p.pid === "number") treeKill(p.pid);
+		});
+	} else config.onSuccess(config, ab.signal);
+	return ab;
+}
+const debug$2 = createDebug("tsdown:attw");
+const label$1 = dim`[attw]`;
+const problemFlags = {
+	NoResolution: "no-resolution",
+	UntypedResolution: "untyped-resolution",
+	FalseCJS: "false-cjs",
+	FalseESM: "false-esm",
+	CJSResolvesToESM: "cjs-resolves-to-esm",
+	FallbackCondition: "fallback-condition",
+	CJSOnlyExportsDefault: "cjs-only-exports-default",
+	NamedExports: "named-exports",
+	FalseExportDefault: "false-export-default",
+	MissingExportEquals: "missing-export-equals",
+	UnexpectedModuleSyntax: "unexpected-module-syntax",
+	InternalResolutionError: "internal-resolution-error"
+};
+/**
+* ATTW profiles.
+* Defines the resolution modes to ignore for each profile.
+*
+* @see https://github.com/arethetypeswrong/arethetypeswrong.github.io/blob/main/packages/cli/README.md#profiles
+*/
+const profiles = {
+	strict: [],
+	node16: ["node10"],
+	"esm-only": ["node10", "node16-cjs"]
+};
+async function attw(options, tarball) {
+	if (!options.attw) return;
+	if (!options.pkg) {
+		options.logger.warn("attw is enabled but package.json is not found");
+		return;
+	}
+	const { profile = "strict", level = "warn", ignoreRules = [], ...attwOptions } = options.attw;
+	const invalidRules = ignoreRules.filter((rule) => !Object.values(problemFlags).includes(rule));
+	if (invalidRules.length) options.logger.warn(`attw config option 'ignoreRules' contains invalid value '${invalidRules.join(", ")}'.`);
+	const t = performance.now();
+	debug$2("Running attw check");
+	const attwCore = await importWithError("@arethetypeswrong/core", options.attw.resolvePaths);
+	const pkg = attwCore.createPackageFromTarballData(tarball);
+	const checkResult = await attwCore.checkPackage(pkg, attwOptions);
+	let errorMessage;
+	if (checkResult.types) {
+		const problems = checkResult.problems.filter((problem) => {
+			if (ignoreRules.includes(problemFlags[problem.kind])) return false;
+			if ("resolutionKind" in problem) return !profiles[profile]?.includes(problem.resolutionKind);
+			return true;
+		});
+		if (problems.length) errorMessage = `problems found:\n${problems.map((problem) => formatProblem(checkResult.packageName, problem)).join("\n")}`;
+	} else errorMessage = `Package has no types`;
+	if (errorMessage) options.logger[level](options.nameLabel, label$1, errorMessage);
+	else options.logger.success(options.nameLabel, label$1, "No problems found", dim`(${Math.round(performance.now() - t)}ms)`);
+}
+/**
+* Format an ATTW problem for display
+*/
+function formatProblem(packageName, problem) {
+	const resolutionKind = "resolutionKind" in problem ? ` (${problem.resolutionKind})` : "";
+	const entrypoint = "entrypoint" in problem ? ` at ${slash(path.join(packageName, problem.entrypoint))}` : "";
+	switch (problem.kind) {
+		case "NoResolution": return `  ❌ No resolution${resolutionKind}${entrypoint}`;
+		case "UntypedResolution": return `  ⚠️  Untyped resolution${resolutionKind}${entrypoint}`;
+		case "FalseESM": return `  🔄 False ESM: Types indicate ESM (${problem.typesModuleKind}) but implementation is CJS (${problem.implementationModuleKind})\n     Types: ${problem.typesFileName} | Implementation: ${problem.implementationFileName}`;
+		case "FalseCJS": return `  🔄 False CJS: Types indicate CJS (${problem.typesModuleKind}) but implementation is ESM (${problem.implementationModuleKind})\n     Types: ${problem.typesFileName} | Implementation: ${problem.implementationFileName}`;
+		case "CJSResolvesToESM": return `  ⚡ CJS resolves to ESM${resolutionKind}${entrypoint}`;
+		case "NamedExports": {
+			const missingExports = problem.missing?.length > 0 ? ` Missing: ${problem.missing.join(", ")}` : "";
+			return `  📤 Named exports problem${problem.isMissingAllNamed ? " (all named exports missing)" : ""}${missingExports}\n     Types: ${problem.typesFileName} | Implementation: ${problem.implementationFileName}`;
+		}
+		case "FallbackCondition": return `  🎯 Fallback condition used${resolutionKind}${entrypoint}`;
+		case "FalseExportDefault": return `  🎭 False export default\n     Types: ${problem.typesFileName} | Implementation: ${problem.implementationFileName}`;
+		case "MissingExportEquals": return `  📝 Missing export equals\n     Types: ${problem.typesFileName} | Implementation: ${problem.implementationFileName}`;
+		case "InternalResolutionError": return `  💥 Internal resolution error in ${problem.fileName} (${problem.resolutionOption})\n     Module: ${problem.moduleSpecifier} | Mode: ${problem.resolutionMode}`;
+		case "UnexpectedModuleSyntax": return `  📋 Unexpected module syntax in ${problem.fileName}\n     Expected: ${problem.moduleKind} | Found: ${problem.syntax === 99 ? "ESM" : "CJS"}`;
+		case "CJSOnlyExportsDefault": return `  🏷️  CJS only exports default in ${problem.fileName}`;
+		default: return `  ❓ Unknown problem: ${JSON.stringify(problem)}`;
+	}
+}
+const debug$1 = createDebug("tsdown:publint");
+const label = dim`[publint]`;
+async function publint(options, tarball) {
+	if (!options.publint) return;
+	if (!options.pkg) {
+		options.logger.warn(options.nameLabel, "publint is enabled but package.json is not found");
+		return;
+	}
+	const t = performance.now();
+	debug$1("Running publint");
+	const { publint } = await importWithError("publint", options.publint.resolvePaths);
+	const { formatMessage } = await importWithError("publint/utils", options.publint.resolvePaths);
+	const { messages } = await publint({
+		...options.publint,
+		pack: { tarball: tarball.buffer }
+	});
+	debug$1("Found %d issues", messages.length);
+	if (!messages.length) {
+		options.logger.success(options.nameLabel, label, "No issues found", dim`(${Math.round(performance.now() - t)}ms)`);
+		return;
+	}
+	for (const message of messages) {
+		const formattedMessage = formatMessage(message, options.pkg);
+		const logType = {
+			error: "error",
+			warning: "warn",
+			suggestion: "info"
+		}[message.type];
+		options.logger[logType](options.nameLabel, label, formattedMessage);
+	}
+}
+function initBundleByPkg(configs) {
+	const map = {};
+	for (const config of configs) {
+		const pkgJson = config.pkg?.packageJsonPath;
+		if (!pkgJson) continue;
+		if (!map[pkgJson]) {
+			const { promise, resolve } = promiseWithResolvers();
+			map[pkgJson] = {
+				promise,
+				resolve,
+				count: 0,
+				formats: /* @__PURE__ */ new Set(),
+				bundles: []
+			};
+		}
+		map[pkgJson].count++;
+		map[pkgJson].formats.add(config.format);
+	}
+	return map;
+}
+async function bundleDone(bundleByPkg, bundle) {
+	const pkg = bundle.config.pkg;
+	if (!pkg) return;
+	const ctx = bundleByPkg[pkg.packageJsonPath];
+	ctx.bundles.push(bundle);
+	if (ctx.bundles.length < ctx.count) return ctx.promise;
+	const configs = ctx.bundles.map(({ config }) => config);
+	const exportsConfigs = dedupeConfigs(configs, "exports");
+	if (exportsConfigs.length) {
+		if (exportsConfigs.length > 1) throw new Error(`Conflicting exports options for package at ${pkg.packageJsonPath}. Please merge them:\n${exportsConfigs.map((config) => `- ${formatWithOptions({ colors: true }, config.exports)}`).join("\n")}`);
+		const chunks = {};
+		for (const bundle of ctx.bundles) {
+			if (!bundle.config.exports) continue;
+			chunks[bundle.config.format] ||= [];
+			chunks[bundle.config.format].push(...bundle.chunks);
+		}
+		await writeExports(exportsConfigs[0], chunks);
+	}
+	const publintConfigs = dedupeConfigs(configs, "publint");
+	const attwConfigs = dedupeConfigs(configs, "attw");
+	if (publintConfigs.length > 1 || attwConfigs.length > 1) publintConfigs[1].logger.warn(`Multiple publint or attw configurations found for package at ${pkg.packageJsonPath}. Consider merging them for better consistency and performance.`);
+	try {
+		if (publintConfigs.length || attwConfigs.length) {
+			const tarball = await packTarball(pkg.packageJsonPath);
+			await Promise.all([...publintConfigs.map((config) => publint(config, tarball)), ...attwConfigs.map((config) => attw(config, tarball))]);
+		}
+	} catch (error) {
+		configs[0].logger.error("Pack failed:", error);
+	}
+	ctx.resolve();
+}
+async function packTarball(packageJsonPath) {
+	const pkgDir = path.dirname(packageJsonPath);
+	const destination = await mkdtemp(path.join(tmpdir(), "tsdown-pack-"));
+	const [{ detect }, { pack }] = await Promise.all([import("./detect-CCATtVj7-B86m8IqW.js"), import("./index-node-BjDys8jy--sqPE5mM.js")]);
+	try {
+		const detected = await detect({ cwd: pkgDir });
+		if (detected?.name === "deno") throw new Error(`Cannot pack tarball for Deno projects at ${pkgDir}`);
+		return readFile(await pack(pkgDir, {
+			destination,
+			packageManager: detected?.name
+		}));
+	} finally {
+		await fsRemove(destination);
+	}
+}
+function dedupeConfigs(configs, key) {
+	const filtered = configs.filter((config) => config[key]);
+	if (!filtered.length) return [];
+	const seen = /* @__PURE__ */ new Set();
+	const results = filtered.filter((config) => {
+		if (!Object.keys(config[key]).length) return false;
+		if (seen.has(config[key])) return false;
+		seen.add(config[key]);
+		return true;
+	});
+	if (results.length === 0) return [filtered[0]];
+	return results;
+}
+/**
+* Converts esbuild target [^1] (which is also used by Rolldown [^2]) to Lightning CSS targets [^3].
+*
+* [^1]: https://esbuild.github.io/api/#target
+* [^2]: https://github.com/rolldown/rolldown/blob/v1.0.0-beta.8/packages/rolldown/src/binding.d.ts#L1429-L1431
+* [^3]: https://lightningcss.dev/transpilation.html
+*/
+function esbuildTargetToLightningCSS(target) {
+	let targets;
+	const matches = [...target.join(" ").toLowerCase().matchAll(TARGET_REGEX)];
+	for (const match of matches) {
+		const browser = ESBUILD_LIGHTNINGCSS_MAPPING[match[1]];
+		if (!browser) continue;
+		const version = match[2];
+		const versionInt = parseVersion(version);
+		if (versionInt == null) continue;
+		targets = targets || {};
+		targets[browser] = versionInt;
+	}
+	return targets;
+}
+const TARGET_REGEX = /([a-z]+)(\d+(?:\.\d+)*)/g;
+const ESBUILD_LIGHTNINGCSS_MAPPING = {
+	chrome: "chrome",
+	edge: "edge",
+	firefox: "firefox",
+	ie: "ie",
+	ios: "ios_saf",
+	opera: "opera",
+	safari: "safari"
+};
+function parseVersion(version) {
+	const [major, minor = 0, patch = 0] = version.split("-")[0].split(".").map((v) => Number.parseInt(v, 10));
+	if (Number.isNaN(major) || Number.isNaN(minor) || Number.isNaN(patch)) return null;
+	return major << 16 | minor << 8 | patch;
+}
+async function LightningCSSPlugin(options) {
+	const LightningCSS = await import("unplugin-lightningcss/rolldown").catch(() => void 0);
+	if (!LightningCSS) return;
+	const targets = options.target && esbuildTargetToLightningCSS(options.target);
+	if (!targets) return;
+	return LightningCSS.default({ options: { targets } });
+}
+/**
+* CSS Code Split Plugin
+*
+* When css.splitting is false, this plugin merges all CSS files into a single file.
+* When css.splitting is true (default), CSS code splitting is preserved.
+* Based on Vite's implementation.
+*/
+function CssCodeSplitPlugin(config) {
+	const { splitting, fileName } = config.css;
+	if (splitting) return;
+	return {
+		name: "tsdown:css:splitting",
+		generateBundle(_outputOptions, bundle) {
+			const chunks = Object.values(bundle);
+			const cssAssets = /* @__PURE__ */ new Map();
+			for (const asset of chunks) if (asset.type === "asset" && typeof asset.source === "string" && RE_CSS.test(fileName)) cssAssets.set(asset.fileName, asset.source);
+			if (!cssAssets.size) return;
+			const chunkCSSMap = /* @__PURE__ */ new Map();
+			for (const chunk of chunks) {
+				if (chunk.type !== "chunk") continue;
+				for (const moduleId of chunk.moduleIds) if (RE_CSS.test(moduleId)) {
+					if (!chunkCSSMap.has(chunk.fileName)) chunkCSSMap.set(chunk.fileName, []);
+					break;
+				}
+			}
+			for (const cssFileName of cssAssets.keys()) {
+				const cssBaseName = normalizeCssFileName(cssFileName);
+				for (const chunkFileName of chunkCSSMap.keys()) if (normalizeChunkFileName(chunkFileName) === cssBaseName || chunkFileName.startsWith(`${cssBaseName}-`)) {
+					chunkCSSMap.get(chunkFileName).push(cssFileName);
+					break;
+				}
+			}
+			let extractedCss = "";
+			const collected = /* @__PURE__ */ new Set();
+			const dynamicImports = /* @__PURE__ */ new Set();
+			function collect(chunk) {
+				if (!chunk || chunk.type !== "chunk" || collected.has(chunk)) return;
+				collected.add(chunk);
+				chunk.imports.forEach((importName) => {
+					collect(bundle[importName]);
+				});
+				chunk.dynamicImports.forEach((importName) => {
+					dynamicImports.add(importName);
+				});
+				const files = chunkCSSMap.get(chunk.fileName);
+				if (files && files.length > 0) for (const filename of files) extractedCss += cssAssets.get(filename) ?? "";
+			}
+			for (const chunk of chunks) if (chunk.type === "chunk" && chunk.isEntry) collect(chunk);
+			for (const chunkName of dynamicImports) collect(bundle[chunkName]);
+			if (extractedCss) {
+				for (const fileName of cssAssets.keys()) delete bundle[fileName];
+				this.emitFile({
+					type: "asset",
+					source: extractedCss,
+					fileName,
+					originalFileName: defaultCssBundleName
+				});
+			}
+		}
+	};
+}
+const RE_CSS_HASH = /-[\w-]+\.css$/;
+const RE_CHUNK_HASH = /-[\w-]+\.(m?js|cjs)$/;
+const RE_CHUNK_EXT = /\.(m?js|cjs)$/;
+/**
+* Normalize CSS file name by removing hash pattern and extension.
+* e.g., "async-DcjEOEdU.css" -> "async"
+*/
+function normalizeCssFileName(cssFileName) {
+	return cssFileName.replace(RE_CSS_HASH, "").replace(RE_CSS, "");
+}
+/**
+* Normalize chunk file name by removing hash pattern and extension.
+* e.g., "async-CvIfFAic.mjs" -> "async"
+*/
+function normalizeChunkFileName(chunkFileName) {
+	return chunkFileName.replace(RE_CHUNK_HASH, "").replace(RE_CHUNK_EXT, "");
+}
+function resolveJsOutputExtension(packageType, format, fixedExtension) {
+	switch (format) {
+		case "es": return !fixedExtension && packageType === "module" ? "js" : "mjs";
+		case "cjs": return fixedExtension || packageType === "module" ? "cjs" : "js";
+		default: return "js";
+	}
+}
+function resolveChunkFilename({ outExtensions, fixedExtension, pkg, hash }, inputOptions, format) {
+	const packageType = getPackageType(pkg);
+	let jsExtension;
+	let dtsExtension;
+	if (outExtensions) {
+		const { js, dts } = outExtensions({
+			options: inputOptions,
+			format,
+			pkgType: packageType
+		}) || {};
+		jsExtension = js;
+		dtsExtension = dts;
+	}
+	jsExtension ??= `.${resolveJsOutputExtension(packageType, format, fixedExtension)}`;
+	const suffix = format === "iife" || format === "umd" ? `.${format}` : "";
+	return [createChunkFilename(`[name]${suffix}`, jsExtension, dtsExtension), createChunkFilename(`[name]${suffix}${hash ? "-[hash]" : ""}`, jsExtension, dtsExtension)];
+}
+function createChunkFilename(basename, jsExtension, dtsExtension) {
+	if (dtsExtension === void 0) return `${basename}${jsExtension}`;
+	return (chunk) => {
+		return `${basename}${chunk.name.endsWith(".d") ? dtsExtension : jsExtension}`;
+	};
+}
+function resolveChunkAddon(chunkAddon, format) {
+	if (!chunkAddon) return;
+	return (chunk) => {
+		if (typeof chunkAddon === "function") chunkAddon = chunkAddon({
+			format,
+			fileName: chunk.fileName
+		});
+		if (typeof chunkAddon === "string") return chunkAddon;
+		switch (true) {
+			case RE_JS.test(chunk.fileName): return chunkAddon?.js || "";
+			case RE_CSS.test(chunk.fileName): return chunkAddon?.css || "";
+			case RE_DTS.test(chunk.fileName): return chunkAddon?.dts || "";
+			default: return "";
+		}
+	};
+}
+const debug = createDebug("tsdown:rolldown");
+async function getBuildOptions(config, format, configFiles, bundle, cjsDts = false, isDualFormat) {
+	const inputOptions = await resolveInputOptions(config, format, configFiles, bundle, cjsDts, isDualFormat);
+	const outputOptions = await resolveOutputOptions(inputOptions, config, format, cjsDts);
+	const rolldownConfig = {
+		...inputOptions,
+		output: outputOptions,
+		write: config.write
+	};
+	debug("rolldown config with format \"%s\" %O", cjsDts ? "cjs dts" : format, rolldownConfig);
+	return rolldownConfig;
+}
+async function resolveInputOptions(config, format, configFiles, bundle, cjsDts, isDualFormat) {
+	const { alias, checks: { legacyCjs, ...checks } = {}, cjsDefault, cwd, devtools, dts, entry, env, external, globImport, loader, logger, nameLabel, nodeProtocol, platform, plugins: userPlugins, report, shims, target, treeshake, tsconfig, unused, watch } = config;
+	const plugins = [];
+	if (nodeProtocol) plugins.push(NodeProtocolPlugin(nodeProtocol));
+	if (config.pkg || config.skipNodeModulesBundle) plugins.push(DepPlugin(config));
+	if (dts) {
+		const { dts: dtsPlugin } = await import("./dist-BVMGwPdF.js");
+		const options = {
+			tsconfig,
+			...dts
+		};
+		if (format === "es") plugins.push(dtsPlugin(options));
+		else if (cjsDts) plugins.push(dtsPlugin({
+			...options,
+			emitDtsOnly: true,
+			cjsDefault
+		}));
+	}
+	if (!cjsDts) {
+		if (unused) {
+			const { Unused } = await importWithError("unplugin-unused");
+			plugins.push(Unused.rolldown({
+				root: cwd,
+				...unused
+			}));
+		}
+		if (target) plugins.push(await LightningCSSPlugin({ target }));
+		const cssPlugin = CssCodeSplitPlugin(config);
+		if (cssPlugin) plugins.push(cssPlugin);
+		plugins.push(ShebangPlugin(logger, cwd, nameLabel, isDualFormat));
+		if (globImport) plugins.push(importGlobPlugin({ root: cwd }));
+	}
+	if (report && LogLevels[logger.level] >= 3) plugins.push(ReportPlugin(report, logger, cwd, cjsDts, nameLabel, isDualFormat));
+	if (watch) plugins.push(WatchPlugin(configFiles, bundle));
+	if (!cjsDts) plugins.push(userPlugins);
+	const define = {
+		...config.define,
+		...Object.keys(env).reduce((acc, key) => {
+			const value = JSON.stringify(env[key]);
+			acc[`process.env.${key}`] = value;
+			acc[`import.meta.env.${key}`] = value;
+			return acc;
+		}, Object.create(null))
+	};
+	const inject = shims && !cjsDts ? getShimsInject(format, platform) : void 0;
+	return await mergeUserOptions({
+		input: entry,
+		cwd,
+		external,
+		resolve: { alias },
+		tsconfig: tsconfig || void 0,
+		treeshake,
+		platform: cjsDts || format === "cjs" ? "node" : platform,
+		transform: {
+			target,
+			define,
+			inject
+		},
+		plugins,
+		moduleTypes: loader,
+		logLevel: logger.level === "error" ? "silent" : logger.level,
+		onLog: cjsDefault ? (level, log, defaultHandler) => {
+			if (log.code === "MIXED_EXPORT") return;
+			defaultHandler(level, log);
+		} : void 0,
+		devtools: devtools || void 0,
+		checks
+	}, config.inputOptions, [format, { cjsDts }]);
+}
+async function resolveOutputOptions(inputOptions, config, format, cjsDts) {
+	const { banner, cjsDefault, entry, footer, minify, outDir, sourcemap, unbundle } = config;
+	const [entryFileNames, chunkFileNames] = resolveChunkFilename(config, inputOptions, format);
+	return await mergeUserOptions({
+		format: cjsDts ? "es" : format,
+		name: config.globalName,
+		sourcemap,
+		dir: outDir,
+		exports: cjsDefault ? "auto" : "named",
+		minify: !cjsDts && minify,
+		entryFileNames,
+		chunkFileNames,
+		preserveModules: unbundle,
+		preserveModulesRoot: unbundle ? lowestCommonAncestor(...Object.values(entry)) : void 0,
+		postBanner: resolveChunkAddon(banner, format),
+		postFooter: resolveChunkAddon(footer, format)
+	}, config.outputOptions, [format, { cjsDts }]);
+}
+async function getDebugRolldownDir() {
+	if (!debug.enabled) return;
+	return await mkdtemp(path.join(tmpdir(), "tsdown-config-"));
+}
+async function debugBuildOptions(dir, name, format, buildOptions) {
+	const outFile = path.join(dir, `rolldown.config.${format}.js`);
+	handlePluginInspect(buildOptions.plugins);
+	const serialized = formatWithOptions({
+		depth: null,
+		maxArrayLength: null,
+		maxStringLength: null
+	}, buildOptions);
+	await writeFile(outFile, `/*
+Auto-generated rolldown config for tsdown debug purposes
+tsdown v${version}, rolldown v${VERSION}
+Generated on ${(/* @__PURE__ */ new Date()).toISOString()}
+Package name: ${name || "not specified"}
+*/
+
+export default ${serialized}\n`);
+	debug("Wrote debug rolldown config for \"%s\" (%s) -> %s", name || "default name", format, outFile);
+}
+function handlePluginInspect(plugins) {
+	if (Array.isArray(plugins)) for (const plugin of plugins) handlePluginInspect(plugin);
+	else if (typeof plugins === "object" && plugins !== null && "name" in plugins) plugins[inspect.custom] = function(depth, options, inspect) {
+		if ("_options" in plugins) return inspect({
+			name: plugins.name,
+			options: plugins._options
+		}, options);
+		else return `"rolldown plugin: ${plugins.name}"`;
+	};
+}
+function shortcuts(restart) {
+	let actionRunning = false;
+	async function onInput(input) {
+		if (actionRunning) return;
+		input = input.trim().toLowerCase();
+		const SHORTCUTS = [
+			{
+				key: "r",
+				description: "reload config and rebuild",
+				action() {
+					restart();
+				}
+			},
+			{
+				key: "c",
+				description: "clear console",
+				action() {
+					console.clear();
+				}
+			},
+			{
+				key: "q",
+				description: "quit",
+				action() {
+					process$1.exit(0);
+				}
+			}
+		];
+		if (input === "h") {
+			const loggedKeys = /* @__PURE__ */ new Set();
+			globalLogger.info("  Shortcuts");
+			for (const shortcut of SHORTCUTS) {
+				if (loggedKeys.has(shortcut.key)) continue;
+				loggedKeys.add(shortcut.key);
+				if (shortcut.action == null) continue;
+				globalLogger.info(dim`  press ` + bold`${shortcut.key} + enter` + dim` to ${shortcut.description}`);
+			}
+			return;
+		}
+		const shortcut = SHORTCUTS.find((shortcut) => shortcut.key === input);
+		if (!shortcut) return;
+		actionRunning = true;
+		await shortcut.action();
+		actionRunning = false;
+	}
+	const rl = readline.createInterface({ input: process$1.stdin });
+	rl.on("line", onInput);
+	return () => rl.close();
+}
+var build_exports = /* @__PURE__ */ __exportAll$1({
+	build: () => build$1,
+	buildWithConfigs: () => buildWithConfigs
+});
+const asyncDispose = Symbol.asyncDispose || Symbol.for("Symbol.asyncDispose");
+/**
+* Build with tsdown.
+*/
+async function build$1(inlineConfig = {}) {
+	globalLogger.level = inlineConfig.logLevel || "info";
+	const { configs, files: configFiles } = await resolveConfig(inlineConfig);
+	return buildWithConfigs(configs, configFiles, () => build$1(inlineConfig));
+}
+/**
+* Build with `ResolvedConfigs`.
+*
+* **Internal API, not for public use**
+* @private
+*/
+async function buildWithConfigs(configs, configFiles, _restart) {
+	let cleanPromise;
+	const clean = () => {
+		if (cleanPromise) return cleanPromise;
+		return cleanPromise = cleanOutDir(configs);
+	};
+	const disposeCbs = [];
+	let restarting = false;
+	async function restart() {
+		if (restarting) return;
+		restarting = true;
+		await Promise.all(disposeCbs.map((cb) => cb()));
+		clearRequireCache();
+		_restart();
+	}
+	const configChunksByPkg = initBundleByPkg(configs);
+	function done(bundle) {
+		return bundleDone(configChunksByPkg, bundle);
+	}
+	globalLogger.info("Build start");
+	const bundles = await Promise.all(configs.map((options) => {
+		return buildSingle(options, configFiles, options.pkg ? configChunksByPkg[options.pkg.packageJsonPath].formats.size > 1 : true, clean, restart, done);
+	}));
+	const firstDevtoolsConfig = configs.find((config) => config.devtools && config.devtools.ui);
+	if (configs.some((config) => config.watch)) {
+		disposeCbs.push(shortcuts(restart));
+		for (const bundle of bundles) disposeCbs.push(bundle[asyncDispose]);
+	} else if (firstDevtoolsConfig) startDevtoolsUI(firstDevtoolsConfig.devtools);
+	return bundles;
+}
+/**
+* Build a single configuration, without watch and shortcuts features.
+* @param config Resolved options
+*/
+async function buildSingle(config, configFiles, isDualFormat, clean, restart, done) {
+	const { format, dts, watch: watch$1, logger, outDir } = config;
+	const { hooks, context } = await createHooks(config);
+	warnLegacyCJS(config);
+	const startTime = performance.now();
+	await hooks.callHook("build:prepare", context);
+	await clean();
+	const debugRolldownConfigDir = await getDebugRolldownDir();
+	const chunks = [];
+	let watcher;
+	let ab;
+	let updated = false;
+	const bundle = {
+		chunks,
+		config,
+		async [asyncDispose]() {
+			ab?.abort();
+			await watcher?.close();
+		}
+	};
+	const configs = await initBuildOptions();
+	if (watch$1) {
+		watcher = watch(configs);
+		handleWatcher(watcher);
+	} else {
+		const outputs = await build(configs);
+		for (const { output } of outputs) chunks.push(...addOutDirToChunks(output, outDir));
+	}
+	if (!watch$1) {
+		logger.success(config.nameLabel, `Build complete in ${green(`${Math.round(performance.now() - startTime)}ms`)}`);
+		await postBuild();
+	}
+	return bundle;
+	function handleWatcher(watcher) {
+		const changedFile = [];
+		let hasError = false;
+		watcher.on("change", (id, event) => {
+			if (event.event === "update") changedFile.push(id);
+			if (configFiles.includes(id) || endsWithConfig.test(id)) {
+				globalLogger.info(`Reload config: ${id}, restarting...`);
+				restart();
+			}
+		});
+		watcher.on("event", async (event) => {
+			switch (event.code) {
+				case "START":
+					if (config.clean.length) await cleanChunks(config.outDir, chunks);
+					chunks.length = 0;
+					hasError = false;
+					break;
+				case "END":
+					if (!hasError) await postBuild();
+					break;
+				case "BUNDLE_START":
+					if (changedFile.length) {
+						logger.clearScreen("info");
+						logger.info(`Found ${bold(changedFile.join(", "))} changed, rebuilding...`);
+					}
+					changedFile.length = 0;
+					break;
+				case "BUNDLE_END":
+					await event.result.close();
+					logger.success(config.nameLabel, `Rebuilt in ${event.duration}ms.`);
+					break;
+				case "ERROR":
+					await event.result.close();
+					logger.error(event.error);
+					hasError = true;
+					break;
+			}
+		});
+	}
+	async function initBuildOptions() {
+		const buildOptions = await getBuildOptions(config, format, configFiles, bundle, false, isDualFormat);
+		await hooks.callHook("build:before", {
+			...context,
+			buildOptions
+		});
+		if (debugRolldownConfigDir) await debugBuildOptions(debugRolldownConfigDir, config.name, format, buildOptions);
+		const configs = [buildOptions];
+		if (format === "cjs" && dts) configs.push(await getBuildOptions(config, format, configFiles, bundle, true, isDualFormat));
+		return configs;
+	}
+	async function postBuild() {
+		await copy(config);
+		if (!updated) await done(bundle);
+		await hooks.callHook("build:done", {
+			...context,
+			chunks
+		});
+		updated = true;
+		ab?.abort();
+		ab = executeOnSuccess(config);
+	}
+}
+
+//#endregion
+export { resolveUserConfig as a, mergeConfig as i, buildWithConfigs as n, build_l5WhXg4M_exports as r, build$1 as t };