npm - nitro-nightly - Versions diffs - 3.0.1-20251217-093053-f360ffee → 3.0.1-20251217-124302-0d9f782c - Mend

nitro-nightly 3.0.1-20251217-093053-f360ffee → 3.0.1-20251217-124302-0d9f782c

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (25) hide show

package/dist/_build/rolldown.mjs +3 -3
package/dist/_build/rollup.mjs +3 -3
package/dist/_build/vite.build.mjs +2 -2
package/dist/_build/vite.plugin.mjs +2 -2
package/dist/_dev.mjs +1 -1
package/dist/_libs/{@pi0 → @hiogawa}/vite-plugin-fullstack.mjs +237 -31
package/dist/_libs/@jridgewell/gen-mapping.mjs +2 -166
package/dist/_libs/@rollup/plugin-commonjs.mjs +9 -9
package/dist/_libs/@rollup/plugin-inject.mjs +1 -1
package/dist/_libs/@rollup/plugin-node-resolve.mjs +12 -12
package/dist/_libs/@rollup/plugin-replace.mjs +1 -1
package/dist/_libs/c12.mjs +2 -2
package/dist/_libs/chokidar.mjs +238 -1790
package/dist/_libs/giget.mjs +1 -1
package/dist/_libs/unimport.mjs +1 -1
package/dist/_libs/unwasm.mjs +1 -1
package/dist/builder.mjs +1 -2
package/dist/cli/_chunks/chokidar.mjs +3 -0
package/dist/cli/_chunks/detect-acorn.mjs +1 -2
package/dist/node_modules/unctx/package.json +16 -16
package/dist/types/index.d.mts +17 -0
package/dist/vite.mjs +2 -2
package/package.json +11 -11
package/dist/cli/_chunks/esm.mjs +0 -3
package/dist/types/index.mjs +0 -1

package/dist/_libs/chokidar.mjs CHANGED Viewed

@@ -2,1607 +2,11 @@ import * as sp from "node:path";
 import { join, relative, resolve, sep } from "node:path";
 import { stat, unwatchFile, watch, watchFile } from "node:fs";
 import { lstat, open, readdir, realpath, stat as stat$1 } from "node:fs/promises";
-import { stat as stat$2, unwatchFile as unwatchFile$1, watch as watch$1, watchFile as watchFile$1 } from "fs";
-import * as sysPath from "path";
 import { type } from "node:os";
-import { type as type$1 } from "os";
 import { EventEmitter } from "node:events";
 import { Readable } from "node:stream";
-import { lstat as lstat$1, open as open$1, readdir as readdir$1, realpath as realpath$1, stat as stat$3 } from "fs/promises";
-import { EventEmitter as EventEmitter$1 } from "events";
 //#region node_modules/.pnpm/readdirp@5.0.0/node_modules/readdirp/index.js
