@supsign/unplugin-interfaces 0.2.0 → 1.1.0

package/dist/{src-BKy9tiI6.js → src-BBWM3Bz4.mjs}

@@ -1,15 +1,13 @@
-import { stat, unwatchFile, watch, watchFile } from "fs";
-import { lstat, open, readdir, realpath, stat as stat$1 } from "fs/promises";
-import { EventEmitter } from "events";
-import * as sysPath from "path";
-import { lstat as lstat$1, readdir as readdir$1, realpath as realpath$1, stat as stat$2 } from "node:fs/promises";
-import { Readable } from "node:stream";
+import process$1 from "node:process";
+import { EventEmitter } from "node:events";
+import fs, { stat, unwatchFile, watch, watchFile } from "node:fs";
+import { lstat, open, readdir, realpath, stat as stat$1 } from "node:fs/promises";
+import * as sp from "node:path";
 import path, { join, relative, resolve, sep } from "node:path";
-import { type } from "os";
+import { Readable } from "node:stream";
+import { type } from "node:os";
 import { createUnplugin } from "unplugin";
-import fs from "node:fs";
-
-//#region node_modules/readdirp/esm/index.js
+//#region node_modules/readdirp/index.js
 const EntryTypes = {
 	FILE_TYPE: "files",
 	DIR_TYPE: "directories",
@@ -69,6 +67,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,
@@ -79,16 +91,16 @@ var ReaddirpStream = class extends Readable {
 			...defaultOptions,
 			...options
 		};
-		const { root, type: type$1 } = opts;
+		const { root, type } = opts;
 		this._fileFilter = normalizeFilter(opts.fileFilter);
 		this._directoryFilter = normalizeFilter(opts.directoryFilter);
-		const statMethod = opts.lstat ? lstat$1 : stat$2;
-		if (wantBigintFsStats) this._stat = (path$1) => statMethod(path$1, { bigint: true });
+		const statMethod = opts.lstat ? lstat : stat$1;
+		if (wantBigintFsStats) this._stat = (path) => statMethod(path, { bigint: true });
 		else this._stat = statMethod;
-		this._maxDepth = 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._maxDepth = opts.depth != null && Number.isSafeInteger(opts.depth) ? opts.depth : defaultOptions.depth;
+		this._wantsDir = type ? DIR_TYPES.has(type) : false;
+		this._wantsFile = type ? FILE_TYPES.has(type) : false;
+		this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE;
 		this._root = resolve(root);
 		this._isDirent = !opts.alwaysStat;
 		this._statsProp = this._isDirent ? "dirent" : "stats";
@@ -108,8 +120,8 @@ var ReaddirpStream = class extends Readable {
 				const par = this.parent;
 				const fil = par && par.files;
 				if (fil && fil.length > 0) {
-					const { path: path$1, depth } = par;
-					const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path$1));
+					const { path, depth } = par;
+					const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path));
 					const awaited = await Promise.all(slice);
 					for (const entry of awaited) {
 						if (!entry) continue;
@@ -144,24 +156,24 @@ var ReaddirpStream = class extends Readable {
 			this.reading = false;
 		}
 	}
