@rsbuild/core 2.0.0-beta.7 → 2.0.0-beta.8

package/dist/chokidar.js

@@ -1,9 +1,11 @@
-/*! For license information please see chokidar.js.LICENSE.txt */
-import { __webpack_require__ } from "./rslib-runtime.js";
-import "./131.js";
-import "./397.js";
-import { readdir, lstat, stat as promises_stat, realpath as promises_realpath, promises_open } from "./7.js";
-let external_node_path_ = __webpack_require__("node:path"), external_node_stream_ = __webpack_require__("node:stream"), EntryTypes_FILE_TYPE = 'files', EntryTypes_DIR_TYPE = 'directories', EntryTypes_FILE_DIR_TYPE = 'files_directories', defaultOptions = {
+/*! LICENSE: chokidar.js.LICENSE.txt */
+import { EventEmitter } from "node:events";
+import { stat as external_node_fs_stat, unwatchFile, watch, watchFile } from "node:fs";
+import { lstat, open as promises_open, readdir, realpath as promises_realpath, stat as promises_stat } from "node:fs/promises";
+import { basename as external_node_path_basename, dirname as external_node_path_dirname, extname, isAbsolute, join, normalize, relative as external_node_path_relative, resolve as external_node_path_resolve, sep } from "node:path";
+import { Readable } from "node:stream";
+import { type as external_node_os_type } from "node:os";
+let EntryTypes_FILE_TYPE = 'files', EntryTypes_DIR_TYPE = 'directories', EntryTypes_FILE_DIR_TYPE = 'files_directories', defaultOptions = {
     root: '.',
     fileFilter: (_entryInfo)=>!0,
     directoryFilter: (_entryInfo)=>!0,
@@ -46,7 +48,7 @@ let RECURSIVE_ERROR_CODE = 'READDIRP_RECURSIVE_ERROR', NORMAL_FLOW_ERRORS = new
     }
     return emptyFn;
 };