-const EntryTypes$1 = {
-	FILE_TYPE: "files",
-	DIR_TYPE: "directories",
-	FILE_DIR_TYPE: "files_directories",
-	EVERYTHING_TYPE: "all"
-};
-const defaultOptions$1 = {
-	root: ".",
-	fileFilter: (_entryInfo) => true,
-	directoryFilter: (_entryInfo) => true,
-	type: EntryTypes$1.FILE_TYPE,
-	lstat: false,
-	depth: 2147483648,
-	alwaysStat: false,
-	highWaterMark: 4096
-};
-Object.freeze(defaultOptions$1);
-const RECURSIVE_ERROR_CODE$1 = "READDIRP_RECURSIVE_ERROR";
-const NORMAL_FLOW_ERRORS$1 = new Set([
-	"ENOENT",
-	"EPERM",
-	"EACCES",
-	"ELOOP",
-	RECURSIVE_ERROR_CODE$1
-]);
-const ALL_TYPES$1 = [
-	EntryTypes$1.DIR_TYPE,
-	EntryTypes$1.EVERYTHING_TYPE,
-	EntryTypes$1.FILE_DIR_TYPE,
-	EntryTypes$1.FILE_TYPE
-];
-const DIR_TYPES$1 = new Set([
-	EntryTypes$1.DIR_TYPE,
-	EntryTypes$1.EVERYTHING_TYPE,
-	EntryTypes$1.FILE_DIR_TYPE
-]);
-const FILE_TYPES$1 = new Set([
-	EntryTypes$1.EVERYTHING_TYPE,
-	EntryTypes$1.FILE_DIR_TYPE,
-	EntryTypes$1.FILE_TYPE
-]);
-const isNormalFlowError$1 = (error) => NORMAL_FLOW_ERRORS$1.has(error.code);
-const wantBigintFsStats$1 = process.platform === "win32";
-const emptyFn$1 = (_entryInfo) => true;
-const normalizeFilter$1 = (filter) => {
-	if (filter === void 0) return emptyFn$1;
-	if (typeof filter === "function") return filter;
-	if (typeof filter === "string") {
-		const fl = filter.trim();
-		return (entry) => entry.basename === fl;
-	}
-	if (Array.isArray(filter)) {
-		const trItems = filter.map((item) => item.trim());
-		return (entry) => trItems.some((f) => entry.basename === f);
-	}
-	return emptyFn$1;
-};
-/** Readable readdir stream, emitting new files as they're being listed. */
-var ReaddirpStream$1 = class extends Readable {
-	parents;
-	reading;
-	parent;
-	_stat;
-	_maxDepth;
-	_wantsDir;
-	_wantsFile;
-	_wantsEverything;
-	_root;
-	_isDirent;
-	_statsProp;
-	_rdOptions;
-	_fileFilter;
-	_directoryFilter;
-	constructor(options = {}) {
-		super({
-			objectMode: true,
-			autoDestroy: true,
-			highWaterMark: options.highWaterMark
-		});
-		const opts = {
-			...defaultOptions$1,
-			...options
-		};
-		const { root, type: type$2 } = opts;
-		this._fileFilter = normalizeFilter$1(opts.fileFilter);
-		this._directoryFilter = normalizeFilter$1(opts.directoryFilter);
-		const statMethod = opts.lstat ? lstat : stat$1;
-		if (wantBigintFsStats$1) this._stat = (path$2) => statMethod(path$2, { bigint: true });
-		else this._stat = statMethod;
-		this._maxDepth = opts.depth != null && Number.isSafeInteger(opts.depth) ? opts.depth : defaultOptions$1.depth;
-		this._wantsDir = type$2 ? DIR_TYPES$1.has(type$2) : false;
-		this._wantsFile = type$2 ? FILE_TYPES$1.has(type$2) : false;
-		this._wantsEverything = type$2 === EntryTypes$1.EVERYTHING_TYPE;
-		this._root = resolve(root);
-		this._isDirent = !opts.alwaysStat;
-		this._statsProp = this._isDirent ? "dirent" : "stats";
-		this._rdOptions = {
-			encoding: "utf8",
-			withFileTypes: this._isDirent
-		};
-		this.parents = [this._exploreDir(root, 1)];
-		this.reading = false;
-		this.parent = void 0;
-	}
-	async _read(batch) {
-		if (this.reading) return;
-		this.reading = true;
-		try {
-			while (!this.destroyed && batch > 0) {
-				const par = this.parent;
-				const fil = par && par.files;
-				if (fil && fil.length > 0) {
-					const { path: path$2, depth } = par;
-					const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path$2));
-					const awaited = await Promise.all(slice);
-					for (const entry of awaited) {
-						if (!entry) continue;
-						if (this.destroyed) return;
-						const entryType = await this._getEntryType(entry);
-						if (entryType === "directory" && this._directoryFilter(entry)) {
-							if (depth <= this._maxDepth) this.parents.push(this._exploreDir(entry.fullPath, depth + 1));
-							if (this._wantsDir) {
-								this.push(entry);
-								batch--;
-							}
-						} else if ((entryType === "file" || this._includeAsFile(entry)) && this._fileFilter(entry)) {
-							if (this._wantsFile) {
-								this.push(entry);
-								batch--;
-							}
-						}
-					}
-				} else {
-					const parent = this.parents.pop();
-					if (!parent) {
-						this.push(null);
-						break;
-					}
-					this.parent = await parent;
-					if (this.destroyed) return;
-				}
-			}
-		} catch (error) {
-			this.destroy(error);
-		} finally {
-			this.reading = false;
-		}
-	}
-	async _exploreDir(path$2, depth) {
-		let files;
-		try {
-			files = await readdir(path$2, this._rdOptions);
-		} catch (error) {
-			this._onError(error);
-		}
-		return {
-			files,
-			depth,
-			path: path$2
-		};
-	}
-	async _formatEntry(dirent, path$2) {
-		let entry;
-		const basename$2 = this._isDirent ? dirent.name : dirent;
-		try {
-			const fullPath = resolve(join(path$2, basename$2));
-			entry = {
-				path: relative(this._root, fullPath),
-				fullPath,
-				basename: basename$2
-			};
-			entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
-		} catch (err) {
-			this._onError(err);
-			return;
-		}
-		return entry;
-	}
-	_onError(err) {
-		if (isNormalFlowError$1(err) && !this.destroyed) this.emit("warn", err);
-		else this.destroy(err);
-	}
-	async _getEntryType(entry) {
-		if (!entry && this._statsProp in entry) return "";
-		const stats = entry[this._statsProp];
-		if (stats.isFile()) return "file";
-		if (stats.isDirectory()) return "directory";
-		if (stats && stats.isSymbolicLink()) {
-			const full = entry.fullPath;
-			try {
-				const entryRealPath = await realpath(full);
-				const entryRealPathStats = await lstat(entryRealPath);
-				if (entryRealPathStats.isFile()) return "file";
-				if (entryRealPathStats.isDirectory()) {
-					const len = entryRealPath.length;
-					if (full.startsWith(entryRealPath) && full.substr(len, 1) === sep) {
-						const recursiveError = /* @__PURE__ */ new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
-						recursiveError.code = RECURSIVE_ERROR_CODE$1;
-						return this._onError(recursiveError);
-					}
-					return "directory";
-				}
-			} catch (error) {
-				this._onError(error);
-				return "";
-			}
-		}
-	}
-	_includeAsFile(entry) {
-		const stats = entry && entry[this._statsProp];
-		return stats && this._wantsEverything && !stats.isDirectory();
-	}
-};
-/**
-* Streaming version: Reads all files and directories in given root recursively.
-* Consumes ~constant small amount of RAM.
-* @param root Root directory
-* @param options Options to specify root (start directory), filters and recursion depth
-*/
-function readdirp$1(root, options = {}) {
-	let type$2 = options.entryType || options.type;
-	if (type$2 === "both") type$2 = EntryTypes$1.FILE_DIR_TYPE;
-	if (type$2) options.type = type$2;
-	if (!root) throw new Error("readdirp: root argument is required. Usage: readdirp(root, options)");
-	else if (typeof root !== "string") throw new TypeError("readdirp: root argument must be a string. Usage: readdirp(root, options)");
-	else if (type$2 && !ALL_TYPES$1.includes(type$2)) throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES$1.join(", ")}`);
-	options.root = root;
-	return new ReaddirpStream$1(options);
-}
-//#endregion
-//#region node_modules/.pnpm/chokidar@5.0.0/node_modules/chokidar/handler.js
-const STR_DATA$1 = "data";
-const STR_END$1 = "end";
-const STR_CLOSE$1 = "close";
-const EMPTY_FN$1 = () => {};
-const pl$1 = process.platform;
-const isWindows$1 = pl$1 === "win32";
-const isMacos$1 = pl$1 === "darwin";
-const isLinux$1 = pl$1 === "linux";
-const isFreeBSD$1 = pl$1 === "freebsd";
-const isIBMi$1 = type() === "OS400";
-const EVENTS$1 = {
-	ALL: "all",
-	READY: "ready",
-	ADD: "add",
-	CHANGE: "change",
-	ADD_DIR: "addDir",
-	UNLINK: "unlink",
-	UNLINK_DIR: "unlinkDir",
-	RAW: "raw",
-	ERROR: "error"
-};
-const EV$1 = EVENTS$1;
-const THROTTLE_MODE_WATCH$1 = "watch";
-const statMethods$1 = {
-	lstat,
-	stat: stat$1
-};
-const KEY_LISTENERS$1 = "listeners";
-const KEY_ERR$1 = "errHandlers";
-const KEY_RAW$1 = "rawEmitters";
-const HANDLER_KEYS$1 = [
-	KEY_LISTENERS$1,
-	KEY_ERR$1,
-	KEY_RAW$1
-];
-const binaryExtensions$1 = new Set([
-	"3dm",
-	"3ds",
-	"3g2",
-	"3gp",
-	"7z",
-	"a",
-	"aac",
-	"adp",
-	"afdesign",
-	"afphoto",
-	"afpub",
-	"ai",
-	"aif",
-	"aiff",
-	"alz",
-	"ape",
-	"apk",
-	"appimage",
-	"ar",
-	"arj",
-	"asf",
-	"au",
-	"avi",
-	"bak",
-	"baml",
-	"bh",
-	"bin",
-	"bk",
-	"bmp",
-	"btif",
-	"bz2",
-	"bzip2",
-	"cab",
-	"caf",
-	"cgm",
-	"class",
-	"cmx",
-	"cpio",
-	"cr2",
-	"cur",
-	"dat",
-	"dcm",
-	"deb",
-	"dex",
-	"djvu",
-	"dll",
-	"dmg",
-	"dng",
-	"doc",
-	"docm",
-	"docx",
-	"dot",
-	"dotm",
-	"dra",
-	"DS_Store",
-	"dsk",
-	"dts",
-	"dtshd",
-	"dvb",
-	"dwg",
-	"dxf",
-	"ecelp4800",
-	"ecelp7470",
-	"ecelp9600",
-	"egg",
-	"eol",
-	"eot",
-	"epub",
-	"exe",
-	"f4v",
-	"fbs",
-	"fh",
-	"fla",
-	"flac",
-	"flatpak",
-	"fli",
-	"flv",
-	"fpx",
-	"fst",
-	"fvt",
-	"g3",
-	"gh",
-	"gif",
-	"graffle",
-	"gz",
-	"gzip",
-	"h261",
-	"h263",
-	"h264",
-	"icns",
-	"ico",
-	"ief",
-	"img",
-	"ipa",
-	"iso",
-	"jar",
-	"jpeg",
-	"jpg",
-	"jpgv",
-	"jpm",
-	"jxr",
-	"key",
-	"ktx",
-	"lha",
-	"lib",
-	"lvp",
-	"lz",
-	"lzh",
-	"lzma",
-	"lzo",
-	"m3u",
-	"m4a",
-	"m4v",
-	"mar",
-	"mdi",
-	"mht",
-	"mid",
-	"midi",
-	"mj2",
-	"mka",
-	"mkv",
-	"mmr",
-	"mng",
-	"mobi",
-	"mov",
-	"movie",
-	"mp3",
-	"mp4",
-	"mp4a",
-	"mpeg",
-	"mpg",
-	"mpga",
-	"mxu",
-	"nef",
-	"npx",
-	"numbers",
-	"nupkg",
-	"o",
-	"odp",
-	"ods",
-	"odt",
-	"oga",
-	"ogg",
-	"ogv",
-	"otf",
-	"ott",
-	"pages",
-	"pbm",
-	"pcx",
-	"pdb",
-	"pdf",
-	"pea",
-	"pgm",
-	"pic",
-	"png",
-	"pnm",
-	"pot",
-	"potm",
-	"potx",
-	"ppa",
-	"ppam",
-	"ppm",
-	"pps",
-	"ppsm",
-	"ppsx",
-	"ppt",
-	"pptm",
-	"pptx",
-	"psd",
-	"pya",
-	"pyc",
-	"pyo",
-	"pyv",
-	"qt",
-	"rar",
-	"ras",
-	"raw",
-	"resources",
-	"rgb",
-	"rip",
-	"rlc",
-	"rmf",
-	"rmvb",
-	"rpm",
-	"rtf",
-	"rz",
-	"s3m",
-	"s7z",
-	"scpt",
-	"sgi",
-	"shar",
-	"snap",
-	"sil",
-	"sketch",
-	"slk",
-	"smv",
-	"snk",
-	"so",
-	"stl",
-	"suo",
-	"sub",
-	"swf",
-	"tar",
-	"tbz",
-	"tbz2",
-	"tga",
-	"tgz",
-	"thmx",
-	"tif",
-	"tiff",
-	"tlz",
-	"ttc",
-	"ttf",
-	"txz",
-	"udf",
-	"uvh",
-	"uvi",
-	"uvm",
-	"uvp",
-	"uvs",
-	"uvu",
-	"viv",
-	"vob",
-	"war",
-	"wav",
-	"wax",
-	"wbmp",
-	"wdp",
-	"weba",
-	"webm",
-	"webp",
-	"whl",
-	"wim",
-	"wm",
-	"wma",
-	"wmv",
-	"wmx",
-	"woff",
-	"woff2",
-	"wrm",
-	"wvx",
-	"xbm",
-	"xif",
-	"xla",
-	"xlam",
-	"xls",
-	"xlsb",
-	"xlsm",
-	"xlsx",
-	"xlt",
-	"xltm",
-	"xltx",
-	"xm",
-	"xmind",
-	"xpi",
-	"xpm",
-	"xwd",
-	"xz",
-	"z",
-	"zip",
-	"zipx"
-]);
-const isBinaryPath$1 = (filePath) => binaryExtensions$1.has(sp.extname(filePath).slice(1).toLowerCase());
-const foreach$1 = (val, fn) => {
-	if (val instanceof Set) val.forEach(fn);
-	else fn(val);
-};
-const addAndConvert$1 = (main, prop, item) => {
-	let container = main[prop];
-	if (!(container instanceof Set)) main[prop] = container = new Set([container]);
-	container.add(item);
-};
-const clearItem$1 = (cont) => (key) => {
-	const set = cont[key];
-	if (set instanceof Set) set.clear();
-	else delete cont[key];
-};
-const delFromSet$1 = (main, prop, item) => {
-	const container = main[prop];
-	if (container instanceof Set) container.delete(item);
-	else if (container === item) delete main[prop];
-};
-const isEmptySet$1 = (val) => val instanceof Set ? val.size === 0 : !val;
-const FsWatchInstances$1 = /* @__PURE__ */ new Map();
-/**
-* Instantiates the fs_watch interface
-* @param path to be watched
-* @param options to be passed to fs_watch
-* @param listener main event handler
-* @param errHandler emits info about errors
-* @param emitRaw emits raw event data
-* @returns {NativeFsWatcher}
-*/
-function createFsWatchInstance$1(path$2, options, listener, errHandler, emitRaw) {
-	const handleEvent = (rawEvent, evPath) => {
-		listener(path$2);
-		emitRaw(rawEvent, evPath, { watchedPath: path$2 });
-		if (evPath && path$2 !== evPath) fsWatchBroadcast$1(sp.resolve(path$2, evPath), KEY_LISTENERS$1, sp.join(path$2, evPath));
-	};
-	try {
-		return watch(path$2, { persistent: options.persistent }, handleEvent);
-	} catch (error) {
-		errHandler(error);
-		return;
-	}
-}
-/**
-* Helper for passing fs_watch event data to a collection of listeners
-* @param fullPath absolute path bound to fs_watch instance
-*/
-const fsWatchBroadcast$1 = (fullPath, listenerType, val1, val2, val3) => {
-	const cont = FsWatchInstances$1.get(fullPath);
-	if (!cont) return;
-	foreach$1(cont[listenerType], (listener) => {
-		listener(val1, val2, val3);
-	});
-};
-/**
-* Instantiates the fs_watch interface or binds listeners
-* to an existing one covering the same file system entry
-* @param path
-* @param fullPath absolute path
-* @param options to be passed to fs_watch
-* @param handlers container for event listener functions
-*/
-const setFsWatchListener$1 = (path$2, fullPath, options, handlers) => {
-	const { listener, errHandler, rawEmitter } = handlers;
-	let cont = FsWatchInstances$1.get(fullPath);
-	let watcher;
-	if (!options.persistent) {
-		watcher = createFsWatchInstance$1(path$2, options, listener, errHandler, rawEmitter);
-		if (!watcher) return;
-		return watcher.close.bind(watcher);
-	}
-	if (cont) {
-		addAndConvert$1(cont, KEY_LISTENERS$1, listener);
-		addAndConvert$1(cont, KEY_ERR$1, errHandler);
-		addAndConvert$1(cont, KEY_RAW$1, rawEmitter);
-	} else {
-		watcher = createFsWatchInstance$1(path$2, options, fsWatchBroadcast$1.bind(null, fullPath, KEY_LISTENERS$1), errHandler, fsWatchBroadcast$1.bind(null, fullPath, KEY_RAW$1));
-		if (!watcher) return;
-		watcher.on(EV$1.ERROR, async (error) => {
-			const broadcastErr = fsWatchBroadcast$1.bind(null, fullPath, KEY_ERR$1);
-			if (cont) cont.watcherUnusable = true;
-			if (isWindows$1 && error.code === "EPERM") try {
-				await (await open(path$2, "r")).close();
-				broadcastErr(error);
-			} catch (err) {}
-			else broadcastErr(error);
-		});
-		cont = {
-			listeners: listener,
-			errHandlers: errHandler,
-			rawEmitters: rawEmitter,
-			watcher
-		};
-		FsWatchInstances$1.set(fullPath, cont);
-	}
-	return () => {
-		delFromSet$1(cont, KEY_LISTENERS$1, listener);
-		delFromSet$1(cont, KEY_ERR$1, errHandler);
-		delFromSet$1(cont, KEY_RAW$1, rawEmitter);
-		if (isEmptySet$1(cont.listeners)) {
-			cont.watcher.close();
-			FsWatchInstances$1.delete(fullPath);
-			HANDLER_KEYS$1.forEach(clearItem$1(cont));
-			cont.watcher = void 0;
-			Object.freeze(cont);
-		}
-	};
-};
-const FsWatchFileInstances$1 = /* @__PURE__ */ new Map();
-/**
-* Instantiates the fs_watchFile interface or binds listeners
-* to an existing one covering the same file system entry
-* @param path to be watched
-* @param fullPath absolute path
-* @param options options to be passed to fs_watchFile
-* @param handlers container for event listener functions
-* @returns closer
-*/
-const setFsWatchFileListener$1 = (path$2, fullPath, options, handlers) => {
-	const { listener, rawEmitter } = handlers;
-	let cont = FsWatchFileInstances$1.get(fullPath);
-	const copts = cont && cont.options;
-	if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
-		unwatchFile(fullPath);
-		cont = void 0;
-	}
-	if (cont) {
-		addAndConvert$1(cont, KEY_LISTENERS$1, listener);
-		addAndConvert$1(cont, KEY_RAW$1, rawEmitter);
-	} else {
-		cont = {
-			listeners: listener,
-			rawEmitters: rawEmitter,
-			options,
-			watcher: watchFile(fullPath, options, (curr, prev) => {
-				foreach$1(cont.rawEmitters, (rawEmitter$1) => {
-					rawEmitter$1(EV$1.CHANGE, fullPath, {
-						curr,
-						prev
-					});
-				});
-				const currmtime = curr.mtimeMs;
-				if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) foreach$1(cont.listeners, (listener$1) => listener$1(path$2, curr));
-			})
-		};
-		FsWatchFileInstances$1.set(fullPath, cont);
-	}
-	return () => {
-		delFromSet$1(cont, KEY_LISTENERS$1, listener);
-		delFromSet$1(cont, KEY_RAW$1, rawEmitter);
-		if (isEmptySet$1(cont.listeners)) {
-			FsWatchFileInstances$1.delete(fullPath);
-			unwatchFile(fullPath);
-			cont.options = cont.watcher = void 0;
-			Object.freeze(cont);
-		}
-	};
-};
-/**
-* @mixin
-*/
-var NodeFsHandler$1 = class {
-	fsw;
-	_boundHandleError;
-	constructor(fsW) {
-		this.fsw = fsW;
-		this._boundHandleError = (error) => fsW._handleError(error);
-	}
-	/**
-	* Watch file for changes with fs_watchFile or fs_watch.
-	* @param path to file or dir
-	* @param listener on fs change
-	* @returns closer for the watcher instance
-	*/
-	_watchWithNodeFs(path$2, listener) {
-		const opts = this.fsw.options;
-		const directory = sp.dirname(path$2);
-		const basename$2 = sp.basename(path$2);
-		this.fsw._getWatchedDir(directory).add(basename$2);
-		const absolutePath = sp.resolve(path$2);
-		const options = { persistent: opts.persistent };
-		if (!listener) listener = EMPTY_FN$1;
-		let closer;
-		if (opts.usePolling) {
-			options.interval = opts.interval !== opts.binaryInterval && isBinaryPath$1(basename$2) ? opts.binaryInterval : opts.interval;
-			closer = setFsWatchFileListener$1(path$2, absolutePath, options, {
-				listener,
-				rawEmitter: this.fsw._emitRaw
-			});
-		} else closer = setFsWatchListener$1(path$2, absolutePath, options, {
-			listener,
-			errHandler: this._boundHandleError,
-			rawEmitter: this.fsw._emitRaw
-		});
-		return closer;
-	}
-	/**
-	* Watch a file and emit add event if warranted.
-	* @returns closer for the watcher instance
-	*/
-	_handleFile(file, stats, initialAdd) {
-		if (this.fsw.closed) return;
-		const dirname$2 = sp.dirname(file);
-		const basename$2 = sp.basename(file);
-		const parent = this.fsw._getWatchedDir(dirname$2);
-		let prevStats = stats;
-		if (parent.has(basename$2)) return;
-		const listener = async (path$2, newStats) => {
-			if (!this.fsw._throttle(THROTTLE_MODE_WATCH$1, file, 5)) return;
-			if (!newStats || newStats.mtimeMs === 0) try {
-				const newStats$1 = await stat$1(file);
-				if (this.fsw.closed) return;
-				const at = newStats$1.atimeMs;
-				const mt = newStats$1.mtimeMs;
-				if (!at || at <= mt || mt !== prevStats.mtimeMs) this.fsw._emit(EV$1.CHANGE, file, newStats$1);
-				if ((isMacos$1 || isLinux$1 || isFreeBSD$1) && prevStats.ino !== newStats$1.ino) {
-					this.fsw._closeFile(path$2);
-					prevStats = newStats$1;
-					const closer$1 = this._watchWithNodeFs(file, listener);
-					if (closer$1) this.fsw._addPathCloser(path$2, closer$1);
-				} else prevStats = newStats$1;
-			} catch (error) {
-				this.fsw._remove(dirname$2, basename$2);
-			}
-			else if (parent.has(basename$2)) {
-				const at = newStats.atimeMs;
-				const mt = newStats.mtimeMs;
-				if (!at || at <= mt || mt !== prevStats.mtimeMs) this.fsw._emit(EV$1.CHANGE, file, newStats);
-				prevStats = newStats;
-			}
-		};
-		const closer = this._watchWithNodeFs(file, listener);
-		if (!(initialAdd && this.fsw.options.ignoreInitial) && this.fsw._isntIgnored(file)) {
-			if (!this.fsw._throttle(EV$1.ADD, file, 0)) return;
-			this.fsw._emit(EV$1.ADD, file, stats);
-		}
-		return closer;
-	}
-	/**
-	* Handle symlinks encountered while reading a dir.
-	* @param entry returned by readdirp
-	* @param directory path of dir being read
-	* @param path of this item
-	* @param item basename of this item
-	* @returns true if no more processing is needed for this entry.
-	*/
-	async _handleSymlink(entry, directory, path$2, item) {
-		if (this.fsw.closed) return;
-		const full = entry.fullPath;
-		const dir = this.fsw._getWatchedDir(directory);
-		if (!this.fsw.options.followSymlinks) {
-			this.fsw._incrReadyCount();
-			let linkPath;
-			try {
-				linkPath = await realpath(path$2);
-			} catch (e) {
-				this.fsw._emitReady();
-				return true;
-			}
-			if (this.fsw.closed) return;
-			if (dir.has(item)) {
-				if (this.fsw._symlinkPaths.get(full) !== linkPath) {
-					this.fsw._symlinkPaths.set(full, linkPath);
-					this.fsw._emit(EV$1.CHANGE, path$2, entry.stats);
-				}
-			} else {
-				dir.add(item);
-				this.fsw._symlinkPaths.set(full, linkPath);
-				this.fsw._emit(EV$1.ADD, path$2, entry.stats);
-			}
-			this.fsw._emitReady();
-			return true;
-		}
-		if (this.fsw._symlinkPaths.has(full)) return true;
-		this.fsw._symlinkPaths.set(full, true);
-	}
-	_handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
-		directory = sp.join(directory, "");
-		const throttleKey = target ? `${directory}:${target}` : directory;
-		throttler = this.fsw._throttle("readdir", throttleKey, 1e3);
-		if (!throttler) return;
-		const previous = this.fsw._getWatchedDir(wh.path);
-		const current = /* @__PURE__ */ new Set();
-		let stream = this.fsw._readdirp(directory, {
-			fileFilter: (entry) => wh.filterPath(entry),
-			directoryFilter: (entry) => wh.filterDir(entry)
-		});
-		if (!stream) return;
-		stream.on(STR_DATA$1, async (entry) => {
-			if (this.fsw.closed) {
-				stream = void 0;
-				return;
-			}
-			const item = entry.path;
-			let path$2 = sp.join(directory, item);
-			current.add(item);
-			if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path$2, item)) return;
-			if (this.fsw.closed) {
-				stream = void 0;
-				return;
-			}
-			if (item === target || !target && !previous.has(item)) {
-				this.fsw._incrReadyCount();
-				path$2 = sp.join(dir, sp.relative(dir, path$2));
-				this._addToNodeFs(path$2, initialAdd, wh, depth + 1);
-			}
-		}).on(EV$1.ERROR, this._boundHandleError);
-		return new Promise((resolve$2, reject) => {
-			if (!stream) return reject();
-			stream.once(STR_END$1, () => {
-				if (this.fsw.closed) {
-					stream = void 0;
-					return;
-				}
-				const wasThrottled = throttler ? throttler.clear() : false;
-				resolve$2(void 0);
-				previous.getChildren().filter((item) => {
-					return item !== directory && !current.has(item);
-				}).forEach((item) => {
-					this.fsw._remove(directory, item);
-				});
-				stream = void 0;
-				if (wasThrottled) this._handleRead(directory, false, wh, target, dir, depth, throttler);
-			});
-		});
-	}
-	/**
-	* Read directory to add / remove files from `@watched` list and re-read it on change.
-	* @param dir fs path
-	* @param stats
-	* @param initialAdd
-	* @param depth relative to user-supplied path
-	* @param target child path targeted for watch
-	* @param wh Common watch helpers for this path
-	* @param realpath
-	* @returns closer for the watcher instance.
-	*/
-	async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath$2) {
-		const parentDir = this.fsw._getWatchedDir(sp.dirname(dir));
-		const tracked = parentDir.has(sp.basename(dir));
-		if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) this.fsw._emit(EV$1.ADD_DIR, dir, stats);
-		parentDir.add(sp.basename(dir));
-		this.fsw._getWatchedDir(dir);
-		let throttler;
-		let closer;
-		const oDepth = this.fsw.options.depth;
-		if ((oDepth == null || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath$2)) {
-			if (!target) {
-				await this._handleRead(dir, initialAdd, wh, target, dir, depth, throttler);
-				if (this.fsw.closed) return;
-			}
-			closer = this._watchWithNodeFs(dir, (dirPath, stats$1) => {
-				if (stats$1 && stats$1.mtimeMs === 0) return;
-				this._handleRead(dirPath, false, wh, target, dir, depth, throttler);
-			});
-		}
-		return closer;
-	}
-	/**
-	* Handle added file, directory, or glob pattern.
-	* Delegates call to _handleFile / _handleDir after checks.
-	* @param path to file or ir
-	* @param initialAdd was the file added at watch instantiation?
-	* @param priorWh depth relative to user-supplied path
-	* @param depth Child path actually targeted for watch
-	* @param target Child path actually targeted for watch
-	*/
-	async _addToNodeFs(path$2, initialAdd, priorWh, depth, target) {
-		const ready = this.fsw._emitReady;
-		if (this.fsw._isIgnored(path$2) || this.fsw.closed) {
-			ready();
-			return false;
-		}
-		const wh = this.fsw._getWatchHelpers(path$2);
-		if (priorWh) {
-			wh.filterPath = (entry) => priorWh.filterPath(entry);
-			wh.filterDir = (entry) => priorWh.filterDir(entry);
-		}
-		try {
-			const stats = await statMethods$1[wh.statMethod](wh.watchPath);
-			if (this.fsw.closed) return;
-			if (this.fsw._isIgnored(wh.watchPath, stats)) {
-				ready();
-				return false;
-			}
-			const follow = this.fsw.options.followSymlinks;
-			let closer;
-			if (stats.isDirectory()) {
-				const absPath = sp.resolve(path$2);
-				const targetPath = follow ? await realpath(path$2) : path$2;
-				if (this.fsw.closed) return;
-				closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
-				if (this.fsw.closed) return;
-				if (absPath !== targetPath && targetPath !== void 0) this.fsw._symlinkPaths.set(absPath, targetPath);
-			} else if (stats.isSymbolicLink()) {
-				const targetPath = follow ? await realpath(path$2) : path$2;
-				if (this.fsw.closed) return;
-				const parent = sp.dirname(wh.watchPath);
-				this.fsw._getWatchedDir(parent).add(wh.watchPath);
-				this.fsw._emit(EV$1.ADD, wh.watchPath, stats);
-				closer = await this._handleDir(parent, stats, initialAdd, depth, path$2, wh, targetPath);
-				if (this.fsw.closed) return;
-				if (targetPath !== void 0) this.fsw._symlinkPaths.set(sp.resolve(path$2), targetPath);
-			} else closer = this._handleFile(wh.watchPath, stats, initialAdd);
-			ready();
-			if (closer) this.fsw._addPathCloser(path$2, closer);
-			return false;
-		} catch (error) {
-			if (this.fsw._handleError(error)) {
-				ready();
-				return path$2;
-			}
-		}
-	}
-};
-//#endregion
-//#region node_modules/.pnpm/chokidar@5.0.0/node_modules/chokidar/index.js
-/*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) */
-const SLASH$1 = "/";
-const SLASH_SLASH$1 = "//";
-const ONE_DOT$1 = ".";
-const TWO_DOTS$1 = "..";
-const STRING_TYPE$1 = "string";
-const BACK_SLASH_RE$1 = /\\/g;
-const DOUBLE_SLASH_RE$1 = /\/\//g;
-const DOT_RE$1 = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
-const REPLACER_RE$1 = /^\.[/\\]/;
-function arrify$1(item) {
-	return Array.isArray(item) ? item : [item];
-}
-const isMatcherObject$1 = (matcher) => typeof matcher === "object" && matcher !== null && !(matcher instanceof RegExp);
-function createPattern$1(matcher) {
-	if (typeof matcher === "function") return matcher;
-	if (typeof matcher === "string") return (string) => matcher === string;
-	if (matcher instanceof RegExp) return (string) => matcher.test(string);
-	if (typeof matcher === "object" && matcher !== null) return (string) => {
-		if (matcher.path === string) return true;
-		if (matcher.recursive) {
-			const relative$2 = sp.relative(matcher.path, string);
-			if (!relative$2) return false;
-			return !relative$2.startsWith("..") && !sp.isAbsolute(relative$2);
-		}
-		return false;
-	};
-	return () => false;
-}
-function normalizePath$1(path$2) {
-	if (typeof path$2 !== "string") throw new Error("string expected");
-	path$2 = sp.normalize(path$2);
-	path$2 = path$2.replace(/\\/g, "/");
-	let prepend = false;
-	if (path$2.startsWith("//")) prepend = true;
-	path$2 = path$2.replace(DOUBLE_SLASH_RE$1, "/");
-	if (prepend) path$2 = "/" + path$2;
-	return path$2;
-}
-function matchPatterns$1(patterns, testString, stats) {
-	const path$2 = normalizePath$1(testString);
-	for (let index = 0; index < patterns.length; index++) {
-		const pattern = patterns[index];
-		if (pattern(path$2, stats)) return true;
-	}
-	return false;
-}
-function anymatch$1(matchers, testString) {
-	if (matchers == null) throw new TypeError("anymatch: specify first argument");
-	const patterns = arrify$1(matchers).map((matcher) => createPattern$1(matcher));
-	if (testString == null) return (testString$1, stats) => {
-		return matchPatterns$1(patterns, testString$1, stats);
-	};
-	return matchPatterns$1(patterns, testString);
-}
-const unifyPaths$1 = (paths_) => {
-	const paths = arrify$1(paths_).flat();
-	if (!paths.every((p) => typeof p === STRING_TYPE$1)) throw new TypeError(`Non-string provided as watch path: ${paths}`);
-	return paths.map(normalizePathToUnix$1);
-};
-const toUnix$1 = (string) => {
-	let str = string.replace(BACK_SLASH_RE$1, SLASH$1);
-	let prepend = false;
-	if (str.startsWith(SLASH_SLASH$1)) prepend = true;
-	str = str.replace(DOUBLE_SLASH_RE$1, SLASH$1);
-	if (prepend) str = SLASH$1 + str;
-	return str;
-};
-const normalizePathToUnix$1 = (path$2) => toUnix$1(sp.normalize(toUnix$1(path$2)));
-const normalizeIgnored$1 = (cwd = "") => (path$2) => {
-	if (typeof path$2 === "string") return normalizePathToUnix$1(sp.isAbsolute(path$2) ? path$2 : sp.join(cwd, path$2));
-	else return path$2;
-};
-const getAbsolutePath$1 = (path$2, cwd) => {
-	if (sp.isAbsolute(path$2)) return path$2;
-	return sp.join(cwd, path$2);
-};
-const EMPTY_SET$1 = Object.freeze(/* @__PURE__ */ new Set());
-/**
-* Directory entry.
-*/
-var DirEntry$1 = class {
-	path;
-	_removeWatcher;
-	items;
-	constructor(dir, removeWatcher) {
-		this.path = dir;
-		this._removeWatcher = removeWatcher;
-		this.items = /* @__PURE__ */ new Set();
-	}
-	add(item) {
-		const { items } = this;
-		if (!items) return;
-		if (item !== ONE_DOT$1 && item !== TWO_DOTS$1) items.add(item);
-	}
-	async remove(item) {
-		const { items } = this;
-		if (!items) return;
-		items.delete(item);
-		if (items.size > 0) return;
-		const dir = this.path;
-		try {
-			await readdir(dir);
-		} catch (err) {
-			if (this._removeWatcher) this._removeWatcher(sp.dirname(dir), sp.basename(dir));
-		}
-	}
-	has(item) {
-		const { items } = this;
-		if (!items) return;
-		return items.has(item);
-	}
-	getChildren() {
-		const { items } = this;
-		if (!items) return [];
-		return [...items.values()];
-	}
-	dispose() {
-		this.items.clear();
-		this.path = "";
-		this._removeWatcher = EMPTY_FN$1;
-		this.items = EMPTY_SET$1;
-		Object.freeze(this);
-	}
-};
-const STAT_METHOD_F$1 = "stat";
-const STAT_METHOD_L$1 = "lstat";
-var WatchHelper$1 = class {
-	fsw;
-	path;
-	watchPath;
-	fullWatchPath;
-	dirParts;
-	followSymlinks;
-	statMethod;
-	constructor(path$2, follow, fsw) {
-		this.fsw = fsw;
-		const watchPath = path$2;
-		this.path = path$2 = path$2.replace(REPLACER_RE$1, "");
-		this.watchPath = watchPath;
-		this.fullWatchPath = sp.resolve(watchPath);
-		this.dirParts = [];
-		this.dirParts.forEach((parts) => {
-			if (parts.length > 1) parts.pop();
-		});
-		this.followSymlinks = follow;
-		this.statMethod = follow ? STAT_METHOD_F$1 : STAT_METHOD_L$1;
-	}
-	entryPath(entry) {
-		return sp.join(this.watchPath, sp.relative(this.watchPath, entry.fullPath));
-	}
-	filterPath(entry) {
-		const { stats } = entry;
-		if (stats && stats.isSymbolicLink()) return this.filterDir(entry);
-		const resolvedPath = this.entryPath(entry);
-		return this.fsw._isntIgnored(resolvedPath, stats) && this.fsw._hasReadPermissions(stats);
-	}
-	filterDir(entry) {
-		return this.fsw._isntIgnored(this.entryPath(entry), entry.stats);
-	}
-};
-/**
-* Watches files & directories for changes. Emitted events:
-* `add`, `addDir`, `change`, `unlink`, `unlinkDir`, `all`, `error`
-*
-*     new FSWatcher()
-*       .add(directories)
-*       .on('add', path => log('File', path, 'was added'))
-*/
-var FSWatcher$1 = class extends EventEmitter {
-	closed;
-	options;
-	_closers;
-	_ignoredPaths;
-	_throttled;
-	_streams;
-	_symlinkPaths;
-	_watched;
-	_pendingWrites;
-	_pendingUnlinks;
-	_readyCount;
-	_emitReady;
-	_closePromise;
-	_userIgnored;
-	_readyEmitted;
-	_emitRaw;
-	_boundRemove;
-	_nodeFsHandler;
-	constructor(_opts = {}) {
-		super();
-		this.closed = false;
-		this._closers = /* @__PURE__ */ new Map();
-		this._ignoredPaths = /* @__PURE__ */ new Set();
-		this._throttled = /* @__PURE__ */ new Map();
-		this._streams = /* @__PURE__ */ new Set();
-		this._symlinkPaths = /* @__PURE__ */ new Map();
-		this._watched = /* @__PURE__ */ new Map();
-		this._pendingWrites = /* @__PURE__ */ new Map();
-		this._pendingUnlinks = /* @__PURE__ */ new Map();
-		this._readyCount = 0;
-		this._readyEmitted = false;
-		const awf = _opts.awaitWriteFinish;
-		const DEF_AWF = {
-			stabilityThreshold: 2e3,
-			pollInterval: 100
-		};
-		const opts = {
-			persistent: true,
-			ignoreInitial: false,
-			ignorePermissionErrors: false,
-			interval: 100,
-			binaryInterval: 300,
-			followSymlinks: true,
-			usePolling: false,
-			atomic: true,
-			..._opts,
-			ignored: _opts.ignored ? arrify$1(_opts.ignored) : arrify$1([]),
-			awaitWriteFinish: awf === true ? DEF_AWF : typeof awf === "object" ? {
-				...DEF_AWF,
-				...awf
-			} : false
-		};
-		if (isIBMi$1) opts.usePolling = true;
-		if (opts.atomic === void 0) opts.atomic = !opts.usePolling;
-		const envPoll = process.env.CHOKIDAR_USEPOLLING;
-		if (envPoll !== void 0) {
-			const envLower = envPoll.toLowerCase();
-			if (envLower === "false" || envLower === "0") opts.usePolling = false;
-			else if (envLower === "true" || envLower === "1") opts.usePolling = true;
-			else opts.usePolling = !!envLower;
-		}
-		const envInterval = process.env.CHOKIDAR_INTERVAL;
-		if (envInterval) opts.interval = Number.parseInt(envInterval, 10);
-		let readyCalls = 0;
-		this._emitReady = () => {
-			readyCalls++;
-			if (readyCalls >= this._readyCount) {
-				this._emitReady = EMPTY_FN$1;
-				this._readyEmitted = true;
-				process.nextTick(() => this.emit(EVENTS$1.READY));
-			}
-		};
-		this._emitRaw = (...args) => this.emit(EVENTS$1.RAW, ...args);
-		this._boundRemove = this._remove.bind(this);
-		this.options = opts;
-		this._nodeFsHandler = new NodeFsHandler$1(this);
-		Object.freeze(opts);
-	}
-	_addIgnoredPath(matcher) {
-		if (isMatcherObject$1(matcher)) {
-			for (const ignored of this._ignoredPaths) if (isMatcherObject$1(ignored) && ignored.path === matcher.path && ignored.recursive === matcher.recursive) return;
-		}
-		this._ignoredPaths.add(matcher);
-	}
-	_removeIgnoredPath(matcher) {
-		this._ignoredPaths.delete(matcher);
-		if (typeof matcher === "string") {
-			for (const ignored of this._ignoredPaths) if (isMatcherObject$1(ignored) && ignored.path === matcher) this._ignoredPaths.delete(ignored);
-		}
-	}
-	/**
-	* Adds paths to be watched on an existing FSWatcher instance.
-	* @param paths_ file or file list. Other arguments are unused
-	*/
-	add(paths_, _origAdd, _internal) {
-		const { cwd } = this.options;
-		this.closed = false;
-		this._closePromise = void 0;
-		let paths = unifyPaths$1(paths_);
-		if (cwd) paths = paths.map((path$2) => {
-			return getAbsolutePath$1(path$2, cwd);
-		});
-		paths.forEach((path$2) => {
-			this._removeIgnoredPath(path$2);
-		});
-		this._userIgnored = void 0;
-		if (!this._readyCount) this._readyCount = 0;
-		this._readyCount += paths.length;
-		Promise.all(paths.map(async (path$2) => {
-			const res = await this._nodeFsHandler._addToNodeFs(path$2, !_internal, void 0, 0, _origAdd);
-			if (res) this._emitReady();
-			return res;
-		})).then((results) => {
-			if (this.closed) return;
-			results.forEach((item) => {
-				if (item) this.add(sp.dirname(item), sp.basename(_origAdd || item));
-			});
-		});
-		return this;
-	}
-	/**
-	* Close watchers or start ignoring events from specified paths.
-	*/
-	unwatch(paths_) {
-		if (this.closed) return this;
-		const paths = unifyPaths$1(paths_);
-		const { cwd } = this.options;
-		paths.forEach((path$2) => {
-			if (!sp.isAbsolute(path$2) && !this._closers.has(path$2)) {
-				if (cwd) path$2 = sp.join(cwd, path$2);
-				path$2 = sp.resolve(path$2);
-			}
-			this._closePath(path$2);
-			this._addIgnoredPath(path$2);
-			if (this._watched.has(path$2)) this._addIgnoredPath({
-				path: path$2,
-				recursive: true
-			});
-			this._userIgnored = void 0;
-		});
-		return this;
-	}
-	/**
-	* Close watchers and remove all listeners from watched paths.
-	*/
-	close() {
-		if (this._closePromise) return this._closePromise;
-		this.closed = true;
-		this.removeAllListeners();
-		const closers = [];
-		this._closers.forEach((closerList) => closerList.forEach((closer) => {
-			const promise = closer();
-			if (promise instanceof Promise) closers.push(promise);
-		}));
-		this._streams.forEach((stream) => stream.destroy());
-		this._userIgnored = void 0;
-		this._readyCount = 0;
-		this._readyEmitted = false;
-		this._watched.forEach((dirent) => dirent.dispose());
-		this._closers.clear();
-		this._watched.clear();
-		this._streams.clear();
-		this._symlinkPaths.clear();
-		this._throttled.clear();
-		this._closePromise = closers.length ? Promise.all(closers).then(() => void 0) : Promise.resolve();
-		return this._closePromise;
-	}
-	/**
-	* Expose list of watched paths
-	* @returns for chaining
-	*/
-	getWatched() {
-		const watchList = {};
-		this._watched.forEach((entry, dir) => {
-			const index = (this.options.cwd ? sp.relative(this.options.cwd, dir) : dir) || ONE_DOT$1;
-			watchList[index] = entry.getChildren().sort();
-		});
-		return watchList;
-	}
-	emitWithAll(event, args) {
-		this.emit(event, ...args);
-		if (event !== EVENTS$1.ERROR) this.emit(EVENTS$1.ALL, event, ...args);
-	}
-	/**
-	* Normalize and emit events.
-	* Calling _emit DOES NOT MEAN emit() would be called!
-	* @param event Type of event
-	* @param path File or directory path
-	* @param stats arguments to be passed with event
-	* @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
-	*/
-	async _emit(event, path$2, stats) {
-		if (this.closed) return;
-		const opts = this.options;
-		if (isWindows$1) path$2 = sp.normalize(path$2);
-		if (opts.cwd) path$2 = sp.relative(opts.cwd, path$2);
-		const args = [path$2];
-		if (stats != null) args.push(stats);
-		const awf = opts.awaitWriteFinish;
-		let pw;
-		if (awf && (pw = this._pendingWrites.get(path$2))) {
-			pw.lastChange = /* @__PURE__ */ new Date();
-			return this;
-		}
-		if (opts.atomic) {
-			if (event === EVENTS$1.UNLINK) {
-				this._pendingUnlinks.set(path$2, [event, ...args]);
-				setTimeout(() => {
-					this._pendingUnlinks.forEach((entry, path$3) => {
-						this.emit(...entry);
-						this.emit(EVENTS$1.ALL, ...entry);
-						this._pendingUnlinks.delete(path$3);
-					});
-				}, typeof opts.atomic === "number" ? opts.atomic : 100);
-				return this;
-			}
-			if (event === EVENTS$1.ADD && this._pendingUnlinks.has(path$2)) {
-				event = EVENTS$1.CHANGE;
-				this._pendingUnlinks.delete(path$2);
-			}
-		}
-		if (awf && (event === EVENTS$1.ADD || event === EVENTS$1.CHANGE) && this._readyEmitted) {
-			const awfEmit = (err, stats$1) => {
-				if (err) {
-					event = EVENTS$1.ERROR;
-					args[0] = err;
-					this.emitWithAll(event, args);
-				} else if (stats$1) {
-					if (args.length > 1) args[1] = stats$1;
-					else args.push(stats$1);
-					this.emitWithAll(event, args);
-				}
-			};
-			this._awaitWriteFinish(path$2, awf.stabilityThreshold, event, awfEmit);
-			return this;
-		}
-		if (event === EVENTS$1.CHANGE) {
-			if (!this._throttle(EVENTS$1.CHANGE, path$2, 50)) return this;
-		}
-		if (opts.alwaysStat && stats === void 0 && (event === EVENTS$1.ADD || event === EVENTS$1.ADD_DIR || event === EVENTS$1.CHANGE)) {
-			const fullPath = opts.cwd ? sp.join(opts.cwd, path$2) : path$2;
-			let stats$1;
-			try {
-				stats$1 = await stat$1(fullPath);
-			} catch (err) {}
-			if (!stats$1 || this.closed) return;
-			args.push(stats$1);
-		}
-		this.emitWithAll(event, args);
-		return this;
-	}
-	/**
-	* Common handler for errors
-	* @returns The error if defined, otherwise the value of the FSWatcher instance's `closed` flag
-	*/
-	_handleError(error) {
-		const code = error && error.code;
-		if (error && code !== "ENOENT" && code !== "ENOTDIR" && (!this.options.ignorePermissionErrors || code !== "EPERM" && code !== "EACCES")) this.emit(EVENTS$1.ERROR, error);
-		return error || this.closed;
-	}
-	/**
-	* Helper utility for throttling
-	* @param actionType type being throttled
-	* @param path being acted upon
-	* @param timeout duration of time to suppress duplicate actions
-	* @returns tracking object or false if action should be suppressed
-	*/
-	_throttle(actionType, path$2, timeout) {
-		if (!this._throttled.has(actionType)) this._throttled.set(actionType, /* @__PURE__ */ new Map());
-		const action = this._throttled.get(actionType);
-		if (!action) throw new Error("invalid throttle");
-		const actionPath = action.get(path$2);
-		if (actionPath) {
-			actionPath.count++;
-			return false;
-		}
-		let timeoutObject;
-		const clear = () => {
-			const item = action.get(path$2);
-			const count = item ? item.count : 0;
-			action.delete(path$2);
-			clearTimeout(timeoutObject);
-			if (item) clearTimeout(item.timeoutObject);
-			return count;
-		};
-		timeoutObject = setTimeout(clear, timeout);
-		const thr = {
-			timeoutObject,
-			clear,
-			count: 0
-		};
-		action.set(path$2, thr);
-		return thr;
-	}
-	_incrReadyCount() {
-		return this._readyCount++;
-	}
-	/**
-	* Awaits write operation to finish.
-	* Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback.
-	* @param path being acted upon
-	* @param threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished
-	* @param event
-	* @param awfEmit Callback to be called when ready for event to be emitted.
-	*/
-	_awaitWriteFinish(path$2, threshold, event, awfEmit) {
-		const awf = this.options.awaitWriteFinish;
-		if (typeof awf !== "object") return;
-		const pollInterval = awf.pollInterval;
-		let timeoutHandler;
-		let fullPath = path$2;
-		if (this.options.cwd && !sp.isAbsolute(path$2)) fullPath = sp.join(this.options.cwd, path$2);
-		const now = /* @__PURE__ */ new Date();
-		const writes = this._pendingWrites;
-		function awaitWriteFinishFn(prevStat) {
-			stat(fullPath, (err, curStat) => {
-				if (err || !writes.has(path$2)) {
-					if (err && err.code !== "ENOENT") awfEmit(err);
-					return;
-				}
-				const now$1 = Number(/* @__PURE__ */ new Date());
-				if (prevStat && curStat.size !== prevStat.size) writes.get(path$2).lastChange = now$1;
-				if (now$1 - writes.get(path$2).lastChange >= threshold) {
-					writes.delete(path$2);
-					awfEmit(void 0, curStat);
-				} else timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
-			});
-		}
-		if (!writes.has(path$2)) {
-			writes.set(path$2, {
-				lastChange: now,
-				cancelWait: () => {
-					writes.delete(path$2);
-					clearTimeout(timeoutHandler);
-					return event;
-				}
-			});
-			timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval);
-		}
-	}
-	/**
-	* Determines whether user has asked to ignore this path.
-	*/
-	_isIgnored(path$2, stats) {
-		if (this.options.atomic && DOT_RE$1.test(path$2)) return true;
-		if (!this._userIgnored) {
-			const { cwd } = this.options;
-			const ignored = (this.options.ignored || []).map(normalizeIgnored$1(cwd));
-			this._userIgnored = anymatch$1([...[...this._ignoredPaths].map(normalizeIgnored$1(cwd)), ...ignored], void 0);
-		}
-		return this._userIgnored(path$2, stats);
-	}
-	_isntIgnored(path$2, stat$4) {
-		return !this._isIgnored(path$2, stat$4);
-	}
-	/**
-	* Provides a set of common helpers and properties relating to symlink handling.
-	* @param path file or directory pattern being watched
-	*/
-	_getWatchHelpers(path$2) {
-		return new WatchHelper$1(path$2, this.options.followSymlinks, this);
-	}
-	/**
-	* Provides directory tracking objects
-	* @param directory path of the directory
-	*/
-	_getWatchedDir(directory) {
-		const dir = sp.resolve(directory);
-		if (!this._watched.has(dir)) this._watched.set(dir, new DirEntry$1(dir, this._boundRemove));
-		return this._watched.get(dir);
-	}
-	/**
-	* Check for read permissions: https://stackoverflow.com/a/11781404/1358405
-	*/
-	_hasReadPermissions(stats) {
-		if (this.options.ignorePermissionErrors) return true;
-		return Boolean(Number(stats.mode) & 256);
-	}
-	/**
-	* Handles emitting unlink events for
-	* files and directories, and via recursion, for
-	* files and directories within directories that are unlinked
-	* @param directory within which the following item is located
-	* @param item      base path of item/directory
-	*/
-	_remove(directory, item, isDirectory) {
-		const path$2 = sp.join(directory, item);
-		const fullPath = sp.resolve(path$2);
-		isDirectory = isDirectory != null ? isDirectory : this._watched.has(path$2) || this._watched.has(fullPath);
-		if (!this._throttle("remove", path$2, 100)) return;
-		if (!isDirectory && this._watched.size === 1) this.add(directory, item, true);
-		this._getWatchedDir(path$2).getChildren().forEach((nested) => this._remove(path$2, nested));
-		const parent = this._getWatchedDir(directory);
-		const wasTracked = parent.has(item);
-		parent.remove(item);
-		if (this._symlinkPaths.has(fullPath)) this._symlinkPaths.delete(fullPath);
-		let relPath = path$2;
-		if (this.options.cwd) relPath = sp.relative(this.options.cwd, path$2);
-		if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
-			if (this._pendingWrites.get(relPath).cancelWait() === EVENTS$1.ADD) return;
-		}
-		this._watched.delete(path$2);
-		this._watched.delete(fullPath);
-		const eventName = isDirectory ? EVENTS$1.UNLINK_DIR : EVENTS$1.UNLINK;
-		if (wasTracked && !this._isIgnored(path$2)) this._emit(eventName, path$2);
-		this._closePath(path$2);
-	}
-	/**
-	* Closes all watchers for a path
-	*/
-	_closePath(path$2) {
-		this._closeFile(path$2);
-		const dir = sp.dirname(path$2);
-		this._getWatchedDir(dir).remove(sp.basename(path$2));
-	}
-	/**
-	* Closes only file-specific watchers
-	*/
-	_closeFile(path$2) {
-		const closers = this._closers.get(path$2);
-		if (!closers) return;
-		closers.forEach((closer) => closer());
-		this._closers.delete(path$2);
-	}
-	_addPathCloser(path$2, closer) {
-		if (!closer) return;
-		let list = this._closers.get(path$2);
-		if (!list) {
-			list = [];
-			this._closers.set(path$2, list);
-		}
-		list.push(closer);
-	}
-	_readdirp(root, opts) {
-		if (this.closed) return;
-		let stream = readdirp$1(root, {
-			type: EVENTS$1.ALL,
-			alwaysStat: true,
-			lstat: true,
-			...opts,
-			depth: 0
-		});
-		this._streams.add(stream);
-		stream.once(STR_CLOSE$1, () => {
-			stream = void 0;
-		});
-		stream.once(STR_END$1, () => {
-			if (stream) {
-				this._streams.delete(stream);
-				stream = void 0;
-			}
-		});
-		return stream;
-	}
-};
-/**
-* Instantiates watcher with paths to be tracked.
-* @param paths file / directory paths
-* @param options opts, such as `atomic`, `awaitWriteFinish`, `ignored`, and others
-* @returns an instance of FSWatcher for chaining.
-* @example
-* const watcher = watch('.').on('all', (event, path) => { console.log(event, path); });
-* watch('.', { atomic: true, awaitWriteFinish: true, ignored: (f, stats) => stats?.isFile() && !f.endsWith('.js') })
-*/
-function watch$3(paths, options = {}) {
-	const watcher = new FSWatcher$1(options);
-	watcher.add(paths);
-	return watcher;
-}
-//#endregion
-//#region node_modules/.pnpm/readdirp@4.1.2/node_modules/readdirp/esm/index.js
 const EntryTypes = {
 	FILE_TYPE: "files",
 	DIR_TYPE: "directories",
@@ -1662,6 +66,20 @@ const normalizeFilter = (filter) => {
 };
 /** Readable readdir stream, emitting new files as they're being listed. */
 var ReaddirpStream = class extends Readable {
+	parents;
+	reading;
+	parent;
+	_stat;
+	_maxDepth;
+	_wantsDir;
+	_wantsFile;
+	_wantsEverything;
+	_root;
+	_isDirent;
+	_statsProp;
+	_rdOptions;
+	_fileFilter;
+	_directoryFilter;
 	constructor(options = {}) {
 		super({
 			objectMode: true,
@@ -1672,16 +90,16 @@ var ReaddirpStream = class extends Readable {
 			...defaultOptions,
 			...options
 		};
-		const { root, type: type$2 } = opts;
+		const { root, type: type$1 } = opts;
 		this._fileFilter = normalizeFilter(opts.fileFilter);
 		this._directoryFilter = normalizeFilter(opts.directoryFilter);
 		const statMethod = opts.lstat ? lstat : stat$1;
-		if (wantBigintFsStats) this._stat = (path$2) => statMethod(path$2, { bigint: true });
+		if (wantBigintFsStats) this._stat = (path$1) => statMethod(path$1, { bigint: true });
 		else this._stat = statMethod;
-		this._maxDepth = opts.depth ?? defaultOptions.depth;
-		this._wantsDir = type$2 ? DIR_TYPES.has(type$2) : false;
-		this._wantsFile = type$2 ? FILE_TYPES.has(type$2) : false;
-		this._wantsEverything = type$2 === EntryTypes.EVERYTHING_TYPE;
+		this._maxDepth = opts.depth != null && Number.isSafeInteger(opts.depth) ? opts.depth : defaultOptions.depth;
+		this._wantsDir = type$1 ? DIR_TYPES.has(type$1) : false;
+		this._wantsFile = type$1 ? FILE_TYPES.has(type$1) : false;
+		this._wantsEverything = type$1 === EntryTypes.EVERYTHING_TYPE;
 		this._root = resolve(root);
 		this._isDirent = !opts.alwaysStat;
 		this._statsProp = this._isDirent ? "dirent" : "stats";
@@ -1701,8 +119,8 @@ var ReaddirpStream = class extends Readable {
 				const par = this.parent;
 				const fil = par && par.files;
 				if (fil && fil.length > 0) {
-					const { path: path$2, depth } = par;
-					const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path$2));
+					const { path: path$1, depth } = par;
+					const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path$1));
 					const awaited = await Promise.all(slice);
 					for (const entry of awaited) {
 						if (!entry) continue;
@@ -1737,28 +155,28 @@ var ReaddirpStream = class extends Readable {
 			this.reading = false;
 		}
 	}
-	async _exploreDir(path$2, depth) {
+	async _exploreDir(path$1, depth) {
 		let files;
 		try {
-			files = await readdir(path$2, this._rdOptions);
+			files = await readdir(path$1, this._rdOptions);
 		} catch (error) {
 			this._onError(error);
 		}
 		return {
 			files,
 			depth,
-			path: path$2
+			path: path$1
 		};
 	}
-	async _formatEntry(dirent, path$2) {
+	async _formatEntry(dirent, path$1) {
 		let entry;
-		const basename$2 = this._isDirent ? dirent.name : dirent;
+		const basename$1 = this._isDirent ? dirent.name : dirent;
 		try {
-			const fullPath = resolve(join(path$2, basename$2));
+			const fullPath = resolve(join(path$1, basename$1));
 			entry = {
 				path: relative(this._root, fullPath),
 				fullPath,
-				basename: basename$2
+				basename: basename$1
 			};
 			entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
 		} catch (err) {
@@ -1809,18 +227,18 @@ var ReaddirpStream = class extends Readable {
 * @param options Options to specify root (start directory), filters and recursion depth
 */
 function readdirp(root, options = {}) {
-	let type$2 = options.entryType || options.type;
-	if (type$2 === "both") type$2 = EntryTypes.FILE_DIR_TYPE;
-	if (type$2) options.type = type$2;
+	let type$1 = options.entryType || options.type;
+	if (type$1 === "both") type$1 = EntryTypes.FILE_DIR_TYPE;
+	if (type$1) options.type = type$1;
 	if (!root) throw new Error("readdirp: root argument is required. Usage: readdirp(root, options)");
 	else if (typeof root !== "string") throw new TypeError("readdirp: root argument must be a string. Usage: readdirp(root, options)");
-	else if (type$2 && !ALL_TYPES.includes(type$2)) throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(", ")}`);
+	else if (type$1 && !ALL_TYPES.includes(type$1)) throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(", ")}`);
 	options.root = root;
 	return new ReaddirpStream(options);
 }
 //#endregion
-//#region node_modules/.pnpm/chokidar@4.0.3/node_modules/chokidar/esm/handler.js
+//#region node_modules/.pnpm/chokidar@5.0.0/node_modules/chokidar/handler.js
 const STR_DATA = "data";
 const STR_END = "end";
 const STR_CLOSE = "close";
@@ -1830,7 +248,7 @@ const isWindows = pl === "win32";
 const isMacos = pl === "darwin";
 const isLinux = pl === "linux";
 const isFreeBSD = pl === "freebsd";
-const isIBMi = type$1() === "OS400";
+const isIBMi = type() === "OS400";
 const EVENTS = {
 	ALL: "all",
 	READY: "ready",
@@ -1845,8 +263,8 @@ const EVENTS = {
 const EV = EVENTS;
 const THROTTLE_MODE_WATCH = "watch";
 const statMethods = {
-	lstat: lstat$1,
-	stat: stat$3
+	lstat,
+	stat: stat$1
 };
 const KEY_LISTENERS = "listeners";
 const KEY_ERR = "errHandlers";
@@ -2119,7 +537,7 @@ const binaryExtensions = new Set([
 	"zip",
 	"zipx"
 ]);
-const isBinaryPath = (filePath) => binaryExtensions.has(sysPath.extname(filePath).slice(1).toLowerCase());
+const isBinaryPath = (filePath) => binaryExtensions.has(sp.extname(filePath).slice(1).toLowerCase());
 const foreach = (val, fn) => {
 	if (val instanceof Set) val.forEach(fn);
 	else fn(val);
@@ -2150,14 +568,14 @@ const FsWatchInstances = /* @__PURE__ */ new Map();
 * @param emitRaw emits raw event data
 * @returns {NativeFsWatcher}
 */
-function createFsWatchInstance(path$2, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path$1, options, listener, errHandler, emitRaw) {
 	const handleEvent = (rawEvent, evPath) => {
-		listener(path$2);
-		emitRaw(rawEvent, evPath, { watchedPath: path$2 });
-		if (evPath && path$2 !== evPath) fsWatchBroadcast(sysPath.resolve(path$2, evPath), KEY_LISTENERS, sysPath.join(path$2, evPath));
+		listener(path$1);
+		emitRaw(rawEvent, evPath, { watchedPath: path$1 });
+		if (evPath && path$1 !== evPath) fsWatchBroadcast(sp.resolve(path$1, evPath), KEY_LISTENERS, sp.join(path$1, evPath));
 	};
 	try {
-		return watch$1(path$2, { persistent: options.persistent }, handleEvent);
+		return watch(path$1, { persistent: options.persistent }, handleEvent);
 	} catch (error) {
 		errHandler(error);
 		return;
@@ -2182,12 +600,12 @@ const fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
 * @param options to be passed to fs_watch
 * @param handlers container for event listener functions
 */
-const setFsWatchListener = (path$2, fullPath, options, handlers) => {
+const setFsWatchListener = (path$1, fullPath, options, handlers) => {
 	const { listener, errHandler, rawEmitter } = handlers;
 	let cont = FsWatchInstances.get(fullPath);
 	let watcher;
 	if (!options.persistent) {
-		watcher = createFsWatchInstance(path$2, options, listener, errHandler, rawEmitter);
+		watcher = createFsWatchInstance(path$1, options, listener, errHandler, rawEmitter);
 		if (!watcher) return;
 		return watcher.close.bind(watcher);
 	}
@@ -2196,13 +614,13 @@ const setFsWatchListener = (path$2, fullPath, options, handlers) => {
 		addAndConvert(cont, KEY_ERR, errHandler);
 		addAndConvert(cont, KEY_RAW, rawEmitter);
 	} else {
-		watcher = createFsWatchInstance(path$2, options, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, fsWatchBroadcast.bind(null, fullPath, KEY_RAW));
+		watcher = createFsWatchInstance(path$1, options, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, fsWatchBroadcast.bind(null, fullPath, KEY_RAW));
 		if (!watcher) return;
 		watcher.on(EV.ERROR, async (error) => {
 			const broadcastErr = fsWatchBroadcast.bind(null, fullPath, KEY_ERR);
 			if (cont) cont.watcherUnusable = true;
 			if (isWindows && error.code === "EPERM") try {
-				await (await open$1(path$2, "r")).close();
+				await (await open(path$1, "r")).close();
 				broadcastErr(error);
 			} catch (err) {}
 			else broadcastErr(error);
@@ -2238,12 +656,12 @@ const FsWatchFileInstances = /* @__PURE__ */ new Map();
 * @param handlers container for event listener functions
 * @returns closer
 */
-const setFsWatchFileListener = (path$2, fullPath, options, handlers) => {
+const setFsWatchFileListener = (path$1, fullPath, options, handlers) => {
 	const { listener, rawEmitter } = handlers;
 	let cont = FsWatchFileInstances.get(fullPath);
 	const copts = cont && cont.options;
 	if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
-		unwatchFile$1(fullPath);
+		unwatchFile(fullPath);
 		cont = void 0;
 	}
 	if (cont) {
@@ -2254,7 +672,7 @@ const setFsWatchFileListener = (path$2, fullPath, options, handlers) => {
 			listeners: listener,
 			rawEmitters: rawEmitter,
 			options,
-			watcher: watchFile$1(fullPath, options, (curr, prev) => {
+			watcher: watchFile(fullPath, options, (curr, prev) => {
 				foreach(cont.rawEmitters, (rawEmitter$1) => {
 					rawEmitter$1(EV.CHANGE, fullPath, {
 						curr,
@@ -2262,7 +680,7 @@ const setFsWatchFileListener = (path$2, fullPath, options, handlers) => {
 					});
 				});
 				const currmtime = curr.mtimeMs;
-				if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) foreach(cont.listeners, (listener$1) => listener$1(path$2, curr));
+				if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) foreach(cont.listeners, (listener$1) => listener$1(path$1, curr));
 			})
 		};
 		FsWatchFileInstances.set(fullPath, cont);
@@ -2272,7 +690,7 @@ const setFsWatchFileListener = (path$2, fullPath, options, handlers) => {
 		delFromSet(cont, KEY_RAW, rawEmitter);
 		if (isEmptySet(cont.listeners)) {
 			FsWatchFileInstances.delete(fullPath);
-			unwatchFile$1(fullPath);
+			unwatchFile(fullPath);
 			cont.options = cont.watcher = void 0;
 			Object.freeze(cont);
 		}
@@ -2282,6 +700,8 @@ const setFsWatchFileListener = (path$2, fullPath, options, handlers) => {
 * @mixin
 */
 var NodeFsHandler = class {
+	fsw;
+	_boundHandleError;
 	constructor(fsW) {
 		this.fsw = fsW;
 		this._boundHandleError = (error) => fsW._handleError(error);
@@ -2292,22 +712,22 @@ var NodeFsHandler = class {
 	* @param listener on fs change
 	* @returns closer for the watcher instance
 	*/
-	_watchWithNodeFs(path$2, listener) {
+	_watchWithNodeFs(path$1, listener) {
 		const opts = this.fsw.options;
-		const directory = sysPath.dirname(path$2);
-		const basename$2 = sysPath.basename(path$2);
-		this.fsw._getWatchedDir(directory).add(basename$2);
-		const absolutePath = sysPath.resolve(path$2);
+		const directory = sp.dirname(path$1);
+		const basename$1 = sp.basename(path$1);
+		this.fsw._getWatchedDir(directory).add(basename$1);
+		const absolutePath = sp.resolve(path$1);
 		const options = { persistent: opts.persistent };
 		if (!listener) listener = EMPTY_FN;
 		let closer;
 		if (opts.usePolling) {
-			options.interval = opts.interval !== opts.binaryInterval && isBinaryPath(basename$2) ? opts.binaryInterval : opts.interval;
-			closer = setFsWatchFileListener(path$2, absolutePath, options, {
+			options.interval = opts.interval !== opts.binaryInterval && isBinaryPath(basename$1) ? opts.binaryInterval : opts.interval;
+			closer = setFsWatchFileListener(path$1, absolutePath, options, {
 				listener,
 				rawEmitter: this.fsw._emitRaw
 			});
-		} else closer = setFsWatchListener(path$2, absolutePath, options, {
+		} else closer = setFsWatchListener(path$1, absolutePath, options, {
 			listener,
 			errHandler: this._boundHandleError,
 			rawEmitter: this.fsw._emitRaw
@@ -2320,29 +740,29 @@ var NodeFsHandler = class {
 	*/
 	_handleFile(file, stats, initialAdd) {
 		if (this.fsw.closed) return;
-		const dirname$2 = sysPath.dirname(file);
-		const basename$2 = sysPath.basename(file);
-		const parent = this.fsw._getWatchedDir(dirname$2);
+		const dirname$1 = sp.dirname(file);
+		const basename$1 = sp.basename(file);
+		const parent = this.fsw._getWatchedDir(dirname$1);
 		let prevStats = stats;
-		if (parent.has(basename$2)) return;
-		const listener = async (path$2, newStats) => {
+		if (parent.has(basename$1)) return;
+		const listener = async (path$1, newStats) => {
 			if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5)) return;
 			if (!newStats || newStats.mtimeMs === 0) try {
-				const newStats$1 = await stat$3(file);
+				const newStats$1 = await stat$1(file);
 				if (this.fsw.closed) return;
 				const at = newStats$1.atimeMs;
 				const mt = newStats$1.mtimeMs;
 				if (!at || at <= mt || mt !== prevStats.mtimeMs) this.fsw._emit(EV.CHANGE, file, newStats$1);
 				if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats$1.ino) {
-					this.fsw._closeFile(path$2);
+					this.fsw._closeFile(path$1);
 					prevStats = newStats$1;
 					const closer$1 = this._watchWithNodeFs(file, listener);
-					if (closer$1) this.fsw._addPathCloser(path$2, closer$1);
+					if (closer$1) this.fsw._addPathCloser(path$1, closer$1);
 				} else prevStats = newStats$1;
 			} catch (error) {
-				this.fsw._remove(dirname$2, basename$2);
+				this.fsw._remove(dirname$1, basename$1);
 			}
-			else if (parent.has(basename$2)) {
+			else if (parent.has(basename$1)) {
 				const at = newStats.atimeMs;
 				const mt = newStats.mtimeMs;
 				if (!at || at <= mt || mt !== prevStats.mtimeMs) this.fsw._emit(EV.CHANGE, file, newStats);
@@ -2364,7 +784,7 @@ var NodeFsHandler = class {
 	* @param item basename of this item
 	* @returns true if no more processing is needed for this entry.
 	*/
-	async _handleSymlink(entry, directory, path$2, item) {
+	async _handleSymlink(entry, directory, path$1, item) {
 		if (this.fsw.closed) return;
 		const full = entry.fullPath;
 		const dir = this.fsw._getWatchedDir(directory);
@@ -2372,7 +792,7 @@ var NodeFsHandler = class {
 			this.fsw._incrReadyCount();
 			let linkPath;
 			try {
-				linkPath = await realpath$1(path$2);
+				linkPath = await realpath(path$1);
 			} catch (e) {
 				this.fsw._emitReady();
 				return true;
@@ -2381,12 +801,12 @@ var NodeFsHandler = class {
 			if (dir.has(item)) {
 				if (this.fsw._symlinkPaths.get(full) !== linkPath) {
 					this.fsw._symlinkPaths.set(full, linkPath);
-					this.fsw._emit(EV.CHANGE, path$2, entry.stats);
+					this.fsw._emit(EV.CHANGE, path$1, entry.stats);
 				}
 			} else {
 				dir.add(item);
 				this.fsw._symlinkPaths.set(full, linkPath);
-				this.fsw._emit(EV.ADD, path$2, entry.stats);
+				this.fsw._emit(EV.ADD, path$1, entry.stats);
 			}
 			this.fsw._emitReady();
 			return true;
@@ -2395,8 +815,9 @@ var NodeFsHandler = class {
 		this.fsw._symlinkPaths.set(full, true);
 	}
 	_handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
-		directory = sysPath.join(directory, "");
-		throttler = this.fsw._throttle("readdir", directory, 1e3);
+		directory = sp.join(directory, "");
+		const throttleKey = target ? `${directory}:${target}` : directory;
+		throttler = this.fsw._throttle("readdir", throttleKey, 1e3);
 		if (!throttler) return;
 		const previous = this.fsw._getWatchedDir(wh.path);
 		const current = /* @__PURE__ */ new Set();
@@ -2411,20 +832,20 @@ var NodeFsHandler = class {
 				return;
 			}
 			const item = entry.path;
-			let path$2 = sysPath.join(directory, item);
+			let path$1 = sp.join(directory, item);
 			current.add(item);
-			if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path$2, item)) return;
+			if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path$1, item)) return;
 			if (this.fsw.closed) {
 				stream = void 0;
 				return;
 			}
 			if (item === target || !target && !previous.has(item)) {
 				this.fsw._incrReadyCount();
-				path$2 = sysPath.join(dir, sysPath.relative(dir, path$2));
-				this._addToNodeFs(path$2, initialAdd, wh, depth + 1);
+				path$1 = sp.join(dir, sp.relative(dir, path$1));
+				this._addToNodeFs(path$1, initialAdd, wh, depth + 1);
 			}
 		}).on(EV.ERROR, this._boundHandleError);
-		return new Promise((resolve$2, reject) => {
+		return new Promise((resolve$1, reject) => {
 			if (!stream) return reject();
 			stream.once(STR_END, () => {
 				if (this.fsw.closed) {
@@ -2432,7 +853,7 @@ var NodeFsHandler = class {
 					return;
 				}
 				const wasThrottled = throttler ? throttler.clear() : false;
-				resolve$2(void 0);
+				resolve$1(void 0);
 				previous.getChildren().filter((item) => {
 					return item !== directory && !current.has(item);
 				}).forEach((item) => {
@@ -2454,16 +875,16 @@ var NodeFsHandler = class {
 	* @param realpath
 	* @returns closer for the watcher instance.
 	*/
-	async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath$2) {
-		const parentDir = this.fsw._getWatchedDir(sysPath.dirname(dir));
-		const tracked = parentDir.has(sysPath.basename(dir));
+	async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath$1) {
+		const parentDir = this.fsw._getWatchedDir(sp.dirname(dir));
+		const tracked = parentDir.has(sp.basename(dir));
 		if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) this.fsw._emit(EV.ADD_DIR, dir, stats);
-		parentDir.add(sysPath.basename(dir));
+		parentDir.add(sp.basename(dir));
 		this.fsw._getWatchedDir(dir);
 		let throttler;
 		let closer;
 		const oDepth = this.fsw.options.depth;
-		if ((oDepth == null || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath$2)) {
+		if ((oDepth == null || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath$1)) {
 			if (!target) {
 				await this._handleRead(dir, initialAdd, wh, target, dir, depth, throttler);
 				if (this.fsw.closed) return;
@@ -2484,13 +905,13 @@ var NodeFsHandler = class {
 	* @param depth Child path actually targeted for watch
 	* @param target Child path actually targeted for watch
 	*/
-	async _addToNodeFs(path$2, initialAdd, priorWh, depth, target) {
+	async _addToNodeFs(path$1, initialAdd, priorWh, depth, target) {
 		const ready = this.fsw._emitReady;
-		if (this.fsw._isIgnored(path$2) || this.fsw.closed) {
+		if (this.fsw._isIgnored(path$1) || this.fsw.closed) {
 			ready();
 			return false;
 		}
-		const wh = this.fsw._getWatchHelpers(path$2);
+		const wh = this.fsw._getWatchHelpers(path$1);
 		if (priorWh) {
 			wh.filterPath = (entry) => priorWh.filterPath(entry);
 			wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -2505,36 +926,36 @@ var NodeFsHandler = class {
 			const follow = this.fsw.options.followSymlinks;
 			let closer;
 			if (stats.isDirectory()) {
-				const absPath = sysPath.resolve(path$2);
-				const targetPath = follow ? await realpath$1(path$2) : path$2;
+				const absPath = sp.resolve(path$1);
+				const targetPath = follow ? await realpath(path$1) : path$1;
 				if (this.fsw.closed) return;
 				closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
 				if (this.fsw.closed) return;
 				if (absPath !== targetPath && targetPath !== void 0) this.fsw._symlinkPaths.set(absPath, targetPath);
 			} else if (stats.isSymbolicLink()) {
-				const targetPath = follow ? await realpath$1(path$2) : path$2;
+				const targetPath = follow ? await realpath(path$1) : path$1;
 				if (this.fsw.closed) return;
-				const parent = sysPath.dirname(wh.watchPath);
+				const parent = sp.dirname(wh.watchPath);
 				this.fsw._getWatchedDir(parent).add(wh.watchPath);
 				this.fsw._emit(EV.ADD, wh.watchPath, stats);
-				closer = await this._handleDir(parent, stats, initialAdd, depth, path$2, wh, targetPath);
+				closer = await this._handleDir(parent, stats, initialAdd, depth, path$1, wh, targetPath);
 				if (this.fsw.closed) return;
-				if (targetPath !== void 0) this.fsw._symlinkPaths.set(sysPath.resolve(path$2), targetPath);
+				if (targetPath !== void 0) this.fsw._symlinkPaths.set(sp.resolve(path$1), targetPath);
 			} else closer = this._handleFile(wh.watchPath, stats, initialAdd);
 			ready();
-			if (closer) this.fsw._addPathCloser(path$2, closer);
+			if (closer) this.fsw._addPathCloser(path$1, closer);
 			return false;
 		} catch (error) {
 			if (this.fsw._handleError(error)) {
 				ready();
-				return path$2;
+				return path$1;
 			}
 		}
 	}
 };
 //#endregion
-//#region node_modules/.pnpm/chokidar@4.0.3/node_modules/chokidar/esm/index.js
+//#region node_modules/.pnpm/chokidar@5.0.0/node_modules/chokidar/index.js
 /*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) */
 const SLASH = "/";
 const SLASH_SLASH = "//";
@@ -2542,7 +963,7 @@ const ONE_DOT = ".";
 const TWO_DOTS = "..";
 const STRING_TYPE = "string";
 const BACK_SLASH_RE = /\\/g;
-const DOUBLE_SLASH_RE = /\/\//;
+const DOUBLE_SLASH_RE = /\/\//g;
 const DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
 const REPLACER_RE = /^\.[/\\]/;
 function arrify(item) {
@@ -2556,30 +977,29 @@ function createPattern(matcher) {
 	if (typeof matcher === "object" && matcher !== null) return (string) => {
 		if (matcher.path === string) return true;
 		if (matcher.recursive) {
-			const relative$2 = sysPath.relative(matcher.path, string);
-			if (!relative$2) return false;
-			return !relative$2.startsWith("..") && !sysPath.isAbsolute(relative$2);
+			const relative$1 = sp.relative(matcher.path, string);
+			if (!relative$1) return false;
+			return !relative$1.startsWith("..") && !sp.isAbsolute(relative$1);
 		}
 		return false;
 	};
 	return () => false;
 }
-function normalizePath(path$2) {
-	if (typeof path$2 !== "string") throw new Error("string expected");
-	path$2 = sysPath.normalize(path$2);
-	path$2 = path$2.replace(/\\/g, "/");
+function normalizePath(path$1) {
+	if (typeof path$1 !== "string") throw new Error("string expected");
+	path$1 = sp.normalize(path$1);
+	path$1 = path$1.replace(/\\/g, "/");
 	let prepend = false;
-	if (path$2.startsWith("//")) prepend = true;
-	const DOUBLE_SLASH_RE$2 = /\/\//;
-	while (path$2.match(DOUBLE_SLASH_RE$2)) path$2 = path$2.replace(DOUBLE_SLASH_RE$2, "/");
-	if (prepend) path$2 = "/" + path$2;
-	return path$2;
+	if (path$1.startsWith("//")) prepend = true;
+	path$1 = path$1.replace(DOUBLE_SLASH_RE, "/");
+	if (prepend) path$1 = "/" + path$1;
+	return path$1;
 }
 function matchPatterns(patterns, testString, stats) {
-	const path$2 = normalizePath(testString);
+	const path$1 = normalizePath(testString);
 	for (let index = 0; index < patterns.length; index++) {
 		const pattern = patterns[index];
-		if (pattern(path$2, stats)) return true;
+		if (pattern(path$1, stats)) return true;
 	}
 	return false;
 }
@@ -2600,24 +1020,27 @@ const toUnix = (string) => {
 	let str = string.replace(BACK_SLASH_RE, SLASH);
 	let prepend = false;
 	if (str.startsWith(SLASH_SLASH)) prepend = true;
-	while (str.match(DOUBLE_SLASH_RE)) str = str.replace(DOUBLE_SLASH_RE, SLASH);
+	str = str.replace(DOUBLE_SLASH_RE, SLASH);
 	if (prepend) str = SLASH + str;
 	return str;
 };
-const normalizePathToUnix = (path$2) => toUnix(sysPath.normalize(toUnix(path$2)));
-const normalizeIgnored = (cwd = "") => (path$2) => {
-	if (typeof path$2 === "string") return normalizePathToUnix(sysPath.isAbsolute(path$2) ? path$2 : sysPath.join(cwd, path$2));
-	else return path$2;
+const normalizePathToUnix = (path$1) => toUnix(sp.normalize(toUnix(path$1)));
+const normalizeIgnored = (cwd = "") => (path$1) => {
+	if (typeof path$1 === "string") return normalizePathToUnix(sp.isAbsolute(path$1) ? path$1 : sp.join(cwd, path$1));
+	else return path$1;
 };
-const getAbsolutePath = (path$2, cwd) => {
-	if (sysPath.isAbsolute(path$2)) return path$2;
-	return sysPath.join(cwd, path$2);
+const getAbsolutePath = (path$1, cwd) => {
+	if (sp.isAbsolute(path$1)) return path$1;
+	return sp.join(cwd, path$1);
 };
 const EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 /**
 * Directory entry.
 */
 var DirEntry = class {
+	path;
+	_removeWatcher;
+	items;
 	constructor(dir, removeWatcher) {
 		this.path = dir;
 		this._removeWatcher = removeWatcher;
@@ -2635,9 +1058,9 @@ var DirEntry = class {
 		if (items.size > 0) return;
 		const dir = this.path;
 		try {
-			await readdir$1(dir);
+			await readdir(dir);
 		} catch (err) {
-			if (this._removeWatcher) this._removeWatcher(sysPath.dirname(dir), sysPath.basename(dir));
+			if (this._removeWatcher) this._removeWatcher(sp.dirname(dir), sp.basename(dir));
 		}
 	}
 	has(item) {
@@ -2661,12 +1084,19 @@ var DirEntry = class {
 const STAT_METHOD_F = "stat";
 const STAT_METHOD_L = "lstat";
 var WatchHelper = class {
-	constructor(path$2, follow, fsw) {
+	fsw;
+	path;
+	watchPath;
+	fullWatchPath;
+	dirParts;
+	followSymlinks;
+	statMethod;
+	constructor(path$1, follow, fsw) {
 		this.fsw = fsw;
-		const watchPath = path$2;
-		this.path = path$2 = path$2.replace(REPLACER_RE, "");
+		const watchPath = path$1;
+		this.path = path$1 = path$1.replace(REPLACER_RE, "");
 		this.watchPath = watchPath;
-		this.fullWatchPath = sysPath.resolve(watchPath);
+		this.fullWatchPath = sp.resolve(watchPath);
 		this.dirParts = [];
 		this.dirParts.forEach((parts) => {
 			if (parts.length > 1) parts.pop();
@@ -2675,7 +1105,7 @@ var WatchHelper = class {
 		this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
 	}
 	entryPath(entry) {
-		return sysPath.join(this.watchPath, sysPath.relative(this.watchPath, entry.fullPath));
+		return sp.join(this.watchPath, sp.relative(this.watchPath, entry.fullPath));
 	}
 	filterPath(entry) {
 		const { stats } = entry;
@@ -2695,7 +1125,25 @@ var WatchHelper = class {
 *       .add(directories)
 *       .on('add', path => log('File', path, 'was added'))
 */
-var FSWatcher = class extends EventEmitter$1 {
+var FSWatcher = class extends EventEmitter {
+	closed;
+	options;
+	_closers;
+	_ignoredPaths;
+	_throttled;
+	_streams;
+	_symlinkPaths;
+	_watched;
+	_pendingWrites;
+	_pendingUnlinks;
+	_readyCount;
+	_emitReady;
+	_closePromise;
+	_userIgnored;
+	_readyEmitted;
+	_emitRaw;
+	_boundRemove;
+	_nodeFsHandler;
 	constructor(_opts = {}) {
 		super();
 		this.closed = false;
@@ -2777,23 +1225,23 @@ var FSWatcher = class extends EventEmitter$1 {
 		this.closed = false;
 		this._closePromise = void 0;
 		let paths = unifyPaths(paths_);
-		if (cwd) paths = paths.map((path$2) => {
-			return getAbsolutePath(path$2, cwd);
+		if (cwd) paths = paths.map((path$1) => {
+			return getAbsolutePath(path$1, cwd);
 		});
-		paths.forEach((path$2) => {
-			this._removeIgnoredPath(path$2);
+		paths.forEach((path$1) => {
+			this._removeIgnoredPath(path$1);
 		});
 		this._userIgnored = void 0;
 		if (!this._readyCount) this._readyCount = 0;
 		this._readyCount += paths.length;
-		Promise.all(paths.map(async (path$2) => {
-			const res = await this._nodeFsHandler._addToNodeFs(path$2, !_internal, void 0, 0, _origAdd);
+		Promise.all(paths.map(async (path$1) => {
+			const res = await this._nodeFsHandler._addToNodeFs(path$1, !_internal, void 0, 0, _origAdd);
 			if (res) this._emitReady();
 			return res;
 		})).then((results) => {
 			if (this.closed) return;
 			results.forEach((item) => {
-				if (item) this.add(sysPath.dirname(item), sysPath.basename(_origAdd || item));
+				if (item) this.add(sp.dirname(item), sp.basename(_origAdd || item));
 			});
 		});
 		return this;
@@ -2805,15 +1253,15 @@ var FSWatcher = class extends EventEmitter$1 {
 		if (this.closed) return this;
 		const paths = unifyPaths(paths_);
 		const { cwd } = this.options;
-		paths.forEach((path$2) => {
-			if (!sysPath.isAbsolute(path$2) && !this._closers.has(path$2)) {
-				if (cwd) path$2 = sysPath.join(cwd, path$2);
-				path$2 = sysPath.resolve(path$2);
+		paths.forEach((path$1) => {
+			if (!sp.isAbsolute(path$1) && !this._closers.has(path$1)) {
+				if (cwd) path$1 = sp.join(cwd, path$1);
+				path$1 = sp.resolve(path$1);
 			}
-			this._closePath(path$2);
-			this._addIgnoredPath(path$2);
-			if (this._watched.has(path$2)) this._addIgnoredPath({
-				path: path$2,
+			this._closePath(path$1);
+			this._addIgnoredPath(path$1);
+			if (this._watched.has(path$1)) this._addIgnoredPath({
+				path: path$1,
 				recursive: true
 			});
 			this._userIgnored = void 0;
@@ -2852,7 +1300,7 @@ var FSWatcher = class extends EventEmitter$1 {
 	getWatched() {
 		const watchList = {};
 		this._watched.forEach((entry, dir) => {
-			const index = (this.options.cwd ? sysPath.relative(this.options.cwd, dir) : dir) || ONE_DOT;
+			const index = (this.options.cwd ? sp.relative(this.options.cwd, dir) : dir) || ONE_DOT;
 			watchList[index] = entry.getChildren().sort();
 		});
 		return watchList;
@@ -2869,34 +1317,34 @@ var FSWatcher = class extends EventEmitter$1 {
 	* @param stats arguments to be passed with event
 	* @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
 	*/
-	async _emit(event, path$2, stats) {
+	async _emit(event, path$1, stats) {
 		if (this.closed) return;
 		const opts = this.options;
-		if (isWindows) path$2 = sysPath.normalize(path$2);
-		if (opts.cwd) path$2 = sysPath.relative(opts.cwd, path$2);
-		const args = [path$2];
+		if (isWindows) path$1 = sp.normalize(path$1);
+		if (opts.cwd) path$1 = sp.relative(opts.cwd, path$1);
+		const args = [path$1];
 		if (stats != null) args.push(stats);
 		const awf = opts.awaitWriteFinish;
 		let pw;
-		if (awf && (pw = this._pendingWrites.get(path$2))) {
+		if (awf && (pw = this._pendingWrites.get(path$1))) {
 			pw.lastChange = /* @__PURE__ */ new Date();
 			return this;
 		}
 		if (opts.atomic) {
 			if (event === EVENTS.UNLINK) {
-				this._pendingUnlinks.set(path$2, [event, ...args]);
+				this._pendingUnlinks.set(path$1, [event, ...args]);
 				setTimeout(() => {
-					this._pendingUnlinks.forEach((entry, path$3) => {
+					this._pendingUnlinks.forEach((entry, path$2) => {
 						this.emit(...entry);
 						this.emit(EVENTS.ALL, ...entry);
-						this._pendingUnlinks.delete(path$3);
+						this._pendingUnlinks.delete(path$2);
 					});
 				}, typeof opts.atomic === "number" ? opts.atomic : 100);
 				return this;
 			}
-			if (event === EVENTS.ADD && this._pendingUnlinks.has(path$2)) {
+			if (event === EVENTS.ADD && this._pendingUnlinks.has(path$1)) {
 				event = EVENTS.CHANGE;
-				this._pendingUnlinks.delete(path$2);
+				this._pendingUnlinks.delete(path$1);
 			}
 		}
 		if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -2911,17 +1359,17 @@ var FSWatcher = class extends EventEmitter$1 {
 					this.emitWithAll(event, args);
 				}
 			};
-			this._awaitWriteFinish(path$2, awf.stabilityThreshold, event, awfEmit);
+			this._awaitWriteFinish(path$1, awf.stabilityThreshold, event, awfEmit);
 			return this;
 		}
 		if (event === EVENTS.CHANGE) {
-			if (!this._throttle(EVENTS.CHANGE, path$2, 50)) return this;
+			if (!this._throttle(EVENTS.CHANGE, path$1, 50)) return this;
 		}
 		if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-			const fullPath = opts.cwd ? sysPath.join(opts.cwd, path$2) : path$2;
+			const fullPath = opts.cwd ? sp.join(opts.cwd, path$1) : path$1;
 			let stats$1;
 			try {
-				stats$1 = await stat$3(fullPath);
+				stats$1 = await stat$1(fullPath);
 			} catch (err) {}
 			if (!stats$1 || this.closed) return;
 			args.push(stats$1);
@@ -2945,20 +1393,20 @@ var FSWatcher = class extends EventEmitter$1 {
 	* @param timeout duration of time to suppress duplicate actions
 	* @returns tracking object or false if action should be suppressed
 	*/
-	_throttle(actionType, path$2, timeout) {
+	_throttle(actionType, path$1, timeout) {
 		if (!this._throttled.has(actionType)) this._throttled.set(actionType, /* @__PURE__ */ new Map());
 		const action = this._throttled.get(actionType);
 		if (!action) throw new Error("invalid throttle");
-		const actionPath = action.get(path$2);
+		const actionPath = action.get(path$1);
 		if (actionPath) {
 			actionPath.count++;
 			return false;
 		}
 		let timeoutObject;
 		const clear = () => {
-			const item = action.get(path$2);
+			const item = action.get(path$1);
 			const count = item ? item.count : 0;
-			action.delete(path$2);
+			action.delete(path$1);
 			clearTimeout(timeoutObject);
 			if (item) clearTimeout(item.timeoutObject);
 			return count;
@@ -2969,7 +1417,7 @@ var FSWatcher = class extends EventEmitter$1 {
 			clear,
 			count: 0
 		};
-		action.set(path$2, thr);
+		action.set(path$1, thr);
 		return thr;
 	}
 	_incrReadyCount() {
@@ -2983,34 +1431,34 @@ var FSWatcher = class extends EventEmitter$1 {
 	* @param event
 	* @param awfEmit Callback to be called when ready for event to be emitted.
 	*/
-	_awaitWriteFinish(path$2, threshold, event, awfEmit) {
+	_awaitWriteFinish(path$1, threshold, event, awfEmit) {
 		const awf = this.options.awaitWriteFinish;
 		if (typeof awf !== "object") return;
 		const pollInterval = awf.pollInterval;
 		let timeoutHandler;
-		let fullPath = path$2;
-		if (this.options.cwd && !sysPath.isAbsolute(path$2)) fullPath = sysPath.join(this.options.cwd, path$2);
+		let fullPath = path$1;
+		if (this.options.cwd && !sp.isAbsolute(path$1)) fullPath = sp.join(this.options.cwd, path$1);
 		const now = /* @__PURE__ */ new Date();
 		const writes = this._pendingWrites;
 		function awaitWriteFinishFn(prevStat) {
-			stat$2(fullPath, (err, curStat) => {
-				if (err || !writes.has(path$2)) {
+			stat(fullPath, (err, curStat) => {
+				if (err || !writes.has(path$1)) {
 					if (err && err.code !== "ENOENT") awfEmit(err);
 					return;
 				}
 				const now$1 = Number(/* @__PURE__ */ new Date());
-				if (prevStat && curStat.size !== prevStat.size) writes.get(path$2).lastChange = now$1;
-				if (now$1 - writes.get(path$2).lastChange >= threshold) {
-					writes.delete(path$2);
+				if (prevStat && curStat.size !== prevStat.size) writes.get(path$1).lastChange = now$1;
+				if (now$1 - writes.get(path$1).lastChange >= threshold) {
+					writes.delete(path$1);
 					awfEmit(void 0, curStat);
 				} else timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
 			});
 		}
-		if (!writes.has(path$2)) {
-			writes.set(path$2, {
+		if (!writes.has(path$1)) {
+			writes.set(path$1, {
 				lastChange: now,
 				cancelWait: () => {
-					writes.delete(path$2);
+					writes.delete(path$1);
 					clearTimeout(timeoutHandler);
 					return event;
 				}
@@ -3021,31 +1469,31 @@ var FSWatcher = class extends EventEmitter$1 {
 	/**
 	* Determines whether user has asked to ignore this path.
 	*/
-	_isIgnored(path$2, stats) {
-		if (this.options.atomic && DOT_RE.test(path$2)) return true;
+	_isIgnored(path$1, stats) {
+		if (this.options.atomic && DOT_RE.test(path$1)) return true;
 		if (!this._userIgnored) {
 			const { cwd } = this.options;
 			const ignored = (this.options.ignored || []).map(normalizeIgnored(cwd));
 			this._userIgnored = anymatch([...[...this._ignoredPaths].map(normalizeIgnored(cwd)), ...ignored], void 0);
 		}
-		return this._userIgnored(path$2, stats);
+		return this._userIgnored(path$1, stats);
 	}
-	_isntIgnored(path$2, stat$4) {
-		return !this._isIgnored(path$2, stat$4);
+	_isntIgnored(path$1, stat$2) {
+		return !this._isIgnored(path$1, stat$2);
 	}
 	/**
 	* Provides a set of common helpers and properties relating to symlink handling.
 	* @param path file or directory pattern being watched
 	*/
-	_getWatchHelpers(path$2) {
-		return new WatchHelper(path$2, this.options.followSymlinks, this);
+	_getWatchHelpers(path$1) {
+		return new WatchHelper(path$1, this.options.followSymlinks, this);
 	}
 	/**
 	* Provides directory tracking objects
 	* @param directory path of the directory
 	*/
 	_getWatchedDir(directory) {
-		const dir = sysPath.resolve(directory);
+		const dir = sp.resolve(directory);
 		if (!this._watched.has(dir)) this._watched.set(dir, new DirEntry(dir, this._boundRemove));
 		return this._watched.get(dir);
 	}
@@ -3064,50 +1512,50 @@ var FSWatcher = class extends EventEmitter$1 {
 	* @param item      base path of item/directory
 	*/
 	_remove(directory, item, isDirectory) {
-		const path$2 = sysPath.join(directory, item);
-		const fullPath = sysPath.resolve(path$2);
-		isDirectory = isDirectory != null ? isDirectory : this._watched.has(path$2) || this._watched.has(fullPath);
-		if (!this._throttle("remove", path$2, 100)) return;
+		const path$1 = sp.join(directory, item);
+		const fullPath = sp.resolve(path$1);
+		isDirectory = isDirectory != null ? isDirectory : this._watched.has(path$1) || this._watched.has(fullPath);
+		if (!this._throttle("remove", path$1, 100)) return;
 		if (!isDirectory && this._watched.size === 1) this.add(directory, item, true);
-		this._getWatchedDir(path$2).getChildren().forEach((nested) => this._remove(path$2, nested));
+		this._getWatchedDir(path$1).getChildren().forEach((nested) => this._remove(path$1, nested));
 		const parent = this._getWatchedDir(directory);
 		const wasTracked = parent.has(item);
 		parent.remove(item);
 		if (this._symlinkPaths.has(fullPath)) this._symlinkPaths.delete(fullPath);
-		let relPath = path$2;
-		if (this.options.cwd) relPath = sysPath.relative(this.options.cwd, path$2);
+		let relPath = path$1;
+		if (this.options.cwd) relPath = sp.relative(this.options.cwd, path$1);
 		if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
 			if (this._pendingWrites.get(relPath).cancelWait() === EVENTS.ADD) return;
 		}
-		this._watched.delete(path$2);
+		this._watched.delete(path$1);
 		this._watched.delete(fullPath);
 		const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-		if (wasTracked && !this._isIgnored(path$2)) this._emit(eventName, path$2);
-		this._closePath(path$2);
+		if (wasTracked && !this._isIgnored(path$1)) this._emit(eventName, path$1);
+		this._closePath(path$1);
 	}
 	/**
 	* Closes all watchers for a path
 	*/
-	_closePath(path$2) {
-		this._closeFile(path$2);
-		const dir = sysPath.dirname(path$2);
-		this._getWatchedDir(dir).remove(sysPath.basename(path$2));
+	_closePath(path$1) {
+		this._closeFile(path$1);
+		const dir = sp.dirname(path$1);
+		this._getWatchedDir(dir).remove(sp.basename(path$1));
 	}
 	/**
 	* Closes only file-specific watchers
 	*/
-	_closeFile(path$2) {
-		const closers = this._closers.get(path$2);
+	_closeFile(path$1) {
+		const closers = this._closers.get(path$1);
 		if (!closers) return;
 		closers.forEach((closer) => closer());
-		this._closers.delete(path$2);
+		this._closers.delete(path$1);
 	}
-	_addPathCloser(path$2, closer) {
+	_addPathCloser(path$1, closer) {
 		if (!closer) return;
-		let list = this._closers.get(path$2);
+		let list = this._closers.get(path$1);
 		if (!list) {
 			list = [];
-			this._closers.set(path$2, list);
+			this._closers.set(path$1, list);
 		}
 		list.push(closer);
 	}
@@ -3142,15 +1590,15 @@ var FSWatcher = class extends EventEmitter$1 {
 * const watcher = watch('.').on('all', (event, path) => { console.log(event, path); });
 * watch('.', { atomic: true, awaitWriteFinish: true, ignored: (f, stats) => stats?.isFile() && !f.endsWith('.js') })
 */
-function watch$2(paths, options = {}) {
+function watch$1(paths, options = {}) {
 	const watcher = new FSWatcher(options);
 	watcher.add(paths);
 	return watcher;
 }
-var esm_default = {
-	watch: watch$2,
+var chokidar_default = {
+	watch: watch$1,
 	FSWatcher
 };
 //#endregion
-export { watch$3 as a, watch$2 as i, WatchHelper as n, esm_default as r, FSWatcher as t };
+export { watch$1 as i, WatchHelper as n, chokidar_default as r, FSWatcher as t };