-	async _exploreDir(path$1, depth) {
+	async _exploreDir(path, depth) {
 		let files;
 		try {
-			files = await readdir$1(path$1, this._rdOptions);
+			files = await readdir(path, this._rdOptions);
 		} catch (error) {
 			this._onError(error);
 		}
 		return {
 			files,
 			depth,
-			path: path$1
+			path
 		};
 	}
-	async _formatEntry(dirent, path$1) {
+	async _formatEntry(dirent, path) {
 		let entry;
 		const basename = this._isDirent ? dirent.name : dirent;
 		try {
-			const fullPath = resolve(join(path$1, basename));
+			const fullPath = resolve(join(path, basename));
 			entry = {
 				path: relative(this._root, fullPath),
 				fullPath,
@@ -186,8 +198,8 @@ var ReaddirpStream = class extends Readable {
 		if (stats && stats.isSymbolicLink()) {
 			const full = entry.fullPath;
 			try {
-				const entryRealPath = await realpath$1(full);
-				const entryRealPathStats = await lstat$1(entryRealPath);
+				const entryRealPath = await realpath(full);
+				const entryRealPathStats = await lstat(entryRealPath);
 				if (entryRealPathStats.isFile()) return "file";
 				if (entryRealPathStats.isDirectory()) {
 					const len = entryRealPath.length;
@@ -216,20 +228,18 @@ var ReaddirpStream = class extends Readable {
 * @param options Options to specify root (start directory), filters and recursion depth
 */
 function readdirp(root, options = {}) {
-	let type$1 = options.entryType || options.type;
-	if (type$1 === "both") type$1 = EntryTypes.FILE_DIR_TYPE;
-	if (type$1) options.type = type$1;
+	let type = options.entryType || options.type;
+	if (type === "both") type = EntryTypes.FILE_DIR_TYPE;
+	if (type) options.type = type;
 	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$1 && !ALL_TYPES.includes(type$1)) throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(", ")}`);
+	else if (type && !ALL_TYPES.includes(type)) throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(", ")}`);
 	options.root = root;
 	return new ReaddirpStream(options);
 }
-
 //#endregion
-//#region node_modules/chokidar/esm/handler.js
+//#region node_modules/chokidar/handler.js
 const STR_DATA = "data";
-const STR_END = "end";
 const STR_CLOSE = "close";
 const EMPTY_FN = () => {};
 const pl = process.platform;
@@ -526,7 +536,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);
@@ -557,14 +567,14 @@ const FsWatchInstances = /* @__PURE__ */ new Map();
 * @param emitRaw emits raw event data
 * @returns {NativeFsWatcher}
 */
-function createFsWatchInstance(path$1, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path, options, listener, errHandler, emitRaw) {
 	const handleEvent = (rawEvent, evPath) => {
-		listener(path$1);
-		emitRaw(rawEvent, evPath, { watchedPath: path$1 });
-		if (evPath && path$1 !== evPath) fsWatchBroadcast(sysPath.resolve(path$1, evPath), KEY_LISTENERS, sysPath.join(path$1, evPath));
+		listener(path);
+		emitRaw(rawEvent, evPath, { watchedPath: path });
+		if (evPath && path !== evPath) fsWatchBroadcast(sp.resolve(path, evPath), KEY_LISTENERS, sp.join(path, evPath));
 	};
 	try {
-		return watch(path$1, { persistent: options.persistent }, handleEvent);
+		return watch(path, { persistent: options.persistent }, handleEvent);
 	} catch (error) {
 		errHandler(error);
 		return;
@@ -589,12 +599,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$1, fullPath, options, handlers) => {
+const setFsWatchListener = (path, fullPath, options, handlers) => {
 	const { listener, errHandler, rawEmitter } = handlers;
 	let cont = FsWatchInstances.get(fullPath);
 	let watcher;
 	if (!options.persistent) {
-		watcher = createFsWatchInstance(path$1, options, listener, errHandler, rawEmitter);
+		watcher = createFsWatchInstance(path, options, listener, errHandler, rawEmitter);
 		if (!watcher) return;
 		return watcher.close.bind(watcher);
 	}
@@ -603,13 +613,13 @@ const setFsWatchListener = (path$1, fullPath, options, handlers) => {
 		addAndConvert(cont, KEY_ERR, errHandler);
 		addAndConvert(cont, KEY_RAW, rawEmitter);
 	} else {
-		watcher = createFsWatchInstance(path$1, options, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, fsWatchBroadcast.bind(null, fullPath, KEY_RAW));
+		watcher = createFsWatchInstance(path, 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(path$1, "r")).close();
+				await (await open(path, "r")).close();
 				broadcastErr(error);
 			} catch (err) {}
 			else broadcastErr(error);
@@ -645,7 +655,7 @@ const FsWatchFileInstances = /* @__PURE__ */ new Map();
 * @param handlers container for event listener functions
 * @returns closer
 */
-const setFsWatchFileListener = (path$1, fullPath, options, handlers) => {
+const setFsWatchFileListener = (path, fullPath, options, handlers) => {
 	const { listener, rawEmitter } = handlers;
 	let cont = FsWatchFileInstances.get(fullPath);
 	const copts = cont && cont.options;
@@ -662,14 +672,14 @@ const setFsWatchFileListener = (path$1, fullPath, options, handlers) => {
 			rawEmitters: rawEmitter,
 			options,
 			watcher: watchFile(fullPath, options, (curr, prev) => {
-				foreach(cont.rawEmitters, (rawEmitter$1) => {
-					rawEmitter$1(EV.CHANGE, fullPath, {
+				foreach(cont.rawEmitters, (rawEmitter) => {
+					rawEmitter(EV.CHANGE, fullPath, {
 						curr,
 						prev
 					});
 				});
 				const currmtime = curr.mtimeMs;
-				if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) foreach(cont.listeners, (listener$1) => listener$1(path$1, curr));
+				if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) foreach(cont.listeners, (listener) => listener(path, curr));
 			})
 		};
 		FsWatchFileInstances.set(fullPath, cont);
@@ -689,6 +699,8 @@ const setFsWatchFileListener = (path$1, fullPath, options, handlers) => {
 * @mixin
 */
 var NodeFsHandler = class {
+	fsw;
+	_boundHandleError;
 	constructor(fsW) {
 		this.fsw = fsW;
 		this._boundHandleError = (error) => fsW._handleError(error);
@@ -699,22 +711,22 @@ var NodeFsHandler = class {
 	* @param listener on fs change
 	* @returns closer for the watcher instance
 	*/
-	_watchWithNodeFs(path$1, listener) {
+	_watchWithNodeFs(path, listener) {
 		const opts = this.fsw.options;
-		const directory = sysPath.dirname(path$1);
-		const basename = sysPath.basename(path$1);
+		const directory = sp.dirname(path);
+		const basename = sp.basename(path);
 		this.fsw._getWatchedDir(directory).add(basename);
-		const absolutePath = sysPath.resolve(path$1);
+		const absolutePath = sp.resolve(path);
 		const options = { persistent: opts.persistent };
 		if (!listener) listener = EMPTY_FN;
 		let closer;
 		if (opts.usePolling) {
 			options.interval = opts.interval !== opts.binaryInterval && isBinaryPath(basename) ? opts.binaryInterval : opts.interval;
-			closer = setFsWatchFileListener(path$1, absolutePath, options, {
+			closer = setFsWatchFileListener(path, absolutePath, options, {
 				listener,
 				rawEmitter: this.fsw._emitRaw
 			});
-		} else closer = setFsWatchListener(path$1, absolutePath, options, {
+		} else closer = setFsWatchListener(path, absolutePath, options, {
 			listener,
 			errHandler: this._boundHandleError,
 			rawEmitter: this.fsw._emitRaw
@@ -727,25 +739,25 @@ var NodeFsHandler = class {
 	*/
 	_handleFile(file, stats, initialAdd) {
 		if (this.fsw.closed) return;
-		const dirname = sysPath.dirname(file);
-		const basename = sysPath.basename(file);
+		const dirname = sp.dirname(file);
+		const basename = sp.basename(file);
 		const parent = this.fsw._getWatchedDir(dirname);
 		let prevStats = stats;
 		if (parent.has(basename)) return;
-		const listener = async (path$1, newStats) => {
+		const listener = async (path, newStats) => {
 			if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5)) return;
 			if (!newStats || newStats.mtimeMs === 0) try {
-				const newStats$1 = await stat$1(file);
+				const newStats = 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$1);
-					prevStats = newStats$1;
-					const closer$1 = this._watchWithNodeFs(file, listener);
-					if (closer$1) this.fsw._addPathCloser(path$1, closer$1);
-				} else prevStats = newStats$1;
+				const at = newStats.atimeMs;
+				const mt = newStats.mtimeMs;
+				if (!at || at <= mt || mt !== prevStats.mtimeMs) this.fsw._emit(EV.CHANGE, file, newStats);
+				if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats.ino) {
+					this.fsw._closeFile(path);
+					prevStats = newStats;
+					const closer = this._watchWithNodeFs(file, listener);
+					if (closer) this.fsw._addPathCloser(path, closer);
+				} else prevStats = newStats;
 			} catch (error) {
 				this.fsw._remove(dirname, basename);
 			}
@@ -771,7 +783,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$1, item) {
+	async _handleSymlink(entry, directory, path, item) {
 		if (this.fsw.closed) return;
 		const full = entry.fullPath;
 		const dir = this.fsw._getWatchedDir(directory);
@@ -779,7 +791,7 @@ var NodeFsHandler = class {
 			this.fsw._incrReadyCount();
 			let linkPath;
 			try {
-				linkPath = await realpath(path$1);
+				linkPath = await realpath(path);
 			} catch (e) {
 				this.fsw._emitReady();
 				return true;
@@ -788,12 +800,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$1, entry.stats);
+					this.fsw._emit(EV.CHANGE, path, entry.stats);
 				}
 			} else {
 				dir.add(item);
 				this.fsw._symlinkPaths.set(full, linkPath);
-				this.fsw._emit(EV.ADD, path$1, entry.stats);
+				this.fsw._emit(EV.ADD, path, entry.stats);
 			}
 			this.fsw._emitReady();
 			return true;
@@ -802,8 +814,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();
@@ -818,28 +831,28 @@ var NodeFsHandler = class {
 				return;
 			}
 			const item = entry.path;
-			let path$1 = sysPath.join(directory, item);
+			let path = sp.join(directory, item);
 			current.add(item);
-			if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path$1, item)) return;
+			if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path, item)) return;
 			if (this.fsw.closed) {
 				stream = void 0;
 				return;
 			}
 			if (item === target || !target && !previous.has(item)) {
 				this.fsw._incrReadyCount();
-				path$1 = sysPath.join(dir, sysPath.relative(dir, path$1));
-				this._addToNodeFs(path$1, initialAdd, wh, depth + 1);
+				path = sp.join(dir, sp.relative(dir, path));
+				this._addToNodeFs(path, initialAdd, wh, depth + 1);
 			}
 		}).on(EV.ERROR, this._boundHandleError);
-		return new Promise((resolve$1, reject) => {
+		return new Promise((resolve, reject) => {
 			if (!stream) return reject();
-			stream.once(STR_END, () => {
+			stream.once("end", () => {
 				if (this.fsw.closed) {
 					stream = void 0;
 					return;
 				}
 				const wasThrottled = throttler ? throttler.clear() : false;
-				resolve$1(void 0);
+				resolve(void 0);
 				previous.getChildren().filter((item) => {
 					return item !== directory && !current.has(item);
 				}).forEach((item) => {
@@ -861,22 +874,22 @@ 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) {
+		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)) {
 			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;
+			closer = this._watchWithNodeFs(dir, (dirPath, stats) => {
+				if (stats && stats.mtimeMs === 0) return;
 				this._handleRead(dirPath, false, wh, target, dir, depth, throttler);
 			});
 		}
@@ -891,13 +904,13 @@ var NodeFsHandler = class {
 	* @param depth Child path actually targeted for watch
 	* @param target Child path actually targeted for watch
 	*/
-	async _addToNodeFs(path$1, initialAdd, priorWh, depth, target) {
+	async _addToNodeFs(path, initialAdd, priorWh, depth, target) {
 		const ready = this.fsw._emitReady;
-		if (this.fsw._isIgnored(path$1) || this.fsw.closed) {
+		if (this.fsw._isIgnored(path) || this.fsw.closed) {
 			ready();
 			return false;
 		}
-		const wh = this.fsw._getWatchHelpers(path$1);
+		const wh = this.fsw._getWatchHelpers(path);
 		if (priorWh) {
 			wh.filterPath = (entry) => priorWh.filterPath(entry);
 			wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -912,43 +925,43 @@ var NodeFsHandler = class {
 			const follow = this.fsw.options.followSymlinks;
 			let closer;
 			if (stats.isDirectory()) {
-				const absPath = sysPath.resolve(path$1);
-				const targetPath = follow ? await realpath(path$1) : path$1;
+				const absPath = sp.resolve(path);
+				const targetPath = follow ? await realpath(path) : path;
 				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$1) : path$1;
+				const targetPath = follow ? await realpath(path) : path;
 				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$1, wh, targetPath);
+				closer = await this._handleDir(parent, stats, initialAdd, depth, path, wh, targetPath);
 				if (this.fsw.closed) return;
-				if (targetPath !== void 0) this.fsw._symlinkPaths.set(sysPath.resolve(path$1), targetPath);
+				if (targetPath !== void 0) this.fsw._symlinkPaths.set(sp.resolve(path), targetPath);
 			} else closer = this._handleFile(wh.watchPath, stats, initialAdd);
 			ready();
-			if (closer) this.fsw._addPathCloser(path$1, closer);
+			if (closer) this.fsw._addPathCloser(path, closer);
 			return false;
 		} catch (error) {
 			if (this.fsw._handleError(error)) {
 				ready();
-				return path$1;
+				return path;
 			}
 		}
 	}
 };
-
 //#endregion
-//#region node_modules/chokidar/esm/index.js
+//#region node_modules/chokidar/index.js
+/*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) */
 const SLASH = "/";
 const SLASH_SLASH = "//";
 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) {
@@ -962,38 +975,37 @@ function createPattern(matcher) {
 	if (typeof matcher === "object" && matcher !== null) return (string) => {
 		if (matcher.path === string) return true;
 		if (matcher.recursive) {
-			const relative$1 = sysPath.relative(matcher.path, string);
-			if (!relative$1) return false;
-			return !relative$1.startsWith("..") && !sysPath.isAbsolute(relative$1);
+			const relative = sp.relative(matcher.path, string);
+			if (!relative) return false;
+			return !relative.startsWith("..") && !sp.isAbsolute(relative);
 		}
 		return false;
 	};
 	return () => false;
 }
-function normalizePath(path$1) {
-	if (typeof path$1 !== "string") throw new Error("string expected");
-	path$1 = sysPath.normalize(path$1);
-	path$1 = path$1.replace(/\\/g, "/");
+function normalizePath(path) {
+	if (typeof path !== "string") throw new Error("string expected");
+	path = sp.normalize(path);
+	path = path.replace(/\\/g, "/");
 	let prepend = false;
-	if (path$1.startsWith("//")) prepend = true;
-	const DOUBLE_SLASH_RE$1 = /\/\//;
-	while (path$1.match(DOUBLE_SLASH_RE$1)) path$1 = path$1.replace(DOUBLE_SLASH_RE$1, "/");
-	if (prepend) path$1 = "/" + path$1;
-	return path$1;
+	if (path.startsWith("//")) prepend = true;
+	path = path.replace(DOUBLE_SLASH_RE, "/");
+	if (prepend) path = "/" + path;
+	return path;
 }
 function matchPatterns(patterns, testString, stats) {
-	const path$1 = normalizePath(testString);
+	const path = normalizePath(testString);
 	for (let index = 0; index < patterns.length; index++) {
 		const pattern = patterns[index];
-		if (pattern(path$1, stats)) return true;
+		if (pattern(path, stats)) return true;
 	}
 	return false;
 }
 function anymatch(matchers, testString) {
 	if (matchers == null) throw new TypeError("anymatch: specify first argument");
 	const patterns = arrify(matchers).map((matcher) => createPattern(matcher));
-	if (testString == null) return (testString$1, stats) => {
-		return matchPatterns(patterns, testString$1, stats);
+	if (testString == null) return (testString, stats) => {
+		return matchPatterns(patterns, testString, stats);
 	};
 	return matchPatterns(patterns, testString);
 }
@@ -1006,24 +1018,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$1) => toUnix(sysPath.normalize(toUnix(path$1)));
-const normalizeIgnored = (cwd = "") => (path$1) => {
-	if (typeof path$1 === "string") return normalizePathToUnix(sysPath.isAbsolute(path$1) ? path$1 : sysPath.join(cwd, path$1));
-	else return path$1;
+const normalizePathToUnix = (path) => toUnix(sp.normalize(toUnix(path)));
+const normalizeIgnored = (cwd = "") => (path) => {
+	if (typeof path === "string") return normalizePathToUnix(sp.isAbsolute(path) ? path : sp.join(cwd, path));
+	else return path;
 };
-const getAbsolutePath = (path$1, cwd) => {
-	if (sysPath.isAbsolute(path$1)) return path$1;
-	return sysPath.join(cwd, path$1);
+const getAbsolutePath = (path, cwd) => {
+	if (sp.isAbsolute(path)) return path;
+	return sp.join(cwd, path);
 };
 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;
@@ -1043,7 +1058,7 @@ var DirEntry = class {
 		try {
 			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) {
@@ -1067,12 +1082,19 @@ var DirEntry = class {
 const STAT_METHOD_F = "stat";
 const STAT_METHOD_L = "lstat";
 var WatchHelper = class {
-	constructor(path$1, follow, fsw) {
+	fsw;
+	path;
+	watchPath;
+	fullWatchPath;
+	dirParts;
+	followSymlinks;
+	statMethod;
+	constructor(path, follow, fsw) {
 		this.fsw = fsw;
-		const watchPath = path$1;
-		this.path = path$1 = path$1.replace(REPLACER_RE, "");
+		const watchPath = path;
+		this.path = path = path.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();
@@ -1081,7 +1103,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;
@@ -1102,6 +1124,24 @@ var WatchHelper = class {
 *       .on('add', path => log('File', path, 'was added'))
 */
 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;
@@ -1183,23 +1223,23 @@ var FSWatcher = class extends EventEmitter {
 		this.closed = false;
 		this._closePromise = void 0;
 		let paths = unifyPaths(paths_);
-		if (cwd) paths = paths.map((path$1) => {
-			return getAbsolutePath(path$1, cwd);
+		if (cwd) paths = paths.map((path) => {
+			return getAbsolutePath(path, cwd);
 		});
-		paths.forEach((path$1) => {
-			this._removeIgnoredPath(path$1);
+		paths.forEach((path) => {
+			this._removeIgnoredPath(path);
 		});
 		this._userIgnored = void 0;
 		if (!this._readyCount) this._readyCount = 0;
 		this._readyCount += paths.length;
-		Promise.all(paths.map(async (path$1) => {
-			const res = await this._nodeFsHandler._addToNodeFs(path$1, !_internal, void 0, 0, _origAdd);
+		Promise.all(paths.map(async (path) => {
+			const res = await this._nodeFsHandler._addToNodeFs(path, !_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;
@@ -1211,15 +1251,15 @@ var FSWatcher = class extends EventEmitter {
 		if (this.closed) return this;
 		const paths = unifyPaths(paths_);
 		const { cwd } = this.options;
-		paths.forEach((path$1) => {
-			if (!sysPath.isAbsolute(path$1) && !this._closers.has(path$1)) {
-				if (cwd) path$1 = sysPath.join(cwd, path$1);
-				path$1 = sysPath.resolve(path$1);
+		paths.forEach((path) => {
+			if (!sp.isAbsolute(path) && !this._closers.has(path)) {
+				if (cwd) path = sp.join(cwd, path);
+				path = sp.resolve(path);
 			}
-			this._closePath(path$1);
-			this._addIgnoredPath(path$1);
-			if (this._watched.has(path$1)) this._addIgnoredPath({
-				path: path$1,
+			this._closePath(path);
+			this._addIgnoredPath(path);
+			if (this._watched.has(path)) this._addIgnoredPath({
+				path,
 				recursive: true
 			});
 			this._userIgnored = void 0;
@@ -1258,7 +1298,7 @@ var FSWatcher = class extends EventEmitter {
 	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;
@@ -1275,62 +1315,62 @@ var FSWatcher = class extends EventEmitter {
 	* @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$1, stats) {
+	async _emit(event, path, stats) {
 		if (this.closed) return;
 		const opts = this.options;
-		if (isWindows) path$1 = sysPath.normalize(path$1);
-		if (opts.cwd) path$1 = sysPath.relative(opts.cwd, path$1);
-		const args = [path$1];
+		if (isWindows) path = sp.normalize(path);
+		if (opts.cwd) path = sp.relative(opts.cwd, path);
+		const args = [path];
 		if (stats != null) args.push(stats);
 		const awf = opts.awaitWriteFinish;
 		let pw;
-		if (awf && (pw = this._pendingWrites.get(path$1))) {
+		if (awf && (pw = this._pendingWrites.get(path))) {
 			pw.lastChange = /* @__PURE__ */ new Date();
 			return this;
 		}
 		if (opts.atomic) {
 			if (event === EVENTS.UNLINK) {
-				this._pendingUnlinks.set(path$1, [event, ...args]);
+				this._pendingUnlinks.set(path, [event, ...args]);
 				setTimeout(() => {
-					this._pendingUnlinks.forEach((entry, path$2) => {
+					this._pendingUnlinks.forEach((entry, path) => {
 						this.emit(...entry);
 						this.emit(EVENTS.ALL, ...entry);
-						this._pendingUnlinks.delete(path$2);
+						this._pendingUnlinks.delete(path);
 					});
 				}, typeof opts.atomic === "number" ? opts.atomic : 100);
 				return this;
 			}
-			if (event === EVENTS.ADD && this._pendingUnlinks.has(path$1)) {
+			if (event === EVENTS.ADD && this._pendingUnlinks.has(path)) {
 				event = EVENTS.CHANGE;
-				this._pendingUnlinks.delete(path$1);
+				this._pendingUnlinks.delete(path);
 			}
 		}
 		if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
-			const awfEmit = (err, stats$1) => {
+			const awfEmit = (err, stats) => {
 				if (err) {
 					event = EVENTS.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);
+				} else if (stats) {
+					if (args.length > 1) args[1] = stats;
+					else args.push(stats);
 					this.emitWithAll(event, args);
 				}
 			};
-			this._awaitWriteFinish(path$1, awf.stabilityThreshold, event, awfEmit);
+			this._awaitWriteFinish(path, awf.stabilityThreshold, event, awfEmit);
 			return this;
 		}
 		if (event === EVENTS.CHANGE) {
-			if (!this._throttle(EVENTS.CHANGE, path$1, 50)) return this;
+			if (!this._throttle(EVENTS.CHANGE, path, 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$1) : path$1;
-			let stats$1;
+			const fullPath = opts.cwd ? sp.join(opts.cwd, path) : path;
+			let stats;
 			try {
-				stats$1 = await stat$1(fullPath);
+				stats = await stat$1(fullPath);
 			} catch (err) {}
-			if (!stats$1 || this.closed) return;
-			args.push(stats$1);
+			if (!stats || this.closed) return;
+			args.push(stats);
 		}
 		this.emitWithAll(event, args);
 		return this;
@@ -1351,20 +1391,20 @@ var FSWatcher = class extends EventEmitter {
 	* @param timeout duration of time to suppress duplicate actions
 	* @returns tracking object or false if action should be suppressed
 	*/
-	_throttle(actionType, path$1, timeout) {
+	_throttle(actionType, path, 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$1);
+		const actionPath = action.get(path);
 		if (actionPath) {
 			actionPath.count++;
 			return false;
 		}
 		let timeoutObject;
 		const clear = () => {
-			const item = action.get(path$1);
+			const item = action.get(path);
 			const count = item ? item.count : 0;
-			action.delete(path$1);
+			action.delete(path);
 			clearTimeout(timeoutObject);
 			if (item) clearTimeout(item.timeoutObject);
 			return count;
@@ -1375,7 +1415,7 @@ var FSWatcher = class extends EventEmitter {
 			clear,
 			count: 0
 		};
-		action.set(path$1, thr);
+		action.set(path, thr);
 		return thr;
 	}
 	_incrReadyCount() {
@@ -1389,34 +1429,34 @@ var FSWatcher = class extends EventEmitter {
 	* @param event
 	* @param awfEmit Callback to be called when ready for event to be emitted.
 	*/
-	_awaitWriteFinish(path$1, threshold, event, awfEmit) {
+	_awaitWriteFinish(path, threshold, event, awfEmit) {
 		const awf = this.options.awaitWriteFinish;
 		if (typeof awf !== "object") return;
 		const pollInterval = awf.pollInterval;
 		let timeoutHandler;
-		let fullPath = path$1;
-		if (this.options.cwd && !sysPath.isAbsolute(path$1)) fullPath = sysPath.join(this.options.cwd, path$1);
+		let fullPath = path;
+		if (this.options.cwd && !sp.isAbsolute(path)) fullPath = sp.join(this.options.cwd, path);
 		const now = /* @__PURE__ */ new Date();
 		const writes = this._pendingWrites;
 		function awaitWriteFinishFn(prevStat) {
 			stat(fullPath, (err, curStat) => {
-				if (err || !writes.has(path$1)) {
+				if (err || !writes.has(path)) {
 					if (err && err.code !== "ENOENT") awfEmit(err);
 					return;
 				}
-				const now$1 = Number(/* @__PURE__ */ new Date());
-				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);
+				const now = Number(/* @__PURE__ */ new Date());
+				if (prevStat && curStat.size !== prevStat.size) writes.get(path).lastChange = now;
+				if (now - writes.get(path).lastChange >= threshold) {
+					writes.delete(path);
 					awfEmit(void 0, curStat);
 				} else timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
 			});
 		}
-		if (!writes.has(path$1)) {
-			writes.set(path$1, {
+		if (!writes.has(path)) {
+			writes.set(path, {
 				lastChange: now,
 				cancelWait: () => {
-					writes.delete(path$1);
+					writes.delete(path);
 					clearTimeout(timeoutHandler);
 					return event;
 				}
@@ -1427,31 +1467,31 @@ var FSWatcher = class extends EventEmitter {
 	/**
 	* Determines whether user has asked to ignore this path.
 	*/
-	_isIgnored(path$1, stats) {
-		if (this.options.atomic && DOT_RE.test(path$1)) return true;
+	_isIgnored(path, stats) {
+		if (this.options.atomic && DOT_RE.test(path)) 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$1, stats);
+		return this._userIgnored(path, stats);
 	}
-	_isntIgnored(path$1, stat$3) {
-		return !this._isIgnored(path$1, stat$3);
+	_isntIgnored(path, stat) {
+		return !this._isIgnored(path, stat);
 	}
 	/**
 	* Provides a set of common helpers and properties relating to symlink handling.
 	* @param path file or directory pattern being watched
 	*/
-	_getWatchHelpers(path$1) {
-		return new WatchHelper(path$1, this.options.followSymlinks, this);
+	_getWatchHelpers(path) {
+		return new WatchHelper(path, 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);
 	}
@@ -1470,50 +1510,50 @@ var FSWatcher = class extends EventEmitter {
 	* @param item      base path of item/directory
 	*/
 	_remove(directory, item, isDirectory) {
-		const path$1 = sysPath.join(directory, item);
-		const fullPath = sysPath.resolve(path$1);
-		isDirectory = isDirectory != null ? isDirectory : this._watched.has(path$1) || this._watched.has(fullPath);
-		if (!this._throttle("remove", path$1, 100)) return;
+		const path = sp.join(directory, item);
+		const fullPath = sp.resolve(path);
+		isDirectory = isDirectory != null ? isDirectory : this._watched.has(path) || this._watched.has(fullPath);
+		if (!this._throttle("remove", path, 100)) return;
 		if (!isDirectory && this._watched.size === 1) this.add(directory, item, true);
-		this._getWatchedDir(path$1).getChildren().forEach((nested) => this._remove(path$1, nested));
+		this._getWatchedDir(path).getChildren().forEach((nested) => this._remove(path, 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$1;
-		if (this.options.cwd) relPath = sysPath.relative(this.options.cwd, path$1);
+		let relPath = path;
+		if (this.options.cwd) relPath = sp.relative(this.options.cwd, path);
 		if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
 			if (this._pendingWrites.get(relPath).cancelWait() === EVENTS.ADD) return;
 		}
-		this._watched.delete(path$1);
+		this._watched.delete(path);
 		this._watched.delete(fullPath);
 		const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-		if (wasTracked && !this._isIgnored(path$1)) this._emit(eventName, path$1);
-		this._closePath(path$1);
+		if (wasTracked && !this._isIgnored(path)) this._emit(eventName, path);
+		this._closePath(path);
 	}
 	/**
 	* Closes all watchers for a path
 	*/
-	_closePath(path$1) {
-		this._closeFile(path$1);
-		const dir = sysPath.dirname(path$1);
-		this._getWatchedDir(dir).remove(sysPath.basename(path$1));
+	_closePath(path) {
+		this._closeFile(path);
+		const dir = sp.dirname(path);
+		this._getWatchedDir(dir).remove(sp.basename(path));
 	}
 	/**
 	* Closes only file-specific watchers
 	*/
-	_closeFile(path$1) {
-		const closers = this._closers.get(path$1);
+	_closeFile(path) {
+		const closers = this._closers.get(path);
 		if (!closers) return;
 		closers.forEach((closer) => closer());
-		this._closers.delete(path$1);
+		this._closers.delete(path);
 	}
-	_addPathCloser(path$1, closer) {
+	_addPathCloser(path, closer) {
 		if (!closer) return;
-		let list = this._closers.get(path$1);
+		let list = this._closers.get(path);
 		if (!list) {
 			list = [];
-			this._closers.set(path$1, list);
+			this._closers.set(path, list);
 		}
 		list.push(closer);
 	}
@@ -1530,7 +1570,7 @@ var FSWatcher = class extends EventEmitter {
 		stream.once(STR_CLOSE, () => {
 			stream = void 0;
 		});
-		stream.once(STR_END, () => {
+		stream.once("end", () => {
 			if (stream) {
 				this._streams.delete(stream);
 				stream = void 0;
@@ -1553,63 +1593,65 @@ function watch$1(paths, options = {}) {
 	watcher.add(paths);
 	return watcher;
 }
-var esm_default = {
+var chokidar_default = {
 	watch: watch$1,
 	FSWatcher
 };
-
 //#endregion
 //#region src/core/generator.ts
+const RE_INTERFACE = /^export\s+interface\s+([A-Za-z_$][\w$]*)/gm;
+const RE_NAMED_EXPORT = /export\s*\{([^}]+)\}/g;
+const RE_TYPE_EXPORT = /export\s+type\s*\{([^}]+)\}/g;
+const RE_AS_SPLIT = /\s+as\s+/;
 function generateInterfaces(opts) {
-	const { interfaceDir, indexFile, outputFile, excludeFiles } = opts;
+	const { interfaceDir, outputFile, excludeFiles } = opts;
 	const files = fs.readdirSync(interfaceDir).filter((file) => file.endsWith(".ts") && file !== "index.ts" && !excludeFiles.has(file));
 	const interfaces = [];
 	for (const file of files) {
 		const filePath = path.join(interfaceDir, file);
-		const content = fs.readFileSync(filePath, "utf-8");
-		const interfaceNames = [...content.matchAll(/export\s+interface\s+(\w+)/g)].map((m) => m[1]);
-		const namedExportNames = [...content.matchAll(/export\s*\{\s*([^}]+)\s*\}/g)].flatMap((m) => m[1].split(",").map((item) => item.trim().split(/\s+as\s+/)[0].trim()));
-		const names = [...interfaceNames, ...namedExportNames];
+		const content = fs.readFileSync(filePath, "utf8");
+		const interfaceNames = [...content.matchAll(RE_INTERFACE)].map((match) => match[1]);
+		const namedExportNames = [...content.matchAll(RE_NAMED_EXPORT)].filter((match) => !content.substring(Math.max(0, match.index - 10), match.index).includes("type")).flatMap((match) => match[1].split(",").map((item) => item.trim().split(RE_AS_SPLIT)[0].trim()).filter((name) => name.length > 0));
+		const typeExportNames = [...content.matchAll(RE_TYPE_EXPORT)].flatMap((match) => match[1].split(",").map((item) => item.trim().split(RE_AS_SPLIT)[0].trim()).filter((name) => name.length > 0));
+		const allNames = [
+			...interfaceNames,
+			...namedExportNames,
+			...typeExportNames
+		];
+		const names = [...new Set(allNames)].filter((name) => name && name !== "export");
 		if (names.length) interfaces.push({
 			file,
 			names
 		});
 	}
-	const exportLines = interfaces.map((i) => `export * from './${path.basename(i.file, ".ts")}';`);
-	fs.writeFileSync(indexFile, exportLines.join("\n"), "utf-8");
 	const globalLines = [
-		`import type * as Interfaces from '../interfaces';`,
-		"",
 		"declare global {",
-		...interfaces.flatMap((i) => i.names.map((name) => `  export interface ${name} extends Interfaces.${name} {}`)),
+		...interfaces.flatMap((iface) => iface.names.map((name) => `  type ${name} = import('../interfaces/${path.basename(iface.file, ".ts")}').${name};`)),
 		"}",
 		"",
-		"export {};"
+		"export {};",
+		""
 	];
 	fs.mkdirSync(path.dirname(outputFile), { recursive: true });
-	fs.writeFileSync(outputFile, globalLines.join("\n"), "utf-8");
+	fs.writeFileSync(outputFile, globalLines.join("\n"), "utf8");
 	return {
 		files: files.length,
-		interfaces: interfaces.flatMap((i) => i.names).length
+		interfaces: interfaces.flatMap((iface) => iface.names).length
 	};
 }
-
 //#endregion
 //#region src/core/paths.ts
 function resolveOptions(root, options = {}) {
-	const interfaceDir = path.resolve(root, options.dir ?? "resources/js/interfaces");
 	return {
-		interfaceDir,
-		indexFile: path.join(interfaceDir, "index.ts"),
+		interfaceDir: path.resolve(root, options.dir ?? "resources/js/interfaces"),
 		outputFile: path.resolve(root, options.out ?? "resources/js/types/interfaces.d.ts"),
-		excludeFiles: new Set(options.exclude ?? [])
+		excludeFiles: new Set(options.exclude)
 	};
 }
-
 //#endregion
 //#region src/index.ts
 const unpluginFactory = (userOptions = {}, meta) => {
-	const opts = resolveOptions(meta.framework === "vite" ? meta?.vite?.server?.config?.root ?? process.cwd() : process.cwd(), userOptions);
+	const opts = resolveOptions(meta.framework === "vite" ? meta?.vite?.server?.config?.root ?? process$1.cwd() : process$1.cwd(), userOptions);
 	return {
 		name: "@supsign/unplugin-interfaces",
 		buildStart() {
@@ -1617,8 +1659,8 @@ const unpluginFactory = (userOptions = {}, meta) => {
 			this.info(`Generated ${result.interfaces} interfaces from ${result.files} files`);
 		},
 		vite: { configureServer(server) {
-			const watcher = esm_default.watch(opts.interfaceDir, {
-				ignored: (filePath) => filePath.endsWith("index.ts") || filePath.endsWith(".d.ts") || [...opts.excludeFiles].some((f) => filePath.endsWith(f)),
+			const watcher = chokidar_default.watch(opts.interfaceDir, {
+				ignored: (filePath) => filePath.endsWith("index.ts") || filePath.endsWith(".d.ts") || [...opts.excludeFiles].some((filename) => filePath.endsWith(filename)),
 				ignoreInitial: true
 			});
 			const log = (action) => {
@@ -1637,11 +1679,9 @@ const unpluginFactory = (userOptions = {}, meta) => {
 	};
 };
 const unplugin = /* @__PURE__ */ createUnplugin(unpluginFactory);
-var src_default = unplugin;
 const vite = unplugin.vite;
 const rollup = unplugin.rollup;
 const webpack = unplugin.webpack;
 const esbuild = unplugin.esbuild;
-
 //#endregion
-export { esbuild, rollup, src_default, unplugin, unpluginFactory, vite, webpack };
+export { vite as a, unpluginFactory as i, rollup as n, webpack as o, unplugin as r, esbuild as t };