-class ReaddirpStream extends external_node_stream_.Readable {
+class ReaddirpStream extends Readable {
     parents;
     reading;
     parent;
@@ -75,7 +77,7 @@ class ReaddirpStream extends external_node_stream_.Readable {
         let statMethod = opts.lstat ? lstat : promises_stat;
         wantBigintFsStats ? this._stat = (path)=>statMethod(path, {
                 bigint: !0
-            }) : this._stat = statMethod, this._maxDepth = null != opts.depth && Number.isSafeInteger(opts.depth) ? opts.depth : defaultOptions.depth, this._wantsDir = !!type && DIR_TYPES.has(type), this._wantsFile = !!type && FILE_TYPES.has(type), this._wantsEverything = 'all' === type, this._root = (0, external_node_path_.resolve)(root), this._isDirent = !opts.alwaysStat, this._statsProp = this._isDirent ? 'dirent' : 'stats', this._rdOptions = {
+            }) : this._stat = statMethod, this._maxDepth = null != opts.depth && Number.isSafeInteger(opts.depth) ? opts.depth : defaultOptions.depth, this._wantsDir = !!type && DIR_TYPES.has(type), this._wantsFile = !!type && FILE_TYPES.has(type), this._wantsEverything = 'all' === type, this._root = external_node_path_resolve(root), this._isDirent = !opts.alwaysStat, this._statsProp = this._isDirent ? 'dirent' : 'stats', this._rdOptions = {
             encoding: 'utf8',
             withFileTypes: this._isDirent
         }, this.parents = [
@@ -128,9 +130,9 @@ class ReaddirpStream extends external_node_stream_.Readable {
     async _formatEntry(dirent, path) {
         let entry, basename = this._isDirent ? dirent.name : dirent;
         try {
-            let fullPath = (0, external_node_path_.resolve)((0, external_node_path_.join)(path, basename));
+            let fullPath = external_node_path_resolve(join(path, basename));
             (entry = {
-                path: (0, external_node_path_.relative)(this._root, fullPath),
+                path: external_node_path_relative(this._root, fullPath),
                 fullPath,
                 basename
             })[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
@@ -155,7 +157,7 @@ class ReaddirpStream extends external_node_stream_.Readable {
                 if (entryRealPathStats.isFile()) return 'file';
                 if (entryRealPathStats.isDirectory()) {
                     let len = entryRealPath.length;
-                    if (full.startsWith(entryRealPath) && full.substr(len, 1) === external_node_path_.sep) {
+                    if (full.startsWith(entryRealPath) && full.substr(len, 1) === sep) {
                         let recursiveError = Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
                         return recursiveError.code = RECURSIVE_ERROR_CODE, this._onError(recursiveError);
                     }
@@ -179,7 +181,7 @@ function readdirp(root, options = {}) {
     } else throw Error('readdirp: root argument is required. Usage: readdirp(root, options)');
     return options.root = root, new ReaddirpStream(options);
 }
-let external_node_fs_ = __webpack_require__("node:fs"), external_node_os_ = __webpack_require__("node:os"), EMPTY_FN = ()=>{}, pl = process.platform, isWindows = 'win32' === pl, isMacos = 'darwin' === pl, isLinux = 'linux' === pl, isFreeBSD = 'freebsd' === pl, isIBMi = 'OS400' === (0, external_node_os_.type)(), EVENTS_ALL = 'all', EVENTS_READY = 'ready', EVENTS_ADD = 'add', EVENTS_CHANGE = 'change', EVENTS_ADD_DIR = 'addDir', EVENTS_UNLINK = 'unlink', EVENTS_UNLINK_DIR = 'unlinkDir', EVENTS_RAW = 'raw', EVENTS_ERROR = 'error', statMethods = {
+let EMPTY_FN = ()=>{}, pl = process.platform, isWindows = 'win32' === pl, isMacos = 'darwin' === pl, isLinux = 'linux' === pl, isFreeBSD = 'freebsd' === pl, isIBMi = 'OS400' === external_node_os_type(), EVENTS_ALL = 'all', EVENTS_READY = 'ready', EVENTS_ADD = 'add', EVENTS_CHANGE = 'change', EVENTS_ADD_DIR = 'addDir', EVENTS_UNLINK = 'unlink', EVENTS_UNLINK_DIR = 'unlinkDir', EVENTS_RAW = 'raw', EVENTS_ERROR = 'error', statMethods = {
     lstat: lstat,
     stat: promises_stat
 }, KEY_LISTENERS = 'listeners', KEY_ERR = 'errHandlers', KEY_RAW = 'rawEmitters', HANDLER_KEYS = [
@@ -461,12 +463,12 @@ let external_node_fs_ = __webpack_require__("node:fs"), external_node_os_ = __we
 }, isEmptySet = (val)=>val instanceof Set ? 0 === val.size : !val, FsWatchInstances = new Map();
 function createFsWatchInstance(path, options, listener, errHandler, emitRaw) {
     try {
-        return (0, external_node_fs_.watch)(path, {
+        return watch(path, {
             persistent: options.persistent
         }, (rawEvent, evPath)=>{
             listener(path), emitRaw(rawEvent, evPath, {
                 watchedPath: path
-            }), evPath && path !== evPath && fsWatchBroadcast(external_node_path_.resolve(path, evPath), KEY_LISTENERS, external_node_path_.join(path, evPath));
+            }), evPath && path !== evPath && fsWatchBroadcast(external_node_path_resolve(path, evPath), KEY_LISTENERS, join(path, evPath));
         });
     } catch (error) {
         errHandler(error);
@@ -486,18 +488,18 @@ class NodeFsHandler {
         this.fsw = fsW, this._boundHandleError = (error)=>fsW._handleError(error);
     }
     _watchWithNodeFs(path, listener) {
-        let closer, opts = this.fsw.options, directory = external_node_path_.dirname(path), basename = external_node_path_.basename(path);
+        let closer, opts = this.fsw.options, directory = external_node_path_dirname(path), basename = external_node_path_basename(path);
         this.fsw._getWatchedDir(directory).add(basename);
-        let absolutePath = external_node_path_.resolve(path), options = {
+        let absolutePath = external_node_path_resolve(path), options = {
             persistent: opts.persistent
         };
-        if (listener || (listener = EMPTY_FN), opts.usePolling) options.interval = opts.interval !== opts.binaryInterval && binaryExtensions.has(external_node_path_.extname(basename).slice(1).toLowerCase()) ? opts.binaryInterval : opts.interval, closer = ((path, fullPath, options, handlers)=>{
+        if (listener || (listener = EMPTY_FN), opts.usePolling) options.interval = opts.interval !== opts.binaryInterval && binaryExtensions.has(extname(basename).slice(1).toLowerCase()) ? opts.binaryInterval : opts.interval, closer = ((path, fullPath, options, handlers)=>{
             let { listener, rawEmitter } = handlers, cont = FsWatchFileInstances.get(fullPath), copts = cont && cont.options;
-            return copts && (copts.persistent < options.persistent || copts.interval > options.interval) && ((0, external_node_fs_.unwatchFile)(fullPath), cont = void 0), cont ? (addAndConvert(cont, KEY_LISTENERS, listener), addAndConvert(cont, KEY_RAW, rawEmitter)) : (cont = {
+            return copts && (copts.persistent < options.persistent || copts.interval > options.interval) && (unwatchFile(fullPath), cont = void 0), cont ? (addAndConvert(cont, KEY_LISTENERS, listener), addAndConvert(cont, KEY_RAW, rawEmitter)) : (cont = {
                 listeners: listener,
                 rawEmitters: rawEmitter,
                 options,
-                watcher: (0, external_node_fs_.watchFile)(fullPath, options, (curr, prev)=>{
+                watcher: watchFile(fullPath, options, (curr, prev)=>{
                     foreach(cont.rawEmitters, (rawEmitter)=>{
                         rawEmitter(EVENTS_CHANGE, fullPath, {
                             curr,
@@ -508,7 +510,7 @@ class NodeFsHandler {
                     (curr.size !== prev.size || currmtime > prev.mtimeMs || 0 === currmtime) && foreach(cont.listeners, (listener)=>listener(path, curr));
                 })
             }, FsWatchFileInstances.set(fullPath, cont)), ()=>{
-                delFromSet(cont, KEY_LISTENERS, listener), delFromSet(cont, KEY_RAW, rawEmitter), isEmptySet(cont.listeners) && (FsWatchFileInstances.delete(fullPath), (0, external_node_fs_.unwatchFile)(fullPath), cont.options = cont.watcher = void 0, Object.freeze(cont));
+                delFromSet(cont, KEY_LISTENERS, listener), delFromSet(cont, KEY_RAW, rawEmitter), isEmptySet(cont.listeners) && (FsWatchFileInstances.delete(fullPath), unwatchFile(fullPath), cont.options = cont.watcher = void 0, Object.freeze(cont));
             };
         })(path, absolutePath, options, {
             listener,
@@ -555,7 +557,7 @@ class NodeFsHandler {
     }
     _handleFile(file, stats, initialAdd) {
         if (this.fsw.closed) return;
-        let dirname = external_node_path_.dirname(file), basename = external_node_path_.basename(file), parent = this.fsw._getWatchedDir(dirname), prevStats = stats;
+        let dirname = external_node_path_dirname(file), basename = external_node_path_basename(file), parent = this.fsw._getWatchedDir(dirname), prevStats = stats;
         if (parent.has(basename)) return;
         let listener = async (path, newStats)=>{
             if (this.fsw._throttle('watch', file, 5)) if (newStats && 0 !== newStats.mtimeMs) {
@@ -600,7 +602,7 @@ class NodeFsHandler {
         this.fsw._symlinkPaths.set(full, !0);
     }
     _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
-        directory = external_node_path_.join(directory, '');
+        directory = join(directory, '');
         let throttleKey = target ? `${directory}:${target}` : directory;
         if (!(throttler = this.fsw._throttle('readdir', throttleKey, 1000))) return;
         let previous = this.fsw._getWatchedDir(wh.path), current = new Set(), stream = this.fsw._readdirp(directory, {
@@ -612,13 +614,13 @@ class NodeFsHandler {
                 stream = void 0;
                 return;
             }
-            let item = entry.path, path = external_node_path_.join(directory, item);
+            let item = entry.path, path = join(directory, item);
             if (current.add(item), !(entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path, item))) {
                 if (this.fsw.closed) {
                     stream = void 0;
                     return;
                 }
-                item !== target && (target || previous.has(item)) || (this.fsw._incrReadyCount(), path = external_node_path_.join(dir, external_node_path_.relative(dir, path)), this._addToNodeFs(path, initialAdd, wh, depth + 1));
+                item !== target && (target || previous.has(item)) || (this.fsw._incrReadyCount(), path = join(dir, external_node_path_relative(dir, path)), this._addToNodeFs(path, initialAdd, wh, depth + 1));
             }
         }).on(EVENTS_ERROR, this._boundHandleError), new Promise((resolve, reject)=>{
             if (!stream) return reject();
@@ -635,8 +637,8 @@ class NodeFsHandler {
         });
     }
     async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath) {
-        let throttler, closer, parentDir = this.fsw._getWatchedDir(external_node_path_.dirname(dir)), tracked = parentDir.has(external_node_path_.basename(dir));
-        initialAdd && this.fsw.options.ignoreInitial || target || tracked || this.fsw._emit(EVENTS_ADD_DIR, dir, stats), parentDir.add(external_node_path_.basename(dir)), this.fsw._getWatchedDir(dir);
+        let throttler, closer, parentDir = this.fsw._getWatchedDir(external_node_path_dirname(dir)), tracked = parentDir.has(external_node_path_basename(dir));
+        initialAdd && this.fsw.options.ignoreInitial || target || tracked || this.fsw._emit(EVENTS_ADD_DIR, dir, stats), parentDir.add(external_node_path_basename(dir)), this.fsw._getWatchedDir(dir);
         let oDepth = this.fsw.options.depth;
         if ((null == oDepth || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath)) {
             if (!target && (await this._handleRead(dir, initialAdd, wh, target, dir, depth, throttler), this.fsw.closed)) return;
@@ -657,15 +659,15 @@ class NodeFsHandler {
             if (this.fsw._isIgnored(wh.watchPath, stats)) return ready(), !1;
             let follow = this.fsw.options.followSymlinks;
             if (stats.isDirectory()) {
-                let absPath = external_node_path_.resolve(path), targetPath = follow ? await promises_realpath(path) : path;
+                let absPath = external_node_path_resolve(path), targetPath = follow ? await promises_realpath(path) : path;
                 if (this.fsw.closed || (closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath), this.fsw.closed)) return;
                 absPath !== targetPath && void 0 !== targetPath && this.fsw._symlinkPaths.set(absPath, targetPath);
             } else if (stats.isSymbolicLink()) {
                 let targetPath = follow ? await promises_realpath(path) : path;
                 if (this.fsw.closed) return;
-                let parent = external_node_path_.dirname(wh.watchPath);
+                let parent = external_node_path_dirname(wh.watchPath);
                 if (this.fsw._getWatchedDir(parent).add(wh.watchPath), this.fsw._emit(EVENTS_ADD, wh.watchPath, stats), closer = await this._handleDir(parent, stats, initialAdd, depth, path, wh, targetPath), this.fsw.closed) return;
-                void 0 !== targetPath && this.fsw._symlinkPaths.set(external_node_path_.resolve(path), targetPath);
+                void 0 !== targetPath && this.fsw._symlinkPaths.set(external_node_path_resolve(path), targetPath);
             } else closer = this._handleFile(wh.watchPath, stats, initialAdd);
             return ready(), closer && this.fsw._addPathCloser(path, closer), !1;
         } catch (error) {
@@ -673,7 +675,7 @@ class NodeFsHandler {
         }
     }
 }
-let external_node_events_ = __webpack_require__("node:events"), BACK_SLASH_RE = /\\/g, DOUBLE_SLASH_RE = /\/\//g, DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/, REPLACER_RE = /^\.[/\\]/;
+let BACK_SLASH_RE = /\\/g, DOUBLE_SLASH_RE = /\/\//g, DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/, REPLACER_RE = /^\.[/\\]/;
 function arrify(item) {
     return Array.isArray(item) ? item : [
         item
@@ -684,15 +686,15 @@ function createPattern(matcher) {
     return 'function' == typeof matcher ? matcher : 'string' == typeof matcher ? (string)=>matcher === string : matcher instanceof RegExp ? (string)=>matcher.test(string) : 'object' == typeof matcher && null !== matcher ? (string)=>{
         if (matcher.path === string) return !0;
         if (matcher.recursive) {
-            let relative = external_node_path_.relative(matcher.path, string);
-            return !!relative && !relative.startsWith('..') && !external_node_path_.isAbsolute(relative);
+            let relative = external_node_path_relative(matcher.path, string);
+            return !!relative && !relative.startsWith('..') && !isAbsolute(relative);
         }
         return !1;
     } : ()=>!1;
 }
 function normalizePath(path) {
     if ('string' != typeof path) throw Error('string expected');
-    path = (path = external_node_path_.normalize(path)).replace(/\\/g, '/');
+    path = (path = normalize(path)).replace(/\\/g, '/');
     let prepend = !1;
     return path.startsWith('//') && (prepend = !0), path = path.replace(DOUBLE_SLASH_RE, '/'), prepend && (path = '/' + path), path;
 }
@@ -713,7 +715,7 @@ let unifyPaths = (paths_)=>{
 }, toUnix = (string)=>{
     let str = string.replace(BACK_SLASH_RE, '/'), prepend = !1;
     return str.startsWith('//') && (prepend = !0), str = str.replace(DOUBLE_SLASH_RE, '/'), prepend && (str = '/' + str), str;
-}, normalizePathToUnix = (path)=>toUnix(external_node_path_.normalize(toUnix(path))), normalizeIgnored = (cwd = '')=>(path)=>'string' == typeof path ? normalizePathToUnix(external_node_path_.isAbsolute(path) ? path : external_node_path_.join(cwd, path)) : path, EMPTY_SET = Object.freeze(new Set());
+}, normalizePathToUnix = (path)=>toUnix(normalize(toUnix(path))), normalizeIgnored = (cwd = '')=>(path)=>'string' == typeof path ? normalizePathToUnix(isAbsolute(path) ? path : join(cwd, path)) : path, EMPTY_SET = Object.freeze(new Set());
 class DirEntry {
     path;
     _removeWatcher;
@@ -732,7 +734,7 @@ class DirEntry {
         try {
             await readdir(dir);
         } catch (err) {
-            this._removeWatcher && this._removeWatcher(external_node_path_.dirname(dir), external_node_path_.basename(dir));
+            this._removeWatcher && this._removeWatcher(external_node_path_dirname(dir), external_node_path_basename(dir));
         }
     }
     has(item) {
@@ -760,12 +762,12 @@ class WatchHelper {
     constructor(path, follow, fsw){
         this.fsw = fsw;
         let watchPath = path;
-        this.path = path = path.replace(REPLACER_RE, ''), this.watchPath = watchPath, this.fullWatchPath = external_node_path_.resolve(watchPath), this.dirParts = [], this.dirParts.forEach((parts)=>{
+        this.path = path = path.replace(REPLACER_RE, ''), this.watchPath = watchPath, this.fullWatchPath = external_node_path_resolve(watchPath), this.dirParts = [], this.dirParts.forEach((parts)=>{
             parts.length > 1 && parts.pop();
         }), this.followSymlinks = follow, this.statMethod = follow ? 'stat' : 'lstat';
     }
     entryPath(entry) {
-        return external_node_path_.join(this.watchPath, external_node_path_.relative(this.watchPath, entry.fullPath));
+        return join(this.watchPath, external_node_path_relative(this.watchPath, entry.fullPath));
     }
     filterPath(entry) {
         let { stats } = entry;
@@ -777,7 +779,7 @@ class WatchHelper {
         return this.fsw._isntIgnored(this.entryPath(entry), entry.stats);
     }
 }
-class FSWatcher extends external_node_events_.EventEmitter {
+class FSWatcher extends EventEmitter {
     closed;
     options;
     _closers;
@@ -843,14 +845,14 @@ class FSWatcher extends external_node_events_.EventEmitter {
         let { cwd } = this.options;
         this.closed = !1, this._closePromise = void 0;
         let paths = unifyPaths(paths_);
-        return cwd && (paths = paths.map((path)=>external_node_path_.isAbsolute(path) ? path : external_node_path_.join(cwd, path))), paths.forEach((path)=>{
+        return cwd && (paths = paths.map((path)=>isAbsolute(path) ? path : join(cwd, path))), paths.forEach((path)=>{
             this._removeIgnoredPath(path);
         }), this._userIgnored = void 0, this._readyCount || (this._readyCount = 0), this._readyCount += paths.length, Promise.all(paths.map(async (path)=>{
             let res = await this._nodeFsHandler._addToNodeFs(path, !_internal, void 0, 0, _origAdd);
             return res && this._emitReady(), res;
         })).then((results)=>{
             this.closed || results.forEach((item)=>{
-                item && this.add(external_node_path_.dirname(item), external_node_path_.basename(_origAdd || item));
+                item && this.add(external_node_path_dirname(item), external_node_path_basename(_origAdd || item));
             });
         }), this;
     }
@@ -858,7 +860,7 @@ class FSWatcher extends external_node_events_.EventEmitter {
         if (this.closed) return this;
         let paths = unifyPaths(paths_), { cwd } = this.options;
         return paths.forEach((path)=>{
-            external_node_path_.isAbsolute(path) || this._closers.has(path) || (cwd && (path = external_node_path_.join(cwd, path)), path = external_node_path_.resolve(path)), this._closePath(path), this._addIgnoredPath(path), this._watched.has(path) && this._addIgnoredPath({
+            isAbsolute(path) || this._closers.has(path) || (cwd && (path = join(cwd, path)), path = external_node_path_resolve(path)), this._closePath(path), this._addIgnoredPath(path), this._watched.has(path) && this._addIgnoredPath({
                 path,
                 recursive: !0
             }), this._userIgnored = void 0;
@@ -876,7 +878,7 @@ class FSWatcher extends external_node_events_.EventEmitter {
     getWatched() {
         let watchList = {};
         return this._watched.forEach((entry, dir)=>{
-            watchList[(this.options.cwd ? external_node_path_.relative(this.options.cwd, dir) : dir) || '.'] = entry.getChildren().sort();
+            watchList[(this.options.cwd ? external_node_path_relative(this.options.cwd, dir) : dir) || '.'] = entry.getChildren().sort();
         }), watchList;
     }
     emitWithAll(event, args) {
@@ -886,7 +888,7 @@ class FSWatcher extends external_node_events_.EventEmitter {
         let pw;
         if (this.closed) return;
         let opts = this.options;
-        isWindows && (path = external_node_path_.normalize(path)), opts.cwd && (path = external_node_path_.relative(opts.cwd, path));
+        isWindows && (path = normalize(path)), opts.cwd && (path = external_node_path_relative(opts.cwd, path));
         let args = [
             path
         ];
@@ -912,7 +914,7 @@ class FSWatcher extends external_node_events_.EventEmitter {
         }
         if (event === EVENTS_CHANGE && !this._throttle(EVENTS_CHANGE, path, 50)) return this;
         if (opts.alwaysStat && void 0 === stats && (event === EVENTS_ADD || event === EVENTS_ADD_DIR || event === EVENTS_CHANGE)) {
-            let stats, fullPath = opts.cwd ? external_node_path_.join(opts.cwd, path) : path;
+            let stats, fullPath = opts.cwd ? join(opts.cwd, path) : path;
             try {
                 stats = await promises_stat(fullPath);
             } catch (err) {}
@@ -949,10 +951,10 @@ class FSWatcher extends external_node_events_.EventEmitter {
         let timeoutHandler, awf = this.options.awaitWriteFinish;
         if ('object' != typeof awf) return;
         let pollInterval = awf.pollInterval, fullPath = path;
-        this.options.cwd && !external_node_path_.isAbsolute(path) && (fullPath = external_node_path_.join(this.options.cwd, path));
+        this.options.cwd && !isAbsolute(path) && (fullPath = join(this.options.cwd, path));
         let now = new Date(), writes = this._pendingWrites;
         function awaitWriteFinishFn(prevStat) {
-            (0, external_node_fs_.stat)(fullPath, (err, curStat)=>{
+            external_node_fs_stat(fullPath, (err, curStat)=>{
                 if (err || !writes.has(path)) {
                     err && 'ENOENT' !== err.code && awfEmit(err);
                     return;
@@ -986,28 +988,28 @@ class FSWatcher extends external_node_events_.EventEmitter {
         return new WatchHelper(path, this.options.followSymlinks, this);
     }
     _getWatchedDir(directory) {
-        let dir = external_node_path_.resolve(directory);
+        let dir = external_node_path_resolve(directory);
         return this._watched.has(dir) || this._watched.set(dir, new DirEntry(dir, this._boundRemove)), this._watched.get(dir);
     }
     _hasReadPermissions(stats) {
         return !!this.options.ignorePermissionErrors || !!(256 & Number(stats.mode));
     }
     _remove(directory, item, isDirectory) {
-        let path = external_node_path_.join(directory, item), fullPath = external_node_path_.resolve(path);
+        let path = join(directory, item), fullPath = external_node_path_resolve(path);
         if (isDirectory = null != isDirectory ? isDirectory : this._watched.has(path) || this._watched.has(fullPath), !this._throttle('remove', path, 100)) return;
         isDirectory || 1 !== this._watched.size || this.add(directory, item, !0), this._getWatchedDir(path).getChildren().forEach((nested)=>this._remove(path, nested));
         let parent = this._getWatchedDir(directory), wasTracked = parent.has(item);
         parent.remove(item), this._symlinkPaths.has(fullPath) && this._symlinkPaths.delete(fullPath);
         let relPath = path;
-        if (this.options.cwd && (relPath = external_node_path_.relative(this.options.cwd, path)), this.options.awaitWriteFinish && this._pendingWrites.has(relPath) && this._pendingWrites.get(relPath).cancelWait() === EVENTS_ADD) return;
+        if (this.options.cwd && (relPath = external_node_path_relative(this.options.cwd, path)), this.options.awaitWriteFinish && this._pendingWrites.has(relPath) && this._pendingWrites.get(relPath).cancelWait() === EVENTS_ADD) return;
         this._watched.delete(path), this._watched.delete(fullPath);
         let eventName = isDirectory ? EVENTS_UNLINK_DIR : EVENTS_UNLINK;
         wasTracked && !this._isIgnored(path) && this._emit(eventName, path), this._closePath(path);
     }
     _closePath(path) {
         this._closeFile(path);
-        let dir = external_node_path_.dirname(path);
-        this._getWatchedDir(dir).remove(external_node_path_.basename(path));
+        let dir = external_node_path_dirname(path);
+        this._getWatchedDir(dir).remove(external_node_path_basename(path));
     }
     _closeFile(path) {
         let closers = this._closers.get(path);
@@ -1034,11 +1036,11 @@ class FSWatcher extends external_node_events_.EventEmitter {
         }), stream;
     }
 }
-let chokidar = {
-    watch: function watch(paths, options = {}) {
-        let watcher = new FSWatcher(options);
-        return watcher.add(paths), watcher;
-    },
+function chokidar_watch(paths, options = {}) {
+    let watcher = new FSWatcher(options);
+    return watcher.add(paths), watcher;
+}
+export default {
+    watch: chokidar_watch,
     FSWatcher: FSWatcher
 };
-export { chokidar };

package/dist/client/hmr.js

@@ -1,4 +1,4 @@
-import { logger } from "./59.js";
+import { logger } from "./797.js";
 let createOverlay;
 let clearOverlay;
 function setupCustomHMRListeners(customListenersMap) {

package/dist/client/overlay.js

@@ -1,5 +1,5 @@
 import { registerOverlay } from "./hmr.js";
-import { logger } from "./59.js";
+import { logger } from "./797.js";
 function _define_property(obj, key, value) {
     if (key in obj) Object.defineProperty(obj, key, {
         value: value,